From 6b46e1166ee1a14179ea28c5dde713531e7848bc Mon Sep 17 00:00:00 2001
From: Aravind N <aravindn1308@outlook.com>
Date: Fri, 27 Mar 2026 18:34:00 -0400
Subject: [PATCH 01/15] Add updated code for FinMME

---
 .gitignore                                    |  20 ++
 README.md                                     | 123 ++++++-
 pyproject.toml                                |   3 +-
 scripts/run_finmme_batch.py                   | 231 +++++++++++++
 scripts/run_finmme_batch.sh                   |  22 ++
 scripts/submit_pipeline.sh                    | 110 ++++++
 src/agentfinvqa/agents/planner_agent.py       |   3 +-
 src/agentfinvqa/agents/prompts/planner.txt    |  12 +-
 src/agentfinvqa/agents/prompts/vision.txt     |  25 +-
 src/agentfinvqa/agents/verifier_agent.py      | 322 +++++-------------
 src/agentfinvqa/agents/vision_agent.py        | 106 +++---
 src/agentfinvqa/datasets/chartqapro_loader.py |  29 +-
 src/agentfinvqa/datasets/finmme_loader.py     | 228 +++++++++++++
 src/agentfinvqa/datasets/image_utils.py       |  58 ++++
 src/agentfinvqa/eval/dashboard.py             | 117 ++++++-
 src/agentfinvqa/eval/error_taxonomy.py        |  21 +-
 src/agentfinvqa/eval/eval_outputs.py          |  66 ++++
 src/agentfinvqa/eval/eval_outputs_batch.py    | 190 +++++++++++
 src/agentfinvqa/eval/eval_topk.py             |  10 +-
 src/agentfinvqa/eval/judge.py                 |   3 +-
 src/agentfinvqa/eval/judge_batch.py           | 248 ++++++++++++++
 .../langfuse_integration/client.py            |  46 ++-
 .../langfuse_integration/dataset.py           |  55 ++-
 .../langfuse_integration/tracing.py           |   5 +-
 src/agentfinvqa/mep/schema.py                 |   1 +
 src/agentfinvqa/runner/run_generate_meps.py   | 213 +++++++++---
 src/agentfinvqa/tools/ocr_reader_tool.py      |   5 +-
 src/agentfinvqa/tools/verifier_tool.py        | 221 ++++++++++++
 src/agentfinvqa/tools/vision_qa_tool.py       |  14 +-
 src/agentfinvqa/utils/model_compat.py         |  23 ++
 tests/agentfinvqa/test_finmme_loader.py       |  64 ++++
 tests/conftest.py                             |  12 +-
 uv.lock                                       |   4 +-
 33 files changed, 2185 insertions(+), 425 deletions(-)
 create mode 100644 scripts/run_finmme_batch.py
 create mode 100755 scripts/run_finmme_batch.sh
 create mode 100755 scripts/submit_pipeline.sh
 create mode 100644 src/agentfinvqa/datasets/finmme_loader.py
 create mode 100644 src/agentfinvqa/datasets/image_utils.py
 create mode 100644 src/agentfinvqa/eval/eval_outputs_batch.py
 create mode 100644 src/agentfinvqa/eval/judge_batch.py
 create mode 100644 src/agentfinvqa/tools/verifier_tool.py
 create mode 100644 src/agentfinvqa/utils/model_compat.py
 create mode 100644 tests/agentfinvqa/test_finmme_loader.py

diff --git a/.gitignore b/.gitignore
index f5e1e38..c3955d2 100644
--- a/.gitignore
+++ b/.gitignore
@@ -24,3 +24,23 @@ wheels/
 # macos
 *.DS_Store
 site/
+
+# Media files
+*.jpg
+*.jpeg
+*.png
+*.gif
+
+# CSV and JSON files
+*.csv
+*.json
+*.jsonl
+
+# Log files
+*.log
+logs/
+**/logs/
+
+# Bash and SLURM scripts
+*.slrm
+*.backup
diff --git a/README.md b/README.md
index 84adf9b..5d0ea32 100644
--- a/README.md
+++ b/README.md
@@ -9,7 +9,16 @@
 [![codecov](https://codecov.io/github/VectorInstitute/AgentFinVQA/graph/badge.svg?token=83MYFZ3UPA)](https://codecov.io/github/VectorInstitute/AgentFinVQA)
 ![GitHub License](https://img.shields.io/github/license/VectorInstitute/AgentFinVQA)
 
-A multi-agent evaluation framework for Visual Question Answering on financial charts, built on the [ChartQAPro](https://huggingface.co/datasets/ahmed-masry/ChartQAPro) dataset. The framework decomposes chart QA into an explicit **Plan → Inspect → Explain** loop, producing fully traceable evaluation artifacts for each sample.
+A multi-agent evaluation framework for Visual Question Answering on financial charts, supporting both [ChartQAPro](https://huggingface.co/datasets/ahmed-masry/ChartQAPro) and [FinMME](https://huggingface.co/datasets/luojunyu/FinMME). The framework decomposes chart QA into an explicit **Plan → Inspect → Explain** loop, producing fully traceable evaluation artifacts for each sample.
+
+## Supported datasets
+
+| Dataset | HF handle | Notes |
+| --- | --- | --- |
+| ChartQAPro | `ahmed-masry/ChartQAPro` | Multi-turn chart QA with factoid/mcq/unanswerable tasks. Images cached under `data/chartqapro_images/` by default. |
+| FinMME | `luojunyu/FinMME` | Financial multi-modal evaluation benchmark (only a `train` split on HF; use slicing like `train[:1000]`). Images cached under `data/finmme_images/` by default. |
+
+Select the dataset at runtime with `--dataset {chartqapro|finmme}`; all downstream tooling (Langfuse registration, output directories) key off the same slug.
 
 ## Overview
 
@@ -110,20 +119,122 @@ uv run --env-file .env -m agentfinvqa.runner.run_generate_meps \
     --out meps/
 ```
 
+To target FinMME, switch `--dataset finmme`. The loader automatically writes FinMME charts to `data/finmme_images/` unless you override `--image_dir`. Note: Hugging Face only exposes a `train` split for `luojunyu/FinMME`. Any request for `test` is remapped to `train` internally, so use slicing (e.g. `--split train[:200]`) to simulate held-out subsets.
+
+### Batch helpers
+
+For headless or batch jobs, use the helper scripts:
+
+- Python entrypoint: `python scripts/run_finmme_batch.py --n 500 --split train[:500] --config gemini_gemini --workers 8`
+- Bash wrapper (convenient for schedulers): `scripts/run_finmme_batch.sh --n 500 --split train[:500]`
+
+Both commands default to loading `.env` from the repo root; override by setting `ENV_FILE=/path/to/.env` before calling the bash script or by passing `--env_file` to the Python script.
+
+### SLURM batch job template
+
+If you need to submit a single FinMME run to SLURM (MEP generation + post-eval in one job), use the monolithic template:
+
+```bash
+sbatch scripts/slurm_run_finmme_batch.slrm
+```
+
+This script sets a time limit (`--time=0-04:00:00`), runs the existing bash helper, and logs output to `logs/slurm_finmme_<jobid>.out/err`. Edit the SBATCH directives and the `run_finmme_batch.sh` arguments inside the file to match your workload.
+
+### SLURM two-stage pipeline (recommended for large runs)
+
+For large runs, use the chained pipeline that separates MEP generation from LLM judge evaluation. This uses the [Gemini Batch API](https://ai.google.dev/gemini-api/docs/batch) for judge scoring (50% cost reduction, async):
+
+```bash
+scripts/submit_pipeline.sh \
+    --split "train[3000:5000]" \
+    --n 2000 \
+    --workers 8 \
+    --langfuse \
+    --resume \
+    --planner_model gemini-2.5-flash \
+    --vision_model gemini-2.5-flash \
+    --ocr_model gemini-2.5-flash-lite \
+    --verifier_model gemini-2.5-flash \
+    --judge_model gemini-2.5-flash-lite
+```
+
+This submits two SLURM jobs chained with `--dependency=afterok`:
+
+| Job | Script | What it does |
+|---|---|---|
+| 1 | `slurm_generate_meps.slrm` | MEP generation only |
+| 2 | `slurm_submit_judge_batch.slrm` | Uploads all judge prompts to Gemini Batch API and exits immediately |
+
+Job 2 only runs if job 1 succeeds. When job 2 completes it prints the commands to check status and retrieve results:
+
+```bash
+# Check if Gemini batch job is done
+python3 -m agentfinvqa.eval.eval_outputs_batch status \
+    --state output/metrics_<label>.jsonl.batch_state.json
+
+# Download results when ready
+python3 -m agentfinvqa.eval.eval_outputs_batch retrieve \
+    --state output/metrics_<label>.jsonl.batch_state.json
+```
+
 See `notebooks/run_pipeline.ipynb` for an interactive walkthrough.
 
 ## Evaluation
 
-Evaluate generated MEPs and explore results:
+Evaluation is a four-step pipeline. MEPs must be generated first (see **Running the Pipeline** above).
+
+### Step 1 — Generate metrics from MEPs
+
+The batch helper (`run_finmme_batch.py`) can do this automatically with `--post_eval`:
+
+```bash
+uv run scripts/run_finmme_batch.sh \
+    --n 500 --split train[:500] \
+    --post_eval --use_judge \
+    --workers 4
+```
+
+`--post_eval` writes `output/metrics_<label>.jsonl` and `output/trace_metrics_<label>.jsonl` at the end of the run.
+
+To evaluate an existing MEP directory independently:
+
+```bash
+uv run -m agentfinvqa.eval.eval_outputs \
+    --mep_dir meps/gemini_gemini/finmme/train[:500] \
+    --out output/metrics.jsonl \
+    --judge_model gemini-2.5-flash-lite   # omit --no_judge to include LLM rubric scores
+```
+
+### Step 2 — Failure taxonomy (optional)
+
+Classifies each incorrect answer into a failure category (legend confusion, extraction error, etc.):
+
+```bash
+uv run -m agentfinvqa.eval.error_taxonomy \
+    --mep_dir meps/gemini_gemini/finmme/train[:500] \
+    --metrics_file output/metrics.jsonl \
+    --out output/taxonomy.jsonl \
+    --model gemini-2.5-flash-lite
+```
+
+### Step 3 — Summarize accuracy
+
+Aggregates metrics by config and question type:
 
 ```bash
-# Summarize accuracy across MEPs
-uv run -m agentfinvqa.eval.summarize --mep-dir meps/
+uv run -m agentfinvqa.eval.summarize \
+    --metrics output/metrics.jsonl \
+    --out output/summary.csv
+```
 
-# Launch the Streamlit dashboard
-uv run streamlit run src/agentfinvqa/eval/dashboard.py -- --mep-dir meps/
+### Step 4 — Explore in the dashboard
+
+```bash
+uv run streamlit run src/agentfinvqa/eval/dashboard.py
 ```
 
+The dashboard auto-discovers MEP directories under `meps/` and metric files under `output/`. Use the sidebar to select paths and filters.
+
 See `notebooks/analysis.ipynb` for detailed analysis examples.
 
 ## Project Structure
diff --git a/pyproject.toml b/pyproject.toml
index 0aa14e4..a59597b 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -22,6 +22,7 @@ dependencies = [
     "scikit-learn>=1.5.2",
     "transformers>=4.47.0",
     "langfuse>=4",
+    "google-genai>=1.34.0",
 ]
 
 [build-system]
@@ -159,7 +160,7 @@ markers = [
 ]
 
 [[tool.mypy.overrides]]
-module = ["crewai.*", "streamlit", "google.genai", "openinference.*"]
+module = ["crewai.*", "streamlit", "google.genai", "openinference.*", "datasets"]
 ignore_missing_imports = true
 
 [[tool.mypy.overrides]]
diff --git a/scripts/run_finmme_batch.py b/scripts/run_finmme_batch.py
new file mode 100644
index 0000000..4a746de
--- /dev/null
+++ b/scripts/run_finmme_batch.py
@@ -0,0 +1,231 @@
+#!/usr/bin/env python3
+# ruff: noqa: E402, I001
+"""Convenience entrypoint for running FinMME batches outside notebooks."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from collections import defaultdict
+from pathlib import Path
+
+from dotenv import load_dotenv
+
+
+REPO_ROOT = Path(__file__).resolve().parents[1]
+SRC_PATH = REPO_ROOT / "src"
+
+
+def _ensure_src_on_path() -> None:
+    if str(SRC_PATH) not in sys.path:
+        sys.path.insert(0, str(SRC_PATH))
+
+
+_ensure_src_on_path()
+
+from agentfinvqa.eval.error_taxonomy import classify_failure
+from agentfinvqa.eval.eval_outputs import evaluate_mep
+from agentfinvqa.eval.eval_traces import evaluate_trace
+from agentfinvqa.eval.summarize import summarize, write_csv
+from agentfinvqa.mep.writer import iter_meps
+from agentfinvqa.runner import run_generate_meps
+
+CONFIG_CHOICES = list(run_generate_meps.BACKEND_CONFIGS.keys())
+DATASET_SLUG = "finmme"
+
+
+def _build_runner_args(args: argparse.Namespace) -> list[str]:
+    cmd: list[str] = [
+        "--dataset",
+        DATASET_SLUG,
+        "--split",
+        args.split,
+        "--n",
+        str(args.n),
+        "--config",
+        args.config,
+        "--workers",
+        str(args.workers),
+        "--out",
+        args.out,
+    ]
+
+    def _append(flag: str, value: str | None) -> None:
+        if value:
+            cmd.extend([flag, value])
+
+    _append("--image_dir", args.image_dir)
+    _append("--cache_dir", args.cache_dir)
+    _append("--planner_model", args.planner_model)
+    _append("--vision_model", args.vision_model)
+    _append("--verifier_model", args.verifier_model)
+    _append("--ocr_model", args.ocr_model)
+
+    if args.no_verifier:
+        cmd.append("--no_verifier")
+    if args.no_ocr:
+        cmd.append("--no_ocr")
+    if not args.langfuse:
+        cmd.append("--no_langfuse")
+    if args.resume:
+        cmd.append("--resume")
+
+    return cmd
+
+
+def _write_metrics(out_dir: Path, metrics_path: Path, config: dict, use_judge: bool) -> list[dict]:
+    metrics_list: list[dict] = []
+    judge_model = config.get("vision_model") or config.get("planner_model") or "gemini-2.5-flash-lite"
+    with open(metrics_path, "w") as f_out:
+        for mep in iter_meps(str(out_dir)):
+            try:
+                row = evaluate_mep(
+                    mep,
+                    use_judge=use_judge,
+                    judge_backend=config.get("judge_backend", config["planner_backend"]),
+                    judge_model=judge_model,
+                )
+                metrics_list.append(row)
+                f_out.write(json.dumps(row) + "\n")
+            except Exception as exc:
+                sid = mep.get("sample", {}).get("sample_id", "?")
+                print(f"  [metrics] {sid} ERROR: {exc}")
+    return metrics_list
+
+
+def _print_accuracy(metrics_list: list[dict]) -> None:
+    acc = sum(m.get("answer_accuracy", 0.0) for m in metrics_list) / len(metrics_list)
+    print(f"[post-eval] Accuracy {acc:.1%} (n={len(metrics_list)})")
+    qt_groups: dict[str, list[float]] = defaultdict(list)
+    for row in metrics_list:
+        qt_groups[row.get("question_type", "unknown")].append(row.get("answer_accuracy", 0.0))
+    for qt, vals in sorted(qt_groups.items()):
+        mean_qt = sum(vals) / max(len(vals), 1)
+        print(f"  {qt:<18} {mean_qt:.1%} (n={len(vals)})")
+
+
+def _write_trace_metrics(out_dir: Path, trace_path: Path) -> None:
+    with open(trace_path, "w") as f_out:
+        for mep in iter_meps(str(out_dir)):
+            row = evaluate_trace(mep)
+            f_out.write(json.dumps(row) + "\n")
+    print(f"[post-eval] Trace metrics -> {trace_path}")
+
+
+def _write_taxonomy(out_dir: Path, taxonomy_path: Path, metrics_list: list[dict], config: dict) -> None:
+    acc_map = {row["sample_id"]: row.get("answer_accuracy", 0.0) for row in metrics_list}
+    taxonomy_rows = 0
+    model = config.get("vision_model") or config.get("planner_model") or "gemini-2.5-flash-lite"
+    with open(taxonomy_path, "w") as f_out:
+        for mep in iter_meps(str(out_dir)):
+            sid = mep.get("sample", {}).get("sample_id", "")
+            acc_val = acc_map.get(sid, 0.0)
+            if acc_val >= 0.999:
+                continue
+            try:
+                result = classify_failure(
+                    mep,
+                    answer_accuracy=acc_val,
+                    backend=config.get("vision_backend", "gemini"),
+                    model=model,
+                )
+                row = {"sample_id": sid, "answer_accuracy": acc_val, **result}
+                f_out.write(json.dumps(row) + "\n")
+                taxonomy_rows += 1
+            except Exception as exc:
+                print(f"  [taxonomy] {sid} ERROR: {exc}")
+    print(f"[post-eval] Taxonomy rows: {taxonomy_rows} -> {taxonomy_path}")
+
+
+def _write_summary(metrics_list: list[dict], summary_path: Path) -> None:
+    summary_rows = summarize(metrics_list)
+    write_csv(summary_rows, str(summary_path))
+    print(f"[post-eval] Summary -> {summary_path}")
+
+
+def run_post_evaluation(
+    out_dir: Path,
+    label: str,
+    eval_dir: Path,
+    config: dict,
+    use_judge: bool,
+) -> None:
+    """Compute metrics, traces, taxonomy, and summary artifacts for a run."""
+    if not out_dir.exists():
+        print(f"[post-eval] Skipping metrics: MEP dir {out_dir} not found")
+        return
+
+    eval_dir.mkdir(parents=True, exist_ok=True)
+    print(f"[post-eval] Writing artifacts to {eval_dir.resolve()} (label={label})")
+
+    metrics_path = eval_dir / f"metrics_{label}.jsonl"
+    metrics_list = _write_metrics(out_dir, metrics_path, config, use_judge)
+
+    if not metrics_list:
+        print("[post-eval] No metrics produced; aborting remaining steps.")
+        return
+
+    _print_accuracy(metrics_list)
+    trace_path = eval_dir / f"trace_metrics_{label}.jsonl"
+    _write_trace_metrics(out_dir, trace_path)
+    taxonomy_path = eval_dir / f"taxonomy_{label}.jsonl"
+    _write_taxonomy(out_dir, taxonomy_path, metrics_list, config)
+    summary_path = eval_dir / f"summary_{label}.csv"
+    _write_summary(metrics_list, summary_path)
+    print("[post-eval] Artifacts ready:")
+    for path in [metrics_path, trace_path, taxonomy_path, summary_path]:
+        print(f"  - {path}")
+
+
+def main() -> None:
+    """Run FinMME generation and optional post-evaluation in one command."""
+    parser = argparse.ArgumentParser(description="Run AgentFinVQA on FinMME at scale")
+    parser.add_argument("--n", type=int, default=100, help="Number of FinMME samples to process")
+    parser.add_argument(
+        "--split",
+        default="train",
+        help="FinMME split slice (default train; aliases like test[:50] are remapped to train).",
+    )
+    parser.add_argument("--config", default="gemini_gemini", choices=CONFIG_CHOICES, help="Backend pairing")
+    parser.add_argument("--workers", type=int, default=4, help="Threaded workers for generation")
+    parser.add_argument("--out", default="meps/", help="Base output directory for MEPs")
+    parser.add_argument("--image_dir", default=None, help="Override FinMME image cache directory")
+    parser.add_argument("--cache_dir", default=None, help="HuggingFace datasets cache override")
+    parser.add_argument("--planner_model", default=None, help="Planner model override")
+    parser.add_argument("--vision_model", default=None, help="Vision model override")
+    parser.add_argument("--verifier_model", default=None, help="Verifier model override")
+    parser.add_argument("--ocr_model", default=None, help="OCR model override")
+    parser.add_argument("--no_verifier", action="store_true", help="Disable pass 2.5 verifier")
+    parser.add_argument("--no_ocr", action="store_true", help="Disable OCR preread")
+    parser.add_argument("--langfuse", action="store_true", help="Enable Langfuse registration/tracing")
+    parser.add_argument("--resume", action="store_true", help="Skip samples whose MEPs already exist in the output dir")
+    parser.add_argument("--use_judge", action="store_true", help="Run LLM judge during post-eval")
+    parser.add_argument("--post_eval", action="store_true", help="Compute metrics/taxonomy/summary after generation")
+    parser.add_argument("--eval_dir", default="output", help="Directory for metrics/taxonomy outputs")
+    parser.add_argument("--eval_label", default=None, help="Custom label for eval files (defaults to config_n)")
+    parser.add_argument("--env_file", default=".env", help=".env file to load before running")
+    args = parser.parse_args()
+
+    env_path = Path(args.env_file)
+    if env_path.exists():
+        load_dotenv(env_path, override=True)
+
+    sys.argv = ["run_generate_meps"] + _build_runner_args(args)
+    run_generate_meps.main()
+
+    if args.post_eval:
+        config = run_generate_meps.BACKEND_CONFIGS[args.config]
+        out_dir = Path(args.out) / f"{config['planner_backend']}_{config['vision_backend']}" / DATASET_SLUG / args.split
+        label = args.eval_label or f"{args.config}_n{args.n}"
+        run_post_evaluation(
+            out_dir=out_dir,
+            label=label,
+            eval_dir=Path(args.eval_dir),
+            config=config,
+            use_judge=args.use_judge,
+        )
+
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/run_finmme_batch.sh b/scripts/run_finmme_batch.sh
new file mode 100755
index 0000000..719efdd
--- /dev/null
+++ b/scripts/run_finmme_batch.sh
@@ -0,0 +1,22 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+REPO_ROOT="$(cd -- "$(dirname "${BASH_SOURCE[0]}")"/.. && pwd)"
+ENV_FILE_DEFAULT="$REPO_ROOT/.env"
+LOG_DIR_DEFAULT="$REPO_ROOT/logs"
+
+LOG_DIR="${LOG_DIR:-$LOG_DIR_DEFAULT}"
+mkdir -p "$LOG_DIR"
+timestamp="$(date +%Y%m%d-%H%M%S)"
+LOG_FILE="$LOG_DIR/finmme_${timestamp}.log"
+
+export CREWAI_TRACING_ENABLED=false
+export OTEL_SDK_DISABLED=1
+
+{
+  echo "[$(date --iso-8601=seconds)] Starting FinMME batch → log $LOG_FILE"
+  python3 "$REPO_ROOT/scripts/run_finmme_batch.py" --env_file "${ENV_FILE:-$ENV_FILE_DEFAULT}" "$@"
+  status=$?
+  echo "[$(date --iso-8601=seconds)] Run completed with status $status (log $LOG_FILE)"
+  exit $status
+} 2>&1 | tee "$LOG_FILE"
diff --git a/scripts/submit_pipeline.sh b/scripts/submit_pipeline.sh
new file mode 100755
index 0000000..293936b
--- /dev/null
+++ b/scripts/submit_pipeline.sh
@@ -0,0 +1,110 @@
+#!/usr/bin/env bash
+# Submit MEP generation + batch judge submission as a chained SLURM pipeline.
+# Job 2 only runs if Job 1 succeeds (afterok dependency).
+#
+# Usage:
+#   scripts/submit_pipeline.sh [options]
+#
+# Options:
+#   --split SPLIT          Dataset split slice (default: train[3000:5000])
+#   --n N                  Number of samples (default: 2000)
+#   --workers N            Parallel workers (default: 8)
+#   --planner_model M      Planner model (default: gemini-2.5-flash)
+#   --vision_model M       Vision model (default: gemini-2.5-flash)
+#   --ocr_model M          OCR model (default: gemini-2.5-flash-lite)
+#   --verifier_model M     Verifier model (default: gemini-2.5-flash)
+#   --judge_model M        Judge model for batch eval (default: gemini-2.5-flash-lite)
+#   --langfuse             Enable Langfuse tracing
+#   --resume               Resume from existing MEPs
+#   --out_label LABEL      Label for output files (default: same as split)
+#   --config CONFIG        Backend config preset (default: gemini_gemini)
+#   --after JOB_ID         Hold job 1 until JOB_ID completes successfully (optional)
+
+set -euo pipefail
+
+REPO_ROOT="$(cd -- "$(dirname "${BASH_SOURCE[0]}")"/.. && pwd)"
+cd "$REPO_ROOT"
+
+mkdir -p logs
+
+# Load SLURM module so sbatch is available
+module --force purge
+module load slurm/bonecho/25.05.2
+
+# Defaults
+SPLIT="train[3000:5000]"
+N=2000
+WORKERS=8
+PLANNER_MODEL="gemini-2.5-flash"
+VISION_MODEL="gemini-2.5-flash"
+OCR_MODEL="gemini-2.5-flash-lite"
+VERIFIER_MODEL="gemini-2.5-flash"
+JUDGE_MODEL="gemini-2.5-flash-lite"
+CONFIG="gemini_gemini"
+LANGFUSE=0
+RESUME=0
+OUT_LABEL=""
+AFTER_JOB=""
+
+while [[ $# -gt 0 ]]; do
+    case "$1" in
+        --split)         SPLIT="$2";          shift 2 ;;
+        --n)             N="$2";              shift 2 ;;
+        --workers)       WORKERS="$2";        shift 2 ;;
+        --planner_model) PLANNER_MODEL="$2";  shift 2 ;;
+        --vision_model)  VISION_MODEL="$2";   shift 2 ;;
+        --ocr_model)     OCR_MODEL="$2";      shift 2 ;;
+        --verifier_model) VERIFIER_MODEL="$2"; shift 2 ;;
+        --judge_model)   JUDGE_MODEL="$2";    shift 2 ;;
+        --config)        CONFIG="$2";         shift 2 ;;
+        --langfuse)      LANGFUSE=1;          shift ;;
+        --resume)        RESUME=1;            shift ;;
+        --out_label)     OUT_LABEL="$2";      shift 2 ;;
+        --after)         AFTER_JOB="$2";      shift 2 ;;
+        *) echo "Unknown option: $1"; exit 1 ;;
+    esac
+done
+
+OUT_LABEL="${OUT_LABEL:-$SPLIT}"
+
+# Export vars so sbatch inherits them (avoids --export string parsing issues
+# with special characters like brackets in split names e.g. train[0:1])
+export SPLIT N WORKERS PLANNER_MODEL VISION_MODEL OCR_MODEL VERIFIER_MODEL LANGFUSE RESUME
+export JUDGE_MODEL CONFIG OUT_LABEL
+
+echo "=== Submitting FinMME pipeline ==="
+echo "  Split          : $SPLIT"
+echo "  N              : $N"
+echo "  Workers        : $WORKERS"
+echo "  Planner model  : $PLANNER_MODEL"
+echo "  Vision model   : $VISION_MODEL"
+echo "  OCR model      : $OCR_MODEL"
+echo "  Verifier model : $VERIFIER_MODEL"
+echo "  Judge model    : $JUDGE_MODEL"
+echo "  Langfuse       : $LANGFUSE"
+echo "  Config         : $CONFIG"
+echo "  Resume         : $RESUME"
+echo "  Output label   : $OUT_LABEL"
+[[ -n "$AFTER_JOB" ]] && echo "  After job      : $AFTER_JOB"
+echo ""
+
+# Job 1: MEP generation (optionally held until AFTER_JOB completes)
+JOB1_DEP=""
+[[ -n "$AFTER_JOB" ]] && JOB1_DEP="--dependency=afterok:${AFTER_JOB}"
+JOB1=$(sbatch --parsable --export=ALL $JOB1_DEP scripts/slurm_generate_meps.slrm)
+echo "Job 1 (generate) submitted: $JOB1"
+
+# Load SLURM module so sbatch is available
+module --force purge
+module load slurm/bonecho/25.05.2
+
+# Job 2: submit Gemini Batch judge job (runs only if job 1 succeeds)
+JOB2=$(sbatch --parsable --export=ALL \
+    --dependency=afterok:${JOB1} \
+    scripts/slurm_submit_judge_batch.slrm)
+echo "Job 2 (judge submit) submitted: $JOB2 (depends on $JOB1)"
+
+echo ""
+echo "Monitor with:"
+echo "  squeue -j ${JOB1},${JOB2}"
+echo "  tail -f logs/slurm_generate_${JOB1}.out"
diff --git a/src/agentfinvqa/agents/planner_agent.py b/src/agentfinvqa/agents/planner_agent.py
index 42abad4..4a4a24b 100644
--- a/src/agentfinvqa/agents/planner_agent.py
+++ b/src/agentfinvqa/agents/planner_agent.py
@@ -13,6 +13,7 @@
 from ..datasets.perceived_sample import PerceivedSample
 from ..langfuse_integration.tracing import close_span, open_llm_span
 from ..utils.json_strict import parse_strict
+from ..utils.model_compat import openai_temperature
 
 
 PLANNER_PROMPT_PATH = Path(__file__).parent / "prompts" / "planner.txt"
@@ -95,7 +96,7 @@ def _build_llm(backend: str, model: str, api_key: Optional[str]) -> LLM:
         return LLM(
             model=model,
             api_key=api_key or os.environ.get("OPENAI_API_KEY", ""),
-            temperature=0,
+            **openai_temperature(model),
         )
     if backend == "gemini":
         return LLM(
diff --git a/src/agentfinvqa/agents/prompts/planner.txt b/src/agentfinvqa/agents/prompts/planner.txt
index d314e82..02315ce 100644
--- a/src/agentfinvqa/agents/prompts/planner.txt
+++ b/src/agentfinvqa/agents/prompts/planner.txt
@@ -20,11 +20,13 @@ Output ONLY a JSON object with EXACTLY these keys. No markdown. No explanation.
 Rules:
 - steps: exactly 2-4 short imperative chart-inspection actions
 - Required step types (include as applicable):
-    1. Identify the chart type (bar, line, pie, scatter, dashboard, etc.) and read the title
-    2. Locate relevant axes labels, legend entries, and series names
-    3. Extract the specific data values or trends needed to answer the question
-    4. Compute or compare values if required; check if the answer is determinable from the chart
+    1. Identify the chart type (bar, line, pie, scatter, dashboard, etc.), read the title, and note the number of panels if multiple
+    2. Map each legend entry to its visual representation (color, pattern, position) BEFORE reading any values — do this explicitly for stacked, grouped, pie, and multi-series charts
+    3. Read all axis tick marks and scale units first; then extract the specific data values needed by locating the exact bar/point/slice for each relevant series
+    4. Compute or compare values if required; for multi-part questions (e.g. "for X and Y"), report each part separately — do not aggregate unless explicitly asked
+- If answer choices specify ranges or lettered options, include a step that inspects each choice individually and states what must be compared or computed for it
+- If the question asks for reasons, conclusions, or implications (not just observable values), note that the answer may require chart-level inference — do not mark as unanswerable solely because values are not labeled
 - expected_answer_type: the format expected for the answer
-- answerability_check: can this question be answered from a typical chart of this type?
+- answerability_check: only mark "unanswerable" if the chart structurally cannot provide the answer; use "uncertain" if labels might be present but are ambiguous
 - hints: empty list unless you have specific extraction strategies to suggest
 - Output JSON only — no markdown code fences, no extra keys, no trailing text
diff --git a/src/agentfinvqa/agents/prompts/vision.txt b/src/agentfinvqa/agents/prompts/vision.txt
index b99f0ad..dbb8961 100644
--- a/src/agentfinvqa/agents/prompts/vision.txt
+++ b/src/agentfinvqa/agents/prompts/vision.txt
@@ -3,6 +3,7 @@ You are a chart reading agent. Analyze the chart image and answer the question b
 Chart Image Path: {image_path}
 Question: {question}
 {choices_block}
+{choice_labels_block}
 {context_block}
 {ocr_block}
 
@@ -16,14 +17,28 @@ Instructions:
    - plan_steps: the numbered inspection steps above
    - choices: the MCQ choices if provided
    - context: the conversation context if provided
-2. After receiving the tool result, output your final answer as STRICT JSON only
+2. Before reading any data values:
+   - Read ALL axis tick marks and note the scale/units (e.g. %, $B, index)
+   - For stacked, grouped, pie, or multi-series charts: explicitly map each legend entry to its color/pattern/position before assigning any values
+3. Capture the evidence for each provided choice (or range) in a JSON object named "choice_analysis". Each entry must include:
+   - "evidence": the exact text, bar, or slice you read from the chart (quote tick marks or labels directly)
+   - "trend_or_value": the precise numeric value or trend observed — use a single number, not a range, unless the question explicitly asks for a range
+   - "confidence": number between 0 and 1; use < 0.5 if label is ambiguous or occluded
+   - Limit each entry to a single short phrase (≤ 15 words).
+   If there are no explicit choices, set "choice_analysis" to an empty object.
+4. For multi-part questions asking about X and Y separately, report values for each independently — do not sum or aggregate unless explicitly asked.
+5. After receiving the tool result, output your final answer as STRICT JSON only
 
 Final output format (JSON only — no markdown, no code fences, no extra text):
-{{"answer": "<your answer>", "explanation": "<your explanation>"}}
+{{"choice_analysis": {{"Choice A": {{...}}, ...}}, "answer": "<your answer>", "explanation": "<your explanation>"}}
 
 Rules:
-- If the question CANNOT be answered from the chart: set answer to exactly "UNANSWERABLE"
-- explanation MUST reference specific chart evidence: axis labels, legend entries, series names, data values, trend direction
+- Only set answer to "UNANSWERABLE" if you have genuinely searched the chart and cannot locate any relevant data — not merely because labels are small or the question requires a simple inference. If values are present but partially obscured, give your best reading and note uncertainty in the explanation.
+- If vision_qa_tool returns an error or cannot be called, output {{"choice_analysis": {{}}, "answer": "UNANSWERABLE", "explanation": "TOOL_ERROR: <brief note>"}} and do not fabricate values from OCR or memory.
+- explanation MUST reference specific chart evidence: axis tick values, legend entry names, series colors, data point positions
+- Final explanation must be ≤2 sentences.
 - explanation MUST NOT invent or assume details not visible in the chart
-- For MCQ: answer must be exactly one of the provided choices
+- For MCQ: the `answer` field must be exactly one of the provided choice texts or the precise letter/letter-combo (e.g., "AC"). Do NOT paraphrase.
+- When multiple choice letters form the correct answer, respond with the exact letter combination (e.g., "AC")
+- NEVER output "Thought:", "Action:", or any text outside the JSON. Violations count as failure to follow instructions.
 - JSON only output — no markdown, no preamble, no trailing text
diff --git a/src/agentfinvqa/agents/verifier_agent.py b/src/agentfinvqa/agents/verifier_agent.py
index a182f10..36f0cd0 100644
--- a/src/agentfinvqa/agents/verifier_agent.py
+++ b/src/agentfinvqa/agents/verifier_agent.py
@@ -1,179 +1,49 @@
 """VerifierAgent — Pass 2.5: critically reviews the VisionAgent's draft answer.
 
 The verifier sees the chart image AND the draft answer/explanation and decides
-whether to CONFIRM or REVISE the answer. This teaches multi-agent critique patterns.
+whether to CONFIRM or REVISE the answer.
 
-Unlike VisionAgent (which uses CrewAI + tool-use to explore the chart), the
-verifier makes a single direct VLM call — showing that multi-agent critique
-does not always require a full orchestration framework.
-
-Key teaching point
-------------------
-Two agents looking at the same chart image can disagree. When the second model
-(the verifier) has explicit access to the first model's reasoning, it can catch
-errors the first model missed — axis misreads, arithmetic mistakes, etc.
+Like VisionAgent, this agent uses CrewAI + a dedicated tool (VerifierTool) so
+that the VLM call is observable, traceable, and consistent with the rest of the
+pipeline architecture.
 """
 
-import base64
 import os
-from pathlib import Path
 from typing import Any, Optional, Tuple
 
-from google import genai
-from openai import OpenAI
-from PIL import Image
+from crewai import LLM, Agent, Crew, Task
 
 from ..langfuse_integration.tracing import close_span, open_llm_span
+from ..tools.verifier_tool import VerifierTool
 from ..utils.json_strict import parse_strict
+from ..utils.model_compat import openai_temperature
 
 
 VERIFIER_REQUIRED_KEYS = ["verdict", "answer", "reasoning"]
 
-_VERIFIER_PROMPT = """\
-You are a critical chart QA verifier. A vision agent has already attempted to answer
-the question below. Your job: look at the chart image carefully and audit the work.
-
-Question         : {question}
-Question Type    : {question_type}
-
-Inspection plan the agent was supposed to follow:
-{plan_steps}
-
-Vision Agent's Draft Answer     : {draft_answer}
-Vision Agent's Draft Explanation: {draft_explanation}
-
-Examine the chart image. Then decide:
-  CONFIRM — the draft answer is correct (output the same answer unchanged)
-  REVISE  — you can see a clear, specific error; output the corrected answer
-
-Rules:
-- Only REVISE when you are confident you can point to a concrete error in the chart
-- If uncertain, CONFIRM — do not second-guess without visual evidence
-- For MCQ questions: the answer must be one of the stated choices
-- If the answer is truly unanswerable from the chart, say exactly "UNANSWERABLE"
-- Keep answers concise — numbers, short phrases, or single words where appropriate
-
-Output ONLY JSON, no markdown, no extra text:
-{{"verdict": "confirmed" | "revised", "answer": "<final answer>", "reasoning": "<one sentence grounded in what you see in the chart>"}}"""
-
-
-# ---------------------------------------------------------------------------
-# VLM helpers (same pattern as error_taxonomy.py)
-# ---------------------------------------------------------------------------
-
-
-def _encode_image(image_path: str) -> tuple:
-    """
-    Read an image file and convert it to a base64 string.
-
-    Parameters
-    ----------
-    image_path : str
-        The path to the image file on disk.
-
-    Returns
-    -------
-    b64 : str
-        The base64 encoded image string.
-    mime : str
-        The inferred MIME type of the image.
-    """
-    ext = Path(image_path).suffix.lower().lstrip(".")
-    mime = {
-        "jpg": "jpeg",
-        "jpeg": "jpeg",
-        "png": "png",
-        "gif": "gif",
-        "webp": "webp",
-    }.get(ext, "jpeg")
-    with open(image_path, "rb") as f:
-        b64 = base64.b64encode(f.read()).decode("utf-8")
-    return b64, mime
-
-
-def _call_vlm_openai(prompt: str, image_path: str, model: str, api_key: Optional[str]) -> str:
-    """
-    Submit a vision request to the OpenAI API.
-
-    Parameters
-    ----------
-    prompt : str
-        The text instruction for the model.
-    image_path : str
-        Path to the relevant image.
-    model : str
-        The GPT model name.
-    api_key : str, optional
-        API key for authorization.
-
-    Returns
-    -------
-    str
-        The text response from the OpenAI model.
-    """
-    client = OpenAI(api_key=api_key or os.environ.get("OPENAI_API_KEY", ""))
-    b64, mime = _encode_image(image_path)
-    response = client.chat.completions.create(
-        model=model,
-        messages=[
-            {
-                "role": "user",
-                "content": [
-                    {"type": "text", "text": prompt},
-                    {
-                        "type": "image_url",
-                        "image_url": {"url": f"data:image/{mime};base64,{b64}"},
-                    },
-                ],
-            }
-        ],
-        max_completion_tokens=256,
-        temperature=0,
-    )
-    return response.choices[0].message.content or ""
-
-
-def _call_vlm_gemini(prompt: str, image_path: str, model: str, api_key: Optional[str]) -> str:
-    """
-    Submit a vision request to the Google Gemini API.
 
-    Parameters
-    ----------
-    prompt : str
-        The text instruction for the model.
-    image_path : str
-        Path to the relevant image.
-    model : str
-        The Gemini model name.
-    api_key : str, optional
-        API key for authorization.
-
-    Returns
-    -------
-    str
-        The text response from the Gemini model.
-    """
-    client = genai.Client(api_key=api_key or os.environ.get("GEMINI_API_KEY", ""))
-    image = Image.open(image_path)
-    response = client.models.generate_content(
-        model=model,
-        contents=[image, prompt],
-        config=genai.types.GenerateContentConfig(temperature=0, max_output_tokens=256),
-    )
-    return response.text or ""
-
-
-# ---------------------------------------------------------------------------
-# VerifierAgent
-# ---------------------------------------------------------------------------
+def _build_llm(backend: str, model: str, api_key: Optional[str]) -> LLM:
+    if backend == "openai":
+        return LLM(
+            model=model,
+            api_key=api_key or os.environ.get("OPENAI_API_KEY", ""),
+            **openai_temperature(model),
+        )
+    if backend == "gemini":
+        return LLM(
+            model=f"gemini/{model}",
+            api_key=api_key or os.environ.get("GEMINI_API_KEY", ""),
+            temperature=0,
+        )
+    raise ValueError(f"Unknown verifier backend: {backend!r}")
 
 
 class VerifierAgent:
     """
     A validation agent that critiques draft answers against visual evidence.
 
-    Coordinates a critical second look at the chart image to verify the
-    logical grounding of the initial answer proposed by the VisionAgent.
+    Uses CrewAI + VerifierTool to make a single auditing VLM call, consistent
+    with how VisionAgent uses VisionQATool.
     """
 
     def __init__(
@@ -182,57 +52,40 @@ def __init__(
         model: str = "gemini-2.5-flash-lite",
         api_key: Optional[str] = None,
     ):
-        """
-        Initialize the verifier with the specified multimodal backend.
-
-        Parameters
-        ----------
-        backend : {'openai', 'gemini'}
-            The provider for the verification model.
-        model : str
-            The model name.
-        api_key : str, optional
-            API key to use for calls.
-        """
         self.backend = backend
         self.model = model
         self.api_key = api_key
 
+    def _build_tool(self, lf_trace: Any = None) -> VerifierTool:
+        key = self.api_key or (
+            os.environ.get("OPENAI_API_KEY", "") if self.backend == "openai" else os.environ.get("GEMINI_API_KEY", "")
+        )
+        return VerifierTool(
+            backend=self.backend,
+            model=self.model,
+            api_key=key,
+            lf_trace=lf_trace,
+        )
+
     def run(
         self,
         sample,  # PerceivedSample
         plan: dict,
         vision_parsed: dict,
         lf_trace: Any = None,
-    ) -> Tuple[str, dict, bool, str]:
+    ) -> Tuple[str, dict, bool, str, list]:
         """
-        Critically audit a draft answer using a single VLM call.
-
-        Parameters
-        ----------
-        sample : PerceivedSample
-            The source data sample.
-        plan : dict
-            The inspection plan used by the previous agent.
-        vision_parsed : dict
-            The draft answer and explanation to audit.
-        langfuse_trace : Any, optional
-            Tracing object for observability.
+        Critically audit a draft answer using a CrewAI agent + VerifierTool.
 
         Returns
         -------
-        prompt : str
-            The verifier prompt rendered for the model.
-        parsed : dict
-            The final audited response containing 'verdict', 'answer', and 'reasoning'.
+        task_description : str
+        parsed : dict  — keys: verdict, answer, reasoning
         parse_error : bool
-            True if the JSON result was malformed.
         raw_text : str
-            The raw string response from the VLM.
+        tool_traces : list of dict
         """
         plan_steps = plan.get("steps", [])
-        steps_text = "\n".join(f"  {i + 1}. {s}" for i, s in enumerate(plan_steps)) or "  (none)"
-
         draft_answer = vision_parsed.get("answer", "(none)")
         draft_explanation = vision_parsed.get("explanation", "(none)")
         question_type = getattr(
@@ -240,63 +93,72 @@ def run(
             "value",
             str(getattr(sample, "question_type", "standard")),
         )
+        image_path = getattr(sample, "image_path", "") or ""
 
-        prompt = _VERIFIER_PROMPT.format(
-            question=sample.question,
-            question_type=question_type,
-            plan_steps=steps_text,
-            draft_answer=draft_answer,
-            draft_explanation=draft_explanation,
+        steps_text = "\n".join(f"  {i + 1}. {s}" for i, s in enumerate(plan_steps)) or "  (none)"
+        task_description = (
+            f"You are auditing a vision agent's answer to a chart question.\n\n"
+            f"Question         : {sample.question}\n"
+            f"Question Type    : {question_type}\n"
+            f"Image path       : {image_path}\n\n"
+            f"Inspection plan the agent followed:\n{steps_text}\n\n"
+            f"Vision agent's draft answer     : {draft_answer}\n"
+            f"Vision agent's draft explanation: {draft_explanation}\n\n"
+            f"Call verifier_tool ONCE with all these details and return its JSON output exactly."
         )
 
-        span = open_llm_span(
+        tool = self._build_tool(lf_trace=lf_trace)
+        llm = _build_llm(self.backend, self.model, self.api_key)
+
+        verifier_span = open_llm_span(
             lf_trace,
-            name="verifier",
-            input_data={"prompt": prompt, "draft_answer": draft_answer},
+            name="verifier_agent",
+            input_data={"task_description": task_description, "draft_answer": draft_answer},
             model=self.model,
             metadata={"backend": self.backend},
         )
 
-        image_path = getattr(sample, "image_path", "") or ""
-        has_image = image_path and Path(image_path).exists()
+        agent = Agent(
+            role="Chart QA Verifier",
+            goal=(
+                "Audit the vision agent's draft answer by calling verifier_tool exactly once "
+                "and returning the JSON result with 'verdict', 'answer', and 'reasoning'."
+            ),
+            backstory=(
+                "You are a precise chart QA auditor. You use verifier_tool to inspect the chart "
+                "image alongside the draft answer, identify any errors, and decide to CONFIRM or REVISE."
+            ),
+            llm=llm,
+            tools=[tool],
+            verbose=False,
+            allow_delegation=False,
+            max_iter=2,
+        )
 
-        try:
-            if has_image:
-                if self.backend == "openai":
-                    raw = _call_vlm_openai(prompt, image_path, self.model, self.api_key)
-                elif self.backend == "gemini":
-                    raw = _call_vlm_gemini(prompt, image_path, self.model, self.api_key)
-                else:
-                    raise ValueError(f"Unknown backend: {self.backend!r}")
-            else:
-                # Image missing — cannot verify visually; default to confirm
-                raw = (
-                    '{"verdict": "confirmed", "answer": "'
-                    + draft_answer.replace('"', '\\"')
-                    + '", "reasoning": "Image unavailable; cannot verify visually."}'
-                )
+        task = Task(
+            description=task_description,
+            expected_output='JSON object: {"verdict": "confirmed" | "revised", "answer": "...", "reasoning": "..."}',
+            agent=agent,
+        )
 
-            parsed, parse_ok = parse_strict(raw, required_keys=VERIFIER_REQUIRED_KEYS)
-            if not parsed:
-                parsed = {
-                    "verdict": "confirmed",
-                    "answer": draft_answer,
-                    "reasoning": f"Parse error — defaulting to confirm. Raw: {raw[:120]}",
-                }
-                parse_ok = False
+        crew = Crew(agents=[agent], tasks=[task], verbose=False)
+        result = crew.kickoff()
 
-            # Normalise verdict to known values
-            if parsed.get("verdict", "").lower() not in ("confirmed", "revised"):
-                parsed["verdict"] = "confirmed"
+        raw_text: str = getattr(result, "raw", None) or str(result)
+        parsed, parse_ok = parse_strict(raw_text, required_keys=VERIFIER_REQUIRED_KEYS)
 
-            close_span(span, output=parsed)
-            return prompt, parsed, not parse_ok, raw
+        tool_traces = tool.pop_traces()
 
-        except Exception as exc:
-            fallback = {
+        if not parsed:
+            parsed = {
                 "verdict": "confirmed",
                 "answer": draft_answer,
-                "reasoning": f"Verifier error: {exc}",
+                "reasoning": f"Parse error — defaulting to confirm. Raw: {raw_text[:120]}",
             }
-            close_span(span, output=fallback, error=str(exc))
-            return prompt, fallback, True, ""
+            parse_ok = False
+
+        if parsed.get("verdict", "").lower() not in ("confirmed", "revised"):
+            parsed["verdict"] = "confirmed"
+
+        close_span(verifier_span, output=parsed)
+        return task_description, parsed, not parse_ok, raw_text, tool_traces
diff --git a/src/agentfinvqa/agents/vision_agent.py b/src/agentfinvqa/agents/vision_agent.py
index 28bee45..0529e28 100644
--- a/src/agentfinvqa/agents/vision_agent.py
+++ b/src/agentfinvqa/agents/vision_agent.py
@@ -14,11 +14,12 @@
 from ..langfuse_integration.tracing import close_span, open_llm_span
 from ..tools.vision_qa_tool import VisionQATool
 from ..utils.json_strict import parse_strict
+from ..utils.model_compat import openai_temperature
 
 
 VISION_PROMPT_PATH = Path(__file__).parent / "prompts" / "vision.txt"
 
-VISION_REQUIRED_KEYS = ["answer", "explanation"]
+VISION_REQUIRED_KEYS = ["choice_analysis", "answer", "explanation"]
 
 
 def _load_template() -> str:
@@ -33,6 +34,61 @@ def _load_template() -> str:
     return VISION_PROMPT_PATH.read_text()
 
 
+def _format_choice_blocks(sample: PerceivedSample) -> tuple[str, str]:
+    labeled_choices = sample.metadata.get("choices_labeled") or []
+    if labeled_choices:
+        label_lines = ["Choice labels (letter → text):"]
+        for item in labeled_choices:
+            label_lines.append(f"  {item.get('label')}: {item.get('text')}")
+        return "", "\n".join(label_lines)
+    if sample.choices:
+        return f"Choices: {', '.join(sample.choices)}", ""
+    return "", ""
+
+
+def _format_context_block(sample: PerceivedSample) -> str:
+    if not sample.context:
+        return ""
+    lines = ["Conversation context:"]
+    for turn in sample.context:
+        lines.append(f"  {turn.get('role', 'user')}: {turn.get('content', '')}")
+    return "\n".join(lines)
+
+
+def _format_plan_steps(plan: dict) -> str:
+    steps = plan.get("steps") or []
+    return "\n".join(f"{i + 1}. {step}" for i, step in enumerate(steps))
+
+
+def _format_ocr_block(ocr_result: Optional[dict]) -> str:
+    if not ocr_result:
+        return ""
+    lines = ["Pre-extracted text from chart (use as ground truth for visible text):"]
+    chart_type = (ocr_result.get("chart_type") or "").strip()
+    title = (ocr_result.get("title") or "").strip()
+    if chart_type:
+        lines.append(f"  Chart type : {chart_type}")
+    if title:
+        lines.append(f"  Title      : {title}")
+    x_axis = ocr_result.get("x_axis", {})
+    x_label = (x_axis.get("label") or "").strip()
+    x_ticks = x_axis.get("ticks", [])
+    if x_label or x_ticks:
+        lines.append(f"  X-axis     : label={x_label!r}  ticks={x_ticks}")
+    y_axis = ocr_result.get("y_axis", {})
+    y_label = (y_axis.get("label") or "").strip()
+    y_ticks = y_axis.get("ticks", [])
+    if y_label or y_ticks:
+        lines.append(f"  Y-axis     : label={y_label!r}  ticks={y_ticks}")
+    if ocr_result.get("legend"):
+        lines.append(f"  Legend     : {ocr_result['legend']}")
+    if ocr_result.get("data_labels"):
+        lines.append(f"  Data labels: {ocr_result['data_labels']}")
+    if ocr_result.get("annotations"):
+        lines.append(f"  Annotations: {ocr_result['annotations']}")
+    return "\n".join(lines)
+
+
 def build_vision_task_description(sample: PerceivedSample, plan: dict, ocr_result: Optional[dict] = None) -> str:
     """
     Compose the complete task instruction for the vision agent.
@@ -55,46 +111,16 @@ def build_vision_task_description(sample: PerceivedSample, plan: dict, ocr_resul
         The rendered prompt ready for the vision-capable agent.
     """
     template = _load_template()
-
-    choices_block = ""
-    if sample.choices:
-        choices_block = f"Choices: {', '.join(sample.choices)}"
-
-    context_block = ""
-    if sample.context:
-        lines = ["Conversation context:"]
-        for turn in sample.context:
-            lines.append(f"  {turn.get('role', 'user')}: {turn.get('content', '')}")
-        context_block = "\n".join(lines)
-
-    steps = plan.get("steps", [])
-    plan_steps_block = "\n".join(f"{i + 1}. {s}" for i, s in enumerate(steps))
-
-    ocr_block = ""
-    if ocr_result:
-        lines = ["Pre-extracted text from chart (use as ground truth for visible text):"]
-        if ocr_result.get("chart_type"):
-            lines.append(f"  Chart type : {ocr_result['chart_type']}")
-        if ocr_result.get("title"):
-            lines.append(f"  Title      : {ocr_result['title']}")
-        x = ocr_result.get("x_axis", {})
-        if x.get("label") or x.get("ticks"):
-            lines.append(f"  X-axis     : label={x.get('label', '')!r}  ticks={x.get('ticks', [])}")
-        y = ocr_result.get("y_axis", {})
-        if y.get("label") or y.get("ticks"):
-            lines.append(f"  Y-axis     : label={y.get('label', '')!r}  ticks={y.get('ticks', [])}")
-        if ocr_result.get("legend"):
-            lines.append(f"  Legend     : {ocr_result['legend']}")
-        if ocr_result.get("data_labels"):
-            lines.append(f"  Data labels: {ocr_result['data_labels']}")
-        if ocr_result.get("annotations"):
-            lines.append(f"  Annotations: {ocr_result['annotations']}")
-        ocr_block = "\n".join(lines)
+    choices_block, choice_labels_block = _format_choice_blocks(sample)
+    context_block = _format_context_block(sample)
+    plan_steps_block = _format_plan_steps(plan)
+    ocr_block = _format_ocr_block(ocr_result)
 
     return template.format(
         image_path=sample.image_path,
         question=sample.question,
         choices_block=choices_block,
+        choice_labels_block=choice_labels_block,
         context_block=context_block,
         ocr_block=ocr_block,
         plan_steps_block=plan_steps_block,
@@ -128,7 +154,7 @@ def _build_llm(backend: str, model: str, api_key: Optional[str]) -> LLM:
         return LLM(
             model=model,
             api_key=api_key or os.environ.get("OPENAI_API_KEY", ""),
-            temperature=0,
+            **openai_temperature(model),
         )
     if backend == "gemini":
         return LLM(
@@ -262,11 +288,11 @@ def run(
             role="Chart Reading Vision Agent",
             goal=(
                 "Answer chart questions by calling vision_qa_tool exactly once, "
-                "then output strict JSON with 'answer' and 'explanation'."
+                "then output strict JSON with 'choice_analysis', 'answer', and 'explanation'."
             ),
             backstory=(
                 "You are a precise chart analysis agent. You use vision_qa_tool to "
-                "inspect chart images and produce grounded, evidence-based answers. "
+                "inspect chart images, score each option in 'choice_analysis', and produce grounded answers. "
                 "You follow inspection plans step by step and never hallucinate."
             ),
             llm=llm,
@@ -278,7 +304,7 @@ def run(
 
         task = Task(
             description=task_description,
-            expected_output='JSON object: {"answer": "...", "explanation": "..."}',
+            expected_output='JSON object: {"choice_analysis": {...}, "answer": "...", "explanation": "..."}',
             agent=agent,
         )
 
diff --git a/src/agentfinvqa/datasets/chartqapro_loader.py b/src/agentfinvqa/datasets/chartqapro_loader.py
index bc2f18e..ece569e 100644
--- a/src/agentfinvqa/datasets/chartqapro_loader.py
+++ b/src/agentfinvqa/datasets/chartqapro_loader.py
@@ -11,14 +11,12 @@
 """
 
 import re
-import shutil
 from pathlib import Path
 from typing import Any, List, Optional
 
-import numpy as np
 from datasets import load_dataset
-from PIL import Image as PILImage
 
+from .image_utils import save_image_data
 from .perceived_sample import (
     UNANSWERABLE_ANSWERS,
     UNANSWERABLE_TOKEN,
@@ -99,30 +97,7 @@ def _save_image(image: Any, idx: int, img_dir: Path) -> str:
         The absolute filesystem path to the saved PNG.
     """
     path = img_dir / f"chart_{idx:06d}.png"
-    if path.exists():
-        return str(path)
-    try:
-        if isinstance(image, PILImage.Image):
-            image.save(str(path))
-        elif isinstance(image, bytes):
-            with open(str(path), "wb") as f:
-                f.write(image)
-        elif isinstance(image, dict):
-            # HuggingFace wraps as {"bytes": b"...", "path": "..."}
-            raw = image.get("bytes") or image.get("path")
-            if isinstance(raw, bytes):
-                with open(str(path), "wb") as f:
-                    f.write(raw)
-            elif isinstance(raw, str) and raw:
-                shutil.copy(raw, str(path))
-            else:
-                raise ValueError(f"Unknown image dict keys: {list(image.keys())}")
-        else:
-            PILImage.fromarray(np.array(image)).save(str(path))
-        return str(path)
-    except Exception as e:
-        print(f"  Warning: could not save image row {idx}: {e}")
-        return ""
+    return save_image_data(image, path)
 
 
 def _extract_mcq_choices(question: str) -> Optional[List[str]]:
diff --git a/src/agentfinvqa/datasets/finmme_loader.py b/src/agentfinvqa/datasets/finmme_loader.py
new file mode 100644
index 0000000..dc5f2a5
--- /dev/null
+++ b/src/agentfinvqa/datasets/finmme_loader.py
@@ -0,0 +1,228 @@
+"""FinMME dataset loader → PerceivedSample list.
+
+Dataset: luojunyu/FinMME
+Key columns:
+  id                int        – unique identifier
+  image             Image      – financial chart image
+  question_text     str        – natural language query
+  question_type     str        – dataset-provided category label
+  options           str/list   – MCQ options (optional)
+  answer            str        – reference answer
+  unit              str        – unit metadata (optional)
+  tolerance         float      – numeric tolerance metadata (optional)
+  verified_caption  str        – model-verified caption text
+  related_sentences list[str]  – supporting context sentences
+"""
+
+from __future__ import annotations
+
+import ast
+import json
+import re
+from pathlib import Path
+from typing import Any, List, Optional
+
+from datasets import load_dataset
+
+from .image_utils import save_image_data
+from .perceived_sample import (
+    UNANSWERABLE_ANSWERS,
+    UNANSWERABLE_TOKEN,
+    PerceivedSample,
+    QuestionType,
+)
+
+
+def _map_question_type(raw: Optional[str]) -> QuestionType:
+    """Translate dataset labels into internal QuestionType."""
+    if not raw:
+        return QuestionType.STANDARD
+    label = raw.strip().lower()
+    if any(term in label for term in ("choice", "mcq", "multiple")):
+        return QuestionType.MCQ
+    if "conversation" in label or "conversational" in label:
+        return QuestionType.CONVERSATIONAL
+    if "hypothetical" in label or "what if" in label:
+        return QuestionType.HYPOTHETICAL
+    if label in {"unanswerable", "cannot answer", "not answerable"}:
+        return QuestionType.UNANSWERABLE
+    return QuestionType.STANDARD
+
+
+def _normalize_answer(answer: Any, qtype: QuestionType) -> str:
+    """Convert reference answers into canonical strings."""
+    text = "" if answer is None else str(answer)
+    if qtype == QuestionType.UNANSWERABLE:
+        return UNANSWERABLE_TOKEN
+    if text.strip().lower() in UNANSWERABLE_ANSWERS:
+        return UNANSWERABLE_TOKEN
+    return text.strip()
+
+
+def _clean_options(values: List[str]) -> Optional[List[str]]:
+    cleaned = [opt.strip() for opt in values if isinstance(opt, str) and opt.strip()]
+    return cleaned or None
+
+
+def _parse_options(raw: Any) -> Optional[List[str]]:
+    """Best-effort parser for options stored as string/list/JSON."""
+    if raw is None:
+        return None
+
+    cleaned: Optional[List[str]] = None
+    if isinstance(raw, list):
+        cleaned = _clean_options([str(opt) for opt in raw])
+    elif isinstance(raw, dict):
+        cleaned = _clean_options([str(v) for v in raw.values()])
+    else:
+        text = str(raw).strip()
+        if text:
+            for parser in (json.loads, ast.literal_eval):
+                try:
+                    parsed = parser(text)
+                except Exception:
+                    continue
+                if isinstance(parsed, list):
+                    cleaned = _clean_options([str(opt) for opt in parsed])
+                    break
+            if cleaned is None:
+                labeled = re.findall(r"(?:^|\n)\s*[A-H][\).:\-]\s*([^\n]+)", text)
+                if labeled:
+                    cleaned = _clean_options(labeled)
+                else:
+                    parts = re.split(r"(?:\|\||\||;|\n)+", text)
+                    cleaned = _clean_options(parts)
+
+    return cleaned
+
+
+def _build_sample(row_idx: int, row: dict, img_dir: Path) -> PerceivedSample:
+    """Normalize a FinMME dataset row into a PerceivedSample."""
+    question = (row.get("question_text") or "").strip()
+    if not question:
+        raise ValueError(f"Row {row_idx} missing question_text")
+
+    qtype_raw = row.get("question_type") or ""
+    qtype = _map_question_type(qtype_raw)
+    answer = _normalize_answer(row.get("answer"), qtype)
+    options = _parse_options(row.get("options"))
+
+    label_map: dict[str, str] | None = None
+    if options:
+        labels = [chr(ord("A") + idx) for idx in range(len(options))]
+        label_map = dict(zip(labels, options))
+
+    row_id = row.get("id")
+    row_id_int = row_idx
+    if row_id is not None:
+        try:
+            row_id_int = int(row_id)
+        except (TypeError, ValueError):
+            row_id_int = row_idx
+
+    image_path = ""
+    image = row.get("image")
+    if image is not None:
+        image_path = save_image_data(image, img_dir / f"finmme_{row_id_int:06d}.png")
+
+    answer_raw = row.get("answer")
+    answer_label = str(answer_raw).strip() if answer_raw is not None else ""
+    answer = _normalize_answer(answer_raw, qtype)
+    if label_map and answer_label:
+        normalized_label = answer_label.replace(" ", "").upper()
+        if normalized_label in label_map:
+            answer = label_map[normalized_label]
+        elif all((ch in label_map) for ch in normalized_label):
+            answer = " + ".join(label_map[ch] for ch in normalized_label)
+
+    metadata = {
+        "dataset": "FinMME",
+        "question_type_raw": qtype_raw,
+        "unit": row.get("unit"),
+        "tolerance": row.get("tolerance"),
+        "verified_caption": row.get("verified_caption"),
+        "related_sentences": row.get("related_sentences"),
+        "row_idx": row_idx,
+        "sample_id": row_id,
+    }
+    if label_map:
+        metadata["choice_map"] = label_map
+        metadata["answer_label"] = answer_label
+        metadata["choices_labeled"] = [{"label": label, "text": text} for label, text in label_map.items()]
+        metadata["expected_answer_text"] = answer
+
+    return PerceivedSample(
+        sample_id=f"finmme_{row_id_int:06d}",
+        image_path=image_path,
+        question=question,
+        expected_output=answer,
+        question_type=qtype,
+        choices=options,
+        metadata=metadata,
+    )
+
+
+def load_finmme(
+    split: str = "train",
+    n: Optional[int] = None,
+    image_dir: Optional[str] = None,
+    cache_dir: Optional[str] = None,
+    hf_token: Optional[str] = None,
+) -> List[PerceivedSample]:
+    """
+    Load FinMME samples as PerceivedSample objects.
+
+    Parameters
+    ----------
+    split : str, default 'train'
+        Dataset split to load.
+    n : int, optional
+        Limit of samples to materialize.
+    image_dir : str, optional
+        Directory for cached chart images.
+    cache_dir : str, optional
+        HuggingFace datasets cache override.
+    hf_token : str, optional
+        Token for gated/private datasets.
+
+    Returns
+    -------
+    list[PerceivedSample]
+        Normalized FinMME records.
+    """
+    if split.lower().startswith("test"):
+        suffix = split[4:]
+        mapped_split = "train" + suffix
+        if suffix and not suffix.startswith(":"):
+            mapped_split = "train" + suffix
+        print(f"FinMME dataset only provides a 'train' split. Using '{mapped_split}' instead of '{split}'.")
+        split = mapped_split
+
+    if image_dir is None:
+        image_dir = "data/finmme_images"
+    img_dir = Path(image_dir)
+    img_dir.mkdir(parents=True, exist_ok=True)
+
+    kwargs: dict = {}
+    if cache_dir:
+        kwargs["cache_dir"] = cache_dir
+    if hf_token:
+        kwargs["token"] = hf_token
+
+    print(f"Loading luojunyu/FinMME split={split} …")
+    ds = load_dataset("luojunyu/FinMME", split=split, **kwargs)
+    total_rows = len(ds)
+
+    samples: List[PerceivedSample] = []
+    for row_idx, row in enumerate(ds):
+        try:
+            sample = _build_sample(row_idx, row, img_dir)
+        except Exception as exc:
+            print(f"  Warning: skipping row {row_idx}: {exc}")
+            continue
+        samples.append(sample)
+        if n is not None and len(samples) >= n:
+            break
+
+    print(f"  → {len(samples)} samples loaded (from {total_rows} rows)")
+    return samples
diff --git a/src/agentfinvqa/datasets/image_utils.py b/src/agentfinvqa/datasets/image_utils.py
new file mode 100644
index 0000000..4462cb1
--- /dev/null
+++ b/src/agentfinvqa/datasets/image_utils.py
@@ -0,0 +1,58 @@
+"""Helper utilities for dataset image persistence."""
+
+from __future__ import annotations
+
+import shutil
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+from PIL import Image as PILImage
+
+
+def save_image_data(image: Any, path: Path) -> str:
+    """
+    Persist dataset-provided image content to ``path``.
+
+    Parameters
+    ----------
+    image : Any
+        A PIL Image, numpy array, HF image dict, or binary bytes.
+    path : Path
+        Destination file path (parent directories must already exist).
+
+    Returns
+    -------
+    str
+        Absolute path to the saved file, or empty string on failure.
+    """
+    path = path.resolve()
+    result = ""
+    if path.exists():
+        return str(path)
+
+    try:
+        if isinstance(image, PILImage.Image):
+            image.save(str(path))
+            result = str(path)
+        elif isinstance(image, bytes):
+            path.write_bytes(image)
+            result = str(path)
+        elif isinstance(image, dict):
+            raw = image.get("bytes") or image.get("path")
+            if isinstance(raw, bytes):
+                path.write_bytes(raw)
+                result = str(path)
+            elif isinstance(raw, str) and raw:
+                shutil.copy(raw, str(path))
+                result = str(path)
+            else:
+                raise ValueError(f"Unknown image dict keys: {list(image.keys())}")
+        else:
+            # Fallback: try numpy array-like → PIL
+            PILImage.fromarray(np.array(image)).save(str(path))
+            result = str(path)
+    except Exception as exc:  # pragma: no cover - log + continue
+        print(f"  Warning: could not save image to {path}: {exc}")
+
+    return result
diff --git a/src/agentfinvqa/eval/dashboard.py b/src/agentfinvqa/eval/dashboard.py
index 9801aec..d5a9de4 100644
--- a/src/agentfinvqa/eval/dashboard.py
+++ b/src/agentfinvqa/eval/dashboard.py
@@ -50,6 +50,9 @@
 # ---------------------------------------------------------------------------
 
 
+REPO_ROOT = Path(__file__).resolve().parents[3]
+
+
 @st.cache_data
 def load_metrics(path: str) -> pd.DataFrame:
     """Load a metrics JSONL file and return it as a DataFrame."""
@@ -86,16 +89,75 @@ def load_meps(mep_dir: str) -> dict:
 st.sidebar.markdown("---")
 st.sidebar.subheader("Data Paths")
 
-mep_dir_input = st.sidebar.text_input(
+
+def _relative(path: Path) -> str:
+    try:
+        return str(path.relative_to(REPO_ROOT))
+    except ValueError:
+        return str(path)
+
+
+def _list_metric_files() -> list[str]:
+    candidates: list[str] = []
+    out_dir = REPO_ROOT / "output"
+    if out_dir.exists():
+        for p in sorted(out_dir.glob("metrics*.jsonl")):
+            candidates.append(_relative(p))
+    return candidates
+
+
+def _list_taxonomy_files() -> list[str]:
+    candidates: list[str] = []
+    out_dir = REPO_ROOT / "output"
+    if out_dir.exists():
+        for p in sorted(out_dir.glob("taxonomy*.jsonl")):
+            candidates.append(_relative(p))
+    return candidates
+
+
+def _list_mep_dirs() -> list[str]:
+    dirs: list[str] = []
+    base = REPO_ROOT / "meps"
+    if not base.exists():
+        return dirs
+    for path in sorted(base.rglob("*")):
+        if path.is_dir() and any(path.glob("*.json")):
+            dirs.append(_relative(path))
+    return dirs
+
+
+def sidebar_path_picker(label: str, default: str, options: list[str], help_text: str) -> str:
+    """Select a file path from the sidebar options or enter a custom value."""
+    if not options:
+        return st.sidebar.text_input(label, value=default, help=help_text)
+    choices = ["<custom>"] + options
+    try:
+        default_idx = choices.index(default) if default in choices else 0
+    except ValueError:
+        default_idx = 0
+    selection = st.sidebar.selectbox(label, options=choices, index=default_idx, help=help_text)
+    if selection == "<custom>":
+        return st.sidebar.text_input(f"{label} (custom)", value=default, help=help_text)
+    return selection
+
+
+mep_dir_input = sidebar_path_picker(
     "MEP directory",
-    value="meps/gemini_gemini/chartqapro/test",
-    help="Directory containing .json MEP files",
+    default="meps/gemini_gemini/chartqapro/test",
+    options=_list_mep_dirs(),
+    help_text="Directory containing .json MEP files",
+)
+metrics_input = sidebar_path_picker(
+    "metrics.jsonl",
+    default="output/metrics.jsonl",
+    options=_list_metric_files(),
+    help_text="Output of eval_outputs.py",
 )
-metrics_input = st.sidebar.text_input("metrics.jsonl", value="output/metrics.jsonl", help="Output of eval_outputs.py")
-taxonomy_input = st.sidebar.text_input(
+taxonomy_input = sidebar_path_picker(
     "taxonomy.jsonl (optional)",
-    value="output/taxonomy.jsonl",
-    help="Output of error_taxonomy.py",
+    default="output/taxonomy.jsonl",
+    options=_list_taxonomy_files(),
+    help_text="Output of error_taxonomy.py",
 )
 
 st.sidebar.markdown("---")
@@ -130,7 +192,12 @@ def load_meps(mep_dir: str) -> dict:
     help="Filter by question type",
 )
 
-verdict_options = ["confirmed", "revised", "skipped"]
+default_verdicts = {"confirmed", "revised", "skipped"}
+if df_metrics is not None and "verifier_verdict" in df_metrics.columns:
+    data_verdicts = set(df_metrics["verifier_verdict"].dropna().unique().tolist())
+    verdict_options = sorted(default_verdicts.union(data_verdicts))
+else:
+    verdict_options = sorted(default_verdicts)
 selected_verdicts = st.sidebar.multiselect(
     "Verifier verdict",
     options=verdict_options,
@@ -255,12 +322,17 @@ def load_meps(mep_dir: str) -> dict:
         st.subheader("Failure Taxonomy (Pass 4)")
 
         tax = df_tax.copy()
-        if selected_failures:
+        if "failure_type" not in tax.columns:
+            st.warning("Taxonomy file does not include 'failure_type'. Regenerate with eval.error_taxonomy.")
+            tax = None
+        elif selected_failures:
             tax = tax[tax["failure_type"].isin(selected_failures)]
 
         col_c, col_d = st.columns([2, 1])
         with col_c:
-            if HAS_MPL:
+            if tax is None:
+                st.info("No taxonomy data available.")
+            elif HAS_MPL:
                 counts = tax["failure_type"].value_counts()
                 palette = {
                     "correct": "#00b894",
@@ -291,11 +363,12 @@ def load_meps(mep_dir: str) -> dict:
                 st.dataframe(tax["failure_type"].value_counts())
 
         with col_d:
-            st.dataframe(
-                tax["failure_type"].value_counts().rename("count").reset_index(),
-                use_container_width=True,
-                height=300,
-            )
+            if tax is not None:
+                st.dataframe(
+                    tax["failure_type"].value_counts().rename("count").reset_index(),
+                    use_container_width=True,
+                    height=300,
+                )
 
     # ── Judge scores ──────────────────────────────────────────────────────
     judge_cols = [c for c in df.columns if c.startswith("judge_") and df[c].dtype in ["float64", "int64"]]
@@ -383,6 +456,20 @@ def load_meps(mep_dir: str) -> dict:
             f"**Type:** `{sample.get('question_type', '—')}` &nbsp;|&nbsp; **Expected:** `{sample.get('expected_output', '—')}`"
         )
 
+        # MCQ choices
+        meta = sample.get("metadata", {})
+        choices_labeled = meta.get("choices_labeled", [])
+        expected_label = meta.get("answer_label", "")
+        if choices_labeled:
+            with st.expander("Choices", expanded=True):
+                for item in choices_labeled:
+                    label = item.get("label", "")
+                    text = item.get("text", "")
+                    if label == expected_label:
+                        st.markdown(f"**{label}. {text}** ✓")
+                    else:
+                        st.markdown(f"{label}. {text}")
+
         # Accuracy badge
         acc = m_row.get("answer_accuracy", None)
         if acc is not None:
diff --git a/src/agentfinvqa/eval/error_taxonomy.py b/src/agentfinvqa/eval/error_taxonomy.py
index 267d8a9..8ad029f 100644
--- a/src/agentfinvqa/eval/error_taxonomy.py
+++ b/src/agentfinvqa/eval/error_taxonomy.py
@@ -17,7 +17,7 @@
 import json
 import os
 from pathlib import Path
-from typing import Optional
+from typing import Any, Optional, cast
 
 from dotenv import load_dotenv
 from google import genai
@@ -120,10 +120,12 @@ def _call_vlm_openai(prompt: str, image_path: str, model: str, api_key: Optional
 def _call_vlm_gemini(prompt: str, image_path: str, model: str, api_key: Optional[str]) -> str:
     client = genai.Client(api_key=api_key or os.environ.get("GEMINI_API_KEY", ""))
     b64, mime = _encode_image(image_path)
-    response = client.models.generate_content(
+    image_part = genai.types.Part.from_bytes(data=b64, mime_type=f"image/{mime}")
+    models_api = cast(Any, client.models)
+    response = models_api.generate_content(
         model=model,
-        contents=[genai.types.Part.from_bytes(data=b64, mime_type=f"image/{mime}"), prompt],
-        config=genai.types.GenerateContentConfig(temperature=0, max_output_tokens=256),
+        contents=[image_part, prompt],
+        config=genai.types.GenerateContentConfig(temperature=0, max_output_tokens=768),
     )
     return response.text or ""
 
@@ -184,8 +186,8 @@ def classify_failure(
                 raise ValueError(f"Unknown backend: {backend!r}")
         # Image missing — use text-only fallback via the same models
         elif backend == "openai":
-            client = OpenAI(api_key=api_key or os.environ.get("OPENAI_API_KEY", ""))
-            resp = client.chat.completions.create(
+            openai_client = OpenAI(api_key=api_key or os.environ.get("OPENAI_API_KEY", ""))
+            resp = openai_client.chat.completions.create(
                 model=model,
                 messages=[
                     {
@@ -198,11 +200,12 @@ def classify_failure(
             )
             raw = resp.choices[0].message.content or ""
         elif backend == "gemini":
-            client = genai.Client(api_key=api_key or os.environ.get("GEMINI_API_KEY", ""))
-            resp = client.models.generate_content(
+            gemini_client = genai.Client(api_key=api_key or os.environ.get("GEMINI_API_KEY", ""))
+            models_api = cast(Any, gemini_client.models)
+            resp = models_api.generate_content(
                 model=model,
                 contents=[prompt + "\n\n(Note: chart image unavailable)"],
-                config=genai.types.GenerateContentConfig(temperature=0, max_output_tokens=256),
+                config=genai.types.GenerateContentConfig(temperature=0, max_output_tokens=768),
             )
             raw = resp.text or ""
         else:
diff --git a/src/agentfinvqa/eval/eval_outputs.py b/src/agentfinvqa/eval/eval_outputs.py
index 138301b..49034af 100644
--- a/src/agentfinvqa/eval/eval_outputs.py
+++ b/src/agentfinvqa/eval/eval_outputs.py
@@ -79,6 +79,63 @@ def score_unanswerable(expected: str, predicted: str) -> Optional[float]:
     return None
 
 
+# ---------------------------------------------------------------------------
+# Choice mapping helpers (for datasets like FinMME)
+# ---------------------------------------------------------------------------
+
+
+def _normalize_text(text: str) -> str:
+    text = text.lower()
+    text = re.sub(r"[^a-z0-9]+", " ", text)
+    return re.sub(r"\s+", " ", text).strip()
+
+
+def _parse_choice_labels(answer: str, choice_map: dict[str, str]) -> list[str]:
+    """Extract ordered choice labels (e.g. ['A','C']) from an answer string."""
+    if not answer or not choice_map:
+        return []
+    answer = answer.strip()
+    # Direct match against full choice text
+    normalized_map = {_normalize_text(text): label for label, text in choice_map.items()}
+    normalized_answer = _normalize_text(answer)
+    if normalized_answer in normalized_map:
+        return [normalized_map[normalized_answer]]
+
+    # Letter combo detection (e.g. "ACD")
+    letters_only = re.sub(r"[^A-Za-z]", "", answer).upper()
+    if letters_only and all(ch in choice_map for ch in letters_only):
+        labels: list[str] = []
+        for ch in letters_only:
+            if ch not in labels:
+                labels.append(ch)
+        return labels
+
+    # Direct substring match against choice text
+    labels = []
+    for norm_text, label in normalized_map.items():
+        if norm_text and norm_text in normalized_answer and label not in labels:
+            labels.append(label)
+    if labels:
+        return labels
+
+    # Split via connectors (+, commas, "and", etc.)
+    parts = re.split(r"\s*(?:\+|,|/|;|&|\band\b|\|)\s*", answer, flags=re.IGNORECASE)
+    for part in parts:
+        norm = _normalize_text(part)
+        if not norm:
+            continue
+        maybe_label = normalized_map.get(norm)
+        if maybe_label and maybe_label not in labels:
+            labels.append(maybe_label)
+    return labels
+
+
+def _labels_to_text(labels: list[str], choice_map: dict[str, str]) -> str:
+    if not labels or not choice_map:
+        return ""
+    return " + ".join(choice_map.get(label, label) for label in labels)
+
+
 # ---------------------------------------------------------------------------
 # Per-MEP evaluation
 # ---------------------------------------------------------------------------
@@ -111,6 +168,15 @@ def evaluate_mep(
     vision_ms = timestamps.get("vision_ms") or 0
     verifier_ms = timestamps.get("verifier_ms") or 0
 
+    metadata = sample.get("metadata") or {}
+    choice_map = metadata.get("choice_map") or {}
+    expected_labels = _parse_choice_labels(metadata.get("answer_label", ""), choice_map)
+    predicted_labels = _parse_choice_labels(predicted, choice_map)
+    if expected_labels:
+        expected = _labels_to_text(expected_labels, choice_map)
+    if predicted_labels:
+        predicted = _labels_to_text(predicted_labels, choice_map)
+
     metrics: dict = {
         "sample_id": sample.get("sample_id", ""),
         "question_type": question_type,
diff --git a/src/agentfinvqa/eval/eval_outputs_batch.py b/src/agentfinvqa/eval/eval_outputs_batch.py
new file mode 100644
index 0000000..94db81f
--- /dev/null
+++ b/src/agentfinvqa/eval/eval_outputs_batch.py
@@ -0,0 +1,190 @@
+r"""Async batch-mode MEP evaluation using the Gemini Batch API.
+
+Three subcommands:
+
+  submit    — upload prompts, create job, save state file, exit immediately
+  status    — check job state without blocking
+  retrieve  — download results and write metrics JSONL (run after job completes)
+
+Usage:
+    # 1. Submit (returns immediately, prints job name)
+    uv run --env-file .env -m agentfinvqa.eval.eval_outputs_batch submit \
+        --mep_dir meps/gemini_gemini/finmme/train[1500:3000] \
+        --out output/metrics_1500_3000.jsonl \
+        --judge_model gemini-2.5-flash-lite
+
+    # 2. Check status any time
+    uv run --env-file .env -m agentfinvqa.eval.eval_outputs_batch status \
+        --state output/metrics_1500_3000.jsonl.batch_state.json
+
+    # 3. Retrieve when done
+    uv run --env-file .env -m agentfinvqa.eval.eval_outputs_batch retrieve \
+        --state output/metrics_1500_3000.jsonl.batch_state.json
+"""
+
+import argparse
+import contextlib
+import json
+import os
+
+from dotenv import load_dotenv
+
+from ..langfuse_integration.client import get_client
+from ..mep.writer import iter_meps
+from .eval_outputs import evaluate_mep
+from .judge_batch import get_job_state, retrieve_batch_results, submit_batch_job
+
+
+load_dotenv()
+
+
+def _state_path(out: str) -> str:
+    return out + ".batch_state.json"
+
+
+def _save_state(state_file: str, job_name: str, mep_dir: str, out: str, model: str) -> None:
+    with open(state_file, "w") as f:
+        json.dump(
+            {
+                "job_name": job_name,
+                "mep_dir": mep_dir,
+                "out": out,
+                "model": model,
+                "commands": {
+                    "status": f"uv run --env-file .env -m agentfinvqa.eval.eval_outputs_batch status --state {state_file}",
+                    "retrieve": f"uv run --env-file .env -m agentfinvqa.eval.eval_outputs_batch retrieve --state {state_file}",
+                },
+            },
+            f,
+            indent=2,
+        )
+    print(f"State saved to {state_file}")
+
+
+def _load_state(state_file: str) -> dict:
+    with open(state_file) as f:
+        return json.load(f)
+
+
+# ---------------------------------------------------------------------------
+# Subcommands
+# ---------------------------------------------------------------------------
+
+
+def cmd_submit(args: argparse.Namespace) -> None:
+    """Submit a batch job and write the local state file."""
+    print(f"Loading MEPs from {args.mep_dir} …")
+    meps = list(iter_meps(args.mep_dir))
+    print(f"Loaded {len(meps)} MEPs")
+
+    job_name = submit_batch_job(meps, model=args.judge_model)
+
+    state_file = _state_path(args.out)
+    os.makedirs(os.path.dirname(args.out) or ".", exist_ok=True)
+    _save_state(state_file, job_name, args.mep_dir, args.out, args.judge_model)
+
+    print(f"\nJob submitted: {job_name}")
+    print(f"Check status : uv run -m agentfinvqa.eval.eval_outputs_batch status --state {state_file}")
+    print(f"Retrieve     : uv run -m agentfinvqa.eval.eval_outputs_batch retrieve --state {state_file}")
+
+
+def cmd_status(args: argparse.Namespace) -> None:
+    """Check the current job state for a submitted batch."""
+    state = _load_state(args.state)
+    job_name = state["job_name"]
+    current = get_job_state(job_name)
+    print(f"Job   : {job_name}")
+    print(f"State : {current}")
+    if current == "JOB_STATE_SUCCEEDED":
+        print(f"Ready to retrieve → uv run -m agentfinvqa.eval.eval_outputs_batch retrieve --state {args.state}")
+    elif current in ("JOB_STATE_FAILED", "JOB_STATE_CANCELLED", "JOB_STATE_EXPIRED"):
+        print("Job did not succeed — resubmit if needed.")
+
+
+def cmd_retrieve(args: argparse.Namespace) -> None:
+    """Download batch results, merge with MEPs, and write metrics."""
+    state = _load_state(args.state)
+    job_name = state["job_name"]
+    mep_dir = state["mep_dir"]
+    out = state["out"]
+
+    # Check state first to give a clear error if not done yet
+    current = get_job_state(job_name)
+    if current != "JOB_STATE_SUCCEEDED":
+        print(f"Job not ready (state={current}). Run 'status' to check again.")
+        return
+
+    print(f"Downloading results for {job_name} …")
+    judge_scores = retrieve_batch_results(job_name)
+
+    print(f"Loading MEPs from {mep_dir} …")
+    meps = list(iter_meps(mep_dir))
+
+    os.makedirs(os.path.dirname(out) or ".", exist_ok=True)
+    count = 0
+    with open(out, "w") as f_out:
+        for mep in meps:
+            sid = mep.get("sample", {}).get("sample_id", "")
+            try:
+                metrics = evaluate_mep(mep, use_judge=False)
+                sample_judge_scores = judge_scores.get(sid, {})
+                for k, v in sample_judge_scores.items():
+                    metrics[f"judge_{k}"] = v
+                lf_trace_id = mep.get("lf_trace_id")
+                if lf_trace_id and sample_judge_scores:
+                    client = get_client()
+                    if client:
+                        for k, v in sample_judge_scores.items():
+                            if isinstance(v, (int, float)):
+                                with contextlib.suppress(Exception):
+                                    client.create_score(trace_id=lf_trace_id, name=f"judge_{k}", value=float(v))
+                f_out.write(json.dumps(metrics) + "\n")
+                count += 1
+            except Exception as exc:
+                print(f"  Error on {sid}: {exc}")
+
+    print(f"Done. {count} metrics written to {out}")
+    # Clean up state file
+    os.unlink(args.state)
+    print(f"State file removed: {args.state}")
+
+
+# ---------------------------------------------------------------------------
+# CLI
+# ---------------------------------------------------------------------------
+
+
+def main() -> None:
+    """CLI for submit/status/retrieve batch evaluation workflows."""
+    parser = argparse.ArgumentParser(
+        description="Async batch MEP evaluation via Gemini Batch API",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    # submit
+    p_submit = sub.add_parser("submit", help="Upload prompts and create batch job")
+    p_submit.add_argument("--mep_dir", required=True)
+    p_submit.add_argument("--out", required=True, help="Output metrics JSONL path (used to name state file)")
+    p_submit.add_argument("--judge_model", default="gemini-2.5-flash-lite")
+
+    # status
+    p_status = sub.add_parser("status", help="Check batch job status")
+    p_status.add_argument("--state", required=True, help="Path to .batch_state.json from submit")
+
+    # retrieve
+    p_retrieve = sub.add_parser("retrieve", help="Download results and write metrics JSONL")
+    p_retrieve.add_argument("--state", required=True, help="Path to .batch_state.json from submit")
+
+    args = parser.parse_args()
+
+    if args.command == "submit":
+        cmd_submit(args)
+    elif args.command == "status":
+        cmd_status(args)
+    elif args.command == "retrieve":
+        cmd_retrieve(args)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/src/agentfinvqa/eval/eval_topk.py b/src/agentfinvqa/eval/eval_topk.py
index babafa7..612981a 100644
--- a/src/agentfinvqa/eval/eval_topk.py
+++ b/src/agentfinvqa/eval/eval_topk.py
@@ -19,7 +19,7 @@
 import json
 import os
 from pathlib import Path
-from typing import List, Optional
+from typing import Any, List, Optional, cast
 
 from dotenv import load_dotenv
 from google import genai
@@ -104,10 +104,12 @@ def _call_gemini_topk(
 ) -> str:
     client = genai.Client(api_key=api_key or os.environ.get("GEMINI_API_KEY", ""))
     data, mime = _encode_image(image_path)
-    resp = client.models.generate_content(
+    image_part = genai.types.Part.from_bytes(data=base64.b64decode(data), mime_type=f"image/{mime}")
+    models_api = cast(Any, client.models)
+    resp = models_api.generate_content(
         model=model,
-        contents=[genai.types.Part.from_bytes(data=base64.b64decode(data), mime_type=f"image/{mime}"), prompt],
-        config=genai.types.GenerateContentConfig(temperature=0.3, max_output_tokens=256),
+        contents=[image_part, prompt],
+        config=genai.types.GenerateContentConfig(temperature=0.3, max_output_tokens=768),
     )
     return resp.text or ""
 
diff --git a/src/agentfinvqa/eval/judge.py b/src/agentfinvqa/eval/judge.py
index 6781706..422fc25 100644
--- a/src/agentfinvqa/eval/judge.py
+++ b/src/agentfinvqa/eval/judge.py
@@ -10,6 +10,7 @@
 from openai import OpenAI
 
 from ..utils.json_strict import parse_strict
+from ..utils.model_compat import openai_temperature
 
 
 _JUDGE_PROMPT = """\
@@ -89,8 +90,8 @@ def _call_llm(prompt: str, backend: str, model: str, api_key: Optional[str]) ->
         resp = client.chat.completions.create(
             model=model,
             messages=[{"role": "user", "content": prompt}],
-            temperature=0,
             max_completion_tokens=512,
+            **openai_temperature(model),
         )
         return resp.choices[0].message.content or ""
 
diff --git a/src/agentfinvqa/eval/judge_batch.py b/src/agentfinvqa/eval/judge_batch.py
new file mode 100644
index 0000000..2ff6e23
--- /dev/null
+++ b/src/agentfinvqa/eval/judge_batch.py
@@ -0,0 +1,248 @@
+"""Gemini Batch API judge for large-scale MEP evaluation.
+
+Submits all judge prompts as a single batch job (50% cost, async).
+Use eval_outputs_batch.py as the CLI entry point.
+"""
+
+import contextlib
+import json
+import os
+import tempfile
+import time
+from typing import Optional
+
+from google import genai
+from google.genai import types
+
+from ..utils.json_strict import parse_strict
+from .judge import _JUDGE_KEYS, _JUDGE_PROMPT, _default_scores
+
+
+def _build_judge_prompt(mep: dict) -> str:
+    """Build the judge prompt string for a single MEP."""
+    sample = mep.get("sample", {})
+    plan = mep.get("plan", {}).get("parsed", {})
+    parsed_vision = mep.get("vision", {}).get("parsed", {})
+    steps_text = "\n".join(f"  {i + 1}. {s}" for i, s in enumerate(plan.get("steps", []))) or "  (none)"
+    return _JUDGE_PROMPT.format(
+        question=sample.get("question", "") or "unknown",
+        expected_answer=sample.get("expected_output", ""),
+        agent_answer=parsed_vision.get("answer", ""),
+        agent_explanation=parsed_vision.get("explanation", ""),
+        plan_steps=steps_text,
+    )
+
+
+_COMPLETED_STATES = {
+    "JOB_STATE_SUCCEEDED",
+    "JOB_STATE_FAILED",
+    "JOB_STATE_CANCELLED",
+    "JOB_STATE_EXPIRED",
+}
+
+
+def _write_requests_jsonl(meps: list[dict], display_name: str) -> str:
+    """Write judge requests to a JSONL temp file and return its path."""
+    with tempfile.NamedTemporaryFile(mode="w", suffix=".jsonl", delete=False) as tmp:
+        for mep in meps:
+            sid = mep.get("sample", {}).get("sample_id", "")
+            entry = {
+                "key": sid,
+                "request": {
+                    "contents": [{"parts": [{"text": _build_judge_prompt(mep)}]}],
+                    "generation_config": {"temperature": 0, "max_output_tokens": 512},
+                },
+            }
+            tmp.write(json.dumps(entry) + "\n")
+        tmp.flush()
+        return tmp.name
+
+
+def _extract_response_text(parsed: dict) -> str:
+    text = ""
+    with contextlib.suppress(KeyError, IndexError, TypeError):
+        text = parsed["response"]["candidates"][0]["content"]["parts"][0]["text"]
+    return text
+
+
+def _parse_batch_content(content: str) -> dict[str, dict]:
+    results: dict[str, dict] = {}
+    errors = 0
+    for line in content.splitlines():
+        if not line.strip():
+            continue
+        try:
+            parsed = json.loads(line)
+            key = parsed.get("key", "")
+            text = _extract_response_text(parsed)
+            if text:
+                scores, _ = parse_strict(text, required_keys=_JUDGE_KEYS)
+                results[key] = scores if scores else _default_scores()
+            else:
+                results[key] = _default_scores()
+                errors += 1
+        except Exception:
+            errors += 1
+    print(f"  Parsed {len(results)} results ({errors} errors)")
+    return results
+
+
+def _require_job_state(job: types.BatchJob) -> str:
+    if job.state is None:
+        raise RuntimeError("Batch job state is missing.")
+    return job.state.name
+
+
+def _require_dest_file(job: types.BatchJob) -> str:
+    if job.dest is None or job.dest.file_name is None:
+        raise RuntimeError("Batch job output file is missing.")
+    return job.dest.file_name
+
+
+def batch_judge_meps(
+    meps: list[dict],
+    model: str = "gemini-2.5-flash-lite",
+    api_key: Optional[str] = None,
+    poll_interval: int = 30,
+    display_name: str = "agentfinvqa-judge-batch",
+) -> dict[str, dict]:
+    """Submit all MEPs to the Gemini Batch API and return {sample_id: scores}.
+
+    Uses the file-based approach (recommended for >20 requests).
+    Blocks until the job completes or fails — run in a screen/tmux session
+    or via SLURM for large batches.
+
+    Parameters
+    ----------
+    meps : list of dict
+        MEP dicts to judge.
+    model : str
+        Gemini model name (must support Batch API).
+    api_key : str, optional
+        Gemini API key; defaults to GEMINI_API_KEY env var.
+    poll_interval : int
+        Seconds between status polls.
+    display_name : str
+        Display name for the batch job.
+
+    Returns
+    -------
+    dict[str, dict]
+        Maps sample_id → judge score dict (same keys as judge_mep).
+    """
+    client = genai.Client(api_key=api_key or os.environ.get("GEMINI_API_KEY", ""))
+
+    # Build JSONL — one request per MEP
+    tmp_path = _write_requests_jsonl(meps, display_name)
+
+    try:
+        # Upload JSONL
+        print(f"  Uploading {len(meps)} judge requests …")
+        uploaded = client.files.upload(
+            file=tmp_path,
+            config=types.UploadFileConfig(display_name=display_name, mime_type="jsonl"),
+        )
+        if uploaded.name is None:
+            raise RuntimeError("Upload succeeded without a file name.")
+        print(f"  Uploaded: {uploaded.name}")
+
+        # Create batch job
+        job = client.batches.create(
+            model=model,
+            src=uploaded.name,
+            config={"display_name": display_name},
+        )
+        if job.name is None:
+            raise RuntimeError("Batch job creation returned no job name.")
+        job_name = job.name
+        print(f"  Batch job created: {job_name}")
+
+        # Poll until done
+        while True:
+            job = client.batches.get(name=job_name)
+            state = _require_job_state(job)
+            if state in _COMPLETED_STATES:
+                break
+            print(f"  [{state}] waiting {poll_interval}s …")
+            time.sleep(poll_interval)
+
+        print(f"  Batch job finished: {state}")
+
+        if state != "JOB_STATE_SUCCEEDED":
+            print(f"  Error: {getattr(job, 'error', 'unknown')}")
+            return {}
+
+        # Download and parse results
+        file_name = _require_dest_file(job)
+        content = client.files.download(file=file_name).decode("utf-8")
+        return _parse_batch_content(content)
+
+    finally:
+        os.unlink(tmp_path)
+
+
+# ---------------------------------------------------------------------------
+# Split submit / retrieve for async (fire-and-forget) workflows
+# ---------------------------------------------------------------------------
+
+
+def submit_batch_job(
+    meps: list[dict],
+    model: str = "gemini-2.5-flash-lite",
+    api_key: Optional[str] = None,
+    display_name: str = "agentfinvqa-judge-batch",
+) -> str:
+    """Upload judge prompts and create a Gemini Batch job. Returns the job name.
+
+    Does NOT poll — call retrieve_batch_results later with the returned job name.
+    """
+    client = genai.Client(api_key=api_key or os.environ.get("GEMINI_API_KEY", ""))
+
+    tmp_path = _write_requests_jsonl(meps, display_name)
+
+    try:
+        print(f"  Uploading {len(meps)} judge requests …")
+        uploaded = client.files.upload(
+            file=tmp_path,
+            config=types.UploadFileConfig(display_name=display_name, mime_type="jsonl"),
+        )
+        if uploaded.name is None:
+            raise RuntimeError("Upload succeeded without a file name.")
+        job = client.batches.create(
+            model=model,
+            src=uploaded.name,
+            config={"display_name": display_name},
+        )
+        if job.name is None:
+            raise RuntimeError("Batch job creation returned no job name.")
+        print(f"  Batch job created: {job.name}")
+        return job.name
+    finally:
+        os.unlink(tmp_path)
+
+
+def get_job_state(job_name: str, api_key: Optional[str] = None) -> str:
+    """Return the current state string for a batch job."""
+    client = genai.Client(api_key=api_key or os.environ.get("GEMINI_API_KEY", ""))
+    job = client.batches.get(name=job_name)
+    return _require_job_state(job)
+
+
+def retrieve_batch_results(
+    job_name: str,
+    api_key: Optional[str] = None,
+) -> dict[str, dict]:
+    """Download and parse results for a completed batch job.
+
+    Raises RuntimeError if the job has not succeeded yet.
+    """
+    client = genai.Client(api_key=api_key or os.environ.get("GEMINI_API_KEY", ""))
+    job = client.batches.get(name=job_name)
+    state = _require_job_state(job)
+
+    if state != "JOB_STATE_SUCCEEDED":
+        raise RuntimeError(f"Job {job_name} is not complete (state={state})")
+
+    file_name = _require_dest_file(job)
+    content = client.files.download(file=file_name).decode("utf-8")
+    return _parse_batch_content(content)
diff --git a/src/agentfinvqa/langfuse_integration/client.py b/src/agentfinvqa/langfuse_integration/client.py
index 9491413..d787dcc 100644
--- a/src/agentfinvqa/langfuse_integration/client.py
+++ b/src/agentfinvqa/langfuse_integration/client.py
@@ -1,29 +1,49 @@
-"""Langfuse client singleton with graceful degradation.
+"""Langfuse client helper with optional tracing instrumentation."""
 
-Returns None when LANGFUSE_PUBLIC_KEY / LANGFUSE_SECRET_KEY are not set or
-langfuse is not installed, so every caller can guard with ``if client:``.
-"""
+from __future__ import annotations
 
 import os
 from contextlib import suppress
+from typing import Protocol, cast
 
 from dotenv import load_dotenv
 from langfuse import Langfuse
 
 
-try:
-    from openinference.instrumentation.google_genai import GoogleGenAIInstrumentor
+class _Instrumentor(Protocol):
+    """Minimal interface for instrumentation helpers used at runtime."""
+
+    def instrument(self) -> None:
+        """Activate automatic tracing hooks."""
 
-    _google_instrumentor = GoogleGenAIInstrumentor()
-except Exception:
-    _google_instrumentor = None
 
 try:
-    from openinference.instrumentation.openai import OpenAIInstrumentor
+    from openinference.instrumentation.google_genai import GoogleGenAIInstrumentor as _GoogleInstrumentorImpl
+except Exception:  # pragma: no cover - optional dependency
+    _GoogleInstrumentor: type[_Instrumentor] | None = None
+else:
+    _GoogleInstrumentor = cast(type[_Instrumentor], _GoogleInstrumentorImpl)
+
+try:
+    from openinference.instrumentation.openai import OpenAIInstrumentor as _OpenAIInstrumentorImpl
+except Exception:  # pragma: no cover - optional dependency
+    _OpenAIInstrumentor: type[_Instrumentor] | None = None
+else:
+    _OpenAIInstrumentor = cast(type[_Instrumentor], _OpenAIInstrumentorImpl)
+
+
+def _build_instrumentor(cls: type[_Instrumentor] | None) -> _Instrumentor | None:
+    """Instantiate an instrumentation helper, swallowing runtime errors."""
+    if cls is None:
+        return None
+    try:
+        return cls()
+    except Exception:
+        return None
+
 
-    _openai_instrumentor = OpenAIInstrumentor()
-except Exception:
-    _openai_instrumentor = None
+_google_instrumentor = _build_instrumentor(_GoogleInstrumentor)
+_openai_instrumentor = _build_instrumentor(_OpenAIInstrumentor)
 
 
 _client = None
diff --git a/src/agentfinvqa/langfuse_integration/dataset.py b/src/agentfinvqa/langfuse_integration/dataset.py
index e810bc9..aa5eb70 100644
--- a/src/agentfinvqa/langfuse_integration/dataset.py
+++ b/src/agentfinvqa/langfuse_integration/dataset.py
@@ -1,4 +1,4 @@
-"""Register ChartQAPro samples as a Langfuse Dataset.
+"""Register supported dataset samples as a Langfuse Dataset.
 
 Usage:
     python -m agentfinvqa.langfuse_integration.dataset \
@@ -6,14 +6,42 @@
 """
 
 import argparse
-from typing import Any, List, Optional
+from collections.abc import Callable
+from typing import List, Optional, Sequence, TypedDict
 
 from ..datasets.chartqapro_loader import load_chartqapro
+from ..datasets.finmme_loader import load_finmme
+from ..datasets.perceived_sample import PerceivedSample
 from .client import get_client
 
 
+DatasetLoader = Callable[..., List[PerceivedSample]]
+
+
+class DatasetLoaderConfig(TypedDict):
+    """Configuration describing how to load and label a dataset for Langfuse."""
+
+    loader: DatasetLoader
+    display_name: str
+    default_image_dir: str
+
+
+DATASET_LOADERS: dict[str, DatasetLoaderConfig] = {
+    "chartqapro": {
+        "loader": load_chartqapro,
+        "display_name": "ChartQAPro",
+        "default_image_dir": "data/chartqapro_images",
+    },
+    "finmme": {
+        "loader": load_finmme,
+        "display_name": "FinMME",
+        "default_image_dir": "data/finmme_images",
+    },
+}
+
+
 def register_dataset(
-    samples: List[Any],
+    samples: Sequence[PerceivedSample],
     dataset_name: str = "ChartQAPro",
     split: str = "test",
 ) -> Optional[str]:
@@ -43,7 +71,7 @@ def register_dataset(
     name = f"{dataset_name}_{split}"
     try:
         client.create_dataset(name=name)
-        [
+        for s in samples:
             client.create_dataset_item(
                 dataset_name=name,
                 input={
@@ -55,8 +83,6 @@ def register_dataset(
                 },
                 expected_output=s.expected_output,
             )
-            for s in samples
-        ]
         print(f"[langfuse] Registered {len(samples)} samples → dataset '{name}'")
         return name
     except Exception as exc:
@@ -66,21 +92,28 @@ def register_dataset(
 
 def main() -> None:
     """
-    Command-line interface for registering ChartQAPro datasets.
+    Command-line interface for registering supported datasets.
 
     Returns
     -------
     None
     """
-    parser = argparse.ArgumentParser(description="Register ChartQAPro samples as Langfuse dataset")
+    parser = argparse.ArgumentParser(description="Register dataset samples as Langfuse dataset")
+    parser.add_argument("--dataset", default="chartqapro", choices=sorted(DATASET_LOADERS.keys()))
     parser.add_argument("--split", default="test")
     parser.add_argument("--n", type=int, default=25)
-    parser.add_argument("--image_dir", default="data/chartqapro_images")
+    parser.add_argument("--image_dir", default=None)
     parser.add_argument("--cache_dir", default=None)
     args = parser.parse_args()
 
-    samples = load_chartqapro(split=args.split, n=args.n, image_dir=args.image_dir, cache_dir=args.cache_dir)
-    register_dataset(samples, split=args.split)
+    dataset_key = args.dataset.lower()
+    cfg = DATASET_LOADERS[dataset_key]
+    loader = cfg["loader"]
+    display_name = cfg["display_name"]
+    image_dir = args.image_dir or cfg["default_image_dir"]
+
+    samples = loader(split=args.split, n=args.n, image_dir=image_dir, cache_dir=args.cache_dir)
+    register_dataset(samples, dataset_name=display_name, split=args.split)
 
 
 if __name__ == "__main__":
diff --git a/src/agentfinvqa/langfuse_integration/tracing.py b/src/agentfinvqa/langfuse_integration/tracing.py
index 99827a0..30fe590 100644
--- a/src/agentfinvqa/langfuse_integration/tracing.py
+++ b/src/agentfinvqa/langfuse_integration/tracing.py
@@ -86,6 +86,7 @@ def sample_trace(
     question_type: str,
     config_name: str,
     run_id: str,
+    dataset_slug: str = "chartqapro",
     project_name: str = "chartqapro-eval",
 ) -> Generator[Optional["_TraceHandle"], None, None]:
     """
@@ -107,6 +108,8 @@ def sample_trace(
         The evaluation configuration used.
     run_id : str
         The unique ID of the pipeline run.
+    dataset_slug : str, default 'chartqapro'
+        Dataset identifier for trace naming.
     project_name : str, default 'chartqapro-eval'
         Langfuse project identifier (ignored in v4; use SDK config).
 
@@ -122,7 +125,7 @@ def sample_trace(
 
     with (
         client.start_as_current_observation(  # type: ignore[attr-defined]
-            name=f"chartqapro/{sample_id}",
+            name=f"{dataset_slug}/{sample_id}",
             as_type="span",
             input={"question": question, "expected_output": expected_output},
             metadata={
diff --git a/src/agentfinvqa/mep/schema.py b/src/agentfinvqa/mep/schema.py
index 1ae7a3e..f56fb2b 100644
--- a/src/agentfinvqa/mep/schema.py
+++ b/src/agentfinvqa/mep/schema.py
@@ -119,6 +119,7 @@ class MEPVerifier:
     parsed: Dict[str, Any] = field(default_factory=dict)  # {verdict, answer, reasoning}
     parse_error: bool = False
     verdict: str = "skipped"  # "confirmed" | "revised" | "skipped"
+    tool_trace: List[Dict] = field(default_factory=list)
 
 
 @dataclass
diff --git a/src/agentfinvqa/runner/run_generate_meps.py b/src/agentfinvqa/runner/run_generate_meps.py
index 9aa5ad3..6356ce7 100644
--- a/src/agentfinvqa/runner/run_generate_meps.py
+++ b/src/agentfinvqa/runner/run_generate_meps.py
@@ -12,11 +12,12 @@
 
 import argparse
 import contextlib
+import json
 import traceback
 import uuid
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from pathlib import Path
-from typing import Any, Optional
+from typing import Any, Callable, Optional, TypedDict
 
 from dotenv import load_dotenv
 
@@ -24,6 +25,7 @@
 from ..agents.verifier_agent import VerifierAgent
 from ..agents.vision_agent import VisionAgent
 from ..datasets.chartqapro_loader import load_chartqapro
+from ..datasets.finmme_loader import load_finmme
 from ..datasets.perceived_sample import PerceivedSample
 from ..langfuse_integration.client import get_client
 from ..langfuse_integration.dataset import register_dataset
@@ -87,6 +89,30 @@
     },
 }
 
+DatasetLoader = Callable[..., list[PerceivedSample]]
+
+
+class DatasetConfig(TypedDict):
+    """Loader metadata for supported evaluation datasets."""
+
+    loader: DatasetLoader
+    display_name: str
+    default_image_dir: str
+
+
+DATASET_CONFIGS: dict[str, DatasetConfig] = {
+    "chartqapro": {
+        "loader": load_chartqapro,
+        "display_name": "ChartQAPro",
+        "default_image_dir": "data/chartqapro_images",
+    },
+    "finmme": {
+        "loader": load_finmme,
+        "display_name": "FinMME",
+        "default_image_dir": "data/finmme_images",
+    },
+}
+
 # Fallback plan used when the planner fails entirely
 _FALLBACK_PLAN = {
     "steps": [
@@ -102,9 +128,77 @@
 }
 
 
-# ---------------------------------------------------------------------------
-# Per-sample processing
-# ---------------------------------------------------------------------------
+def _run_verifier_stage(
+    verifier_agent: Optional[VerifierAgent],
+    sample: PerceivedSample,
+    plan_parsed: dict,
+    vision_parsed: dict,
+    lf_trace: Any,
+) -> tuple[str, dict, bool, str, float, str, list, list[str]]:
+    """Run the optional verifier agent and normalize its outputs."""
+    if verifier_agent is None:
+        return "", {}, False, "", 0.0, "skipped", [], []
+
+    errors: list[str] = []
+    verifier_prompt = ""
+    verifier_parsed: dict = {}
+    verifier_parse_error = False
+    verifier_raw = ""
+    verifier_traces: list = []
+    verifier_ms = 0.0
+    verifier_verdict = "skipped"
+    valid_verifier_verdicts = {"confirmed", "revised"}
+
+    try:
+        with timed() as vrt:
+            (
+                verifier_prompt,
+                verifier_parsed,
+                verifier_parse_error,
+                verifier_raw,
+                verifier_traces,
+            ) = verifier_agent.run(sample, plan_parsed, vision_parsed, lf_trace=lf_trace)
+        verifier_ms = vrt.elapsed_ms
+        raw_verdict_value = verifier_parsed.get("verdict")
+        raw_verdict = raw_verdict_value if isinstance(raw_verdict_value, str) else None
+        invalid_output = verifier_parse_error or raw_verdict not in valid_verifier_verdicts
+        if invalid_output:
+            if not verifier_parse_error:
+                verifier_parse_error = True
+            errors.append(f"verifier_invalid_output: {raw_verdict or 'missing verdict'}")
+            verifier_verdict = "error"
+            if not verifier_parsed:
+                verifier_parsed = {}
+            verifier_parsed.setdefault("verdict", "error")
+            verifier_parsed.setdefault("answer", vision_parsed.get("answer", ""))
+            verifier_parsed.setdefault(
+                "reasoning",
+                "Verifier output malformed or unavailable; defaulting to error.",
+            )
+        else:
+            assert raw_verdict is not None
+            verifier_verdict = raw_verdict
+    except Exception as exc:  # pragma: no cover - verifier optional
+        errors.append(f"verifier_error: {exc}")
+        verifier_parse_error = True
+        verifier_parsed = {
+            "verdict": "error",
+            "answer": vision_parsed.get("answer", ""),
+            "reasoning": f"Verifier crashed: {exc}",
+        }
+        verifier_verdict = "error"
+        traceback.print_exc()
+
+    return (
+        verifier_prompt,
+        verifier_parsed,
+        verifier_parse_error,
+        verifier_raw,
+        verifier_ms,
+        verifier_verdict,
+        verifier_traces,
+        errors,
+    )
 
 
 def process_sample(  # noqa: PLR0915
@@ -114,6 +208,7 @@ def process_sample(  # noqa: PLR0915
     config: dict,
     run_id: str,
     out_dir: str,
+    dataset_name: str = "ChartQAPro",
     lf_client: Any = None,
     verifier_agent: Optional[VerifierAgent] = None,
     ocr_tool: Optional[OcrReaderTool] = None,
@@ -138,6 +233,8 @@ def process_sample(  # noqa: PLR0915
         Unique identifier for the current evaluation run.
     out_dir : str
         Directory where the resulting MEP JSON should be saved.
+    dataset_name : str, default 'ChartQAPro'
+        Human-readable dataset label for logging and artifacts.
     langfuse_client : object, optional
         The Langfuse client for tracing and observability.
     verifier_agent : VerifierAgent, optional
@@ -151,6 +248,7 @@ def process_sample(  # noqa: PLR0915
         The absolute path to the written MEP file.
     """
     config_name = f"{config['planner_backend']}_{config['vision_backend']}"
+    dataset_slug = dataset_name.lower().replace(" ", "_")
     run_start = iso_now()
     errors: list = []
 
@@ -162,6 +260,7 @@ def process_sample(  # noqa: PLR0915
         question_type=sample.question_type.value,
         config_name=config_name,
         run_id=run_id,
+        dataset_slug=dataset_slug,
     ) as lf_trace:
         lf_trace_id = getattr(lf_trace, "id", None)
 
@@ -237,34 +336,17 @@ def process_sample(  # noqa: PLR0915
             traceback.print_exc()
 
         # ---- Verifier (Pass 2.5) ----
-        verifier_prompt = ""
-        verifier_parsed: dict = {}
-        verifier_parse_error = False
-        verifier_raw = ""
-        verifier_ms = 0.0
-        verifier_verdict = "skipped"
-
-        if verifier_agent is not None:
-            try:
-                with timed() as vrt:
-                    (
-                        verifier_prompt,
-                        verifier_parsed,
-                        verifier_parse_error,
-                        verifier_raw,
-                    ) = verifier_agent.run(sample, plan_parsed, vision_parsed, lf_trace=lf_trace)
-
-                verifier_ms = vrt.elapsed_ms
-                verifier_verdict = verifier_parsed.get("verdict", "confirmed")
-            except Exception as exc:
-                errors.append(f"verifier_error: {exc}")
-                verifier_parsed = {
-                    "verdict": "confirmed",
-                    "answer": vision_parsed.get("answer", ""),
-                    "reasoning": f"Verifier crashed: {exc}",
-                }
-                verifier_verdict = "confirmed"
-                traceback.print_exc()
+        (
+            verifier_prompt,
+            verifier_parsed,
+            verifier_parse_error,
+            verifier_raw,
+            verifier_ms,
+            verifier_verdict,
+            verifier_traces,
+            verifier_errors,
+        ) = _run_verifier_stage(verifier_agent, sample, plan_parsed, vision_parsed, lf_trace)
+        errors.extend(verifier_errors)
 
         run_end = iso_now()
 
@@ -286,7 +368,7 @@ def process_sample(  # noqa: PLR0915
                 vision_model=config["vision_model"],
             ),
             sample=MEPSample(
-                dataset="ChartQAPro",
+                dataset=dataset_name,
                 sample_id=sample.sample_id,
                 question=sample.question,
                 question_type=sample.question_type.value,
@@ -321,6 +403,7 @@ def process_sample(  # noqa: PLR0915
                 parsed=verifier_parsed,
                 parse_error=verifier_parse_error,
                 verdict=verifier_verdict,
+                tool_trace=verifier_traces,
             )
             if verifier_agent is not None
             else None,
@@ -367,11 +450,12 @@ def main() -> None:  # noqa: PLR0912, PLR0915
     -------
     None
     """
-    parser = argparse.ArgumentParser(description="Generate MEPs for ChartQAPro")
+    parser = argparse.ArgumentParser(description="Generate MEPs for supported financial VQA datasets")
     parser.add_argument(
         "--dataset",
         default="chartqapro",
-        help="Dataset name (currently only chartqapro)",
+        choices=sorted(DATASET_CONFIGS.keys()),
+        help="Dataset name",
     )
     parser.add_argument("--split", default="test", help="Dataset split")
     parser.add_argument("--n", type=int, default=10, help="Number of samples to process")
@@ -383,11 +467,7 @@ def main() -> None:  # noqa: PLR0912, PLR0915
     )
     parser.add_argument("--workers", type=int, default=1, help="Parallel workers (1 = sequential)")
     parser.add_argument("--out", default="meps/", help="Output directory for MEPs")
-    parser.add_argument(
-        "--image_dir",
-        default="data/chartqapro_images",
-        help="Directory to save/load chart images",
-    )
+    parser.add_argument("--image_dir", default=None, help="Directory to save/load chart images (defaults per dataset)")
     parser.add_argument("--cache_dir", default=None, help="HuggingFace datasets cache dir")
     parser.add_argument(
         "--planner_model",
@@ -406,6 +486,10 @@ def main() -> None:  # noqa: PLR0912, PLR0915
     )
     parser.add_argument("--no_verifier", action="store_true", help="Skip Pass 2.5 verifier agent")
     parser.add_argument("--no_ocr", action="store_true", help="Skip OCR pre-read step")
+    parser.add_argument("--no_langfuse", action="store_true", help="Disable Langfuse dataset/prompt registration")
+    parser.add_argument(
+        "--resume", action="store_true", help="Skip samples that already have MEP JSONs in the output dir"
+    )
     parser.add_argument(
         "--ocr_model",
         default=None,
@@ -419,31 +503,58 @@ def main() -> None:  # noqa: PLR0912, PLR0915
     if args.vision_model:
         config["vision_model"] = args.vision_model
     run_id = str(uuid.uuid4())
+    dataset_key = args.dataset.lower()
+    ds_cfg = DATASET_CONFIGS[dataset_key]
+    dataset_name: str = ds_cfg["display_name"]
+    dataset_slug = dataset_key
+
+    image_dir = args.image_dir or ds_cfg["default_image_dir"]
+
     out_dir = str(
-        Path(args.out) / f"{config['planner_backend']}_{config['vision_backend']}" / "chartqapro" / args.split
+        Path(args.out) / f"{config['planner_backend']}_{config['vision_backend']}" / dataset_slug / args.split
     )
     Path(out_dir).mkdir(parents=True, exist_ok=True)
 
-    print(f"Loading dataset  : {args.dataset} split={args.split} n={args.n}")
-    samples = load_chartqapro(
+    print(f"Loading dataset  : {dataset_name} ({dataset_slug}) split={args.split} n={args.n}")
+    samples: list[PerceivedSample] = ds_cfg["loader"](
         split=args.split,
         n=args.n,
-        image_dir=args.image_dir,
+        image_dir=image_dir,
         cache_dir=args.cache_dir,
     )
+    if args.resume:
+        existing_ids: set[str] = set()
+        for p in Path(out_dir).glob("*.json"):
+            try:
+                data = json.loads(p.read_text())
+                sid = data.get("sample", {}).get("sample_id") or p.stem
+            except Exception:
+                sid = p.stem
+            existing_ids.add(sid)
+        before = len(samples)
+        samples = [s for s in samples if s.sample_id not in existing_ids]
+        skipped = before - len(samples)
+        print(f"Resume enabled   : skipped {skipped} existing samples")
+        if not samples:
+            print("All requested samples already processed; exiting early.")
+            return
     print(f"Samples loaded   : {len(samples)}")
     print(f"Config           : {args.config}  run_id={run_id}")
     print(f"Output dir       : {out_dir}")
     print(f"Workers          : {args.workers}")
 
     # Langfuse: register dataset + version prompts at run start (no-ops if unavailable)
-    lf_client = get_client()
-    if lf_client:
-        print("Langfuse         : enabled")
-        register_dataset(samples, split=args.split)
-        push_prompts()
+    lf_client = None
+    if args.no_langfuse:
+        print("Langfuse         : disabled (--no_langfuse)")
     else:
-        print("Langfuse         : not configured (set LANGFUSE_PUBLIC_KEY + LANGFUSE_SECRET_KEY to enable)")
+        lf_client = get_client()
+        if lf_client:
+            print("Langfuse         : enabled")
+            register_dataset(samples, dataset_name=dataset_name, split=args.split)
+            push_prompts()
+        else:
+            print("Langfuse         : not configured (set LANGFUSE_PUBLIC_KEY + LANGFUSE_SECRET_KEY to enable)")
 
     # Build agents once — run() creates fresh Crew/Tool per call so this is thread-safe
     print("Initialising agents …")
@@ -482,6 +593,7 @@ def main() -> None:  # noqa: PLR0912, PLR0915
                     config,
                     run_id,
                     out_dir,
+                    dataset_name,
                     lf_client,
                     verifier,
                     ocr,
@@ -500,6 +612,7 @@ def main() -> None:  # noqa: PLR0912, PLR0915
                     config,
                     run_id,
                     out_dir,
+                    dataset_name,
                     lf_client,
                     verifier,
                     ocr,
diff --git a/src/agentfinvqa/tools/ocr_reader_tool.py b/src/agentfinvqa/tools/ocr_reader_tool.py
index 2655b12..095a938 100644
--- a/src/agentfinvqa/tools/ocr_reader_tool.py
+++ b/src/agentfinvqa/tools/ocr_reader_tool.py
@@ -19,6 +19,7 @@
 from pydantic import BaseModel, Field, PrivateAttr
 
 from ..langfuse_integration.tracing import close_span, open_llm_span
+from ..utils.model_compat import openai_temperature
 
 
 _OCR_PROMPT = """\
@@ -235,7 +236,7 @@ def _call_openai(self, image_path: str) -> tuple:
                 }
             ],
             max_completion_tokens=512,
-            temperature=0,
+            **openai_temperature(self.model),
         )
 
         raw_text = response.choices[0].message.content or ""
@@ -271,7 +272,7 @@ def _call_gemini(self, image_path: str) -> tuple:
         response = client.models.generate_content(
             model=self.model,
             contents=[genai.types.Part.from_bytes(data=base64.b64decode(data), mime_type=f"image/{mime}"), _OCR_PROMPT],
-            config=genai.types.GenerateContentConfig(temperature=0, max_output_tokens=512),
+            config=genai.types.GenerateContentConfig(temperature=0, max_output_tokens=768),
         )
 
         raw_text = response.text or ""
diff --git a/src/agentfinvqa/tools/verifier_tool.py b/src/agentfinvqa/tools/verifier_tool.py
new file mode 100644
index 0000000..0194015
--- /dev/null
+++ b/src/agentfinvqa/tools/verifier_tool.py
@@ -0,0 +1,221 @@
+"""verifier_tool — CrewAI tool wrapping the verifier VLM call.
+
+Accepts the draft answer/explanation alongside the chart image and question,
+runs the verifier prompt against a VLM backend, and returns a JSON string
+with 'verdict', 'answer', and 'reasoning' fields.
+"""
+
+import base64
+import json
+import os
+import time
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, List, Optional, Type
+
+from crewai.tools import BaseTool
+from google import genai
+from openai import OpenAI
+from pydantic import BaseModel, Field, PrivateAttr
+
+from ..langfuse_integration.tracing import close_span, open_llm_span
+from ..utils.model_compat import openai_temperature
+
+
+_VERIFIER_PROMPT = """\
+You are a critical chart QA verifier. A vision agent has already attempted to answer
+the question below. Your job: look at the chart image carefully and audit the work.
+
+Question         : {question}
+Question Type    : {question_type}
+
+Inspection plan the agent was supposed to follow:
+{plan_steps}
+
+Vision Agent's Draft Answer     : {draft_answer}
+Vision Agent's Draft Explanation: {draft_explanation}
+
+Examine the chart image. Then decide:
+  CONFIRM — the draft answer is correct (output the same answer unchanged)
+  REVISE  — you can see a clear, specific error; output the corrected answer
+
+Rules:
+- Only REVISE when you are confident you can point to a concrete error in the chart
+- If uncertain, CONFIRM — do not second-guess without visual evidence
+- For MCQ questions: the answer must be one of the stated choices
+- For MCQ questions: return exactly one of the provided choice texts or the precise letter/letter-combo (e.g., "AC")
+- If the answer is truly unanswerable from the chart, say exactly "UNANSWERABLE"
+- Keep answers concise — numbers, short phrases, or single words where appropriate
+- Always cite at least one numeric value or labeled element from the chart in your reasoning; if you cannot cite evidence, REVISE
+- For MCQ questions, compare the draft answer against at least one alternative choice before confirming
+- Limit the final answer to a short phrase (≤10 words) and keep the reasoning ≤2 sentences.
+
+Output ONLY JSON, no markdown, no extra text:
+{{"verdict": "confirmed" | "revised", "answer": "<final answer>", "reasoning": "<one sentence grounded in what you see in the chart>"}}"""
+
+
+class VerifierInput(BaseModel):
+    """Input schema for VerifierTool."""
+
+    image_path: str = Field(description="Absolute or relative path to the chart image file")
+    question: str = Field(description="The question being answered")
+    question_type: str = Field(description="The type of question (e.g. MCQ, standard)")
+    plan_steps: List[str] = Field(description="Ordered inspection steps from the planner")
+    draft_answer: str = Field(description="The draft answer produced by the vision agent")
+    draft_explanation: str = Field(description="The draft explanation produced by the vision agent")
+
+
+class VerifierTool(BaseTool):
+    """Calls a VLM backend to critically audit a chart QA draft answer."""
+
+    name: str = "verifier_tool"
+    description: str = (
+        "Critically audit a vision agent's draft answer against the chart image. "
+        "Provide the image path, question, question type, plan steps, draft answer, "
+        "and draft explanation. Returns a JSON string with 'verdict', 'answer', and 'reasoning'."
+    )
+    args_schema: Type[BaseModel] = VerifierInput
+
+    backend: str = "gemini"
+    model: str = "gemini-2.5-flash-lite"
+    api_key: str = ""
+    lf_trace: Optional[Any] = None
+
+    _traces: list = PrivateAttr(default_factory=list)
+
+    def pop_traces(self) -> list:
+        """Return buffered tool traces and clear the buffer."""
+        traces = list(self._traces)
+        self._traces.clear()
+        return traces
+
+    def _run(
+        self,
+        image_path: str,
+        question: str,
+        question_type: str,
+        plan_steps: List[str],
+        draft_answer: str,
+        draft_explanation: str,
+    ) -> str:
+        start_ts = datetime.now(timezone.utc).isoformat()
+        t0 = time.time()
+
+        lf_span = open_llm_span(
+            self.lf_trace,
+            name="verifier_tool",
+            input_data={
+                "image_path": image_path,
+                "question": question,
+                "draft_answer": draft_answer,
+            },
+            model=self.model,
+            metadata={"backend": self.backend},
+        )
+
+        steps_text = "\n".join(f"  {i + 1}. {s}" for i, s in enumerate(plan_steps)) or "  (none)"
+        prompt = _VERIFIER_PROMPT.format(
+            question=question,
+            question_type=question_type,
+            plan_steps=steps_text,
+            draft_answer=draft_answer,
+            draft_explanation=draft_explanation,
+        )
+
+        provider_meta: dict = {}
+        error_str: Optional[str] = None
+        has_image = image_path and Path(image_path).exists()
+
+        try:
+            if not has_image:
+                raw_text = json.dumps(
+                    {
+                        "verdict": "confirmed",
+                        "answer": draft_answer,
+                        "reasoning": "Image unavailable; cannot verify visually.",
+                    }
+                )
+                provider_meta = {"skipped": "no image"}
+            elif self.backend == "openai":
+                raw_text, provider_meta = self._call_openai(prompt, image_path)
+            elif self.backend == "gemini":
+                raw_text, provider_meta = self._call_gemini(prompt, image_path)
+            else:
+                raise ValueError(f"Unknown backend: {self.backend!r}")
+        except Exception as exc:
+            raw_text = json.dumps(
+                {
+                    "verdict": "confirmed",
+                    "answer": draft_answer,
+                    "reasoning": f"Tool error: {exc}",
+                }
+            )
+            provider_meta = {"error": str(exc)}
+            error_str = str(exc)
+
+        end_ts = datetime.now(timezone.utc).isoformat()
+        elapsed_ms = (time.time() - t0) * 1000.0
+
+        model_used = provider_meta.pop("model", self.model)
+        usage = provider_meta.get("usage", {})
+
+        close_span(lf_span, output={"raw_text": raw_text}, usage=usage if usage else None, error=error_str)
+
+        self._traces.append(
+            {
+                "tool": "verifier_tool",
+                "backend": self.backend,
+                "model": model_used,
+                "start_ts": start_ts,
+                "end_ts": end_ts,
+                "elapsed_ms": elapsed_ms,
+                "provider_metadata": provider_meta,
+            }
+        )
+
+        return raw_text
+
+    def _encode_image(self, image_path: str) -> tuple:
+        ext = Path(image_path).suffix.lower().lstrip(".")
+        mime = {"jpg": "jpeg", "jpeg": "jpeg", "png": "png", "gif": "gif", "webp": "webp"}.get(ext, "jpeg")
+        with open(image_path, "rb") as f:
+            b64 = base64.b64encode(f.read()).decode("utf-8")
+        return b64, mime
+
+    def _call_openai(self, prompt: str, image_path: str) -> tuple:
+        client = OpenAI(api_key=self.api_key or os.environ.get("OPENAI_API_KEY", ""))
+        b64, mime = self._encode_image(image_path)
+        response = client.chat.completions.create(
+            model=self.model,
+            messages=[
+                {
+                    "role": "user",
+                    "content": [
+                        {"type": "text", "text": prompt},
+                        {"type": "image_url", "image_url": {"url": f"data:image/{mime};base64,{b64}"}},
+                    ],
+                }
+            ],
+            max_completion_tokens=256,
+            **openai_temperature(self.model),
+        )
+        raw_text = response.choices[0].message.content or ""
+        provider_meta = {
+            "model": response.model,
+            "request_id": response.id,
+            "usage": response.usage.model_dump() if response.usage else {},
+        }
+        return raw_text, provider_meta
+
+    def _call_gemini(self, prompt: str, image_path: str) -> tuple:
+        client = genai.Client(api_key=self.api_key or os.environ.get("GEMINI_API_KEY", ""))
+        b64, mime = self._encode_image(image_path)
+        response = client.models.generate_content(
+            model=self.model,
+            contents=[genai.types.Part.from_bytes(data=base64.b64decode(b64), mime_type=f"image/{mime}"), prompt],
+            config=genai.types.GenerateContentConfig(temperature=0, max_output_tokens=768),
+        )
+        raw_text = response.text or ""
+        finish = str(response.candidates[0].finish_reason) if response.candidates else "unknown"
+        provider_meta = {"model": self.model, "finish_reason": finish}
+        return raw_text, provider_meta
diff --git a/src/agentfinvqa/tools/vision_qa_tool.py b/src/agentfinvqa/tools/vision_qa_tool.py
index 01c3c9c..898054a 100644
--- a/src/agentfinvqa/tools/vision_qa_tool.py
+++ b/src/agentfinvqa/tools/vision_qa_tool.py
@@ -19,6 +19,7 @@
 from pydantic import BaseModel, Field, PrivateAttr
 
 from ..langfuse_integration.tracing import close_span, open_llm_span
+from ..utils.model_compat import openai_temperature
 
 
 class VisionQAInput(BaseModel):
@@ -200,6 +201,15 @@ def _build_prompt(
         for i, step in enumerate(plan_steps, 1):
             parts.append(f"  {i}. {step}")
 
+        parts.append(
+            "\nExtraction rules:"
+            "\n- Read ALL axis tick marks and note scale/units before extracting any values"
+            "\n- For stacked, grouped, pie, or multi-series charts: match each legend entry to its color/pattern/position FIRST"
+            "\n- Report exact numeric values (single number, not a range) unless the question explicitly asks for a range"
+            "\n- For multi-part questions (e.g. 'for X and Y'), report each part separately — do not aggregate"
+            "\n- Only answer UNANSWERABLE if relevant data is genuinely absent; if values are partially visible, give your best reading"
+        )
+
         parts.append(
             "\nOutput ONLY this JSON (no markdown, no extra text):\n"
             '{"answer": "...", "explanation": "..."}\n'
@@ -291,7 +301,7 @@ def _call_openai(
                 }
             ],
             max_completion_tokens=1024,
-            temperature=0,
+            **openai_temperature(self.model),
         )
 
         raw_text = response.choices[0].message.content or ""
@@ -344,7 +354,7 @@ def _call_gemini(
         response = client.models.generate_content(
             model=self.model,
             contents=[genai.types.Part.from_bytes(data=b64, mime_type=f"image/{mime}"), prompt],
-            config=genai.types.GenerateContentConfig(temperature=0, max_output_tokens=1024),
+            config=genai.types.GenerateContentConfig(temperature=0, max_output_tokens=768),
         )
 
         raw_text = response.text or ""
diff --git a/src/agentfinvqa/utils/model_compat.py b/src/agentfinvqa/utils/model_compat.py
new file mode 100644
index 0000000..266a576
--- /dev/null
+++ b/src/agentfinvqa/utils/model_compat.py
@@ -0,0 +1,23 @@
+"""Model compatibility helpers for provider-specific quirks."""
+
+# OpenAI models that reject the temperature parameter (only default/1 supported)
+_NO_TEMPERATURE_MODELS = frozenset(
+    {
+        "o1",
+        "o1-mini",
+        "o1-preview",
+        "o3",
+        "o3-mini",
+        "gpt-5-mini",
+    }
+)
+
+
+def openai_temperature(model: str) -> dict:
+    """Return ``{"temperature": 0}`` for models that support it, else ``{}``.
+
+    Use as ``**openai_temperature(model)`` when building OpenAI API kwargs.
+    """
+    if model in _NO_TEMPERATURE_MODELS:
+        return {}
+    return {"temperature": 0}
diff --git a/tests/agentfinvqa/test_finmme_loader.py b/tests/agentfinvqa/test_finmme_loader.py
new file mode 100644
index 0000000..9dab132
--- /dev/null
+++ b/tests/agentfinvqa/test_finmme_loader.py
@@ -0,0 +1,64 @@
+"""Unit tests for the FinMME dataset loader utilities."""
+
+from PIL import Image
+
+from agentfinvqa.datasets import finmme_loader
+from agentfinvqa.datasets.perceived_sample import QuestionType
+
+
+def test_parse_options_from_json():
+    text = '["Option A", "Option B", ""]'
+    assert finmme_loader._parse_options(text) == ["Option A", "Option B"]
+
+
+def test_parse_options_from_labeled_text():
+    text = "A. Growth\nB. Value\nC. Income"
+    assert finmme_loader._parse_options(text) == ["Growth", "Value", "Income"]
+
+
+def test_map_question_type_variants():
+    assert finmme_loader._map_question_type("Multiple Choice") == QuestionType.MCQ
+    assert finmme_loader._map_question_type("Conversational Q&A") == QuestionType.CONVERSATIONAL
+    assert finmme_loader._map_question_type("Unanswerable") == QuestionType.UNANSWERABLE
+    assert finmme_loader._map_question_type("Random Type") == QuestionType.STANDARD
+
+
+def test_build_sample_writes_image(tmp_path):
+    row = {
+        "id": 7,
+        "image": Image.new("RGB", (2, 2), color="white"),
+        "question_text": "Select the correct metric.",
+        "question_type": "multiple choice",
+        "options": "A. Foo\nB. Bar",
+        "answer": "A",
+        "unit": "%",
+        "tolerance": 0.1,
+        "verified_caption": "A caption",
+        "related_sentences": ["Foo is better"],
+    }
+
+    sample = finmme_loader._build_sample(0, row, tmp_path)
+
+    assert sample.sample_id == "finmme_000007"
+    assert sample.image_path.endswith("finmme_000007.png")
+    assert sample.choices == ["Foo", "Bar"]
+    assert sample.metadata["dataset"] == "FinMME"
+    assert sample.expected_output == "Foo"
+    assert sample.metadata["answer_label"] == "A"
+    assert sample.metadata["choice_map"]["B"] == "Bar"
+
+
+def test_build_sample_handles_multi_letter_answer(tmp_path):
+    row = {
+        "id": 8,
+        "image": Image.new("RGB", (2, 2), color="white"),
+        "question_text": "Pick the combo.",
+        "question_type": "multiple choice",
+        "options": ["Alpha", "Beta", "Gamma"],
+        "answer": "AC",
+    }
+
+    sample = finmme_loader._build_sample(0, row, tmp_path)
+
+    assert sample.expected_output == "Alpha + Gamma"
+    assert sample.metadata["answer_label"] == "AC"
diff --git a/tests/conftest.py b/tests/conftest.py
index c49f938..e4f0a50 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -1,8 +1,18 @@
-"""Conftest."""
+"""Pytest fixtures and path setup."""
+
+import sys
+from pathlib import Path
 
 import pytest
 
 
+_SRC_DIR = Path(__file__).resolve().parents[1] / "src"
+if _SRC_DIR.exists():
+    src_path = str(_SRC_DIR)
+    if src_path not in sys.path:
+        sys.path.insert(0, src_path)
+
+
 @pytest.fixture
 def my_test_number() -> int:
     """My test number.
diff --git a/uv.lock b/uv.lock
index b2ee1a5..e1ececc 100644
--- a/uv.lock
+++ b/uv.lock
@@ -19,6 +19,7 @@ version = "0.1.0"
 source = { editable = "." }
 dependencies = [
     { name = "datasets" },
+    { name = "google-genai" },
     { name = "ipykernel" },
     { name = "ipython" },
     { name = "ipywidgets" },
@@ -68,6 +69,7 @@ docs = [
 [package.metadata]
 requires-dist = [
     { name = "datasets", specifier = ">=4.0.0" },
+    { name = "google-genai", specifier = ">=1.34.0" },
     { name = "ipykernel", specifier = ">=6.29.5" },
     { name = "ipython", specifier = ">=9.4.0" },
     { name = "ipywidgets", specifier = ">=8.1.7" },
@@ -3539,7 +3541,7 @@ name = "pexpect"
 version = "4.9.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "ptyprocess" },
+    { name = "ptyprocess", marker = "sys_platform != 'emscripten' and sys_platform != 'win32'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/42/92/cc564bf6381ff43ce1f4d06852fc19a2f11d180f23dc32d9588bee2f149d/pexpect-4.9.0.tar.gz", hash = "sha256:ee7d41123f3c9911050ea2c2dac107568dc43b2d3b0c7557a33212c398ead30f", size = 166450, upload-time = "2023-11-25T09:07:26.339Z" }
 wheels = [

From 8b47e0d34f846fab19c027635c0e9c15d6d43855 Mon Sep 17 00:00:00 2001
From: Aravind N <aravindn1308@outlook.com>
Date: Sun, 5 Apr 2026 11:56:17 -0400
Subject: [PATCH 02/15] Update pre-commit configuration, enhance README, and
 add zero-shot baseline scripts

---
 .pre-commit-config.yaml                       |  98 +++---
 README.md                                     | 165 ++++++---
 baselines/fix_zeroshot_scores.py              | 139 ++++++++
 baselines/run_zeroshot.py                     | 329 ++++++++++++++++++
 baselines/run_zeroshot.sh                     |   7 +
 baselines/submit_zeroshot.sh                  |  68 ++++
 pyproject.toml                                |   6 +-
 scripts/run_batch.py                          | 274 +++++++++++++++
 scripts/run_batch.sh                          |  34 ++
 scripts/run_finmme_batch.py                   |  26 +-
 scripts/run_finmme_batch.sh                   |  12 +-
 scripts/submit_eval.sh                        |  94 +++++
 scripts/submit_pipeline.sh                    |  49 ++-
 src/agentfinvqa/agents/prompts/planner.txt    |  35 +-
 src/agentfinvqa/agents/prompts/planner_v1.txt |  32 ++
 src/agentfinvqa/datasets/finmme_loader.py     |   4 +-
 src/agentfinvqa/datasets/image_utils.py       |   3 +-
 src/agentfinvqa/eval/eval_outputs_batch.py    |   3 +-
 src/agentfinvqa/mep/writer.py                 |  24 ++
 src/agentfinvqa/runner/run_generate_meps.py   |  22 +-
 src/agentfinvqa/tools/vision_qa_tool.py       |   2 +-
 uv.lock                                       |  20 ++
 22 files changed, 1312 insertions(+), 134 deletions(-)
 create mode 100644 baselines/fix_zeroshot_scores.py
 create mode 100644 baselines/run_zeroshot.py
 create mode 100755 baselines/run_zeroshot.sh
 create mode 100755 baselines/submit_zeroshot.sh
 create mode 100644 scripts/run_batch.py
 create mode 100755 scripts/run_batch.sh
 create mode 100755 scripts/submit_eval.sh
 create mode 100644 src/agentfinvqa/agents/prompts/planner_v1.txt

diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index fdb843a..5bbd1cf 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -1,23 +1,23 @@
 repos:
   - repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v6.0.0  # Use the ref you want to point at
+    rev: v6.0.0
     hooks:
-    - id: trailing-whitespace
-    - id: check-ast
-    - id: check-builtin-literals
-    - id: check-docstring-first
-    - id: check-executables-have-shebangs
-    - id: debug-statements
-    - id: end-of-file-fixer
-    - id: mixed-line-ending
-      args: [--fix=lf]
-    - id: fix-byte-order-marker
-    - id: check-merge-conflict
-    - id: check-symlinks
-    - id: detect-private-key
-    - id: check-yaml
-      args: [--unsafe]
-    - id: check-toml
+      - id: trailing-whitespace
+      - id: check-ast
+      - id: check-builtin-literals
+      - id: check-docstring-first
+      - id: check-executables-have-shebangs
+      - id: debug-statements
+      - id: end-of-file-fixer
+      - id: mixed-line-ending
+        args: [--fix=lf]
+      - id: fix-byte-order-marker
+      - id: check-merge-conflict
+      - id: check-symlinks
+      - id: detect-private-key
+      - id: check-yaml
+        args: [--unsafe]
+      - id: check-toml
 
   - repo: https://github.com/astral-sh/uv-pre-commit
     rev: 0.10.12
@@ -25,52 +25,54 @@ repos:
       - id: uv-lock
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: 'v0.15.7'
+    rev: v0.15.7
     hooks:
-    - id: ruff
-      args: [--fix, --exit-non-zero-on-fix]
-      types_or: [python, jupyter]
-    - id: ruff-format
-      types_or: [python, jupyter]
+      - id: ruff
+        args: [--fix, --exit-non-zero-on-fix]
+        types_or: [python, jupyter]
+      - id: ruff-format
+        types_or: [python, jupyter]
 
-  - repo: https://github.com/pre-commit/mirrors-mypy
-    rev: v1.19.1
+  - repo: local
     hooks:
-    - id: mypy
-      entry: python3 -m mypy --config-file pyproject.toml
-      language: system
-      types: [python]
-      exclude: "tests"
+      - id: mypy
+        name: mypy
+        entry: .venv/bin/mypy
+        language: system
+        types: [python]
+        exclude: "tests"
+        args: [--config-file, pyproject.toml]
+        pass_filenames: false
+        always_run: true
 
   - repo: https://github.com/crate-ci/typos
     rev: v1.44.0
     hooks:
       - id: typos
-        args: []
 
   - repo: https://github.com/nbQA-dev/nbQA
     rev: 1.9.1
     hooks:
-    - id: nbqa-ruff
-      args: [--fix, --exit-non-zero-on-fix]
+      - id: nbqa-ruff
+        args: [--fix, --exit-non-zero-on-fix]
 
   - repo: local
     hooks:
-    - id: pytest
-      name: pytest
-      entry: python3 -m pytest -m "not integration_test"
-      language: system
-      pass_filenames: false
-      always_run: true
+      - id: pytest
+        name: pytest
+        entry: python -m pytest -m "not integration_test"
+        language: system
+        pass_filenames: false
+        always_run: true
 
 ci:
-    autofix_commit_msg: |
-        [pre-commit.ci] Add auto fixes from pre-commit.com hooks
+  autofix_commit_msg: |
+    [pre-commit.ci] Add auto fixes from pre-commit.com hooks
 
-        for more information, see https://pre-commit.ci
-    autofix_prs: true
-    autoupdate_branch: ''
-    autoupdate_commit_msg: '[pre-commit.ci] pre-commit autoupdate'
-    autoupdate_schedule: weekly
-    skip: [pytest,doctest,mypy]
-    submodules: false
+    for more information, see https://pre-commit.ci
+  autofix_prs: true
+  autoupdate_branch: ''
+  autoupdate_commit_msg: '[pre-commit.ci] pre-commit autoupdate'
+  autoupdate_schedule: weekly
+  skip: [pytest, doctest, mypy]
+  submodules: false
diff --git a/README.md b/README.md
index 5d0ea32..817920d 100644
--- a/README.md
+++ b/README.md
@@ -121,31 +121,99 @@ uv run --env-file .env -m agentfinvqa.runner.run_generate_meps \
 
 To target FinMME, switch `--dataset finmme`. The loader automatically writes FinMME charts to `data/finmme_images/` unless you override `--image_dir`. Note: Hugging Face only exposes a `train` split for `luojunyu/FinMME`. Any request for `test` is remapped to `train` internally, so use slicing (e.g. `--split train[:200]`) to simulate held-out subsets.
 
+### Sample selection (`--split` and `--n`)
+
+- **`--split`** — Hugging Face split and optional row slice (e.g. `test`, `test[1000:]`, `train[:500]`). This selects *which rows* of the dataset are loaded.
+- **`--n`** — Maximum number of **perceived samples** to process after that slice. Use **`0` or a negative value for no cap** (process the entire loaded slice). Positive `n` stops early once enough samples are materialized.
+
+So “run the whole `test` split” is typically:
+
+```bash
+--split test --n 0
+```
+
+A partial slice with no further cap:
+
+```bash
+--split 'test[1000:]' --n 0
+```
+
 ### Batch helpers
 
-For headless or batch jobs, use the helper scripts:
+The recommended entrypoints for all datasets are `scripts/run_batch.py` and its bash wrapper `scripts/run_batch.sh`. These are dataset-agnostic and run generation + post-evaluation in a single MEP pass (metrics, traces, failure taxonomy, and summary in one go):
+
+```bash
+scripts/run_batch.sh \
+    --dataset chartqapro \
+    --split test \
+    --n 500 \
+    --config gemini_gemini \
+    --workers 8 \
+    --post_eval \
+    --use_judge \
+    --langfuse \
+    --resume \
+    --eval_label chartqapro_test_n500
+```
+
+To skip generation and run post-eval on existing MEPs only:
 
-- Python entrypoint: `python scripts/run_finmme_batch.py --n 500 --split train[:500] --config gemini_gemini --workers 8`
-- Bash wrapper (convenient for schedulers): `scripts/run_finmme_batch.sh --n 500 --split train[:500]`
+```bash
+scripts/run_batch.sh \
+    --dataset chartqapro \
+    --split test \
+    --config gemini_gemini \
+    --eval_only \
+    --use_judge \
+    --langfuse \
+    --eval_label chartqapro_test_n500
+```
 
-Both commands default to loading `.env` from the repo root; override by setting `ENV_FILE=/path/to/.env` before calling the bash script or by passing `--env_file` to the Python script.
+Both commands default to loading `.env` from the repo root. `--langfuse` pushes all numeric eval scores (accuracy, judge rubric scores) back to the originating Langfuse traces.
 
-### SLURM batch job template
+**Verifier ablation:** pass `--no_verifier` to skip the VerifierAgent (Pass 2.5); the pipeline keeps the planner/vision draft without a revise step. Supported by `scripts/run_batch.py`, `scripts/run_finmme_batch.py`, and `scripts/submit_pipeline.sh` (see below).
 
-If you need to submit a single FinMME run to SLURM (MEP generation + post-eval in one job), use the monolithic template:
+### SLURM — single job (generation + eval)
+
+Submit a complete run (generation and post-eval) as one SLURM job:
 
 ```bash
-sbatch scripts/slurm_run_finmme_batch.slrm
+sbatch scripts/slurm_run_batch.slrm
 ```
 
-This script sets a time limit (`--time=0-04:00:00`), runs the existing bash helper, and logs output to `logs/slurm_finmme_<jobid>.out/err`. Edit the SBATCH directives and the `run_finmme_batch.sh` arguments inside the file to match your workload.
+Environment variables (`DATASET`, `SPLIT`, `N`, `CONFIG`, `WORKERS`, `LANGFUSE`, `RESUME`, `NO_VERIFIER`, and model overrides) are passed through from the environment or from `submit_pipeline.sh` via `--export`. Set `NO_VERIFIER=1` before `sbatch` if you call `slurm_run_batch.slrm` without the submit helper.
+
+### SLURM — eval only
 
-### SLURM two-stage pipeline (recommended for large runs)
+To run post-eval on MEPs that already exist:
+
+```bash
+scripts/submit_eval.sh \
+    --dataset chartqapro \
+    --split test \
+    --use_judge \
+    --langfuse \
+    --out_label chartqapro_test_n500
+```
+
+This submits `slurm_eval_only.slrm` as a single SLURM job. You can chain it after a generation job:
+
+```bash
+scripts/submit_eval.sh \
+    --dataset chartqapro \
+    --split test \
+    --use_judge \
+    --langfuse \
+    --after <JOB_ID>
+```
+
+### SLURM — two-stage pipeline (async judge, recommended for large runs)
 
 For large runs, use the chained pipeline that separates MEP generation from LLM judge evaluation. This uses the [Gemini Batch API](https://ai.google.dev/gemini-api/docs/batch) for judge scoring (50% cost reduction, async):
 
 ```bash
 scripts/submit_pipeline.sh \
+    --dataset finmme \
     --split "train[3000:5000]" \
     --n 2000 \
     --workers 8 \
@@ -158,13 +226,33 @@ scripts/submit_pipeline.sh \
     --judge_model gemini-2.5-flash-lite
 ```
 
+**Defaults (you usually do not need to repeat model flags)** — `submit_pipeline.sh` already defaults to `--config gemini_gemini`, `--workers 8`, and the same planner/vision/OCR/verifier/judge models as above. Override only what you change. Add `--langfuse` and/or `--resume` when you want tracing or skip-existing MEPs. For a **verifier-off ablation**, add `--no_verifier`.
+
+**Full split without counting rows** — use `--n 0` (see the *Sample selection* subsection above):
+
+```bash
+scripts/submit_pipeline.sh \
+    --dataset chartqapro \
+    --split test \
+    --n 0 \
+    --no_verifier \
+    --resume
+```
+
+**Not the same as `run_batch.sh --post_eval`** — Job 1 in this chain runs **MEP generation only** (via `slurm_run_batch.slrm` → `run_batch.sh` **without** `--post_eval`). Job 2 submits prompts to the **Gemini Batch API** for async judge scoring. For **local / threaded** post-eval in one process (metrics, traces, taxonomy, summary written immediately), use `scripts/run_batch.sh` with `--post_eval` (and `--use_judge` if you want the LLM judge path during that step) instead of this two-stage pipeline.
+
 This submits two SLURM jobs chained with `--dependency=afterok`:
 
 | Job | Script | What it does |
 |---|---|---|
-| 1 | `slurm_generate_meps.slrm` | MEP generation only |
+| 1 | `slurm_run_batch.slrm` | MEP generation |
 | 2 | `slurm_submit_judge_batch.slrm` | Uploads all judge prompts to Gemini Batch API and exits immediately |
 
+**Where MEPs and batch metrics go**
+
+- **MEP directory** (generation output): `meps/<CONFIG>/<dataset>/<split>/` when the verifier is on (default). With **`--no_verifier`**, MEPs go under **`meps/<CONFIG>/<dataset>/no_verifier/<split>/`** so verifier-on and verifier-off runs do not overwrite each other. Example: `meps/gemini_gemini/chartqapro/test/` vs `meps/gemini_gemini/chartqapro/no_verifier/test/`.
+- **Batch judge file** (job 2): `output/metrics_<out_label>.jsonl` plus `output/metrics_<out_label>.jsonl.batch_state.json`. If you omit `--out_label`, the script sets `<out_label>` to `{dataset}_{sanitized_split}` and appends `_no_verifier` when `--no_verifier` is set (e.g. `chartqapro_test_no_verifier`), so different runs do not overwrite `metrics_test.jsonl`.
+
 Job 2 only runs if job 1 succeeds. When job 2 completes it prints the commands to check status and retrieve results:
 
 ```bash
@@ -177,57 +265,46 @@ python3 -m agentfinvqa.eval.eval_outputs_batch retrieve \
     --state output/metrics_<label>.jsonl.batch_state.json
 ```
 
-See `notebooks/run_pipeline.ipynb` for an interactive walkthrough.
-
-## Evaluation
-
-Evaluation is a four-step pipeline. MEPs must be generated first (see **Running the Pipeline** above).
+The batch job display name in the Gemini console follows the metrics filename (from `--out_label` or the auto-generated label above).
 
-### Step 1 — Generate metrics from MEPs
+See `notebooks/run_pipeline.ipynb` for an interactive walkthrough.
 
-The batch helper (`run_finmme_batch.py`) can do this automatically with `--post_eval`:
+### Zero-shot baseline
 
-```bash
-uv run scripts/run_finmme_batch.sh \
-    --n 500 --split train[:500] \
-    --post_eval --use_judge \
-    --workers 4
-```
+For a single VLM call per sample (no agents), use `baselines/run_zeroshot.py`. Outputs metrics JSONL in the same schema as the agent pipeline for easy comparison.
 
-`--post_eval` writes `output/metrics_<label>.jsonl` and `output/trace_metrics_<label>.jsonl` at the end of the run.
+- **Structured prompt (default)** — rules plus JSON `answer` / `explanation` format.
+- **Minimal prompt** — bare `Question: … / Answer:` (first line of the model reply is scored); use `--prompt_style minimal`.
 
-To evaluate an existing MEP directory independently:
+On SLURM:
 
 ```bash
-uv run -m agentfinvqa.eval.eval_outputs \
-    --mep_dir meps/gemini_gemini/finmme/train[:500] \
-    --out output/metrics.jsonl \
-    --judge_model gemini-2.5-flash-lite   # omit --no_judge to include LLM rubric scores
+baselines/submit_zeroshot.sh --dataset chartqapro --split test --prompt_style minimal
 ```
 
-### Step 2 — Failure taxonomy (optional)
+## Evaluation
 
-Classifies each incorrect answer into a failure category (legend confusion, extraction error, etc.):
+The `run_batch.sh` scripts above handle the full eval pipeline automatically via `--post_eval` or `--eval_only`. All four artifacts are produced in a **single MEP pass**:
 
-```bash
-uv run -m agentfinvqa.eval.error_taxonomy \
-    --mep_dir meps/gemini_gemini/finmme/train[:500] \
-    --metrics_file output/metrics.jsonl \
-    --out output/taxonomy.jsonl \
-    --model gemini-2.5-flash-lite
-```
+| Artifact | Path |
+|---|---|
+| Per-sample metrics | `output/metrics_<label>.jsonl` |
+| Trace metrics | `output/trace_metrics_<label>.jsonl` |
+| Failure taxonomy | `output/taxonomy_<label>.jsonl` |
+| Summary CSV | `output/summary_<label>.csv` |
 
-### Step 3 — Summarize accuracy
+If `--langfuse` is set, all numeric scores are pushed back to the originating Langfuse traces.
 
-Aggregates metrics by config and question type:
+To evaluate an existing MEP directory with the low-level CLI directly:
 
 ```bash
-uv run -m agentfinvqa.eval.summarize \
-    --metrics output/metrics.jsonl \
-    --out output/summary.csv
+uv run -m agentfinvqa.eval.eval_outputs \
+    --mep_dir meps/gemini_gemini/chartqapro/test \
+    --out output/metrics.jsonl \
+    --judge_model gemini-2.5-flash-lite
 ```
 
-### Step 4 — Explore in the dashboard
+### Explore in the dashboard
 
 ```bash
 uv run streamlit run src/agentfinvqa/eval/dashboard.py
diff --git a/baselines/fix_zeroshot_scores.py b/baselines/fix_zeroshot_scores.py
new file mode 100644
index 0000000..b390164
--- /dev/null
+++ b/baselines/fix_zeroshot_scores.py
@@ -0,0 +1,139 @@
+"""Fix zero-shot metrics JSONL in-place without re-running API calls.
+
+Repairs two issues:
+  1. MCQ scoring: "c) 42%" was scored 0 against expected "C" — extract leading letter.
+  2. Truncated JSON: tries to recover answer from cut-off raw_response by closing the
+     JSON.
+
+Usage:
+    .venv/bin/python baselines/fix_zeroshot_scores.py \
+        output/baselines/metrics_chartqapro_test_zeroshot_gemini_gemini_2_5_flash.jsonl
+"""
+
+from __future__ import annotations
+
+import argparse
+import contextlib
+import json
+import re
+import shutil
+import sys
+from pathlib import Path
+
+
+_REPO_ROOT = Path(__file__).resolve().parent.parent
+if str(_REPO_ROOT / "src") not in sys.path:
+    sys.path.insert(0, str(_REPO_ROOT / "src"))
+
+from agentfinvqa.eval.eval_outputs import score_answer_accuracy  # noqa: E402
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+
+def _try_parse_raw(raw: str) -> str | None:
+    """Try to extract an answer from a (possibly truncated) raw JSON string."""
+    raw = raw.strip().removeprefix("```json").removeprefix("```").removesuffix("```").strip()
+
+    # Happy path
+    with contextlib.suppress(Exception):
+        return json.loads(raw).get("answer", "")
+
+    # Truncated mid-value: close the string and object
+    for suffix in ['"}', '"}}', '"}}}']:
+        with contextlib.suppress(Exception):
+            return json.loads(raw + suffix).get("answer", "")
+
+    # Extract answer field with regex as last resort
+    m = re.search(r'"answer"\s*:\s*"([^"]*)"', raw)
+    if m:
+        return m.group(1)
+
+    return None
+
+
+def _normalize_mcq(predicted: str, expected: str) -> str:
+    """If expected is a single MCQ letter, strip trailing text from predicted."""
+    if not re.fullmatch(r"[A-Da-d]", expected.strip()):
+        return predicted
+    m = re.match(r"^\s*([A-Da-d])\s*[).:]?\s*", predicted.strip())
+    return m.group(1) if m else predicted
+
+
+# ---------------------------------------------------------------------------
+# Main
+# ---------------------------------------------------------------------------
+
+
+def fix_file(path: Path) -> None:
+    """Fix scoring errors in a metrics JSONL file in-place."""
+    rows = [json.loads(line) for line in path.open() if line.strip()]
+
+    reparsed = fixed_score = 0
+    out_rows = []
+
+    for row in rows:
+        raw = row.get("raw_response", "")
+        expected = row.get("expected", "")
+        old_predicted = row.get("predicted", "")
+        old_accuracy = row.get("answer_accuracy", 0.0)
+        old_parse_ok = row.get("parse_ok", False)
+        qt = row.get("question_type", "standard")
+
+        # Step 1: re-parse if truncated
+        new_predicted = old_predicted
+        new_parse_ok = old_parse_ok
+        if not old_parse_ok and raw:
+            recovered = _try_parse_raw(raw)
+            if recovered is not None:
+                new_predicted = recovered
+                new_parse_ok = True
+                reparsed += 1
+
+        # Step 2: normalize MCQ letter
+        scored_predicted = _normalize_mcq(new_predicted, expected)
+
+        # Step 3: re-score (cast to str in case of numeric values in the data)
+        new_accuracy = score_answer_accuracy(str(expected), str(scored_predicted), qt)
+
+        if new_accuracy != old_accuracy or new_predicted != old_predicted:
+            fixed_score += 1
+
+        row["predicted"] = new_predicted
+        row["parse_ok"] = new_parse_ok
+        row["answer_accuracy"] = new_accuracy
+        out_rows.append(row)
+
+    # Backup original
+    backup = path.with_suffix(".jsonl.bak")
+    shutil.copy(path, backup)
+    print(f"Backup  → {backup}")
+
+    # Write fixed file
+    with open(path, "w") as f:
+        for row in out_rows:
+            f.write(json.dumps(row) + "\n")
+
+    total = len(out_rows)
+    acc = sum(r["answer_accuracy"] for r in out_rows) / total if total else 0
+    print(f"Rows    : {total}")
+    print(f"Reparsed truncated : {reparsed}")
+    print(f"Score changed      : {fixed_score}")
+    print(f"New accuracy       : {acc:.4f}")
+    print(f"Fixed  → {path}")
+
+
+def main() -> None:
+    """CLI entry point: fix scoring errors in one or more metrics JSONL files."""
+    parser = argparse.ArgumentParser()
+    parser.add_argument("files", nargs="+", help="JSONL file(s) to fix")
+    args = parser.parse_args()
+    for f in args.files:
+        print(f"\n=== {f} ===")
+        fix_file(Path(f))
+
+
+if __name__ == "__main__":
+    main()
diff --git a/baselines/run_zeroshot.py b/baselines/run_zeroshot.py
new file mode 100644
index 0000000..69fd10b
--- /dev/null
+++ b/baselines/run_zeroshot.py
@@ -0,0 +1,329 @@
+r"""Zero-shot VLM baseline — single direct VLM call, no agent pipeline.
+
+Usage:
+    .venv/bin/python baselines/run_zeroshot.py \
+        --dataset chartqapro \
+        --split test \
+        --n 200 \
+        --backend gemini \
+        --model gemini-2.5-flash \
+        --workers 8 \
+        --out output/baselines/
+
+    # Weaker baseline (bare prompt, first line = answer):
+    #   ... --prompt_style minimal
+
+Outputs a metrics JSONL to --out with the same schema as the agent pipeline
+so results are directly comparable with summarize.py.
+"""
+
+from __future__ import annotations
+
+import argparse
+import base64
+import contextlib
+import json
+import os
+import re
+import statistics
+import sys
+import time
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from pathlib import Path
+
+from dotenv import load_dotenv
+
+# ---------------------------------------------------------------------------
+# Make src importable when run as a script
+# ---------------------------------------------------------------------------
+_REPO_ROOT = Path(__file__).resolve().parent.parent
+if str(_REPO_ROOT / "src") not in sys.path:
+    sys.path.insert(0, str(_REPO_ROOT / "src"))
+
+load_dotenv(_REPO_ROOT / ".env")
+
+# ruff: noqa: E402, I001
+from agentfinvqa.datasets.chartqapro_loader import load_chartqapro  # noqa: E402
+from agentfinvqa.datasets.finmme_loader import load_finmme  # noqa: E402
+from agentfinvqa.datasets.perceived_sample import PerceivedSample  # noqa: E402
+from agentfinvqa.eval.eval_outputs import score_answer_accuracy  # noqa: E402
+
+# ---------------------------------------------------------------------------
+# Dataset registry (mirrors run_generate_meps.py)
+# ---------------------------------------------------------------------------
+DATASET_CONFIGS: dict = {
+    "chartqapro": {
+        "loader": load_chartqapro,
+        "display_name": "ChartQAPro",
+        "default_image_dir": str(_REPO_ROOT / "data/chartqapro_images"),
+    },
+    "finmme": {
+        "loader": load_finmme,
+        "display_name": "FinMME",
+        "default_image_dir": str(_REPO_ROOT / "data/finmme_images"),
+    },
+}
+
+# ---------------------------------------------------------------------------
+# Zero-shot prompt
+# ---------------------------------------------------------------------------
+
+# Structured prompt: explicit rules + JSON output format (current default)
+_PROMPT_STRUCTURED = """Look at the chart image and answer the following question.
+
+{context_block}Question: {question}
+{choices_block}
+Rules:
+- Read axis labels, legend, and scale carefully before answering
+- Give a single exact value unless the question asks for multiple
+- Only answer UNANSWERABLE if the data is genuinely absent from the chart
+
+Output ONLY this JSON (no markdown, no extra text):
+{{"answer": "...", "explanation": "..."}}
+If the question cannot be answered from the chart:
+{{"answer": "UNANSWERABLE", "explanation": "..."}}"""
+
+# Minimal prompt: bare question, no rules, no structured output hint
+_PROMPT_MINIMAL = """{context_block}Question: {question}
+{choices_block}Answer:"""
+
+
+def _build_prompt(sample: PerceivedSample, prompt_style: str = "structured") -> str:
+    context_block = ""
+    if sample.context:
+        lines = ["Conversation so far:"]
+        for turn in sample.context:
+            lines.append(f"  {turn.get('role', 'user')}: {turn.get('content', '')}")
+        context_block = "\n".join(lines) + "\n\n"
+
+    choices_block = ""
+    if sample.choices:
+        choices_block = "Choices: " + ", ".join(sample.choices) + "\n"
+
+    template = _PROMPT_MINIMAL if prompt_style == "minimal" else _PROMPT_STRUCTURED
+    return template.format(
+        context_block=context_block,
+        question=sample.question,
+        choices_block=choices_block,
+    )
+
+
+# ---------------------------------------------------------------------------
+# VLM callers (minimal, no CrewAI dependency)
+# ---------------------------------------------------------------------------
+
+
+def _encode_image(image_path: str) -> tuple[str, str]:
+    ext = Path(image_path).suffix.lower().lstrip(".")
+    mime = {"jpg": "jpeg", "jpeg": "jpeg", "png": "png", "gif": "gif", "webp": "webp"}.get(ext, "jpeg")
+    with open(image_path, "rb") as f:
+        b64 = base64.b64encode(f.read()).decode("utf-8")
+    return b64, mime
+
+
+def _call_openai(model: str, prompt: str, image_path: str) -> tuple[str, float]:
+    from openai import OpenAI  # noqa: PLC0415
+    from agentfinvqa.utils.model_compat import openai_temperature  # noqa: PLC0415
+
+    client = OpenAI(api_key=os.environ.get("OPENAI_API_KEY", ""))
+    b64, mime = _encode_image(image_path)
+    t0 = time.time()
+    response = client.chat.completions.create(
+        model=model,
+        messages=[
+            {
+                "role": "user",
+                "content": [
+                    {"type": "text", "text": prompt},
+                    {"type": "image_url", "image_url": {"url": f"data:image/{mime};base64,{b64}"}},
+                ],
+            }
+        ],
+        max_completion_tokens=1024,
+        **openai_temperature(model),
+    )
+    latency = time.time() - t0
+    return response.choices[0].message.content or "", latency
+
+
+def _call_gemini(model: str, prompt: str, image_path: str) -> tuple[str, float]:
+    from google import genai  # noqa: PLC0415
+
+    client = genai.Client(api_key=os.environ.get("GEMINI_API_KEY", ""))
+    b64, mime = _encode_image(image_path)
+    raw_bytes = base64.b64decode(b64)
+    t0 = time.time()
+    response = client.models.generate_content(
+        model=model,
+        contents=[  # type: ignore[arg-type]
+            genai.types.Part.from_bytes(data=raw_bytes, mime_type=f"image/{mime}"),
+            genai.types.Part.from_text(text=prompt),
+        ],
+        config=genai.types.GenerateContentConfig(temperature=0, max_output_tokens=1024),
+    )
+    latency = time.time() - t0
+    return response.text or "", latency
+
+
+# ---------------------------------------------------------------------------
+# Per-sample evaluation
+# ---------------------------------------------------------------------------
+
+
+def _run_sample(
+    sample: PerceivedSample,
+    backend: str,
+    model: str,
+    config_name: str,
+    prompt_style: str = "structured",
+) -> dict:
+    prompt = _build_prompt(sample, prompt_style)
+    raw_text = ""
+    latency = 0.0
+    error = None
+
+    try:
+        if backend == "openai":
+            raw_text, latency = _call_openai(model, prompt, sample.image_path)
+        else:
+            raw_text, latency = _call_gemini(model, prompt, sample.image_path)
+    except Exception as exc:
+        error = str(exc)
+        raw_text = json.dumps({"answer": "ERROR", "explanation": error})
+
+    # Parse answer
+    predicted = ""
+    parse_ok = False
+    if prompt_style == "minimal":
+        # Raw text IS the answer — just clean it up
+        predicted = raw_text.strip().splitlines()[0].strip()
+        parse_ok = bool(predicted)
+    else:
+        with contextlib.suppress(Exception):
+            cleaned = raw_text.strip().removeprefix("```json").removeprefix("```").removesuffix("```").strip()
+            parsed = json.loads(cleaned)
+            predicted = parsed.get("answer", "")
+            parse_ok = True
+
+    # Score — mirror evaluate_mep MCQ label-to-text expansion
+    expected = sample.expected_output
+    # If expected is a single letter (MCQ), strip trailing text from predicted
+    # so "c) 42%" → "c" scores correctly against expected "C"
+    scored_predicted = predicted
+    if re.fullmatch(r"[A-Da-d]", expected.strip()):
+        m = re.match(r"^\s*([A-Da-d])\s*[).:]?\s*", predicted.strip())
+        if m:
+            scored_predicted = m.group(1)
+    accuracy = score_answer_accuracy(expected, scored_predicted, sample.question_type.value)
+
+    row: dict = {
+        "sample_id": sample.sample_id,
+        "question_type": sample.question_type.value,
+        "config_name": config_name,
+        "expected": expected,
+        "predicted": predicted,
+        "raw_response": raw_text,
+        "answer_accuracy": accuracy,
+        "latency_sec": round(latency, 4),
+        "parse_ok": parse_ok,
+        "has_errors": error is not None,
+    }
+    if error:
+        row["error"] = error
+    return row
+
+
+# ---------------------------------------------------------------------------
+# Main
+# ---------------------------------------------------------------------------
+
+
+def main() -> None:  # noqa: PLR0915
+    """CLI entry point for zero-shot VLM baseline evaluation."""
+    parser = argparse.ArgumentParser(description="Zero-shot VLM baseline")
+    parser.add_argument("--dataset", default="chartqapro", choices=list(DATASET_CONFIGS.keys()))
+    parser.add_argument("--split", default="test")
+    parser.add_argument("--n", type=int, default=100, help="Number of samples (0 = all)")
+    parser.add_argument("--backend", default="gemini", choices=["openai", "gemini"])
+    parser.add_argument("--model", default="gemini-2.5-flash")
+    parser.add_argument("--workers", type=int, default=4)
+    parser.add_argument("--out", default="output/baselines/", help="Output directory")
+    parser.add_argument("--image_dir", default=None)
+    parser.add_argument("--resume", action="store_true", help="Skip already-completed samples")
+    parser.add_argument(
+        "--prompt_style",
+        default="structured",
+        choices=["structured", "minimal"],
+        help="structured: rules + JSON output (default); minimal: bare question only",
+    )
+    args = parser.parse_args()
+
+    ds_cfg = DATASET_CONFIGS[args.dataset]
+    image_dir = args.image_dir or ds_cfg["default_image_dir"]
+    model_slug = args.model.replace("-", "_").replace(".", "_")
+    config_name = f"zeroshot_{args.prompt_style}_{args.backend}_{model_slug}"
+
+    out_dir = Path(args.out)
+    out_dir.mkdir(parents=True, exist_ok=True)
+    out_file = out_dir / f"metrics_{args.dataset}_{args.split}_{config_name}.jsonl"
+
+    print(f"Dataset  : {ds_cfg['display_name']} / {args.split}")
+    print(f"Model    : {args.backend} / {args.model}")
+    print(f"Prompt   : {args.prompt_style}")
+    print(f"Workers  : {args.workers}")
+    print(f"Output   : {out_file}")
+
+    # Load samples
+    samples: list[PerceivedSample] = ds_cfg["loader"](
+        split=args.split,
+        image_dir=image_dir,
+        n=args.n if args.n > 0 else None,
+    )
+    print(f"Samples  : {len(samples)}")
+
+    # Resume: skip already-written sample IDs
+    done_ids: set[str] = set()
+    if args.resume and out_file.exists():
+        with open(out_file) as f:
+            for line in f:
+                with contextlib.suppress(Exception):
+                    done_ids.add(json.loads(line)["sample_id"])
+        print(f"Resume   : skipping {len(done_ids)} already done")
+
+    todo = [s for s in samples if s.sample_id not in done_ids]
+
+    # Run in parallel
+    completed = 0
+    errors = 0
+    mode = "a" if args.resume else "w"
+    with open(out_file, mode) as f_out, ThreadPoolExecutor(max_workers=args.workers) as pool:
+        futures = {
+            pool.submit(_run_sample, s, args.backend, args.model, config_name, args.prompt_style): s for s in todo
+        }
+        for future in as_completed(futures):
+            try:
+                row = future.result()
+            except Exception as exc:
+                s = futures[future]
+                print(f"  ERROR {s.sample_id}: {exc}")
+                errors += 1
+                continue
+            f_out.write(json.dumps(row) + "\n")
+            f_out.flush()
+            completed += 1
+            if completed % 50 == 0:
+                print(f"  {completed}/{len(todo)} done ...")
+
+    print(f"\nDone: {completed} samples, {errors} errors → {out_file}")
+
+    # Quick accuracy summary
+    with open(out_file) as _f:
+        rows = [json.loads(line) for line in _f if line.strip()]
+    if rows:
+        acc = statistics.mean(r["answer_accuracy"] for r in rows)
+        lat = statistics.mean(r["latency_sec"] for r in rows)
+        print(f"Accuracy : {acc:.4f}   Latency: {lat:.2f}s")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/baselines/run_zeroshot.sh b/baselines/run_zeroshot.sh
new file mode 100755
index 0000000..842c215
--- /dev/null
+++ b/baselines/run_zeroshot.sh
@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+source "$REPO_ROOT/.venv/bin/activate"
+
+exec python "$REPO_ROOT/baselines/run_zeroshot.py" "$@"
diff --git a/baselines/submit_zeroshot.sh b/baselines/submit_zeroshot.sh
new file mode 100755
index 0000000..695f624
--- /dev/null
+++ b/baselines/submit_zeroshot.sh
@@ -0,0 +1,68 @@
+#!/usr/bin/env bash
+# Submit a zero-shot baseline SLURM job.
+#
+# Usage:
+#   baselines/submit_zeroshot.sh --dataset chartqapro --backend gemini --model gemini-2.5-flash
+#   baselines/submit_zeroshot.sh --dataset finmme --backend openai --model gpt-4o --after 12345
+#
+# Options:
+#   --dataset   DATASET   chartqapro | finmme  (default: chartqapro)
+#   --split     SPLIT     test | train | ...   (default: test)
+#   --n         N         samples, 0=all       (default: 0)
+#   --backend   BACKEND   gemini | openai      (default: gemini)
+#   --model     MODEL     model name           (default: gemini-2.5-flash)
+#   --workers   N         parallel workers     (default: 8)
+#   --resume              skip done samples
+#   --out       DIR       output dir           (default: output/baselines/)
+#   --prompt_style STYLE  structured (default) | minimal — minimal = bare Q/A, no JSON rules
+#   --after     JOB_ID    hold until job completes
+set -euo pipefail
+
+REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+
+DATASET="chartqapro"
+SPLIT="test"
+N=0
+BACKEND="gemini"
+MODEL="gemini-2.5-flash"
+WORKERS=8
+RESUME=0
+OUT="output/baselines/"
+AFTER_JOB=""
+PROMPT_STYLE="structured"
+
+while [[ $# -gt 0 ]]; do
+    case "$1" in
+        --dataset)  DATASET="$2";  shift 2 ;;
+        --split)    SPLIT="$2";    shift 2 ;;
+        --n)        N="$2";        shift 2 ;;
+        --backend)  BACKEND="$2";  shift 2 ;;
+        --model)    MODEL="$2";    shift 2 ;;
+        --workers)  WORKERS="$2";  shift 2 ;;
+        --resume)        RESUME=1;              shift ;;
+        --out)           OUT="$2";             shift 2 ;;
+        --after)         AFTER_JOB="$2";       shift 2 ;;
+        --prompt_style)  PROMPT_STYLE="$2";    shift 2 ;;
+        *) echo "Unknown option: $1"; exit 1 ;;
+    esac
+done
+
+export DATASET SPLIT N BACKEND MODEL WORKERS RESUME OUT PROMPT_STYLE
+
+echo "=== Submitting zero-shot baseline ==="
+echo "  Dataset  : $DATASET / $SPLIT  (n=$N)"
+echo "  Model    : $BACKEND / $MODEL"
+echo "  Workers  : $WORKERS"
+echo "  Prompt   : $PROMPT_STYLE"
+echo "  Output   : $OUT"
+[[ -n "$AFTER_JOB" ]] && echo "  After    : $AFTER_JOB"
+echo ""
+
+DEP=""
+[[ -n "$AFTER_JOB" ]] && DEP="--dependency=afterok:${AFTER_JOB}"
+
+JOB=$(sbatch --parsable --export=ALL \
+    --job-name="zeroshot_${BACKEND}_${DATASET}" \
+    $DEP \
+    "$REPO_ROOT/baselines/slurm_zeroshot.slrm")
+echo "Submitted job: $JOB"
diff --git a/pyproject.toml b/pyproject.toml
index a59597b..de8d135 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -23,6 +23,9 @@ dependencies = [
     "transformers>=4.47.0",
     "langfuse>=4",
     "google-genai>=1.34.0",
+    "seaborn>=0.13.2",
+    "mypy>=1.19.1",
+    "pytest>=9.0.2",
 ]
 
 [build-system]
@@ -86,6 +89,7 @@ implicit_reexport = false
 strict_equality = true
 extra_checks = true
 mypy_path = "src"
+cache_dir = "/tmp/mypy_cache_agentfinvqa"
 
 [tool.ruff]
 include = ["*.py", "pyproject.toml", "*.ipynb"]
@@ -160,7 +164,7 @@ markers = [
 ]
 
 [[tool.mypy.overrides]]
-module = ["crewai.*", "streamlit", "google.genai", "openinference.*", "datasets"]
+module = ["crewai.*", "streamlit", "google.genai", "openinference.*", "datasets", "json_repair"]
 ignore_missing_imports = true
 
 [[tool.mypy.overrides]]
diff --git a/scripts/run_batch.py b/scripts/run_batch.py
new file mode 100644
index 0000000..8dbc679
--- /dev/null
+++ b/scripts/run_batch.py
@@ -0,0 +1,274 @@
+#!/usr/bin/env python3
+# ruff: noqa: E402, I001
+"""Run dataset batches with single-pass post-evaluation."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+import threading
+from typing import Any
+from collections import defaultdict
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from pathlib import Path
+
+from dotenv import load_dotenv
+
+
+REPO_ROOT = Path(__file__).resolve().parents[1]
+SRC_PATH = REPO_ROOT / "src"
+
+
+def _ensure_src_on_path() -> None:
+    if str(SRC_PATH) not in sys.path:
+        sys.path.insert(0, str(SRC_PATH))
+
+
+_ensure_src_on_path()
+
+import contextlib
+
+from agentfinvqa.eval.error_taxonomy import classify_failure
+from agentfinvqa.eval.eval_outputs import evaluate_mep
+from agentfinvqa.eval.eval_traces import evaluate_trace
+from agentfinvqa.eval.summarize import summarize, write_csv
+from agentfinvqa.langfuse_integration.client import get_client
+from agentfinvqa.mep.writer import iter_meps, mep_dataset_split_relpath
+from agentfinvqa.runner import run_generate_meps
+
+CONFIG_CHOICES = list(run_generate_meps.BACKEND_CONFIGS.keys())
+DATASET_CHOICES = list(run_generate_meps.DATASET_CONFIGS.keys())
+
+
+def _build_runner_args(args: argparse.Namespace) -> list[str]:
+    cmd: list[str] = [
+        "--dataset",
+        args.dataset,
+        "--split",
+        args.split,
+        "--n",
+        str(args.n),
+        "--config",
+        args.config,
+        "--workers",
+        str(args.workers),
+        "--out",
+        args.out,
+    ]
+
+    def _append(flag: str, value: str | None) -> None:
+        if value:
+            cmd.extend([flag, value])
+
+    _append("--image_dir", args.image_dir)
+    _append("--cache_dir", args.cache_dir)
+    _append("--planner_model", args.planner_model)
+    _append("--vision_model", args.vision_model)
+    _append("--verifier_model", args.verifier_model)
+    _append("--ocr_model", args.ocr_model)
+
+    if args.no_verifier:
+        cmd.append("--no_verifier")
+    if args.no_ocr:
+        cmd.append("--no_ocr")
+    _append("--run_tag", args.run_tag)
+    if not args.langfuse:
+        cmd.append("--no_langfuse")
+    if args.resume:
+        cmd.append("--resume")
+
+    return cmd
+
+
+def _eval_mep(
+    mep: dict,
+    config: dict,
+    use_judge: bool,
+    judge_model: str,
+    lf_client: Any,
+) -> tuple[dict, dict, dict | None]:
+    """Evaluate a single MEP. Returns (metrics_row, trace_row, taxonomy_row | None)."""
+    sid = mep.get("sample", {}).get("sample_id", "?")
+
+    row = evaluate_mep(
+        mep,
+        use_judge=use_judge,
+        judge_backend=config.get("judge_backend", config["planner_backend"]),
+        judge_model=judge_model,
+    )
+
+    if lf_client:
+        lf_trace_id = mep.get("lf_trace_id")
+        if lf_trace_id:
+            for k, v in row.items():
+                if isinstance(v, (int, float)):
+                    with contextlib.suppress(Exception):
+                        lf_client.create_score(trace_id=lf_trace_id, name=k, value=float(v))
+
+    trace_row = evaluate_trace(mep)
+
+    tax_row = None
+    acc_val = row.get("answer_accuracy", 0.0)
+    if acc_val < 0.999:
+        result = classify_failure(
+            mep,
+            answer_accuracy=acc_val,
+            backend=config.get("vision_backend", "gemini"),
+            model=judge_model,
+        )
+        tax_row = {"sample_id": sid, "answer_accuracy": acc_val, **result}
+
+    return row, trace_row, tax_row
+
+
+def run_post_evaluation(
+    out_dir: Path,
+    label: str,
+    eval_dir: Path,
+    config: dict,
+    use_judge: bool,
+    use_langfuse: bool = False,
+    workers: int = 4,
+    judge_model: str | None = None,
+    mep_start: int = 0,
+) -> None:
+    """Compute metrics, traces, taxonomy, and summary using a thread pool."""
+    if not out_dir.exists():
+        print(f"[post-eval] Skipping: MEP dir {out_dir} not found")
+        return
+
+    eval_dir.mkdir(parents=True, exist_ok=True)
+    print(f"[post-eval] Writing artifacts to {eval_dir.resolve()} (label={label}, workers={workers})")
+
+    metrics_path = eval_dir / f"metrics_{label}.jsonl"
+    trace_path = eval_dir / f"trace_metrics_{label}.jsonl"
+    taxonomy_path = eval_dir / f"taxonomy_{label}.jsonl"
+
+    judge_model = judge_model or config.get("vision_model") or config.get("planner_model") or "gemini-2.5-flash-lite"
+    lf_client = get_client() if use_langfuse else None
+    metrics_list: list[dict] = []
+    taxonomy_rows = 0
+    write_lock = threading.Lock()
+
+    with (
+        open(metrics_path, "w") as f_met,
+        open(trace_path, "w") as f_trace,
+        open(taxonomy_path, "w") as f_tax,
+        ThreadPoolExecutor(max_workers=workers) as pool,
+    ):
+        all_meps = list(iter_meps(str(out_dir)))
+        if mep_start > 0:
+            print(f"[post-eval] Skipping first {mep_start} MEPs (mep_start={mep_start}, total={len(all_meps)})")
+            all_meps = all_meps[mep_start:]
+        futures = {pool.submit(_eval_mep, mep, config, use_judge, judge_model, lf_client): mep for mep in all_meps}
+        for future in as_completed(futures):
+            mep = futures[future]
+            sid = mep.get("sample", {}).get("sample_id", "?")
+            try:
+                row, trace_row, tax_row = future.result()
+            except Exception as exc:
+                print(f"  [eval] {sid} ERROR: {exc}")
+                continue
+            with write_lock:
+                metrics_list.append(row)
+                f_met.write(json.dumps(row) + "\n")
+                f_trace.write(json.dumps(trace_row) + "\n")
+                if tax_row:
+                    f_tax.write(json.dumps(tax_row) + "\n")
+                    taxonomy_rows += 1
+
+    if not metrics_list:
+        print("[post-eval] No metrics produced.")
+        return
+
+    acc = sum(m.get("answer_accuracy", 0.0) for m in metrics_list) / len(metrics_list)
+    print(f"[post-eval] Accuracy {acc:.1%} (n={len(metrics_list)})")
+    qt_groups: dict[str, list[float]] = defaultdict(list)
+    for row in metrics_list:
+        qt_groups[row.get("question_type", "unknown")].append(row.get("answer_accuracy", 0.0))
+    for qt, vals in sorted(qt_groups.items()):
+        print(f"  {qt:<18} {sum(vals) / max(len(vals), 1):.1%} (n={len(vals)})")
+
+    print(f"[post-eval] Trace metrics  -> {trace_path}")
+    print(f"[post-eval] Taxonomy rows: {taxonomy_rows} -> {taxonomy_path}")
+
+    summary_path = eval_dir / f"summary_{label}.csv"
+    write_csv(summarize(metrics_list), str(summary_path))
+    print(f"[post-eval] Summary -> {summary_path}")
+
+    print("[post-eval] Artifacts ready:")
+    for path in [metrics_path, trace_path, taxonomy_path, summary_path]:
+        print(f"  - {path}")
+
+
+def main() -> None:
+    """Run dataset generation and optional post-evaluation in one command."""
+    parser = argparse.ArgumentParser(description="Run AgentFinVQA on a dataset at scale")
+    parser.add_argument("--dataset", default="finmme", choices=DATASET_CHOICES, help="Dataset to run")
+    parser.add_argument(
+        "--n",
+        type=int,
+        default=100,
+        help="Max samples (0 or negative = entire split after --split slice)",
+    )
+    parser.add_argument("--split", default="train", help="Dataset split slice (default train).")
+    parser.add_argument("--config", default="gemini_gemini", choices=CONFIG_CHOICES, help="Backend pairing")
+    parser.add_argument("--workers", type=int, default=4, help="Threaded workers for generation")
+    parser.add_argument("--out", default="meps/", help="Base output directory for MEPs")
+    parser.add_argument("--image_dir", default=None, help="Override image cache directory")
+    parser.add_argument("--cache_dir", default=None, help="HuggingFace datasets cache override")
+    parser.add_argument("--planner_model", default=None, help="Planner model override")
+    parser.add_argument("--vision_model", default=None, help="Vision model override")
+    parser.add_argument("--verifier_model", default=None, help="Verifier model override")
+    parser.add_argument("--ocr_model", default=None, help="OCR model override")
+    parser.add_argument("--no_verifier", action="store_true", help="Disable verifier")
+    parser.add_argument("--no_ocr", action="store_true", help="Disable OCR preread")
+    parser.add_argument("--run_tag", default=None, help="Subfolder tag within dataset dir (e.g. planner_v2)")
+    parser.add_argument("--langfuse", action="store_true", help="Enable Langfuse tracing")
+    parser.add_argument("--resume", action="store_true", help="Skip samples whose MEPs already exist")
+    parser.add_argument("--use_judge", action="store_true", help="Run LLM judge during post-eval")
+    parser.add_argument(
+        "--judge_model", default="gemini-2.5-flash-lite", help="Judge model (default: gemini-2.5-flash-lite)"
+    )
+    parser.add_argument("--mep_start", type=int, default=0, help="Skip first N MEPs (default: 0 = process all)")
+    parser.add_argument("--post_eval", action="store_true", help="Run post-eval after generation")
+    parser.add_argument("--eval_only", action="store_true", help="Skip generation, run post-eval on existing MEPs")
+    parser.add_argument("--eval_dir", default="output", help="Directory for eval outputs")
+    parser.add_argument("--eval_label", default=None, help="Label for eval files (defaults to config_n)")
+    parser.add_argument("--env_file", default=".env", help=".env file to load before running")
+    args = parser.parse_args()
+
+    env_path = Path(args.env_file)
+    if env_path.exists():
+        load_dotenv(env_path, override=True)
+
+    if not args.eval_only:
+        sys.argv = ["run_generate_meps"] + _build_runner_args(args)
+        run_generate_meps.main()
+
+    if args.post_eval or args.eval_only:
+        config = run_generate_meps.BACKEND_CONFIGS[args.config]
+        out_dir = (
+            Path(args.out)
+            / f"{config['planner_backend']}_{config['vision_backend']}"
+            / mep_dataset_split_relpath(
+                args.dataset, args.split, no_verifier=args.no_verifier, no_ocr=args.no_ocr, run_tag=args.run_tag
+            )
+        )
+        label = args.eval_label or (f"{args.config}_all" if args.n <= 0 else f"{args.config}_n{args.n}")
+        run_post_evaluation(
+            out_dir=out_dir,
+            label=label,
+            eval_dir=Path(args.eval_dir),
+            config=config,
+            use_judge=args.use_judge,
+            use_langfuse=args.langfuse,
+            workers=args.workers,
+            judge_model=args.judge_model,
+            mep_start=args.mep_start,
+        )
+
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/run_batch.sh b/scripts/run_batch.sh
new file mode 100755
index 0000000..a529e30
--- /dev/null
+++ b/scripts/run_batch.sh
@@ -0,0 +1,34 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+REPO_ROOT="$(cd -- "$(dirname "${BASH_SOURCE[0]}")"/.. && pwd)"
+ENV_FILE_DEFAULT="$REPO_ROOT/.env"
+LOG_DIR_DEFAULT="$REPO_ROOT/logs"
+
+LOG_DIR="${LOG_DIR:-$LOG_DIR_DEFAULT}"
+mkdir -p "$LOG_DIR"
+timestamp="$(date +%Y%m%d-%H%M%S)"
+
+# Extract --dataset value from forwarded args for log naming
+DATASET="batch"
+prev=""
+for arg in "$@"; do
+    if [[ "$prev" == "--dataset" ]]; then DATASET="$arg"; fi
+    prev="$arg"
+done
+LOG_FILE="$LOG_DIR/${DATASET}_${timestamp}.log"
+
+if [ -f "$REPO_ROOT/.venv/bin/activate" ]; then
+    source "$REPO_ROOT/.venv/bin/activate"
+fi
+
+export CREWAI_TRACING_ENABLED=false
+export OTEL_SDK_DISABLED=1
+
+{
+  echo "[$(date --iso-8601=seconds)] Starting ${DATASET} batch → log $LOG_FILE"
+  python3 "$REPO_ROOT/scripts/run_batch.py" --env_file "${ENV_FILE:-$ENV_FILE_DEFAULT}" "$@"
+  status=$?
+  echo "[$(date --iso-8601=seconds)] Run completed with status $status (log $LOG_FILE)"
+  exit $status
+} 2>&1 | tee "$LOG_FILE"
diff --git a/scripts/run_finmme_batch.py b/scripts/run_finmme_batch.py
index 4a746de..aa9fe52 100644
--- a/scripts/run_finmme_batch.py
+++ b/scripts/run_finmme_batch.py
@@ -28,17 +28,17 @@ def _ensure_src_on_path() -> None:
 from agentfinvqa.eval.eval_outputs import evaluate_mep
 from agentfinvqa.eval.eval_traces import evaluate_trace
 from agentfinvqa.eval.summarize import summarize, write_csv
-from agentfinvqa.mep.writer import iter_meps
+from agentfinvqa.mep.writer import iter_meps, mep_dataset_split_relpath
 from agentfinvqa.runner import run_generate_meps
 
 CONFIG_CHOICES = list(run_generate_meps.BACKEND_CONFIGS.keys())
-DATASET_SLUG = "finmme"
+DATASET_CHOICES = list(run_generate_meps.DATASET_CONFIGS.keys())
 
 
 def _build_runner_args(args: argparse.Namespace) -> list[str]:
     cmd: list[str] = [
         "--dataset",
-        DATASET_SLUG,
+        args.dataset,
         "--split",
         args.split,
         "--n",
@@ -180,12 +180,18 @@ def run_post_evaluation(
 
 def main() -> None:
     """Run FinMME generation and optional post-evaluation in one command."""
-    parser = argparse.ArgumentParser(description="Run AgentFinVQA on FinMME at scale")
-    parser.add_argument("--n", type=int, default=100, help="Number of FinMME samples to process")
+    parser = argparse.ArgumentParser(description="Run AgentFinVQA on a dataset at scale")
+    parser.add_argument("--dataset", default="finmme", choices=DATASET_CHOICES, help="Dataset to run")
+    parser.add_argument(
+        "--n",
+        type=int,
+        default=100,
+        help="Max samples (0 or negative = entire split after --split slice)",
+    )
     parser.add_argument(
         "--split",
         default="train",
-        help="FinMME split slice (default train; aliases like test[:50] are remapped to train).",
+        help="Dataset split slice (default train).",
     )
     parser.add_argument("--config", default="gemini_gemini", choices=CONFIG_CHOICES, help="Backend pairing")
     parser.add_argument("--workers", type=int, default=4, help="Threaded workers for generation")
@@ -216,8 +222,12 @@ def main() -> None:
 
     if args.post_eval:
         config = run_generate_meps.BACKEND_CONFIGS[args.config]
-        out_dir = Path(args.out) / f"{config['planner_backend']}_{config['vision_backend']}" / DATASET_SLUG / args.split
-        label = args.eval_label or f"{args.config}_n{args.n}"
+        out_dir = (
+            Path(args.out)
+            / f"{config['planner_backend']}_{config['vision_backend']}"
+            / mep_dataset_split_relpath(args.dataset, args.split, no_verifier=args.no_verifier)
+        )
+        label = args.eval_label or (f"{args.config}_all" if args.n <= 0 else f"{args.config}_n{args.n}")
         run_post_evaluation(
             out_dir=out_dir,
             label=label,
diff --git a/scripts/run_finmme_batch.sh b/scripts/run_finmme_batch.sh
index 719efdd..2781abb 100755
--- a/scripts/run_finmme_batch.sh
+++ b/scripts/run_finmme_batch.sh
@@ -8,13 +8,21 @@ LOG_DIR_DEFAULT="$REPO_ROOT/logs"
 LOG_DIR="${LOG_DIR:-$LOG_DIR_DEFAULT}"
 mkdir -p "$LOG_DIR"
 timestamp="$(date +%Y%m%d-%H%M%S)"
-LOG_FILE="$LOG_DIR/finmme_${timestamp}.log"
+
+# Extract --dataset value from forwarded args for log naming
+DATASET="batch"
+prev=""
+for arg in "$@"; do
+    if [[ "$prev" == "--dataset" ]]; then DATASET="$arg"; fi
+    prev="$arg"
+done
+LOG_FILE="$LOG_DIR/${DATASET}_${timestamp}.log"
 
 export CREWAI_TRACING_ENABLED=false
 export OTEL_SDK_DISABLED=1
 
 {
-  echo "[$(date --iso-8601=seconds)] Starting FinMME batch → log $LOG_FILE"
+  echo "[$(date --iso-8601=seconds)] Starting ${DATASET} batch → log $LOG_FILE"
   python3 "$REPO_ROOT/scripts/run_finmme_batch.py" --env_file "${ENV_FILE:-$ENV_FILE_DEFAULT}" "$@"
   status=$?
   echo "[$(date --iso-8601=seconds)] Run completed with status $status (log $LOG_FILE)"
diff --git a/scripts/submit_eval.sh b/scripts/submit_eval.sh
new file mode 100755
index 0000000..54021b4
--- /dev/null
+++ b/scripts/submit_eval.sh
@@ -0,0 +1,94 @@
+#!/usr/bin/env bash
+# Submit a post-evaluation-only SLURM job on existing MEPs.
+#
+# Usage:
+#   scripts/submit_eval.sh [options]
+#
+# Options:
+#   --dataset DATASET      Dataset (default: finmme)
+#   --split SPLIT          Split slice used during generation (default: train)
+#   --config CONFIG        Backend config preset (default: gemini_gemini)
+#   --workers N            Parallel eval workers (default: 8)
+#   --judge_model M        Judge model (default: gemini-2.5-flash-lite)
+#   --use_judge            Run inline LLM judge per sample
+#   --langfuse             Push eval scores to Langfuse traces
+#   --eval_dir DIR         Output directory for artifacts (default: output)
+#   --out_label LABEL      Label for output files (default: DATASET_SPLIT)
+#   --no_verifier          MEPs live under <dataset>/no_verifier/<split> (match generation)
+#   --no_ocr               MEPs live under <dataset>/no_ocr/<split> (match generation)
+#   --after JOB_ID         Hold until JOB_ID completes successfully (optional)
+
+set -euo pipefail
+
+REPO_ROOT="$(cd -- "$(dirname "${BASH_SOURCE[0]}")"/.. && pwd)"
+cd "$REPO_ROOT"
+
+mkdir -p logs
+
+module --force purge
+module load slurm/bonecho/25.05.2
+
+# Defaults
+DATASET="finmme"
+SPLIT="train"
+CONFIG="gemini_gemini"
+WORKERS=8
+JUDGE_MODEL="gemini-2.5-flash-lite"
+MEP_START=0
+USE_JUDGE=0
+LANGFUSE=0
+EVAL_DIR="output"
+OUT_LABEL=""
+AFTER_JOB=""
+NO_VERIFIER=0
+NO_OCR=0
+RUN_TAG=""
+
+while [[ $# -gt 0 ]]; do
+    case "$1" in
+        --dataset)   DATASET="$2";   shift 2 ;;
+        --split)     SPLIT="$2";     shift 2 ;;
+        --config)    CONFIG="$2";    shift 2 ;;
+        --workers)     WORKERS="$2";     shift 2 ;;
+        --judge_model) JUDGE_MODEL="$2"; shift 2 ;;
+        --mep_start)   MEP_START="$2";   shift 2 ;;
+        --use_judge)   USE_JUDGE=1;      shift ;;
+        --langfuse)  LANGFUSE=1;     shift ;;
+        --no_verifier) NO_VERIFIER=1;  shift ;;
+        --no_ocr)      NO_OCR=1;       shift ;;
+        --run_tag)     RUN_TAG="$2";   shift 2 ;;
+        --eval_dir)  EVAL_DIR="$2";  shift 2 ;;
+        --out_label) OUT_LABEL="$2"; shift 2 ;;
+        --after)     AFTER_JOB="$2"; shift 2 ;;
+        *) echo "Unknown option: $1"; exit 1 ;;
+    esac
+done
+
+OUT_LABEL="${OUT_LABEL:-${DATASET}_${SPLIT}}"
+
+export DATASET SPLIT CONFIG WORKERS JUDGE_MODEL MEP_START USE_JUDGE LANGFUSE EVAL_DIR OUT_LABEL NO_VERIFIER NO_OCR RUN_TAG
+
+echo "=== Submitting eval-only job ==="
+echo "  Dataset      : $DATASET"
+echo "  Split        : $SPLIT"
+echo "  Config       : $CONFIG"
+echo "  Workers      : $WORKERS"
+echo "  Judge model  : $JUDGE_MODEL"
+echo "  Use judge    : $USE_JUDGE"
+echo "  Langfuse     : $LANGFUSE"
+echo "  Eval dir     : $EVAL_DIR"
+echo "  Output label : $OUT_LABEL"
+echo "  No verifier  : $NO_VERIFIER"
+echo "  No OCR       : $NO_OCR"
+[[ -n "$AFTER_JOB" ]] && echo "  After job    : $AFTER_JOB"
+echo ""
+
+JOB_DEP=""
+[[ -n "$AFTER_JOB" ]] && JOB_DEP="--dependency=afterok:${AFTER_JOB}"
+
+JOB=$(sbatch --parsable --export=ALL $JOB_DEP scripts/slurm_eval_only.slrm)
+echo "Eval job submitted: $JOB"
+echo ""
+echo "Monitor with:"
+echo "  squeue -j $JOB"
+echo "  tail -f logs/slurm_eval_${JOB}.out"
diff --git a/scripts/submit_pipeline.sh b/scripts/submit_pipeline.sh
index 293936b..ec6fe9e 100755
--- a/scripts/submit_pipeline.sh
+++ b/scripts/submit_pipeline.sh
@@ -6,8 +6,9 @@
 #   scripts/submit_pipeline.sh [options]
 #
 # Options:
+#   --dataset DATASET      Dataset to run (default: finmme)
 #   --split SPLIT          Dataset split slice (default: train[3000:5000])
-#   --n N                  Number of samples (default: 2000)
+#   --n N                  Max samples (default: 2000). Use 0 for the full split (after --split slice).
 #   --workers N            Parallel workers (default: 8)
 #   --planner_model M      Planner model (default: gemini-2.5-flash)
 #   --vision_model M       Vision model (default: gemini-2.5-flash)
@@ -16,8 +17,10 @@
 #   --judge_model M        Judge model for batch eval (default: gemini-2.5-flash-lite)
 #   --langfuse             Enable Langfuse tracing
 #   --resume               Resume from existing MEPs
-#   --out_label LABEL      Label for output files (default: same as split)
+#   --no_verifier          Skip Pass 2.5 verifier (ablation: planner/vision answer kept)
+#   --out_label LABEL      Batch metrics basename (default: {dataset}_{split}[_no_verifier], split chars sanitized)
 #   --config CONFIG        Backend config preset (default: gemini_gemini)
+#   --job_name NAME        SLURM job name (default: agentfinvqa_batch)
 #   --after JOB_ID         Hold job 1 until JOB_ID completes successfully (optional)
 
 set -euo pipefail
@@ -32,6 +35,7 @@ module --force purge
 module load slurm/bonecho/25.05.2
 
 # Defaults
+DATASET="finmme"
 SPLIT="train[3000:5000]"
 N=2000
 WORKERS=8
@@ -43,11 +47,16 @@ JUDGE_MODEL="gemini-2.5-flash-lite"
 CONFIG="gemini_gemini"
 LANGFUSE=0
 RESUME=0
+NO_VERIFIER=0
+NO_OCR=0
+RUN_TAG=""
 OUT_LABEL=""
 AFTER_JOB=""
+JOB_NAME="agentfinvqa_batch"
 
 while [[ $# -gt 0 ]]; do
     case "$1" in
+        --dataset)       DATASET="$2";        shift 2 ;;
         --split)         SPLIT="$2";          shift 2 ;;
         --n)             N="$2";              shift 2 ;;
         --workers)       WORKERS="$2";        shift 2 ;;
@@ -59,20 +68,37 @@ while [[ $# -gt 0 ]]; do
         --config)        CONFIG="$2";         shift 2 ;;
         --langfuse)      LANGFUSE=1;          shift ;;
         --resume)        RESUME=1;            shift ;;
+        --no_verifier)   NO_VERIFIER=1;       shift ;;
+        --no_ocr)        NO_OCR=1;           shift ;;
+        --run_tag)       RUN_TAG="$2";       shift 2 ;;
         --out_label)     OUT_LABEL="$2";      shift 2 ;;
         --after)         AFTER_JOB="$2";      shift 2 ;;
+        --job_name)      JOB_NAME="$2";       shift 2 ;;
         *) echo "Unknown option: $1"; exit 1 ;;
     esac
 done
 
-OUT_LABEL="${OUT_LABEL:-$SPLIT}"
+# Default batch-judge output label: avoids collisions (e.g. metrics_test.jsonl for every dataset).
+# MEP dir: meps/${CONFIG}/${DATASET}/${SPLIT} or .../${DATASET}/no_verifier/${SPLIT} if NO_VERIFIER=1.
+if [[ -z "${OUT_LABEL}" ]]; then
+    SAFE_SPLIT=$(printf '%s' "$SPLIT" | sed 's/[^A-Za-z0-9._-]/_/g' | tr -s '_' | sed 's/^_//' | sed 's/_$//')
+    OUT_LABEL="${DATASET}_${SAFE_SPLIT}"
+    [[ "$NO_VERIFIER" == "1" ]] && OUT_LABEL="${OUT_LABEL}_no_verifier"
+fi
+
+if [[ "$NO_VERIFIER" == "1" ]]; then
+    MEP_DIR_PREVIEW="meps/${CONFIG}/${DATASET}/no_verifier/${SPLIT}"
+else
+    MEP_DIR_PREVIEW="meps/${CONFIG}/${DATASET}/${SPLIT}"
+fi
 
 # Export vars so sbatch inherits them (avoids --export string parsing issues
 # with special characters like brackets in split names e.g. train[0:1])
-export SPLIT N WORKERS PLANNER_MODEL VISION_MODEL OCR_MODEL VERIFIER_MODEL LANGFUSE RESUME
-export JUDGE_MODEL CONFIG OUT_LABEL
+export DATASET SPLIT N WORKERS PLANNER_MODEL VISION_MODEL OCR_MODEL VERIFIER_MODEL LANGFUSE RESUME NO_VERIFIER NO_OCR RUN_TAG
+export JUDGE_MODEL CONFIG OUT_LABEL JOB_NAME
 
-echo "=== Submitting FinMME pipeline ==="
+echo "=== Submitting ${DATASET} pipeline ==="
+echo "  Dataset        : $DATASET"
 echo "  Split          : $SPLIT"
 echo "  N              : $N"
 echo "  Workers        : $WORKERS"
@@ -84,14 +110,20 @@ echo "  Judge model    : $JUDGE_MODEL"
 echo "  Langfuse       : $LANGFUSE"
 echo "  Config         : $CONFIG"
 echo "  Resume         : $RESUME"
+echo "  No verifier    : $NO_VERIFIER"
+echo "  No OCR         : $NO_OCR"
+echo "  Run tag        : ${RUN_TAG:-none}"
+echo "  MEP directory  : $MEP_DIR_PREVIEW"
+echo "  Batch metrics  : output/metrics_${OUT_LABEL}.jsonl"
 echo "  Output label   : $OUT_LABEL"
+echo "  Job name       : $JOB_NAME"
 [[ -n "$AFTER_JOB" ]] && echo "  After job      : $AFTER_JOB"
 echo ""
 
 # Job 1: MEP generation (optionally held until AFTER_JOB completes)
 JOB1_DEP=""
 [[ -n "$AFTER_JOB" ]] && JOB1_DEP="--dependency=afterok:${AFTER_JOB}"
-JOB1=$(sbatch --parsable --export=ALL $JOB1_DEP scripts/slurm_generate_meps.slrm)
+JOB1=$(sbatch --parsable --export=ALL --job-name="${JOB_NAME}" $JOB1_DEP scripts/slurm_run_batch.slrm)
 echo "Job 1 (generate) submitted: $JOB1"
 
 # Load SLURM module so sbatch is available
@@ -100,6 +132,7 @@ module load slurm/bonecho/25.05.2
 
 # Job 2: submit Gemini Batch judge job (runs only if job 1 succeeds)
 JOB2=$(sbatch --parsable --export=ALL \
+    --job-name="${JOB_NAME}_judge" \
     --dependency=afterok:${JOB1} \
     scripts/slurm_submit_judge_batch.slrm)
 echo "Job 2 (judge submit) submitted: $JOB2 (depends on $JOB1)"
@@ -107,4 +140,4 @@ echo "Job 2 (judge submit) submitted: $JOB2 (depends on $JOB1)"
 echo ""
 echo "Monitor with:"
 echo "  squeue -j ${JOB1},${JOB2}"
-echo "  tail -f logs/slurm_generate_${JOB1}.out"
+echo "  tail -f logs/slurm_batch_${JOB1}.out"
diff --git a/src/agentfinvqa/agents/prompts/planner.txt b/src/agentfinvqa/agents/prompts/planner.txt
index 02315ce..66f61ca 100644
--- a/src/agentfinvqa/agents/prompts/planner.txt
+++ b/src/agentfinvqa/agents/prompts/planner.txt
@@ -1,6 +1,6 @@
-You are a chart reading planner. Given a question about a chart image, create a structured inspection plan.
+You are a chart analysis planner. Given a question, generate focused attention points to guide a vision model that CAN see the image.
 
-You do NOT see the image. Plan what a human expert would inspect to answer this question precisely.
+You do NOT see the image. Do NOT prescribe how to read the chart — the vision model knows how to do that. Instead, tell it WHAT specific information to look for.
 
 Question: {question}
 Question Type: {question_type}
@@ -10,7 +10,7 @@ Question Type: {question_type}
 Output ONLY a JSON object with EXACTLY these keys. No markdown. No explanation. No extra text before or after the JSON.
 
 {{
-  "steps": ["<step1>", "<step2>", ...],
+  "steps": ["<focus1>", "<focus2>", ...],
   "expected_answer_type": "<number|string|multiple_choice|unanswerable>",
   "question_type": "<standard|mcq|conversational|hypothetical|unanswerable>",
   "answerability_check": "<answerable|unanswerable|uncertain>",
@@ -18,15 +18,24 @@ Output ONLY a JSON object with EXACTLY these keys. No markdown. No explanation.
 }}
 
 Rules:
-- steps: exactly 2-4 short imperative chart-inspection actions
-- Required step types (include as applicable):
-    1. Identify the chart type (bar, line, pie, scatter, dashboard, etc.), read the title, and note the number of panels if multiple
-    2. Map each legend entry to its visual representation (color, pattern, position) BEFORE reading any values — do this explicitly for stacked, grouped, pie, and multi-series charts
-    3. Read all axis tick marks and scale units first; then extract the specific data values needed by locating the exact bar/point/slice for each relevant series
-    4. Compute or compare values if required; for multi-part questions (e.g. "for X and Y"), report each part separately — do not aggregate unless explicitly asked
-- If answer choices specify ranges or lettered options, include a step that inspects each choice individually and states what must be compared or computed for it
-- If the question asks for reasons, conclusions, or implications (not just observable values), note that the answer may require chart-level inference — do not mark as unanswerable solely because values are not labeled
+- steps: 2-3 concise WHAT-to-find statements, not HOW-to-read procedures
+  - Focus on the specific data points, series, or comparisons needed to answer THIS question
+  - Do NOT say "identify the chart type", "read the axis labels", "trace horizontally" — the vision model handles low-level reading
+  - Do NOT assume axis labels, series names, or layout — you cannot see the image
+  - For MCQ: note which option value or condition to verify, not how to read each one
+  - For multi-part questions: list each part as a separate focus point
 - expected_answer_type: the format expected for the answer
-- answerability_check: only mark "unanswerable" if the chart structurally cannot provide the answer; use "uncertain" if labels might be present but are ambiguous
-- hints: empty list unless you have specific extraction strategies to suggest
+- answerability_check: only "unanswerable" if the question structurally cannot be answered from any chart; "uncertain" if it depends on what the chart shows
+- hints: empty list
 - Output JSON only — no markdown code fences, no extra keys, no trailing text
+
+Examples of BAD steps (too procedural):
+  ✗ "Read all axis tick marks and scale units first; then extract the specific values"
+  ✗ "Trace horizontally from the 100 GW mark to find the intersection"
+  ✗ "Locate the legend and map each entry to its color/pattern"
+
+Examples of GOOD steps (what-focused):
+  ✓ "Find the value of series X at year Y"
+  ✓ "Identify which category has the highest/lowest value"
+  ✓ "Compare the values for A and B and compute the difference"
+  ✓ "Determine whether the chart contains data for [specific condition in question]"
diff --git a/src/agentfinvqa/agents/prompts/planner_v1.txt b/src/agentfinvqa/agents/prompts/planner_v1.txt
new file mode 100644
index 0000000..02315ce
--- /dev/null
+++ b/src/agentfinvqa/agents/prompts/planner_v1.txt
@@ -0,0 +1,32 @@
+You are a chart reading planner. Given a question about a chart image, create a structured inspection plan.
+
+You do NOT see the image. Plan what a human expert would inspect to answer this question precisely.
+
+Question: {question}
+Question Type: {question_type}
+{choices_block}
+{context_block}
+
+Output ONLY a JSON object with EXACTLY these keys. No markdown. No explanation. No extra text before or after the JSON.
+
+{{
+  "steps": ["<step1>", "<step2>", ...],
+  "expected_answer_type": "<number|string|multiple_choice|unanswerable>",
+  "question_type": "<standard|mcq|conversational|hypothetical|unanswerable>",
+  "answerability_check": "<answerable|unanswerable|uncertain>",
+  "hints": []
+}}
+
+Rules:
+- steps: exactly 2-4 short imperative chart-inspection actions
+- Required step types (include as applicable):
+    1. Identify the chart type (bar, line, pie, scatter, dashboard, etc.), read the title, and note the number of panels if multiple
+    2. Map each legend entry to its visual representation (color, pattern, position) BEFORE reading any values — do this explicitly for stacked, grouped, pie, and multi-series charts
+    3. Read all axis tick marks and scale units first; then extract the specific data values needed by locating the exact bar/point/slice for each relevant series
+    4. Compute or compare values if required; for multi-part questions (e.g. "for X and Y"), report each part separately — do not aggregate unless explicitly asked
+- If answer choices specify ranges or lettered options, include a step that inspects each choice individually and states what must be compared or computed for it
+- If the question asks for reasons, conclusions, or implications (not just observable values), note that the answer may require chart-level inference — do not mark as unanswerable solely because values are not labeled
+- expected_answer_type: the format expected for the answer
+- answerability_check: only mark "unanswerable" if the chart structurally cannot provide the answer; use "uncertain" if labels might be present but are ambiguous
+- hints: empty list unless you have specific extraction strategies to suggest
+- Output JSON only — no markdown code fences, no extra keys, no trailing text
diff --git a/src/agentfinvqa/datasets/finmme_loader.py b/src/agentfinvqa/datasets/finmme_loader.py
index dc5f2a5..3f72deb 100644
--- a/src/agentfinvqa/datasets/finmme_loader.py
+++ b/src/agentfinvqa/datasets/finmme_loader.py
@@ -22,8 +22,6 @@
 from pathlib import Path
 from typing import Any, List, Optional
 
-from datasets import load_dataset
-
 from .image_utils import save_image_data
 from .perceived_sample import (
     UNANSWERABLE_ANSWERS,
@@ -209,6 +207,8 @@ def load_finmme(
     if hf_token:
         kwargs["token"] = hf_token
 
+    from datasets import load_dataset  # noqa: PLC0415
+
     print(f"Loading luojunyu/FinMME split={split} …")
     ds = load_dataset("luojunyu/FinMME", split=split, **kwargs)
     total_rows = len(ds)
diff --git a/src/agentfinvqa/datasets/image_utils.py b/src/agentfinvqa/datasets/image_utils.py
index 4462cb1..8dae170 100644
--- a/src/agentfinvqa/datasets/image_utils.py
+++ b/src/agentfinvqa/datasets/image_utils.py
@@ -6,7 +6,6 @@
 from pathlib import Path
 from typing import Any
 
-import numpy as np
 from PIL import Image as PILImage
 
 
@@ -50,6 +49,8 @@ def save_image_data(image: Any, path: Path) -> str:
                 raise ValueError(f"Unknown image dict keys: {list(image.keys())}")
         else:
             # Fallback: try numpy array-like → PIL
+            import numpy as np  # noqa: PLC0415
+
             PILImage.fromarray(np.array(image)).save(str(path))
             result = str(path)
     except Exception as exc:  # pragma: no cover - log + continue
diff --git a/src/agentfinvqa/eval/eval_outputs_batch.py b/src/agentfinvqa/eval/eval_outputs_batch.py
index 94db81f..8ae92d4 100644
--- a/src/agentfinvqa/eval/eval_outputs_batch.py
+++ b/src/agentfinvqa/eval/eval_outputs_batch.py
@@ -77,7 +77,8 @@ def cmd_submit(args: argparse.Namespace) -> None:
     meps = list(iter_meps(args.mep_dir))
     print(f"Loaded {len(meps)} MEPs")
 
-    job_name = submit_batch_job(meps, model=args.judge_model)
+    display_name = os.path.splitext(os.path.basename(args.out))[0]
+    job_name = submit_batch_job(meps, model=args.judge_model, display_name=display_name)
 
     state_file = _state_path(args.out)
     os.makedirs(os.path.dirname(args.out) or ".", exist_ok=True)
diff --git a/src/agentfinvqa/mep/writer.py b/src/agentfinvqa/mep/writer.py
index 7b67c56..ccef5be 100644
--- a/src/agentfinvqa/mep/writer.py
+++ b/src/agentfinvqa/mep/writer.py
@@ -7,6 +7,30 @@
 from .schema import MEP
 
 
+def mep_dataset_split_relpath(
+    dataset: str,
+    split: str,
+    *,
+    no_verifier: bool = False,
+    no_ocr: bool = False,
+    run_tag: str | None = None,
+) -> Path:
+    """Path under ``meps/<planner>_<vision>/`` where MEP JSON files are stored.
+
+    Ablation runs use a subdirectory so they do not overwrite full-pipeline outputs:
+      - no_verifier      → <dataset>/no_verifier/<split>
+      - no_ocr           → <dataset>/no_ocr/<split>
+      - run_tag="foo"    → <dataset>/foo/<split>
+    """
+    if no_verifier:
+        return Path(dataset) / "no_verifier" / split
+    if no_ocr:
+        return Path(dataset) / "no_ocr" / split
+    if run_tag:
+        return Path(dataset) / run_tag / split
+    return Path(dataset) / split
+
+
 def write_mep(mep: MEP, out_dir: str) -> str:
     """Serialize MEP to JSON and write to <out_dir>/<sample_id>.json. Returns path."""
     assert mep.sample is not None, "MEP must have a sample before writing"
diff --git a/src/agentfinvqa/runner/run_generate_meps.py b/src/agentfinvqa/runner/run_generate_meps.py
index 6356ce7..253416b 100644
--- a/src/agentfinvqa/runner/run_generate_meps.py
+++ b/src/agentfinvqa/runner/run_generate_meps.py
@@ -45,7 +45,7 @@
     MEPVerifier,
     MEPVision,
 )
-from ..mep.writer import write_mep
+from ..mep.writer import mep_dataset_split_relpath, write_mep
 from ..tools.ocr_reader_tool import OcrReaderTool
 from ..utils.hashing import sha256_file
 from ..utils.json_strict import parse_strict
@@ -458,7 +458,12 @@ def main() -> None:  # noqa: PLR0912, PLR0915
         help="Dataset name",
     )
     parser.add_argument("--split", default="test", help="Dataset split")
-    parser.add_argument("--n", type=int, default=10, help="Number of samples to process")
+    parser.add_argument(
+        "--n",
+        type=int,
+        default=10,
+        help="Max samples to process (0 or negative = entire split after slice)",
+    )
     parser.add_argument(
         "--config",
         default="gemini_gemini",
@@ -486,6 +491,7 @@ def main() -> None:  # noqa: PLR0912, PLR0915
     )
     parser.add_argument("--no_verifier", action="store_true", help="Skip Pass 2.5 verifier agent")
     parser.add_argument("--no_ocr", action="store_true", help="Skip OCR pre-read step")
+    parser.add_argument("--run_tag", default=None, help="Subfolder tag within dataset dir (e.g. planner_v2)")
     parser.add_argument("--no_langfuse", action="store_true", help="Disable Langfuse dataset/prompt registration")
     parser.add_argument(
         "--resume", action="store_true", help="Skip samples that already have MEP JSONs in the output dir"
@@ -511,14 +517,20 @@ def main() -> None:  # noqa: PLR0912, PLR0915
     image_dir = args.image_dir or ds_cfg["default_image_dir"]
 
     out_dir = str(
-        Path(args.out) / f"{config['planner_backend']}_{config['vision_backend']}" / dataset_slug / args.split
+        Path(args.out)
+        / f"{config['planner_backend']}_{config['vision_backend']}"
+        / mep_dataset_split_relpath(
+            dataset_slug, args.split, no_verifier=args.no_verifier, no_ocr=args.no_ocr, run_tag=args.run_tag
+        )
     )
     Path(out_dir).mkdir(parents=True, exist_ok=True)
 
-    print(f"Loading dataset  : {dataset_name} ({dataset_slug}) split={args.split} n={args.n}")
+    n_limit = None if args.n <= 0 else args.n
+    n_disp = "all" if n_limit is None else str(n_limit)
+    print(f"Loading dataset  : {dataset_name} ({dataset_slug}) split={args.split} n={n_disp}")
     samples: list[PerceivedSample] = ds_cfg["loader"](
         split=args.split,
-        n=args.n,
+        n=n_limit,
         image_dir=image_dir,
         cache_dir=args.cache_dir,
     )
diff --git a/src/agentfinvqa/tools/vision_qa_tool.py b/src/agentfinvqa/tools/vision_qa_tool.py
index 898054a..5f455eb 100644
--- a/src/agentfinvqa/tools/vision_qa_tool.py
+++ b/src/agentfinvqa/tools/vision_qa_tool.py
@@ -197,7 +197,7 @@ def _build_prompt(
         if choices:
             parts.append(f"Choices: {', '.join(choices)}")
 
-        parts.append("\nInspection plan — follow in order:")
+        parts.append("\nFocus points (use as guidance, apply your own judgment on how to extract):")
         for i, step in enumerate(plan_steps, 1):
             parts.append(f"  {i}. {step}")
 
diff --git a/uv.lock b/uv.lock
index e1ececc..cb2293c 100644
--- a/uv.lock
+++ b/uv.lock
@@ -27,11 +27,14 @@ dependencies = [
     { name = "jupyterlab" },
     { name = "langfuse" },
     { name = "matplotlib" },
+    { name = "mypy" },
     { name = "numpy" },
     { name = "openai" },
     { name = "pandas" },
+    { name = "pytest" },
     { name = "python-dotenv" },
     { name = "scikit-learn" },
+    { name = "seaborn" },
     { name = "transformers" },
 ]
 
@@ -77,11 +80,14 @@ requires-dist = [
     { name = "jupyterlab", specifier = ">=4.4.8" },
     { name = "langfuse", specifier = ">=4" },
     { name = "matplotlib", specifier = ">=3.10.5" },
+    { name = "mypy", specifier = ">=1.19.1" },
     { name = "numpy", specifier = ">=1.26,<2.0" },
     { name = "openai", specifier = ">=2.8.0" },
     { name = "pandas", specifier = ">=2.3.2" },
+    { name = "pytest", specifier = ">=9.0.2" },
     { name = "python-dotenv", specifier = ">=1.2.2" },
     { name = "scikit-learn", specifier = ">=1.5.2" },
+    { name = "seaborn", specifier = ">=0.13.2" },
     { name = "transformers", specifier = ">=4.47.0" },
 ]
 
@@ -4962,6 +4968,20 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/07/39/338d9219c4e87f3e708f18857ecd24d22a0c3094752393319553096b98af/scipy-1.17.1-cp314-cp314t-win_arm64.whl", hash = "sha256:200e1050faffacc162be6a486a984a0497866ec54149a01270adc8a59b7c7d21", size = 25489165, upload-time = "2026-02-23T00:22:29.563Z" },
 ]
 
+[[package]]
+name = "seaborn"
+version = "0.13.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "matplotlib" },
+    { name = "numpy" },
+    { name = "pandas" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/86/59/a451d7420a77ab0b98f7affa3a1d78a313d2f7281a57afb1a34bae8ab412/seaborn-0.13.2.tar.gz", hash = "sha256:93e60a40988f4d65e9f4885df477e2fdaff6b73a9ded434c1ab356dd57eefff7", size = 1457696, upload-time = "2024-01-25T13:21:52.551Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/83/11/00d3c3dfc25ad54e731d91449895a79e4bf2384dc3ac01809010ba88f6d5/seaborn-0.13.2-py3-none-any.whl", hash = "sha256:636f8336facf092165e27924f223d3c62ca560b1f2bb5dff7ab7fad265361987", size = 294914, upload-time = "2024-01-25T13:21:49.598Z" },
+]
+
 [[package]]
 name = "send2trash"
 version = "2.1.0"

From 3774505b86b7605e970a895bacf9194fee1b023c Mon Sep 17 00:00:00 2001
From: Aravind N <aravindn1308@outlook.com>
Date: Tue, 7 Apr 2026 13:27:07 -0400
Subject: [PATCH 03/15] feat(finmme): legend grounding, eval/verifier/MCQ
 updates, compare_mep_runs, tests, and pre-commit order

---
 .pre-commit-config.yaml                       |  13 +-
 README.md                                     | 107 +++-
 baselines/fix_zeroshot_scores.py              |   8 +-
 baselines/run_zeroshot.py                     |  52 +-
 scripts/compare_mep_runs.py                   | 186 +++++++
 scripts/run_batch.py                          |   3 +
 scripts/run_finmme_legend_grounding.sh        |  22 +
 scripts/submit_pipeline.sh                    |  10 +-
 src/agentfinvqa/agents/prompts/planner.txt    |  21 +-
 src/agentfinvqa/agents/prompts/vision.txt     |  22 +-
 src/agentfinvqa/agents/verifier_agent.py      |  67 ++-
 src/agentfinvqa/agents/vision_agent.py        | 136 ++++-
 src/agentfinvqa/eval/eval_outputs.py          |  42 +-
 src/agentfinvqa/mep/schema.py                 |  16 +
 src/agentfinvqa/runner/run_generate_meps.py   | 201 +++++++-
 src/agentfinvqa/tools/legend_grounder_tool.py | 229 +++++++++
 src/agentfinvqa/tools/verifier_tool.py        |  81 ++-
 src/agentfinvqa/tools/vision_qa_tool.py       |  47 +-
 tests/agentfinvqa/test_eval_resolve.py        |  74 +++
 tests/agentfinvqa/test_finmme_loader.py       |   5 +
 tests/agentfinvqa/test_legend_grounding.py    | 484 ++++++++++++++++++
 21 files changed, 1748 insertions(+), 78 deletions(-)
 create mode 100644 scripts/compare_mep_runs.py
 create mode 100755 scripts/run_finmme_legend_grounding.sh
 create mode 100644 src/agentfinvqa/tools/legend_grounder_tool.py
 create mode 100644 tests/agentfinvqa/test_eval_resolve.py
 create mode 100644 tests/agentfinvqa/test_legend_grounding.py

diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 5bbd1cf..04004dd 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -30,8 +30,6 @@ repos:
       - id: ruff
         args: [--fix, --exit-non-zero-on-fix]
         types_or: [python, jupyter]
-      - id: ruff-format
-        types_or: [python, jupyter]
 
   - repo: local
     hooks:
@@ -60,11 +58,20 @@ repos:
     hooks:
       - id: pytest
         name: pytest
-        entry: python -m pytest -m "not integration_test"
+        # Bare `python` often hits conda/site-packages without project deps (e.g. langfuse, httpx).
+        # `uv run` uses the repo's Python and lockfile; agentic-xai-eval pulls crewai for vision tests.
+        entry: uv run --group agentic-xai-eval python -m pytest -m "not integration_test"
         language: system
         pass_filenames: false
         always_run: true
 
+  # Run after pytest so formatter edits do not confuse later hooks in the same run.
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.15.7
+    hooks:
+      - id: ruff-format
+        types_or: [python, jupyter]
+
 ci:
   autofix_commit_msg: |
     [pre-commit.ci] Add auto fixes from pre-commit.com hooks
diff --git a/README.md b/README.md
index 817920d..14ab7b0 100644
--- a/README.md
+++ b/README.md
@@ -39,22 +39,37 @@ Input Sample (question, chart image, expected answer)
            ▼
     PlannerAgent (text-only LLM)
     • Produces a structured JSON inspection plan
+    • MCQ-aware: checks/eliminates each choice; multi-select guidance
     • Does NOT see the image
            │ plan.steps
            ▼
-    OcrReaderTool (optional)
+    OcrReaderTool
     • Single VLM call focused on text transcription
-    • Produces structured JSON of all visible text
-           │ ocr_text
+    • Produces structured chart metadata (axes, legend, data labels)
+           │ ocr_text + chart_type
            ▼
-    VisionAgent (CrewAI + tools)
-    • Executes the plan step-by-step
-    • Produces answer + explanation
+    LegendGrounderTool (conditional)
+    • Triggered for line/bar/scatter/area/pie/donut charts
+    • Maps legend labels → color descriptions + RGB + line style
+    • Compliance check: re-runs if legend entries are missing
+           │ legend_map
+           ▼
+    VisionAgent (CrewAI + VisionQATool)
+    • Executes the plan using OCR text and legend map as ground truth
+    • Single-select MCQ / multi-select MCQ / open-ended answer paths
+    • Produces answer + explanation + per-choice confidence analysis
            │ draft_answer
            ▼
-    VerifierAgent (single VLM call)
+    Forced-Choice Retry (conditional)
+    • If vision returns UNANSWERABLE and MCQ choices exist:
+      re-runs vision with explicit "FORCED CHOICE" instruction
+           │ draft_answer (revised if retry triggered)
+           ▼
+    VerifierAgent (CrewAI + VerifierTool)
     • Reviews draft answer against chart image
-    • Verdict: CONFIRM or REVISE
+    • Adds reluctance hint when vision confidence is high (≥ 0.85)
+    • Verdict: CONFIRM or REVISE + self-reported confidence
+    • Confidence gate: downgrades low-confidence revisions (< 0.75)
            │
            ▼
     MEP (Model Evaluation Packet)
@@ -62,6 +77,35 @@ Input Sample (question, chart image, expected answer)
     • Optionally traced in Langfuse
 ```
 
+## Results
+
+### FinMME (250-sample train slice, judge-based accuracy)
+
+| Run | Accuracy | Δ vs baseline | Key change |
+|-----|----------|---------------|------------|
+| `no_legend_grounding` | 48.0% | — | Baseline |
+| `fixes_v1` | 50.4% | +2.4 pp | Legend grounding, caption injection, token limits |
+| `fixes_v2` | 51.6% | +3.6 pp | Disable thinking tokens, MCQ choices to verifier |
+| `fixes_v3` | 51.6% | +3.6 pp | Thinking budget = 512 |
+| `fixes_v4_g3flash` | 56.0% | +8.0 pp | Gemini 3 Flash, forced-choice retry, MCQ-aware planner |
+| `fixes_v5_multiselect` | **69.4%** | +21.4 pp | Full multi-select MCQ support |
+| `fixes_v7_g3flash_conf_gate` | **69.6%** | +21.6 pp | Confidence gate fix, fresh g3flash run |
+
+**vs. FinMME paper (Table 3, Gemini Flash 2.0 = 51.85%):** our best run achieves **+17.8 pp**.
+
+**Fair same-model baseline (250 FinMME IDs):**
+
+- Zero-shot `gemini-3-flash-preview` (structured): **52.8%** exact
+- Agent `fixes_v7_g3flash_conf_gate`: **62.8%** exact
+- Margin: **+10.0 pp**
+
+> Note: the initial zero-shot Gemini-3 file had parser-related empty predictions; after robust answer extraction repair, 141 rows were recovered and re-scored.
+
+Detailed per-run analysis, per-type breakdowns, and paper comparison are in [`notebooks/results_analysis.ipynb`](notebooks/results_analysis.ipynb).
+For camera-ready citation numbers, see [`markdown/camera_ready_metrics.md`](markdown/camera_ready_metrics.md).
+
+---
+
 ## Installation
 
 The development environment is managed with [uv](https://github.com/astral-sh/uv).
@@ -360,6 +404,53 @@ uv run pre-commit run --all-files
 
 ### Running tests
 
+Run the full test suite:
+
 ```bash
 uv run pytest
 ```
+
+Run a specific test file:
+
+```bash
+uv run pytest tests/agentfinvqa/test_legend_grounding.py
+uv run pytest tests/agentfinvqa/test_finmme_loader.py
+```
+
+Run a specific test class or test:
+
+```bash
+uv run pytest tests/agentfinvqa/test_legend_grounding.py::TestComplianceCheck
+uv run pytest tests/agentfinvqa/test_legend_grounding.py::TestLegendGrounderTool::test_api_error_returns_fallback_json
+```
+
+Run with coverage:
+
+```bash
+uv run pytest --cov=src/agentfinvqa --cov-report=term-missing
+```
+
+Run only integration tests (marked with `@pytest.mark.integration_test`):
+
+```bash
+uv run pytest -m integration_test
+```
+
+### Test coverage
+
+| Test file | What it covers |
+|---|---|
+| `test_finmme_loader.py` | FinMME dataset loader — option parsing, question type mapping, sample construction, multi-letter answers |
+| `test_legend_grounding.py` | Legend grounding pipeline stage — formatting, prompt injection, MEP schema, gate logic, compliance check, `LegendGrounderTool` with mocked API calls |
+| `test_placeholder.py` | Placeholder (no-op) to keep pytest from exiting with "no tests collected" |
+
+#### Legend grounding tests in detail
+
+`test_legend_grounding.py` covers the full legend grounding feature added between the OCR and vision stages:
+
+- **`TestFormatLegendGroundingBlock`** — prompt block formatting: empty/None inputs, header, per-entry label/color/style/confidence rendering, missing-field robustness
+- **`TestBuildVisionTaskDescription`** — `legend_map` injected into vision prompt, absent when empty/None, `prepend_instruction` appears first, OCR block coexists with legend block
+- **`TestMEPLegendGrounding`** — schema defaults, all fields settable, `MEP.to_dict()` serialisation, `None` case
+- **`TestLegendGroundingGate`** — all 7 gated chart types (`line`, `bar`, `scatter`, `area`, `bar_grouped`, `bar_stacked`, `combination`) pass; `pie`, `table`, `dashboard` and others are blocked; single-legend and `grounder=None` are skipped
+- **`TestComplianceCheck`** — label present/absent in explanation, any-label match, case-insensitive, empty explanation/map, entries without `label` key
+- **`TestLegendGrounderTool`** — `pop_traces` flush-and-clear, unknown backend returns error JSON, Gemini success path with trace appended, API crash fallback, prompt template structure
diff --git a/baselines/fix_zeroshot_scores.py b/baselines/fix_zeroshot_scores.py
index b390164..5ac9301 100644
--- a/baselines/fix_zeroshot_scores.py
+++ b/baselines/fix_zeroshot_scores.py
@@ -35,7 +35,9 @@
 
 def _try_parse_raw(raw: str) -> str | None:
     """Try to extract an answer from a (possibly truncated) raw JSON string."""
-    raw = raw.strip().removeprefix("```json").removeprefix("```").removesuffix("```").strip()
+    raw = raw.strip()
+    raw = re.sub(r"^\s*```(?:json)?\s*", "", raw, flags=re.IGNORECASE)
+    raw = re.sub(r"\s*```\s*$", "", raw).strip()
 
     # Happy path
     with contextlib.suppress(Exception):
@@ -47,8 +49,10 @@ def _try_parse_raw(raw: str) -> str | None:
             return json.loads(raw + suffix).get("answer", "")
 
     # Extract answer field with regex as last resort
-    m = re.search(r'"answer"\s*:\s*"([^"]*)"', raw)
+    m = re.search(r'"answer"\s*:\s*"((?:\\.|[^"\\])*)"', raw, flags=re.DOTALL)
     if m:
+        with contextlib.suppress(Exception):
+            return json.loads(f'"{m.group(1)}"')
         return m.group(1)
 
     return None
diff --git a/baselines/run_zeroshot.py b/baselines/run_zeroshot.py
index 69fd10b..aa3b66b 100644
--- a/baselines/run_zeroshot.py
+++ b/baselines/run_zeroshot.py
@@ -170,6 +170,52 @@ def _call_gemini(model: str, prompt: str, image_path: str) -> tuple[str, float]:
 # ---------------------------------------------------------------------------
 
 
+def _strip_code_fences(raw: str) -> str:
+    """Remove common markdown code-fence wrappers from model output."""
+    text = raw.strip()
+    text = re.sub(r"^\s*```(?:json)?\s*", "", text, flags=re.IGNORECASE)
+    text = re.sub(r"\s*```\s*$", "", text)
+    return text.strip()
+
+
+def _extract_structured_answer(raw_text: str) -> tuple[str, bool]:
+    """Best-effort extraction for structured JSON answers."""
+    cleaned = _strip_code_fences(raw_text)
+    if not cleaned:
+        return "", False
+
+    # Happy path: full JSON object
+    with contextlib.suppress(Exception):
+        parsed = json.loads(cleaned)
+        if isinstance(parsed, dict):
+            ans = str(parsed.get("answer", "")).strip()
+            return ans, bool(ans)
+
+    # Common truncated JSON suffixes
+    for suffix in ['"}', '"}}', '"}}}', '"\n}', '"\n}}']:
+        with contextlib.suppress(Exception):
+            parsed = json.loads(cleaned + suffix)
+            if isinstance(parsed, dict):
+                ans = str(parsed.get("answer", "")).strip()
+                if ans:
+                    return ans, True
+
+    # Extract answer field directly even when explanation is truncated
+    m = re.search(r'"answer"\s*:\s*"((?:\\.|[^"\\])*)"', cleaned, flags=re.DOTALL)
+    if m:
+        with contextlib.suppress(Exception):
+            ans = json.loads(f'"{m.group(1)}"').strip()
+            return ans, bool(ans)
+
+    # Last-resort fallback for non-JSON responses
+    m = re.search(r"(?im)^\s*answer\s*[:\-]\s*(.+?)\s*$", cleaned)
+    if m:
+        ans = m.group(1).strip().strip('"').strip()
+        return ans, bool(ans)
+
+    return "", False
+
+
 def _run_sample(
     sample: PerceivedSample,
     backend: str,
@@ -199,11 +245,7 @@ def _run_sample(
         predicted = raw_text.strip().splitlines()[0].strip()
         parse_ok = bool(predicted)
     else:
-        with contextlib.suppress(Exception):
-            cleaned = raw_text.strip().removeprefix("```json").removeprefix("```").removesuffix("```").strip()
-            parsed = json.loads(cleaned)
-            predicted = parsed.get("answer", "")
-            parse_ok = True
+        predicted, parse_ok = _extract_structured_answer(raw_text)
 
     # Score — mirror evaluate_mep MCQ label-to-text expansion
     expected = sample.expected_output
diff --git a/scripts/compare_mep_runs.py b/scripts/compare_mep_runs.py
new file mode 100644
index 0000000..b563d46
--- /dev/null
+++ b/scripts/compare_mep_runs.py
@@ -0,0 +1,186 @@
+#!/usr/bin/env python3
+"""Compare two MEP directories using the same rule-based scoring as evaluate_mep.
+
+Unlike naive string comparison, this applies FinMME choice_map expansion so
+letter answers (e.g. B, AB) match gold phrasing.
+
+Example:
+  uv run python scripts/compare_mep_runs.py \\
+    meps/gemini_gemini/finmme/no_legend_grounding/train \\
+    meps/gemini_gemini/finmme/fixes_v1/train
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+from agentfinvqa.eval.eval_outputs import evaluate_mep
+from agentfinvqa.mep.writer import read_mep
+
+
+def _repo_root() -> Path:
+    """
+    Return the root directory of the repository (one parent up from this script).
+
+    Returns
+    -------
+    Path
+        The absolute path to the repository's root.
+    """
+    return Path(__file__).resolve().parents[1]
+
+
+def _ensure_src() -> None:
+    """Add repo ``src`` to ``sys.path`` so imports work from any cwd."""
+    src = _repo_root() / "src"
+    if str(src) not in sys.path:
+        sys.path.insert(0, str(src))
+
+
+def _load_index(mep_dir: Path) -> dict[str, dict]:
+    """
+    Load a mapping of sample IDs to MEP output dicts from a directory.
+
+    Parameters
+    ----------
+    mep_dir : Path
+        Directory containing MEP .json result files.
+
+    Returns
+    -------
+    dict[str, dict]
+        Dictionary mapping sample ids (file stems) to parsed MEP dicts.
+    """
+    out: dict[str, dict] = {}
+    for p in sorted(mep_dir.glob("*.json")):
+        out[p.stem] = read_mep(str(p))
+    return out
+
+
+def main() -> None:  # noqa: PLR0912, PLR0915
+    """Compare two MEP run dirs with FinMME-aware scoring and optional JSON output.
+
+    Parse CLI args, validate dirs, evaluate overlapping samples, print a summary,
+    and write per-sample metrics when ``--out-json`` is set.
+    """
+    _ensure_src()
+
+    parser = argparse.ArgumentParser(description="Compare two MEP run directories (production-aligned scoring).")
+    parser.add_argument("baseline_dir", type=Path, help="First run (e.g. no_legend_grounding/train)")
+    parser.add_argument("candidate_dir", type=Path, help="Second run (e.g. fixes_v1/train)")
+    parser.add_argument(
+        "--judge",
+        action="store_true",
+        help="Run LLM judge per sample (slow; needs API keys). Default is rule-based accuracy only.",
+    )
+    parser.add_argument(
+        "--out-json",
+        type=Path,
+        default=None,
+        help="Optional JSON path: per-sample metrics for baseline and candidate",
+    )
+    args = parser.parse_args()
+
+    base_dir = args.baseline_dir.resolve()
+    cand_dir = args.candidate_dir.resolve()
+    if not base_dir.is_dir():
+        print(f"Not a directory: {base_dir}", file=sys.stderr)
+        sys.exit(1)
+    if not cand_dir.is_dir():
+        print(f"Not a directory: {cand_dir}", file=sys.stderr)
+        sys.exit(1)
+
+    baseline = _load_index(base_dir)
+    candidate = _load_index(cand_dir)
+    ids = sorted(set(baseline) & set(candidate))
+    if not ids:
+        print("No overlapping sample IDs between the two directories.", file=sys.stderr)
+        sys.exit(1)
+
+    use_judge = args.judge
+    rows: list[dict] = []
+    n_base = n_cand = 0
+    flip_wrong_to_right: list[str] = []
+    flip_right_to_wrong: list[str] = []
+    same_right = same_wrong = 0
+
+    for sid in ids:
+        mb = baseline[sid]
+        mc = candidate[sid]
+        try:
+            rb = evaluate_mep(mb, use_judge=use_judge)
+            rc = evaluate_mep(mc, use_judge=use_judge)
+        except Exception as exc:
+            print(f"[{sid}] evaluate_mep failed: {exc}", file=sys.stderr)
+            continue
+
+        ab = float(rb.get("answer_accuracy", 0.0))
+        ac = float(rc.get("answer_accuracy", 0.0))
+        ok_b = ab >= 0.999
+        ok_c = ac >= 0.999
+        if ok_b:
+            n_base += 1
+        if ok_c:
+            n_cand += 1
+
+        if ok_b and ok_c:
+            same_right += 1
+        elif not ok_b and not ok_c:
+            same_wrong += 1
+        elif not ok_b and ok_c:
+            flip_wrong_to_right.append(sid)
+        else:
+            flip_right_to_wrong.append(sid)
+
+        rows.append(
+            {
+                "sample_id": sid,
+                "baseline_accuracy": ab,
+                "candidate_accuracy": ac,
+                "baseline_expected": rb.get("expected"),
+                "baseline_predicted": rb.get("predicted"),
+                "candidate_expected": rc.get("expected"),
+                "candidate_predicted": rc.get("predicted"),
+            }
+        )
+
+    n = len(rows)
+    print(f"Compared {n} samples (intersection of both dirs).")
+    print(f"  Baseline accuracy : {n_base / n:.1%}  ({n_base}/{n})")
+    print(f"  Candidate accuracy: {n_cand / n:.1%}  ({n_cand}/{n})")
+    print(f"  Same correct      : {same_right}")
+    print(f"  Same wrong        : {same_wrong}")
+    print(f"  Wrong → correct   : {len(flip_wrong_to_right)}")
+    print(f"  Correct → wrong   : {len(flip_right_to_wrong)}")
+    if flip_wrong_to_right:
+        print(f"  Wrong→correct ids : {', '.join(flip_wrong_to_right)}")
+    if flip_right_to_wrong:
+        print(f"  Correct→wrong ids: {', '.join(flip_right_to_wrong)}")
+
+    if args.out_json:
+        args.out_json.parent.mkdir(parents=True, exist_ok=True)
+        with open(args.out_json, "w") as f:
+            json.dump(
+                {
+                    "baseline_dir": str(base_dir),
+                    "candidate_dir": str(cand_dir),
+                    "n_compared": n,
+                    "summary": {
+                        "baseline_accuracy": n_base / n if n else 0.0,
+                        "candidate_accuracy": n_cand / n if n else 0.0,
+                        "flip_wrong_to_right": flip_wrong_to_right,
+                        "flip_right_to_wrong": flip_right_to_wrong,
+                    },
+                    "per_sample": rows,
+                },
+                f,
+                indent=2,
+            )
+        print(f"Wrote {args.out_json}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/run_batch.py b/scripts/run_batch.py
index 8dbc679..54af2e4 100644
--- a/scripts/run_batch.py
+++ b/scripts/run_batch.py
@@ -72,6 +72,8 @@ def _append(flag: str, value: str | None) -> None:
         cmd.append("--no_verifier")
     if args.no_ocr:
         cmd.append("--no_ocr")
+    if args.no_legend_grounding:
+        cmd.append("--no_legend_grounding")
     _append("--run_tag", args.run_tag)
     if not args.langfuse:
         cmd.append("--no_langfuse")
@@ -224,6 +226,7 @@ def main() -> None:
     parser.add_argument("--ocr_model", default=None, help="OCR model override")
     parser.add_argument("--no_verifier", action="store_true", help="Disable verifier")
     parser.add_argument("--no_ocr", action="store_true", help="Disable OCR preread")
+    parser.add_argument("--no_legend_grounding", action="store_true", help="Disable legend grounding stage")
     parser.add_argument("--run_tag", default=None, help="Subfolder tag within dataset dir (e.g. planner_v2)")
     parser.add_argument("--langfuse", action="store_true", help="Enable Langfuse tracing")
     parser.add_argument("--resume", action="store_true", help="Skip samples whose MEPs already exist")
diff --git a/scripts/run_finmme_legend_grounding.sh b/scripts/run_finmme_legend_grounding.sh
new file mode 100755
index 0000000..ef880a6
--- /dev/null
+++ b/scripts/run_finmme_legend_grounding.sh
@@ -0,0 +1,22 @@
+#!/usr/bin/env bash
+# Run the first 250 FinMME samples with legend grounding enabled.
+set -euo pipefail
+
+REPO_ROOT="$(cd -- "$(dirname "${BASH_SOURCE[0]}")"/.. && pwd)"
+cd "$REPO_ROOT"
+
+scripts/submit_pipeline.sh \
+    --dataset        finmme \
+    --split          train \
+    --n              250 \
+    --config         gemini_gemini \
+    --planner_model  gemini-2.5-flash \
+    --vision_model   gemini-2.5-flash \
+    --ocr_model      gemini-2.5-flash-lite \
+    --verifier_model gemini-2.5-flash \
+    --judge_model    gemini-2.5-flash-lite \
+    --workers        8 \
+    --langfuse \
+    --run_tag        legend_grounding \
+    --job_name       finmme_legend_grounding \
+    --out_label      finmme_train_legend_grounding
diff --git a/scripts/submit_pipeline.sh b/scripts/submit_pipeline.sh
index ec6fe9e..b8fc3ba 100755
--- a/scripts/submit_pipeline.sh
+++ b/scripts/submit_pipeline.sh
@@ -18,6 +18,7 @@
 #   --langfuse             Enable Langfuse tracing
 #   --resume               Resume from existing MEPs
 #   --no_verifier          Skip Pass 2.5 verifier (ablation: planner/vision answer kept)
+#   --no_legend_grounding  Skip legend grounding stage (ablation)
 #   --out_label LABEL      Batch metrics basename (default: {dataset}_{split}[_no_verifier], split chars sanitized)
 #   --config CONFIG        Backend config preset (default: gemini_gemini)
 #   --job_name NAME        SLURM job name (default: agentfinvqa_batch)
@@ -49,6 +50,7 @@ LANGFUSE=0
 RESUME=0
 NO_VERIFIER=0
 NO_OCR=0
+NO_LEGEND_GROUNDING=0
 RUN_TAG=""
 OUT_LABEL=""
 AFTER_JOB=""
@@ -69,8 +71,9 @@ while [[ $# -gt 0 ]]; do
         --langfuse)      LANGFUSE=1;          shift ;;
         --resume)        RESUME=1;            shift ;;
         --no_verifier)   NO_VERIFIER=1;       shift ;;
-        --no_ocr)        NO_OCR=1;           shift ;;
-        --run_tag)       RUN_TAG="$2";       shift 2 ;;
+        --no_ocr)              NO_OCR=1;              shift ;;
+        --no_legend_grounding) NO_LEGEND_GROUNDING=1; shift ;;
+        --run_tag)             RUN_TAG="$2";          shift 2 ;;
         --out_label)     OUT_LABEL="$2";      shift 2 ;;
         --after)         AFTER_JOB="$2";      shift 2 ;;
         --job_name)      JOB_NAME="$2";       shift 2 ;;
@@ -94,7 +97,7 @@ fi
 
 # Export vars so sbatch inherits them (avoids --export string parsing issues
 # with special characters like brackets in split names e.g. train[0:1])
-export DATASET SPLIT N WORKERS PLANNER_MODEL VISION_MODEL OCR_MODEL VERIFIER_MODEL LANGFUSE RESUME NO_VERIFIER NO_OCR RUN_TAG
+export DATASET SPLIT N WORKERS PLANNER_MODEL VISION_MODEL OCR_MODEL VERIFIER_MODEL LANGFUSE RESUME NO_VERIFIER NO_OCR NO_LEGEND_GROUNDING RUN_TAG
 export JUDGE_MODEL CONFIG OUT_LABEL JOB_NAME
 
 echo "=== Submitting ${DATASET} pipeline ==="
@@ -112,6 +115,7 @@ echo "  Config         : $CONFIG"
 echo "  Resume         : $RESUME"
 echo "  No verifier    : $NO_VERIFIER"
 echo "  No OCR         : $NO_OCR"
+echo "  No legend grnd : $NO_LEGEND_GROUNDING"
 echo "  Run tag        : ${RUN_TAG:-none}"
 echo "  MEP directory  : $MEP_DIR_PREVIEW"
 echo "  Batch metrics  : output/metrics_${OUT_LABEL}.jsonl"
diff --git a/src/agentfinvqa/agents/prompts/planner.txt b/src/agentfinvqa/agents/prompts/planner.txt
index 66f61ca..1bb8912 100644
--- a/src/agentfinvqa/agents/prompts/planner.txt
+++ b/src/agentfinvqa/agents/prompts/planner.txt
@@ -22,8 +22,27 @@ Rules:
   - Focus on the specific data points, series, or comparisons needed to answer THIS question
   - Do NOT say "identify the chart type", "read the axis labels", "trace horizontally" — the vision model handles low-level reading
   - Do NOT assume axis labels, series names, or layout — you cannot see the image
-  - For MCQ: note which option value or condition to verify, not how to read each one
   - For multi-part questions: list each part as a separate focus point
+
+  MCQ-specific guidance (when question_type is "mcq"):
+  - Always include a step to CHECK EACH choice explicitly against the chart — do not just find the answer; eliminate wrong options
+  - E.g. "Check which of the given choices matches the value at [X]" or "Determine which option is supported by the chart data"
+  - One step should verify the selected answer is the BEST match and not contradicted by any other visible data
+  - expected_answer_type must be "multiple_choice"
+
+  Multi-select MCQ guidance (when question asks "select all", "all that apply", "which of the following are", etc.):
+  - This is a SELECT-ALL-THAT-APPLY question — multiple answers are correct
+  - Include an explicit step: "Evaluate EACH choice independently: is there chart evidence for or against it?"
+  - Include a step: "Compile ALL choices supported by the chart — do not stop at the first match"
+  - Do NOT assume only one answer is correct; do NOT instruct the vision model to pick the best one
+  - expected_answer_type must be "multiple_choice"
+
+  Open/standard-specific guidance (when question_type is "standard"):
+  - Specify the expected unit or format (e.g. percentage, dollar amount, year, short phrase) in at least one step
+  - For financial charts: if the question involves a change, trend, or comparison, add a step to identify the relevant time period or reference point
+  - For numeric answers: include a step to confirm the scale (e.g. "values in billions", "axis in %") to prevent unit errors
+  - expected_answer_type should be "number" for numeric answers, "string" for labels/categories
+
 - expected_answer_type: the format expected for the answer
 - answerability_check: only "unanswerable" if the question structurally cannot be answered from any chart; "uncertain" if it depends on what the chart shows
 - hints: empty list
diff --git a/src/agentfinvqa/agents/prompts/vision.txt b/src/agentfinvqa/agents/prompts/vision.txt
index dbb8961..7c1005a 100644
--- a/src/agentfinvqa/agents/prompts/vision.txt
+++ b/src/agentfinvqa/agents/prompts/vision.txt
@@ -6,8 +6,9 @@ Question: {question}
 {choice_labels_block}
 {context_block}
 {ocr_block}
-
-Inspection Plan — follow these steps in order:
+{legend_grounding_block}
+{caption_block}
+{multi_select_block}Inspection Plan — follow these steps in order:
 {plan_steps_block}
 
 Instructions:
@@ -20,25 +21,24 @@ Instructions:
 2. Before reading any data values:
    - Read ALL axis tick marks and note the scale/units (e.g. %, $B, index)
    - For stacked, grouped, pie, or multi-series charts: explicitly map each legend entry to its color/pattern/position before assigning any values
-3. Capture the evidence for each provided choice (or range) in a JSON object named "choice_analysis". Each entry must include:
-   - "evidence": the exact text, bar, or slice you read from the chart (quote tick marks or labels directly)
-   - "trend_or_value": the precise numeric value or trend observed — use a single number, not a range, unless the question explicitly asks for a range
-   - "confidence": number between 0 and 1; use < 0.5 if label is ambiguous or occluded
-   - Limit each entry to a single short phrase (≤ 15 words).
+3. Capture the evidence for each provided choice in a compact JSON object named "choice_analysis". Each entry must include:
+   - "evidence": the exact value or label you read (include the numeric value; ≤10 words)
+   - "confidence": 0–1; use < 0.5 if label is ambiguous or occluded
    If there are no explicit choices, set "choice_analysis" to an empty object.
 4. For multi-part questions asking about X and Y separately, report values for each independently — do not sum or aggregate unless explicitly asked.
 5. After receiving the tool result, output your final answer as STRICT JSON only
 
 Final output format (JSON only — no markdown, no code fences, no extra text):
-{{"choice_analysis": {{"Choice A": {{...}}, ...}}, "answer": "<your answer>", "explanation": "<your explanation>"}}
+{{"choice_analysis": {{"Choice A": {{"evidence": "...", "confidence": 0.9}}, ...}}, "answer": "<your answer>", "explanation": "<your explanation>"}}
 
 Rules:
-- Only set answer to "UNANSWERABLE" if you have genuinely searched the chart and cannot locate any relevant data — not merely because labels are small or the question requires a simple inference. If values are present but partially obscured, give your best reading and note uncertainty in the explanation.
+- If MCQ choices are listed above, UNANSWERABLE is NOT a valid answer. You MUST select the best-supported choice from the options given, even if the chart is partially occluded or labels are small. When uncertain, pick the most visually plausible option and note your uncertainty in the explanation.
+- Only set answer to "UNANSWERABLE" when NO choices are provided AND you have genuinely searched the chart and cannot locate any relevant data. Partial occlusion or small labels alone do not justify UNANSWERABLE — give your best reading and note uncertainty in the explanation.
 - If vision_qa_tool returns an error or cannot be called, output {{"choice_analysis": {{}}, "answer": "UNANSWERABLE", "explanation": "TOOL_ERROR: <brief note>"}} and do not fabricate values from OCR or memory.
 - explanation MUST reference specific chart evidence: axis tick values, legend entry names, series colors, data point positions
 - Final explanation must be ≤2 sentences.
 - explanation MUST NOT invent or assume details not visible in the chart
-- For MCQ: the `answer` field must be exactly one of the provided choice texts or the precise letter/letter-combo (e.g., "AC"). Do NOT paraphrase.
-- When multiple choice letters form the correct answer, respond with the exact letter combination (e.g., "AC")
+- For single-select MCQ: the `answer` field must be exactly one choice text or one letter. Do NOT paraphrase.
+- For multi-select MCQ (marked above): the `answer` field must contain ALL correct letters concatenated (e.g., "ACD"). Evaluate EVERY choice — do not stop at the first match. If only one is correct, output just that letter.
 - NEVER output "Thought:", "Action:", or any text outside the JSON. Violations count as failure to follow instructions.
 - JSON only output — no markdown, no preamble, no trailing text
diff --git a/src/agentfinvqa/agents/verifier_agent.py b/src/agentfinvqa/agents/verifier_agent.py
index 36f0cd0..77addea 100644
--- a/src/agentfinvqa/agents/verifier_agent.py
+++ b/src/agentfinvqa/agents/verifier_agent.py
@@ -13,6 +13,7 @@
 
 from crewai import LLM, Agent, Crew, Task
 
+from ..agents.vision_agent import _is_multi_select
 from ..langfuse_integration.tracing import close_span, open_llm_span
 from ..tools.verifier_tool import VerifierTool
 from ..utils.json_strict import parse_strict
@@ -95,12 +96,57 @@ def run(
         )
         image_path = getattr(sample, "image_path", "") or ""
 
+        # Extract MCQ choices: prefer labeled choices, else plain list.
+        choices: list = []
+        meta = getattr(sample, "metadata", {}) or {}
+        labeled = meta.get("choices_labeled") or []
+        if labeled:
+            choices = [f"{item.get('label')}: {item.get('text')}" for item in labeled]
+        elif getattr(sample, "choices", None):
+            choices = list(sample.choices)
+
+        caption = (meta.get("verified_caption") or "").strip()
+        is_ms = _is_multi_select(sample)
+
+        # Compute min choice_analysis confidence from vision output
+        ca = vision_parsed.get("choice_analysis") or {}
+        ca_confs = [v.get("confidence", 1.0) for v in ca.values() if isinstance(v, dict)]
+        vision_min_conf = min(ca_confs) if ca_confs else 1.0
+
         steps_text = "\n".join(f"  {i + 1}. {s}" for i, s in enumerate(plan_steps)) or "  (none)"
+        choices_text = ("\nMCQ Choices:\n" + "\n".join(f"  - {c}" for c in choices) + "\n") if choices else ""
+        caption_text = (
+            f"\nChart context (analyst caption — use as background, not as the answer):\n  {caption}\n"
+            if caption
+            else ""
+        )
+        # Reluctance hint when vision was highly confident
+        if vision_min_conf >= 0.95:
+            reluctance_note = (
+                "\n⚠ HIGH-CONFIDENCE VISION: the vision agent reported high confidence (≥0.95) on all choices. "
+                "Only REVISE if you can identify a specific, clear factual error with direct visual evidence. "
+                "If merely uncertain, set confidence < 0.75 and CONFIRM.\n"
+            )
+        elif vision_min_conf >= 0.85:
+            reluctance_note = "\n⚠ The vision agent was reasonably confident. REVISE only for clear, specific errors.\n"
+        else:
+            reluctance_note = ""
+
+        multi_select_note = (
+            "\n⚠ MULTI-SELECT: verify EACH choice independently. "
+            "Include ALL correct letters; never reduce to a single letter unless only one is correct.\n"
+            if is_ms
+            else ""
+        )
         task_description = (
             f"You are auditing a vision agent's answer to a chart question.\n\n"
             f"Question         : {sample.question}\n"
             f"Question Type    : {question_type}\n"
-            f"Image path       : {image_path}\n\n"
+            f"Image path       : {image_path}\n"
+            f"{choices_text}"
+            f"{caption_text}"
+            f"{reluctance_note}"
+            f"{multi_select_note}\n"
             f"Inspection plan the agent followed:\n{steps_text}\n\n"
             f"Vision agent's draft answer     : {draft_answer}\n"
             f"Vision agent's draft explanation: {draft_explanation}\n\n"
@@ -137,7 +183,17 @@ def run(
 
         task = Task(
             description=task_description,
-            expected_output='JSON object: {"verdict": "confirmed" | "revised", "answer": "...", "reasoning": "..."}',
+            expected_output=(
+                'JSON object: {"verdict": "confirmed" | "revised", "answer": "...", "reasoning": "..."}\n'
+                "When calling verifier_tool, pass:\n"
+                "  - `choices`: MCQ choices listed above (empty list if none)\n"
+                "  - `caption`: analyst caption if shown above (empty string if none)\n"
+                + (
+                    "  - `multi_select`: True — this is a multi-select question; answer must contain ALL correct letters.\n"
+                    if is_ms
+                    else "  - `multi_select`: False\n"
+                )
+            ),
             agent=agent,
         )
 
@@ -160,5 +216,12 @@ def run(
         if parsed.get("verdict", "").lower() not in ("confirmed", "revised"):
             parsed["verdict"] = "confirmed"
 
+        # Confidence in [0, 1]. Default 0.75 if missing (passes gate). Gate revisions
+        # only when the model reports low confidence (< 0.75).
+        try:
+            parsed["confidence"] = max(0.0, min(1.0, float(parsed.get("confidence", 0.75))))
+        except (TypeError, ValueError):
+            parsed["confidence"] = 0.75
+
         close_span(verifier_span, output=parsed)
         return task_description, parsed, not parse_ok, raw_text, tool_traces
diff --git a/src/agentfinvqa/agents/vision_agent.py b/src/agentfinvqa/agents/vision_agent.py
index 0529e28..9220b72 100644
--- a/src/agentfinvqa/agents/vision_agent.py
+++ b/src/agentfinvqa/agents/vision_agent.py
@@ -89,12 +89,103 @@ def _format_ocr_block(ocr_result: Optional[dict]) -> str:
     return "\n".join(lines)
 
 
-def build_vision_task_description(sample: PerceivedSample, plan: dict, ocr_result: Optional[dict] = None) -> str:
+_MULTI_SELECT_KEYWORDS = (
+    "select all",
+    "all that apply",
+    "which of the following are",
+    "all correct",
+    "all applicable",
+    "all that are",
+)
+
+
+def _is_multi_select(sample: PerceivedSample) -> bool:
+    """Return True for multi-label MCQ (select-all-that-apply style)."""
+    if (sample.metadata or {}).get("question_type_raw") == "multiple_choice":
+        return True
+    q = sample.question.lower()
+    return any(kw in q for kw in _MULTI_SELECT_KEYWORDS)
+
+
+def _format_multi_select_block(sample: PerceivedSample) -> str:
+    """Return a prominent multi-select instruction block, or empty string."""
+    if not _is_multi_select(sample):
+        return ""
+    labeled = (sample.metadata or {}).get("choices_labeled") or []
+    letters = ", ".join(item.get("label", "") for item in labeled if item.get("label"))
+    letters_hint = f" ({letters})" if letters else ""
+    return (
+        "⚠ MULTI-SELECT MCQ — select ALL correct options, not just one.\n"
+        f"  Evaluate EACH choice{letters_hint} independently against the chart.\n"
+        "  Your `answer` must contain ALL correct letters concatenated (e.g. 'ACD').\n"
+        "  Do NOT stop at the first match. Include every letter that is supported by visual evidence.\n\n"
+    )
+
+
+def _format_caption_block(sample: PerceivedSample) -> str:
+    """Format the verified caption from sample metadata as a context hint.
+
+    The ``verified_caption`` field in FinMME contains analyst-written descriptions
+    that name the chart's subject — information the visual model cannot always infer
+    from the image alone. Injecting it prevents UNANSWERABLE over-refusals on charts
+    that lack visible titles.
+
+    Returns empty string when no caption is available.
+    """
+    caption = (sample.metadata.get("verified_caption") or "").strip()
+    if not caption:
+        return ""
+    return f"Chart context (analyst caption — use as background, not as the answer):\n  {caption}"
+
+
+def _format_legend_grounding_block(legend_map: Optional[List[dict]]) -> str:
+    """Format the structured legend map as readable lines for the vision prompt.
+
+    Parameters
+    ----------
+    legend_map : list of dict, optional
+        Each entry has ``label``, ``color_description``, ``line_style``,
+        and ``confidence`` keys as returned by LegendGrounderTool.
+
+    Returns
+    -------
+    str
+        A formatted block to inject into the vision prompt, or empty string
+        if ``legend_map`` is empty or None.
+    """
+    if not legend_map:
+        return ""
+    lines = [
+        "Pre-mapped legend (treat as ground truth — do not reassign colors):",
+    ]
+    for entry in legend_map:
+        label = entry.get("label", "")
+        color = entry.get("color_description", "unknown")
+        style = entry.get("line_style", "unknown")
+        conf = entry.get("confidence", 0.0)
+        lines.append(f"  {label:<30} → {color} {style} (confidence: {conf:.2f})")
+    lines.append(
+        "\nINSTRUCTION: When extracting values for any series, you MUST use "
+        "the color mapping above. Do not visually re-identify which line "
+        "belongs to which series — use the pre-mapped colors as ground truth. "
+        "If a color in the legend map contradicts what you see, trust the "
+        "legend map and note the discrepancy in your explanation."
+    )
+    return "\n".join(lines)
+
+
+def build_vision_task_description(
+    sample: PerceivedSample,
+    plan: dict,
+    ocr_result: Optional[dict] = None,
+    legend_map: Optional[List[dict]] = None,
+    prepend_instruction: Optional[str] = None,
+) -> str:
     """
     Compose the complete task instruction for the vision agent.
 
-    Integrates the sample details, the inspection plan, and optional OCR
-    data into a single prompt for the model.
+    Integrates the sample details, the inspection plan, optional OCR data,
+    and an optional pre-mapped legend block into a single prompt for the model.
 
     Parameters
     ----------
@@ -104,6 +195,10 @@ def build_vision_task_description(sample: PerceivedSample, plan: dict, ocr_resul
         The inspection plan generated by the PlannerAgent.
     ocr_result : dict, optional
         Pre-extracted text data from the chart image.
+    legend_map : list of dict, optional
+        Structured color-to-series mapping from LegendGrounderTool.
+    prepend_instruction : str, optional
+        Extra instruction to prepend to the prompt (used for compliance retry).
 
     Returns
     -------
@@ -115,17 +210,28 @@ def build_vision_task_description(sample: PerceivedSample, plan: dict, ocr_resul
     context_block = _format_context_block(sample)
     plan_steps_block = _format_plan_steps(plan)
     ocr_block = _format_ocr_block(ocr_result)
+    legend_grounding_block = _format_legend_grounding_block(legend_map)
+    caption_block = _format_caption_block(sample)
+    multi_select_block = _format_multi_select_block(sample)
 
-    return template.format(
+    rendered = template.format(
         image_path=sample.image_path,
         question=sample.question,
         choices_block=choices_block,
         choice_labels_block=choice_labels_block,
         context_block=context_block,
         ocr_block=ocr_block,
+        legend_grounding_block=legend_grounding_block,
+        caption_block=caption_block,
+        multi_select_block=multi_select_block,
         plan_steps_block=plan_steps_block,
     )
 
+    if prepend_instruction:
+        rendered = prepend_instruction.rstrip("\n") + "\n\n" + rendered
+
+    return rendered
+
 
 def _build_llm(backend: str, model: str, api_key: Optional[str]) -> LLM:
     """
@@ -241,6 +347,8 @@ def run(
         plan: dict,
         lf_trace: Any = None,
         ocr_result: Optional[dict] = None,
+        legend_map: Optional[List[dict]] = None,
+        prepend_instruction: Optional[str] = None,
     ) -> Tuple[str, dict, bool, str, List[dict]]:
         """
         Execute the vision analysis process for a single chart question.
@@ -258,6 +366,10 @@ def run(
             Trace object for execution tracking.
         ocr_result : dict, optional
             Ground-truth OCR data for grounding.
+        legend_map : list of dict, optional
+            Structured color-to-series mapping from LegendGrounderTool.
+        prepend_instruction : str, optional
+            Extra instruction to prepend (used for compliance retry).
 
         Returns
         -------
@@ -274,7 +386,13 @@ def run(
         """
         tool = self._build_tool(lf_trace=lf_trace)
         llm = _build_llm(self.agent_backend, self.agent_model, self.agent_api_key)
-        task_description = build_vision_task_description(sample, plan, ocr_result=ocr_result)
+        task_description = build_vision_task_description(
+            sample,
+            plan,
+            ocr_result=ocr_result,
+            legend_map=legend_map,
+            prepend_instruction=prepend_instruction,
+        )
 
         vision_span = open_llm_span(
             lf_trace,
@@ -302,9 +420,15 @@ def run(
             max_iter=3,  # limit iterations to prevent runaway tool calls
         )
 
+        is_ms = _is_multi_select(sample)
         task = Task(
             description=task_description,
-            expected_output='JSON object: {"choice_analysis": {...}, "answer": "...", "explanation": "..."}',
+            expected_output=(
+                'JSON object: {"choice_analysis": {...}, "answer": "...", "explanation": "..."}\n'
+                "MULTI-SELECT: answer must contain ALL correct letters concatenated (e.g. 'ACD'), not just one."
+                if is_ms
+                else 'JSON object: {"choice_analysis": {...}, "answer": "...", "explanation": "..."}'
+            ),
             agent=agent,
         )
 
diff --git a/src/agentfinvqa/eval/eval_outputs.py b/src/agentfinvqa/eval/eval_outputs.py
index 49034af..aecf689 100644
--- a/src/agentfinvqa/eval/eval_outputs.py
+++ b/src/agentfinvqa/eval/eval_outputs.py
@@ -31,12 +31,22 @@
 
 def _normalize(text: str) -> str:
     text = text.strip().lower()
+    # Strip leading choice-letter prefix from some models (e.g. "B: sell or avoid…").
+    text = re.sub(r"^[a-z]:\s+", "", text)
     text = re.sub(r"[^\w\s\-\.]", "", text)
     return re.sub(r"\s+", " ", text).strip()
 
 
 def _to_number(text: str) -> Optional[float]:
+    """Extract a scalar for numeric tolerance.
+
+    Returns None for product-style tokens (e.g. Jericho2).
+    """
     text = text.replace(",", "").replace("%", "").strip()
+    # Skip digit-after-letter patterns (Jericho2, 3Q20); avoids false matches like
+    # 1.0 vs Jericho2e + Ramon.
+    if re.search(r"[a-z][0-9]", text.lower()):
+        return None
     m = re.search(r"-?\d+\.?\d*", text)
     try:
         return float(m.group()) if m else None
@@ -136,6 +146,25 @@ def _labels_to_text(labels: list[str], choice_map: dict[str, str]) -> str:
     return " + ".join(choice_map.get(label, label) for label in labels)
 
 
+def resolve_eval_answers(sample: dict, raw_predicted: str) -> tuple[str, str]:
+    """Expand FinMME ``choice_map`` / ``answer_label`` into comparable strings.
+
+    Maps MCQ letter answers (e.g. ``\"B\"``, ``\"AB\"``) to the same canonical
+    phrasing as gold labels so rule-based accuracy matches ``evaluate_mep``.
+    """
+    expected = sample.get("expected_output", "")
+    metadata = sample.get("metadata") or {}
+    choice_map = metadata.get("choice_map") or {}
+    expected_labels = _parse_choice_labels(metadata.get("answer_label", ""), choice_map)
+    predicted_labels = _parse_choice_labels(raw_predicted, choice_map)
+    if expected_labels:
+        expected = _labels_to_text(expected_labels, choice_map)
+    predicted = (raw_predicted or "").strip()
+    if predicted_labels:
+        predicted = _labels_to_text(predicted_labels, choice_map)
+    return expected, predicted
+
+
 # ---------------------------------------------------------------------------
 # Per-MEP evaluation
 # ---------------------------------------------------------------------------
@@ -154,29 +183,20 @@ def evaluate_mep(
     timestamps = mep.get("timestamps", {})
     config = mep.get("config", {})
 
-    expected = sample.get("expected_output", "")
     vision_parsed = vision.get("parsed", {})
     verifier = mep.get("verifier") or {}
     verifier_parsed = verifier.get("parsed") or {}
     verifier_verdict = verifier.get("verdict", "skipped")
 
     # Final answer: use verifier output when it ran, otherwise fall back to vision
-    predicted = verifier_parsed.get("answer") or vision_parsed.get("answer", "")
+    raw_predicted = verifier_parsed.get("answer") or vision_parsed.get("answer", "")
+    expected, predicted = resolve_eval_answers(sample, raw_predicted)
     question_type = sample.get("question_type", "standard")
 
     planner_ms = timestamps.get("planner_ms") or 0
     vision_ms = timestamps.get("vision_ms") or 0
     verifier_ms = timestamps.get("verifier_ms") or 0
 
-    metadata = sample.get("metadata") or {}
-    choice_map = metadata.get("choice_map") or {}
-    expected_labels = _parse_choice_labels(metadata.get("answer_label", ""), choice_map)
-    predicted_labels = _parse_choice_labels(predicted, choice_map)
-    if expected_labels:
-        expected = _labels_to_text(expected_labels, choice_map)
-    if predicted_labels:
-        predicted = _labels_to_text(predicted_labels, choice_map)
-
     metrics: dict = {
         "sample_id": sample.get("sample_id", ""),
         "question_type": question_type,
diff --git a/src/agentfinvqa/mep/schema.py b/src/agentfinvqa/mep/schema.py
index f56fb2b..51fd40f 100644
--- a/src/agentfinvqa/mep/schema.py
+++ b/src/agentfinvqa/mep/schema.py
@@ -122,6 +122,21 @@ class MEPVerifier:
     tool_trace: List[Dict] = field(default_factory=list)
 
 
+@dataclass
+class MEPLegendGrounding:
+    """Trace of the legend grounding stage inserted between OCR and vision.
+
+    Captures whether the stage was triggered, the structured color-to-series
+    map it produced, any parse errors, and whether the compliance retry fired.
+    """
+
+    triggered: bool = False
+    legend_map: List[Dict] = field(default_factory=list)
+    parse_error: bool = False
+    compliance_retry_triggered: bool = False
+    tool_trace: List[Dict] = field(default_factory=list)
+
+
 @dataclass
 class MEPTimestamps:
     """Timestamps for the different steps of the agent run.
@@ -154,6 +169,7 @@ class MEP:
     sample: Optional[MEPSample] = None
     plan: Optional[MEPPlan] = None
     ocr: Optional[MEPOcr] = None  # None when OCR step is skipped
+    legend_grounding: Optional[MEPLegendGrounding] = None  # None when not triggered
     vision: Optional[MEPVision] = None
     verifier: Optional[MEPVerifier] = None  # Pass 2.5 — None when skipped
     timestamps: Optional[MEPTimestamps] = None
diff --git a/src/agentfinvqa/runner/run_generate_meps.py b/src/agentfinvqa/runner/run_generate_meps.py
index 253416b..3826168 100644
--- a/src/agentfinvqa/runner/run_generate_meps.py
+++ b/src/agentfinvqa/runner/run_generate_meps.py
@@ -38,6 +38,7 @@
     MEP,
     ImageRef,
     MEPConfig,
+    MEPLegendGrounding,
     MEPOcr,
     MEPPlan,
     MEPSample,
@@ -46,6 +47,7 @@
     MEPVision,
 )
 from ..mep.writer import mep_dataset_split_relpath, write_mep
+from ..tools.legend_grounder_tool import LegendGrounderTool
 from ..tools.ocr_reader_tool import OcrReaderTool
 from ..utils.hashing import sha256_file
 from ..utils.json_strict import parse_strict
@@ -73,6 +75,22 @@
         "vision_model": "gemini-2.5-flash-lite",
         "judge_backend": "gemini",
     },
+    # Full Flash (non-lite) — higher capability, higher cost
+    "gemini_gemini_flash": {
+        "planner_backend": "gemini",
+        "planner_model": "gemini-2.5-flash",
+        "vision_backend": "gemini",
+        "vision_model": "gemini-2.5-flash",
+        "judge_backend": "gemini",
+    },
+    # Gemini 2.5 Flash Preview — latest preview tier
+    "gemini_gemini_flash_preview": {
+        "planner_backend": "gemini",
+        "planner_model": "gemini-2.5-flash-preview-04-17",
+        "vision_backend": "gemini",
+        "vision_model": "gemini-2.5-flash-preview-04-17",
+        "judge_backend": "gemini",
+    },
     "openai_gemini": {
         "planner_backend": "openai",
         "planner_model": "gpt-4o",
@@ -113,6 +131,19 @@ class DatasetConfig(TypedDict):
     },
 }
 
+# Chart types where legend grounding is worth the extra VLM call
+_LEGEND_GROUNDING_CHART_TYPES = {
+    "line",
+    "bar",
+    "scatter",
+    "area",
+    "bar_grouped",
+    "bar_stacked",
+    "combination",
+    "pie",
+    "donut",
+}
+
 # Fallback plan used when the planner fails entirely
 _FALLBACK_PLAN = {
     "steps": [
@@ -178,6 +209,24 @@ def _run_verifier_stage(
         else:
             assert raw_verdict is not None
             verifier_verdict = raw_verdict
+
+            # ── Confidence gate: downgrade low-confidence revisions to confirmed ──
+            # The verifier self-reports confidence (0–1). When it wants to revise
+            # but isn't confident enough, we keep the vision answer instead.
+            if verifier_verdict == "revised":
+                try:
+                    ver_confidence = float(verifier_parsed.get("confidence", 0.75))
+                except (TypeError, ValueError):
+                    ver_confidence = 0.75
+                if ver_confidence < 0.75:
+                    verifier_verdict = "confirmed"
+                    verifier_parsed["verdict"] = "confirmed"
+                    verifier_parsed["answer"] = vision_parsed.get("answer", "")
+                    verifier_parsed["reasoning"] = (
+                        f"[Confidence gate: revision confidence {ver_confidence:.2f} < 0.75 — "
+                        f"keeping vision answer. Original reasoning: {verifier_parsed.get('reasoning', '')[:80]}]"
+                    )
+                    errors.append(f"verifier_revision_gated: confidence={ver_confidence:.2f}")
     except Exception as exc:  # pragma: no cover - verifier optional
         errors.append(f"verifier_error: {exc}")
         verifier_parse_error = True
@@ -201,7 +250,7 @@ def _run_verifier_stage(
     )
 
 
-def process_sample(  # noqa: PLR0915
+def process_sample(  # noqa: PLR0912, PLR0915
     sample: PerceivedSample,
     planner: PlannerAgent,
     vision_agent: VisionAgent,
@@ -212,6 +261,7 @@ def process_sample(  # noqa: PLR0915
     lf_client: Any = None,
     verifier_agent: Optional[VerifierAgent] = None,
     ocr_tool: Optional[OcrReaderTool] = None,
+    legend_grounder: Optional[LegendGrounderTool] = None,
 ) -> str:
     """
     Execute the multi-stage evaluation pipeline for a single sample.
@@ -306,6 +356,37 @@ def process_sample(  # noqa: PLR0915
                 ocr_parse_error = True
                 traceback.print_exc()
 
+        # ---- Legend grounding (optional, between OCR and vision) ----
+        legend_grounding_triggered = False
+        legend_map: list = []
+        legend_grounding_parse_error = False
+        legend_grounding_traces: list = []
+        compliance_retry_triggered = False
+
+        ocr_legend = ocr_parsed.get("legend", []) if ocr_parsed else []
+        ocr_chart_type = (ocr_parsed.get("chart_type") or "").strip().lower() if ocr_parsed else ""
+        should_ground = (
+            legend_grounder is not None and len(ocr_legend) > 1 and ocr_chart_type in _LEGEND_GROUNDING_CHART_TYPES
+        )
+
+        if should_ground:
+            legend_grounding_triggered = True
+            try:
+                legend_grounder.lf_trace = lf_trace  # type: ignore[union-attr]
+                lg_raw = legend_grounder._run(  # type: ignore[union-attr]
+                    image_path=sample.image_path,
+                    legend_list=ocr_legend,
+                )
+                legend_grounding_traces = legend_grounder.pop_traces()  # type: ignore[union-attr]
+                lg_parsed, lg_ok = parse_strict(lg_raw, required_keys=["legend_map"])
+                legend_grounding_parse_error = not lg_ok
+                if lg_ok and isinstance(lg_parsed.get("legend_map"), list):
+                    legend_map = lg_parsed["legend_map"]
+            except Exception as exc:
+                errors.append(f"legend_grounding_error: {exc}")
+                legend_grounding_parse_error = True
+                traceback.print_exc()
+
         # ---- Vision ----
         vision_prompt = ""
         vision_parsed: dict = {}
@@ -314,6 +395,8 @@ def process_sample(  # noqa: PLR0915
         vision_traces: list = []
         vision_ms = 0.0
 
+        _vision_legend_map = legend_map if legend_grounding_triggered and not legend_grounding_parse_error else None
+
         try:
             with timed() as vt:
                 (
@@ -327,6 +410,7 @@ def process_sample(  # noqa: PLR0915
                     plan_parsed,
                     lf_trace=lf_trace,
                     ocr_result=ocr_parsed if ocr_parsed else None,
+                    legend_map=_vision_legend_map,
                 )
             vision_ms = vt.elapsed_ms
         except Exception as exc:
@@ -335,6 +419,82 @@ def process_sample(  # noqa: PLR0915
             vision_parse_error = True
             traceback.print_exc()
 
+        # ---- Legend compliance check (only when legend grounding was active) ----
+        if legend_grounding_triggered and not legend_grounding_parse_error and legend_map and not vision_parse_error:
+            explanation = vision_parsed.get("explanation", "") or ""
+            label_mentioned = any(
+                entry.get("label", "").lower() in explanation.lower() for entry in legend_map if entry.get("label")
+            )
+            if not label_mentioned:
+                compliance_retry_triggered = True
+                retry_instruction = (
+                    "IMPORTANT: Your previous response did not reference the pre-mapped "
+                    "legend entries by name. You must begin your analysis by explicitly "
+                    "stating which color you are reading for each series mentioned in "
+                    "your answer, using the pre-mapped legend above."
+                )
+                try:
+                    (
+                        vision_prompt,
+                        vision_parsed,
+                        vision_parse_error,
+                        vision_raw,
+                        vision_traces,
+                    ) = vision_agent.run(
+                        sample,
+                        plan_parsed,
+                        lf_trace=lf_trace,
+                        ocr_result=ocr_parsed if ocr_parsed else None,
+                        legend_map=_vision_legend_map,
+                        prepend_instruction=retry_instruction,
+                    )
+                except Exception as exc:
+                    errors.append(f"vision_compliance_retry_error: {exc}")
+                    traceback.print_exc()
+
+        # ---- Forced-choice retry (UNANSWERABLE + MCQ) ----
+        # If vision refused to answer but choices exist, force a selection before
+        # handing off to the verifier — the verifier's override often fires too late.
+        _vision_ua = vision_parsed.get("answer", "").strip().upper() == "UNANSWERABLE"
+        _sample_choices: list = []
+        _meta = getattr(sample, "metadata", {}) or {}
+        _labeled = _meta.get("choices_labeled") or []
+        if _labeled:
+            _sample_choices = [f"{item.get('label')}: {item.get('text')}" for item in _labeled]
+        elif getattr(sample, "choices", None):
+            _sample_choices = list(sample.choices)
+
+        if _vision_ua and _sample_choices and not vision_parse_error:
+            _choices_text = "\n".join(f"  - {c}" for c in _sample_choices)
+            _forced_instruction = (
+                "FORCED CHOICE — your previous response returned UNANSWERABLE, which is not "
+                "permitted when MCQ choices are provided.\n"
+                "You MUST select one of the following options based on whatever visual evidence "
+                "is available in the chart. Even if the chart is partially occluded or labels "
+                "are small, pick the most visually plausible option and note your uncertainty "
+                "in the explanation.\n\n"
+                f"Available choices:\n{_choices_text}\n\n"
+                "Do NOT output UNANSWERABLE. Output the letter or exact text of the best choice."
+            )
+            try:
+                (
+                    vision_prompt,
+                    vision_parsed,
+                    vision_parse_error,
+                    vision_raw,
+                    vision_traces,
+                ) = vision_agent.run(
+                    sample,
+                    plan_parsed,
+                    lf_trace=lf_trace,
+                    ocr_result=ocr_parsed if ocr_parsed else None,
+                    legend_map=_vision_legend_map,
+                    prepend_instruction=_forced_instruction,
+                )
+            except Exception as exc:
+                errors.append(f"vision_forced_choice_retry_error: {exc}")
+                traceback.print_exc()
+
         # ---- Verifier (Pass 2.5) ----
         (
             verifier_prompt,
@@ -390,6 +550,15 @@ def process_sample(  # noqa: PLR0915
             )
             if ocr_tool is not None
             else None,
+            legend_grounding=MEPLegendGrounding(
+                triggered=legend_grounding_triggered,
+                legend_map=legend_map,
+                parse_error=legend_grounding_parse_error,
+                compliance_retry_triggered=compliance_retry_triggered,
+                tool_trace=legend_grounding_traces,
+            )
+            if legend_grounding_triggered
+            else None,
             vision=MEPVision(
                 prompt=vision_prompt,
                 raw_text=vision_raw,
@@ -420,14 +589,14 @@ def process_sample(  # noqa: PLR0915
         )
 
         # ---- Immediately log available scores to Langfuse ----
-        log_trace_scores(
-            lf_trace,
-            {
-                "planner_parse_ok": float(not plan_parse_error),
-                "vision_parse_ok": float(not vision_parse_error),
-                "has_errors": float(bool(errors)),
-            },
-        )
+        scores: dict = {
+            "planner_parse_ok": float(not plan_parse_error),
+            "vision_parse_ok": float(not vision_parse_error),
+            "has_errors": float(bool(errors)),
+        }
+        if legend_grounding_triggered:
+            scores["legend_compliance"] = float(not compliance_retry_triggered)
+        log_trace_scores(lf_trace, scores)
         if lf_trace:
             lf_trace.update(output=vision_parsed if vision_parsed else None)
 
@@ -467,7 +636,7 @@ def main() -> None:  # noqa: PLR0912, PLR0915
     parser.add_argument(
         "--config",
         default="gemini_gemini",
-        choices=list(BACKEND_CONFIGS.keys()),
+        choices=sorted(BACKEND_CONFIGS.keys()),
         help="Backend config preset",
     )
     parser.add_argument("--workers", type=int, default=1, help="Parallel workers (1 = sequential)")
@@ -491,6 +660,7 @@ def main() -> None:  # noqa: PLR0912, PLR0915
     )
     parser.add_argument("--no_verifier", action="store_true", help="Skip Pass 2.5 verifier agent")
     parser.add_argument("--no_ocr", action="store_true", help="Skip OCR pre-read step")
+    parser.add_argument("--no_legend_grounding", action="store_true", help="Skip legend grounding stage")
     parser.add_argument("--run_tag", default=None, help="Subfolder tag within dataset dir (e.g. planner_v2)")
     parser.add_argument("--no_langfuse", action="store_true", help="Disable Langfuse dataset/prompt registration")
     parser.add_argument(
@@ -592,6 +762,15 @@ def main() -> None:  # noqa: PLR0912, PLR0915
         print(f"OCR pre-reader   : enabled ({config['vision_backend']} / {ocr_model})")
     else:
         print("OCR pre-reader   : disabled (--no_ocr)")
+
+    legend_grounder: Optional[LegendGrounderTool] = None
+    if not args.no_ocr and not args.no_legend_grounding:
+        lg_model = args.ocr_model or config["vision_model"]
+        legend_grounder = LegendGrounderTool(backend=config["vision_backend"], model=lg_model)
+        print(f"Legend grounder  : enabled ({config['vision_backend']} / {lg_model})")
+    else:
+        reason = "--no_ocr" if args.no_ocr else "--no_legend_grounding"
+        print(f"Legend grounder  : disabled ({reason})")
     print()
 
     if args.workers <= 1:
@@ -609,6 +788,7 @@ def main() -> None:  # noqa: PLR0912, PLR0915
                     lf_client,
                     verifier,
                     ocr,
+                    legend_grounder,
                 )
                 print(f"OK → {path}")
             except Exception as exc:
@@ -628,6 +808,7 @@ def main() -> None:  # noqa: PLR0912, PLR0915
                     lf_client,
                     verifier,
                     ocr,
+                    legend_grounder,
                 ): s
                 for s in samples
             }
diff --git a/src/agentfinvqa/tools/legend_grounder_tool.py b/src/agentfinvqa/tools/legend_grounder_tool.py
new file mode 100644
index 0000000..d18355b
--- /dev/null
+++ b/src/agentfinvqa/tools/legend_grounder_tool.py
@@ -0,0 +1,229 @@
+"""legend_grounder_tool — VLM call that maps legend entries to visual properties.
+
+Runs a single structured extraction call to bind each legend label to its
+color, line style, and confidence score. The output is injected into the
+vision prompt as locked ground truth, preventing the vision agent from
+visually re-identifying series (which is the root cause of legend confusion).
+"""
+
+import base64
+import json
+import os
+import time
+from datetime import datetime, timezone
+from typing import Any, List, Optional, Type
+
+from crewai.tools import BaseTool
+from google import genai
+from openai import OpenAI
+from pydantic import BaseModel, Field, PrivateAttr
+
+from ..langfuse_integration.tracing import close_span, open_llm_span
+from ..utils.model_compat import openai_temperature
+
+
+_LEGEND_GROUNDER_PROMPT_TEMPLATE = """\
+You are analyzing a chart image. The following legend entries have been \
+extracted from this chart:
+
+{legend_list}
+
+For each legend entry, identify its visual representation in the chart.
+Output ONLY a JSON object with this exact structure — no markdown, \
+no explanation:
+
+{{
+  "legend_map": [
+    {{
+      "label": "<exact legend text>",
+      "color_description": "<e.g. dark blue, orange, dashed grey>",
+      "rgb_approximate": "<e.g. (70, 130, 180) — your best estimate>",
+      "line_style": "<solid|dashed|dotted|bar|area|point>",
+      "confidence": <0.0 to 1.0>
+    }}
+  ]
+}}
+
+Rules:
+- Include every legend entry, even if confidence is low
+- color_description must be a human-readable color name
+- If two entries look visually similar, note that in color_description
+- Do not invent entries not in the legend list
+- Output JSON only
+"""
+
+
+class LegendGrounderInput(BaseModel):
+    """Input schema for LegendGrounderTool."""
+
+    image_path: str = Field(description="Absolute or relative path to the chart image file")
+    legend_list: List[str] = Field(description="Legend entry labels extracted by OCR")
+
+
+class LegendGrounderTool(BaseTool):
+    """Map OCR legend labels to visual properties (color, line style)."""
+
+    name: str = "legend_grounder_tool"
+    description: str = (
+        "Given a chart image and a list of legend entry labels, identify the color, "
+        "line style, and confidence score for each entry. Returns structured JSON "
+        "to ground the vision agent's series identification."
+    )
+    args_schema: Type[BaseModel] = LegendGrounderInput
+
+    backend: str = "gemini"
+    model: str = "gemini-2.5-flash-lite"
+    api_key: str = ""
+    lf_trace: Optional[Any] = None
+
+    _traces: list = PrivateAttr(default_factory=list)
+
+    def pop_traces(self) -> list:
+        """Flush and return the tool's execution traces."""
+        traces = list(self._traces)
+        self._traces.clear()
+        return traces
+
+    # ------------------------------------------------------------------
+    # CrewAI entry point
+    # ------------------------------------------------------------------
+
+    def _run(self, image_path: str, legend_list: List[str]) -> str:
+        """
+        Make a single VLM call to map each legend entry to its visual properties.
+
+        Parameters
+        ----------
+        image_path : str
+            Path to the chart image.
+        legend_list : list of str
+            Legend entry labels from OCR.
+
+        Returns
+        -------
+        str
+            JSON string with a ``legend_map`` list.
+        """
+        start_ts = datetime.now(timezone.utc).isoformat()
+        t0 = time.time()
+
+        legend_formatted = "\n".join(f"  - {entry}" for entry in legend_list)
+        prompt = _LEGEND_GROUNDER_PROMPT_TEMPLATE.format(legend_list=legend_formatted)
+
+        lf_span = open_llm_span(
+            self.lf_trace,
+            name="legend_grounder_tool",
+            input_data={"image_path": image_path, "legend_list": legend_list},
+            model=self.model,
+            metadata={"backend": self.backend},
+        )
+
+        provider_meta: dict = {}
+        error_str: Optional[str] = None
+        try:
+            if self.backend == "openai":
+                raw_text, provider_meta = self._call_openai(image_path, prompt)
+            elif self.backend == "gemini":
+                raw_text, provider_meta = self._call_gemini(image_path, prompt)
+            else:
+                raise ValueError(f"Unknown backend: {self.backend!r}")
+        except Exception as exc:
+            raw_text = json.dumps({"legend_map": [], "error": str(exc)})
+            provider_meta = {"error": str(exc)}
+            error_str = str(exc)
+
+        end_ts = datetime.now(timezone.utc).isoformat()
+        elapsed_ms = (time.time() - t0) * 1000.0
+
+        model_used = provider_meta.pop("model", self.model)
+        usage = provider_meta.get("usage", {})
+
+        close_span(
+            lf_span,
+            output={"raw_text": raw_text},
+            usage=usage if usage else None,
+            error=error_str,
+        )
+
+        self._traces.append(
+            {
+                "tool": "legend_grounder_tool",
+                "backend": self.backend,
+                "model": model_used,
+                "start_ts": start_ts,
+                "end_ts": end_ts,
+                "elapsed_ms": elapsed_ms,
+                "provider_metadata": provider_meta,
+            }
+        )
+
+        return raw_text
+
+    # ------------------------------------------------------------------
+    # Image encoding
+    # ------------------------------------------------------------------
+
+    def _encode_image(self, image_path: str) -> tuple:
+        with open(image_path, "rb") as f:
+            data = f.read()
+        b64 = base64.b64encode(data).decode("utf-8")
+        mime = "png" if image_path.lower().endswith(".png") else "jpeg"
+        return b64, mime
+
+    # ------------------------------------------------------------------
+    # OpenAI backend
+    # ------------------------------------------------------------------
+
+    def _call_openai(self, image_path: str, prompt: str) -> tuple:
+        client = OpenAI(api_key=self.api_key or os.environ.get("OPENAI_API_KEY", ""))
+        b64, mime = self._encode_image(image_path)
+
+        response = client.chat.completions.create(
+            model=self.model,
+            messages=[
+                {
+                    "role": "user",
+                    "content": [
+                        {"type": "text", "text": prompt},
+                        {
+                            "type": "image_url",
+                            "image_url": {"url": f"data:image/{mime};base64,{b64}"},
+                        },
+                    ],
+                }
+            ],
+            max_completion_tokens=512,
+            **openai_temperature(self.model),
+        )
+
+        raw_text = response.choices[0].message.content or ""
+        provider_meta = {
+            "model": response.model,
+            "request_id": response.id,
+            "usage": response.usage.model_dump() if response.usage else {},
+        }
+        return raw_text, provider_meta
+
+    # ------------------------------------------------------------------
+    # Gemini backend
+    # ------------------------------------------------------------------
+
+    def _call_gemini(self, image_path: str, prompt: str) -> tuple:
+        client = genai.Client(api_key=self.api_key or os.environ.get("GEMINI_API_KEY", ""))
+        b64, mime = self._encode_image(image_path)
+        response = client.models.generate_content(
+            model=self.model,
+            contents=[
+                genai.types.Part.from_bytes(data=base64.b64decode(b64), mime_type=f"image/{mime}"),
+                prompt,
+            ],
+            config=genai.types.GenerateContentConfig(temperature=0, max_output_tokens=512),
+        )
+
+        raw_text = response.text or ""
+        finish = str(response.candidates[0].finish_reason) if response.candidates else "unknown"
+        provider_meta = {
+            "model": self.model,
+            "finish_reason": finish,
+        }
+        return raw_text, provider_meta
diff --git a/src/agentfinvqa/tools/verifier_tool.py b/src/agentfinvqa/tools/verifier_tool.py
index 0194015..7131e5c 100644
--- a/src/agentfinvqa/tools/verifier_tool.py
+++ b/src/agentfinvqa/tools/verifier_tool.py
@@ -22,13 +22,13 @@
 from ..utils.model_compat import openai_temperature
 
 
-_VERIFIER_PROMPT = """\
+_VERIFIER_PROMPT_SINGLE = """\
 You are a critical chart QA verifier. A vision agent has already attempted to answer
 the question below. Your job: look at the chart image carefully and audit the work.
 
 Question         : {question}
 Question Type    : {question_type}
-
+{choices_block}{caption_block}
 Inspection plan the agent was supposed to follow:
 {plan_steps}
 
@@ -42,16 +42,59 @@
 Rules:
 - Only REVISE when you are confident you can point to a concrete error in the chart
 - If uncertain, CONFIRM — do not second-guess without visual evidence
-- For MCQ questions: the answer must be one of the stated choices
+- For MCQ questions: the answer must be one of the stated choices above
 - For MCQ questions: return exactly one of the provided choice texts or the precise letter/letter-combo (e.g., "AC")
-- If the answer is truly unanswerable from the chart, say exactly "UNANSWERABLE"
+- UNANSWERABLE override: if the draft answer is "UNANSWERABLE" and MCQ choices are listed above,
+  you MUST systematically check EACH choice against the chart before confirming:
+    1. For each choice: is there visual evidence (bar height, line position, label, tick mark) that
+       supports OR rules it out?
+    2. If ANY choice can be supported or ruled out, REVISE to the best-supported choice.
+    3. Only confirm UNANSWERABLE when ALL choices are genuinely undeterminable from the chart.
 - Keep answers concise — numbers, short phrases, or single words where appropriate
-- Always cite at least one numeric value or labeled element from the chart in your reasoning; if you cannot cite evidence, REVISE
+- Always cite at least one numeric value or labeled element from the chart in your reasoning
 - For MCQ questions, compare the draft answer against at least one alternative choice before confirming
 - Limit the final answer to a short phrase (≤10 words) and keep the reasoning ≤2 sentences.
+- Add a `confidence` field (0.0–1.0): your confidence that your verdict and answer are correct based on what you can see in the chart.
+  Use ≥0.8 only when you can cite specific visual evidence (tick value, bar height, label). Use <0.6 when the chart is ambiguous or partially occluded.
 
 Output ONLY JSON, no markdown, no extra text:
-{{"verdict": "confirmed" | "revised", "answer": "<final answer>", "reasoning": "<one sentence grounded in what you see in the chart>"}}"""
+{{"verdict": "confirmed" | "revised", "answer": "<final answer>", "reasoning": "<one sentence grounded in what you see in the chart>", "confidence": 0.0}}"""
+
+_VERIFIER_PROMPT_MULTI = """\
+You are a critical chart QA verifier. This is a MULTI-SELECT question — multiple choices may be correct.
+
+Question         : {question}
+Question Type    : {question_type}
+{choices_block}{caption_block}
+Inspection plan the agent was supposed to follow:
+{plan_steps}
+
+Vision Agent's Draft Answer     : {draft_answer}
+Vision Agent's Draft Explanation: {draft_explanation}
+
+YOUR TASK — evaluate the draft answer for a multi-select question:
+  CONFIRM — all selected letters are correct AND no correct letters are missing
+  REVISE  — some letters are wrong, or correct letters were omitted
+
+Step-by-step verification (do this for EVERY choice listed above):
+  1. For each letter in the draft answer: is there clear visual evidence it is correct?
+     If NOT supported → it must be removed.
+  2. For each letter NOT in the draft answer: is there clear visual evidence it should be included?
+     If YES → it must be added.
+  3. Your final answer = all and only the letters with chart evidence.
+
+Rules:
+- NEVER collapse a multi-select answer to a single letter unless truly only one is correct
+- NEVER add letters you cannot visually confirm
+- If the draft already selected the right set, CONFIRM — do not change it
+- Return letters concatenated with no separator (e.g. "ABC")
+- Reasoning must cite specific chart evidence (values, labels, bar heights) for each included/excluded choice
+- Keep reasoning ≤3 sentences.
+- Add a `confidence` field (0.0–1.0): your confidence that your final letter set is correct.
+  Use ≥0.8 only when you have clear visual evidence for each included/excluded choice. Use <0.6 when the chart is ambiguous.
+
+Output ONLY JSON, no markdown, no extra text:
+{{"verdict": "confirmed" | "revised", "answer": "<all correct letters concatenated, e.g. ABC>", "reasoning": "<evidence-grounded sentence(s)>", "confidence": 0.0}}"""
 
 
 class VerifierInput(BaseModel):
@@ -63,6 +106,9 @@ class VerifierInput(BaseModel):
     plan_steps: List[str] = Field(description="Ordered inspection steps from the planner")
     draft_answer: str = Field(description="The draft answer produced by the vision agent")
     draft_explanation: str = Field(description="The draft explanation produced by the vision agent")
+    choices: Optional[List[str]] = Field(default=None, description="MCQ answer choices if applicable")
+    caption: Optional[str] = Field(default=None, description="Analyst-written chart caption for context")
+    multi_select: bool = Field(default=False, description="True when multiple choices can be correct simultaneously")
 
 
 class VerifierTool(BaseTool):
@@ -97,6 +143,9 @@ def _run(
         plan_steps: List[str],
         draft_answer: str,
         draft_explanation: str,
+        choices: Optional[List[str]] = None,
+        caption: Optional[str] = None,
+        multi_select: bool = False,
     ) -> str:
         start_ts = datetime.now(timezone.utc).isoformat()
         t0 = time.time()
@@ -114,9 +163,19 @@ def _run(
         )
 
         steps_text = "\n".join(f"  {i + 1}. {s}" for i, s in enumerate(plan_steps)) or "  (none)"
-        prompt = _VERIFIER_PROMPT.format(
+        choices_block = "MCQ Choices:\n" + "\n".join(f"  - {c}" for c in choices) + "\n" if choices else ""
+        if caption and caption.strip():
+            caption_block = (
+                f"Chart context (analyst caption — use as background, not as the answer):\n  {caption.strip()}\n"
+            )
+        else:
+            caption_block = ""
+        template = _VERIFIER_PROMPT_MULTI if multi_select else _VERIFIER_PROMPT_SINGLE
+        prompt = template.format(
             question=question,
             question_type=question_type,
+            choices_block=choices_block,
+            caption_block=caption_block,
             plan_steps=steps_text,
             draft_answer=draft_answer,
             draft_explanation=draft_explanation,
@@ -196,7 +255,7 @@ def _call_openai(self, prompt: str, image_path: str) -> tuple:
                     ],
                 }
             ],
-            max_completion_tokens=256,
+            max_completion_tokens=2048,
             **openai_temperature(self.model),
         )
         raw_text = response.choices[0].message.content or ""
@@ -213,7 +272,11 @@ def _call_gemini(self, prompt: str, image_path: str) -> tuple:
         response = client.models.generate_content(
             model=self.model,
             contents=[genai.types.Part.from_bytes(data=base64.b64decode(b64), mime_type=f"image/{mime}"), prompt],
-            config=genai.types.GenerateContentConfig(temperature=0, max_output_tokens=768),
+            config=genai.types.GenerateContentConfig(
+                temperature=0,
+                max_output_tokens=2048,
+                thinking_config=genai.types.ThinkingConfig(thinking_budget=512),
+            ),
         )
         raw_text = response.text or ""
         finish = str(response.candidates[0].finish_reason) if response.candidates else "unknown"
diff --git a/src/agentfinvqa/tools/vision_qa_tool.py b/src/agentfinvqa/tools/vision_qa_tool.py
index 5f455eb..b97fc30 100644
--- a/src/agentfinvqa/tools/vision_qa_tool.py
+++ b/src/agentfinvqa/tools/vision_qa_tool.py
@@ -30,6 +30,9 @@ class VisionQAInput(BaseModel):
     plan_steps: List[str] = Field(description="Ordered inspection steps from the planner")
     choices: Optional[List[str]] = Field(default=None, description="MCQ answer choices if applicable")
     context: Optional[List[dict]] = Field(default=None, description="Prior conversation turns")
+    multi_select: bool = Field(
+        default=False, description="True when multiple choices can be correct simultaneously (select-all-that-apply)"
+    )
 
 
 class VisionQATool(BaseTool):
@@ -76,6 +79,7 @@ def _run(
         plan_steps: List[str],
         choices: Optional[List[str]] = None,
         context: Optional[List[dict]] = None,
+        multi_select: bool = False,
     ) -> str:
         """
         Execute the primary VLM analysis logic.
@@ -117,9 +121,13 @@ def _run(
         error_str: Optional[str] = None
         try:
             if self.backend == "openai":
-                raw_text, provider_meta = self._call_openai(image_path, question, plan_steps, choices, context)
+                raw_text, provider_meta = self._call_openai(
+                    image_path, question, plan_steps, choices, context, multi_select
+                )
             elif self.backend == "gemini":
-                raw_text, provider_meta = self._call_gemini(image_path, question, plan_steps, choices, context)
+                raw_text, provider_meta = self._call_gemini(
+                    image_path, question, plan_steps, choices, context, multi_select
+                )
             else:
                 raise ValueError(f"Unknown backend: {self.backend!r}")
         except Exception as exc:
@@ -164,6 +172,7 @@ def _build_prompt(
         plan_steps: List[str],
         choices: Optional[List[str]],
         context: Optional[List[dict]],
+        multi_select: bool = False,
     ) -> str:
         """
         Assemble the final prompt from various input components.
@@ -201,13 +210,31 @@ def _build_prompt(
         for i, step in enumerate(plan_steps, 1):
             parts.append(f"  {i}. {step}")
 
+        if multi_select:
+            mcq_rule = (
+                "\n- MULTI-SELECT MCQ: evaluate EVERY choice independently against the chart."
+                " Include ALL letters that are supported by visual evidence."
+                " Do NOT stop at the first correct choice — check every option."
+                " Concatenate all correct letters in your answer (e.g. 'ACD')."
+                " If only one is correct, output just that letter."
+            )
+        elif choices:
+            mcq_rule = (
+                "\n- MCQ RULE: UNANSWERABLE is NOT valid when choices are listed — pick the best-supported choice"
+                " even if partially occluded. Note uncertainty in explanation."
+            )
+        else:
+            mcq_rule = (
+                "\n- Only answer UNANSWERABLE if relevant data is genuinely absent from the chart;"
+                " partial occlusion → best reading + note uncertainty"
+            )
         parts.append(
             "\nExtraction rules:"
             "\n- Read ALL axis tick marks and note scale/units before extracting any values"
             "\n- For stacked, grouped, pie, or multi-series charts: match each legend entry to its color/pattern/position FIRST"
             "\n- Report exact numeric values (single number, not a range) unless the question explicitly asks for a range"
             "\n- For multi-part questions (e.g. 'for X and Y'), report each part separately — do not aggregate"
-            "\n- Only answer UNANSWERABLE if relevant data is genuinely absent; if values are partially visible, give your best reading"
+            + mcq_rule
         )
 
         parts.append(
@@ -258,6 +285,7 @@ def _call_openai(
         plan_steps: List[str],
         choices: Optional[List[str]],
         context: Optional[List[dict]],
+        multi_select: bool = False,
     ) -> tuple:
         """
         Interface with the OpenAI Chat Completion API for vision analysis.
@@ -283,7 +311,7 @@ def _call_openai(
             Metadata including usage and request ID.
         """
         client = OpenAI(api_key=self.api_key or os.environ.get("OPENAI_API_KEY", ""))
-        prompt = self._build_prompt(question, plan_steps, choices, context)
+        prompt = self._build_prompt(question, plan_steps, choices, context, multi_select)
         b64, mime = self._encode_image(image_path)
 
         response = client.chat.completions.create(
@@ -300,7 +328,7 @@ def _call_openai(
                     ],
                 }
             ],
-            max_completion_tokens=1024,
+            max_completion_tokens=2048,
             **openai_temperature(self.model),
         )
 
@@ -323,6 +351,7 @@ def _call_gemini(
         plan_steps: List[str],
         choices: Optional[List[str]],
         context: Optional[List[dict]],
+        multi_select: bool = False,
     ) -> tuple:
         """
         Interface with the Google Generative AI API for vision analysis.
@@ -348,13 +377,17 @@ def _call_gemini(
             Metadata including finish reason.
         """
         client = genai.Client(api_key=self.api_key or os.environ.get("GEMINI_API_KEY", ""))
-        prompt = self._build_prompt(question, plan_steps, choices, context)
+        prompt = self._build_prompt(question, plan_steps, choices, context, multi_select)
         b64, mime = self._encode_image(image_path)
 
         response = client.models.generate_content(
             model=self.model,
             contents=[genai.types.Part.from_bytes(data=b64, mime_type=f"image/{mime}"), prompt],
-            config=genai.types.GenerateContentConfig(temperature=0, max_output_tokens=768),
+            config=genai.types.GenerateContentConfig(
+                temperature=0,
+                max_output_tokens=2048,
+                thinking_config=genai.types.ThinkingConfig(thinking_budget=512),
+            ),
         )
 
         raw_text = response.text or ""
diff --git a/tests/agentfinvqa/test_eval_resolve.py b/tests/agentfinvqa/test_eval_resolve.py
new file mode 100644
index 0000000..a0cfa77
--- /dev/null
+++ b/tests/agentfinvqa/test_eval_resolve.py
@@ -0,0 +1,74 @@
+"""Tests for FinMME choice expansion used in rule-based eval."""
+
+import math
+
+from agentfinvqa.eval.eval_outputs import _to_number, resolve_eval_answers, score_answer_accuracy
+
+
+def test_resolve_letter_to_full_choice_text():
+    """Map a single letter to full choice text using ``choice_map``."""
+    sample = {
+        "expected_output": "Sell or avoid, as the stock shows a declining trend",
+        "question_type": "mcq",
+        "metadata": {
+            "answer_label": "B",
+            "choice_map": {
+                "A": "Buy, as the stock price will increase",
+                "B": "Sell or avoid, as the stock shows a declining trend",
+                "C": "Hold, as there is potential for recovery",
+                "D": "Diversify, as the stock is too volatile",
+            },
+        },
+    }
+    exp, pred = resolve_eval_answers(sample, "B")
+    assert exp == pred == "Sell or avoid, as the stock shows a declining trend"
+
+
+def test_resolve_multi_select_letters():
+    """Join multi-select letters into full choice text; accuracy is 1.0 when exact."""
+    sample = {
+        "expected_output": "US + Germany",
+        "question_type": "mcq",
+        "metadata": {
+            "answer_label": "AB",
+            "choice_map": {
+                "A": "US",
+                "B": "Germany",
+                "C": "Spain",
+                "D": "Japan",
+            },
+        },
+    }
+    exp, pred = resolve_eval_answers(sample, "AB")
+    assert exp == pred == "US + Germany"
+    acc = score_answer_accuracy(exp, pred, "mcq")
+    assert acc == 1.0
+
+
+def test_no_spurious_numeric_match_on_product_names():
+    """Do not treat product names with digits as matching numbers spuriously."""
+    assert _to_number("jericho2") is None
+    assert _to_number("jericho2e ramon") is None
+    s = score_answer_accuracy("Jericho2e + Ramon", "Jericho2", "mcq")
+    assert s < 1.0
+
+
+def test_numeric_tolerance_still_works_for_plain_numbers():
+    """Phrase-wrapped numbers still parse and can match plain numeric gold."""
+    assert _to_number("approximately 115") is not None
+    assert math.isclose(score_answer_accuracy("115", "approximately 115", "standard"), 1.0)
+
+
+def test_resolve_predicted_full_text_unchanged():
+    """Keep full-text predictions; still expand expected from labels when needed."""
+    sample = {
+        "expected_output": "US + Germany",
+        "question_type": "mcq",
+        "metadata": {
+            "answer_label": "AB",
+            "choice_map": {"A": "US", "B": "Germany", "C": "Spain", "D": "Japan"},
+        },
+    }
+    exp, pred = resolve_eval_answers(sample, "US, Germany")
+    assert exp == "US + Germany"
+    assert "US" in pred and "Germany" in pred
diff --git a/tests/agentfinvqa/test_finmme_loader.py b/tests/agentfinvqa/test_finmme_loader.py
index 9dab132..fab8500 100644
--- a/tests/agentfinvqa/test_finmme_loader.py
+++ b/tests/agentfinvqa/test_finmme_loader.py
@@ -7,16 +7,19 @@
 
 
 def test_parse_options_from_json():
+    """Parse a JSON-like options string and drop empty entries."""
     text = '["Option A", "Option B", ""]'
     assert finmme_loader._parse_options(text) == ["Option A", "Option B"]
 
 
 def test_parse_options_from_labeled_text():
+    """Extract option text from labeled (A./B./C.) lines."""
     text = "A. Growth\nB. Value\nC. Income"
     assert finmme_loader._parse_options(text) == ["Growth", "Value", "Income"]
 
 
 def test_map_question_type_variants():
+    """Map FinMME question-type strings to ``QuestionType``."""
     assert finmme_loader._map_question_type("Multiple Choice") == QuestionType.MCQ
     assert finmme_loader._map_question_type("Conversational Q&A") == QuestionType.CONVERSATIONAL
     assert finmme_loader._map_question_type("Unanswerable") == QuestionType.UNANSWERABLE
@@ -24,6 +27,7 @@ def test_map_question_type_variants():
 
 
 def test_build_sample_writes_image(tmp_path):
+    """``_build_sample`` writes the image, parses choices, and sets metadata."""
     row = {
         "id": 7,
         "image": Image.new("RGB", (2, 2), color="white"),
@@ -49,6 +53,7 @@ def test_build_sample_writes_image(tmp_path):
 
 
 def test_build_sample_handles_multi_letter_answer(tmp_path):
+    """Expand multi-letter answers to combined expected text and ``answer_label``."""
     row = {
         "id": 8,
         "image": Image.new("RGB", (2, 2), color="white"),
diff --git a/tests/agentfinvqa/test_legend_grounding.py b/tests/agentfinvqa/test_legend_grounding.py
new file mode 100644
index 0000000..fe42a80
--- /dev/null
+++ b/tests/agentfinvqa/test_legend_grounding.py
@@ -0,0 +1,484 @@
+"""Tests for the legend grounding pipeline stage.
+
+Covers:
+- _format_legend_grounding_block formatting
+- build_vision_task_description legend injection and prepend_instruction
+- MEPLegendGrounding schema fields and serialisation
+- LegendGrounderTool prompt construction, error fallback, pop_traces
+- Gate logic (chart type + legend length)
+- Compliance check (label mentioned / not mentioned in explanation)
+"""
+
+import io
+import json
+import os
+import tempfile
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from agentfinvqa.agents.vision_agent import (
+    _format_legend_grounding_block,
+    build_vision_task_description,
+)
+from agentfinvqa.datasets.perceived_sample import PerceivedSample, QuestionType
+from agentfinvqa.mep.schema import MEP, MEPLegendGrounding
+from agentfinvqa.runner.run_generate_meps import _LEGEND_GROUNDING_CHART_TYPES
+from agentfinvqa.tools.legend_grounder_tool import _LEGEND_GROUNDER_PROMPT_TEMPLATE, LegendGrounderTool
+
+
+try:
+    from PIL import Image as PILImage
+except ImportError:
+    PILImage = None
+
+_MINIMAL_PNG = (
+    b"\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x01"
+    b"\x00\x00\x00\x01\x08\x02\x00\x00\x00\x90wS\xde\x00\x00"
+    b"\x00\x0cIDATx\x9cc\xf8\x0f\x00\x00\x01\x01\x00\x05\x18"
+    b"\xd8N\x00\x00\x00\x00IEND\xaeB`\x82"
+)
+
+
+def _tiny_png_bytes(width: int = 2, height: int = 2) -> bytes:
+    if PILImage is None:
+        return _MINIMAL_PNG
+    buf = io.BytesIO()
+    PILImage.new("RGB", (width, height), color="white").save(buf, format="PNG")
+    return buf.getvalue()
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+
+def _make_sample(image_path: str = "/tmp/chart.png") -> PerceivedSample:
+    """Create a dummy PerceivedSample for testing."""
+    return PerceivedSample(
+        sample_id="test_001",
+        question="Which player scored highest?",
+        question_type=QuestionType.STANDARD,
+        expected_output="Clayton Oliver",
+        image_path=image_path,
+        choices=[],
+        context=[],
+        metadata={},
+    )
+
+
+def _make_plan() -> dict:
+    """Create a sample plan dict for testing."""
+    return {"steps": ["Read legend", "Find max value"]}
+
+
+_SAMPLE_LEGEND_MAP = [
+    {
+        "label": "Clayton Oliver",
+        "color_description": "orange",
+        "rgb_approximate": "(255, 165, 0)",
+        "line_style": "solid",
+        "confidence": 0.92,
+    },
+    {
+        "label": "Marcus Bontempelli",
+        "color_description": "blue",
+        "rgb_approximate": "(70, 130, 180)",
+        "line_style": "solid",
+        "confidence": 0.88,
+    },
+    {
+        "label": "Top-10 Player",
+        "color_description": "grey",
+        "rgb_approximate": "(128, 128, 128)",
+        "line_style": "dashed",
+        "confidence": 0.91,
+    },
+]
+
+
+# ---------------------------------------------------------------------------
+# _format_legend_grounding_block
+# ---------------------------------------------------------------------------
+
+
+class TestFormatLegendGroundingBlock:
+    """Tests for ``_format_legend_grounding_block``."""
+
+    def test_empty_returns_empty_string(self):
+        """Test returns empty string for an empty legend map."""
+        assert _format_legend_grounding_block([]) == ""
+
+    def test_none_returns_empty_string(self):
+        """Test returns empty string for legend map None."""
+        assert _format_legend_grounding_block(None) == ""
+
+    def test_header_present(self):
+        """Test the output contains the proper header for a valid legend map."""
+        result = _format_legend_grounding_block(_SAMPLE_LEGEND_MAP)
+        assert "Pre-mapped legend (treat as ground truth" in result
+
+    def test_each_label_present(self):
+        """Test all legend labels are present in the formatted block."""
+        result = _format_legend_grounding_block(_SAMPLE_LEGEND_MAP)
+        assert "Clayton Oliver" in result
+        assert "Marcus Bontempelli" in result
+        assert "Top-10 Player" in result
+
+    def test_color_and_style_present(self):
+        """Test that color descriptions and line styles are included in the output."""
+        result = _format_legend_grounding_block(_SAMPLE_LEGEND_MAP)
+        assert "orange" in result
+        assert "solid" in result
+        assert "dashed" in result
+
+    def test_confidence_formatted(self):
+        """Test that confidence values are formatted correctly."""
+        result = _format_legend_grounding_block(_SAMPLE_LEGEND_MAP)
+        assert "0.92" in result
+        assert "0.88" in result
+
+    def test_instruction_block_present(self):
+        """Test that the instruction block is appended in the legend ground output."""
+        result = _format_legend_grounding_block(_SAMPLE_LEGEND_MAP)
+        assert "INSTRUCTION" in result
+        assert "pre-mapped colors as ground truth" in result
+
+    def test_missing_fields_do_not_crash(self):
+        """Sparse entries format without error; missing fields use ``unknown``."""
+        sparse_map = [{"label": "SeriesA"}]
+        result = _format_legend_grounding_block(sparse_map)
+        assert "SeriesA" in result
+        assert "unknown" in result  # default color/style fallback
+
+
+# ---------------------------------------------------------------------------
+# build_vision_task_description — legend_map and prepend_instruction
+# ---------------------------------------------------------------------------
+
+
+class TestBuildVisionTaskDescription:
+    """Tests for ``build_vision_task_description`` (legend map and prefix)."""
+
+    def test_legend_grounding_block_injected_when_legend_map_given(self):
+        """Include the legend block when ``legend_map`` is non-empty."""
+        sample = _make_sample()
+        plan = _make_plan()
+        desc = build_vision_task_description(sample, plan, legend_map=_SAMPLE_LEGEND_MAP)
+        assert "Pre-mapped legend" in desc
+        assert "Clayton Oliver" in desc
+        assert "INSTRUCTION" in desc
+
+    def test_no_legend_block_when_legend_map_empty(self):
+        """Test that the legend block is not included when legend_map is empty."""
+        sample = _make_sample()
+        plan = _make_plan()
+        desc = build_vision_task_description(sample, plan, legend_map=[])
+        assert "Pre-mapped legend" not in desc
+        assert "INSTRUCTION: When extracting values" not in desc
+
+    def test_no_legend_block_when_legend_map_none(self):
+        """Test that no legend block appears when legend_map is None."""
+        sample = _make_sample()
+        plan = _make_plan()
+        desc = build_vision_task_description(sample, plan, legend_map=None)
+        assert "Pre-mapped legend" not in desc
+
+    def test_prepend_instruction_appears_first(self):
+        """``prepend_instruction`` is the first text in the description."""
+        sample = _make_sample()
+        plan = _make_plan()
+        prefix = "IMPORTANT: Use the pre-mapped legend."
+        desc = build_vision_task_description(sample, plan, prepend_instruction=prefix)
+        assert desc.startswith(prefix)
+
+    def test_prepend_instruction_none_no_effect(self):
+        """``prepend_instruction=None`` matches omitting the argument."""
+        sample = _make_sample()
+        plan = _make_plan()
+        desc_no_prefix = build_vision_task_description(sample, plan)
+        desc_with_none = build_vision_task_description(sample, plan, prepend_instruction=None)
+        assert desc_no_prefix == desc_with_none
+
+    def test_ocr_block_still_present_alongside_legend_map(self):
+        """Test that the OCR block is present even when using a legend_map."""
+        sample = _make_sample()
+        plan = _make_plan()
+        ocr_result = {
+            "chart_type": "line",
+            "title": "Player Rankings",
+            "x_axis": {"label": "Year", "ticks": ["2020", "2021"]},
+            "y_axis": {"label": "Score", "ticks": ["0", "100"]},
+            "legend": ["Clayton Oliver", "Marcus Bontempelli"],
+            "data_labels": [],
+            "annotations": [],
+        }
+        desc = build_vision_task_description(sample, plan, ocr_result=ocr_result, legend_map=_SAMPLE_LEGEND_MAP)
+        assert "Pre-extracted text from chart" in desc
+        assert "Pre-mapped legend" in desc
+
+
+# ---------------------------------------------------------------------------
+# MEPLegendGrounding schema
+# ---------------------------------------------------------------------------
+
+
+class TestMEPLegendGrounding:
+    """Tests for ``MEPLegendGrounding`` defaults and serialization."""
+
+    def test_default_values(self):
+        """Test that defaults are set correctly for MEPLegendGrounding."""
+        lg = MEPLegendGrounding()
+        assert lg.triggered is False
+        assert lg.legend_map == []
+        assert lg.parse_error is False
+        assert lg.compliance_retry_triggered is False
+        assert lg.tool_trace == []
+
+    def test_can_set_all_fields(self):
+        """Test that all MEPLegendGrounding fields can be set and are stored."""
+        lg = MEPLegendGrounding(
+            triggered=True,
+            legend_map=_SAMPLE_LEGEND_MAP,
+            parse_error=False,
+            compliance_retry_triggered=True,
+            tool_trace=[{"tool": "legend_grounder_tool"}],
+        )
+        assert lg.triggered is True
+        assert len(lg.legend_map) == 3
+        assert lg.compliance_retry_triggered is True
+
+    def test_mep_serialises_legend_grounding(self):
+        """Test serializing legend_grounding inside MEP produces correct output."""
+        mep = MEP(run_id="r1")
+        mep.legend_grounding = MEPLegendGrounding(
+            triggered=True,
+            legend_map=_SAMPLE_LEGEND_MAP,
+        )
+        d = mep.to_dict()
+        assert d["legend_grounding"]["triggered"] is True
+        assert len(d["legend_grounding"]["legend_map"]) == 3
+
+    def test_mep_legend_grounding_none_serialises(self):
+        """Test serialization of a MEP with no legend_grounding yields None."""
+        mep = MEP(run_id="r2")
+        d = mep.to_dict()
+        assert d["legend_grounding"] is None
+
+
+# ---------------------------------------------------------------------------
+# Gate logic: _LEGEND_GROUNDING_CHART_TYPES
+# ---------------------------------------------------------------------------
+
+
+class TestLegendGroundingGate:
+    """Tests for legend-grounding gate (chart type and legend length)."""
+
+    @pytest.mark.parametrize(
+        "chart_type",
+        [
+            "line",
+            "bar",
+            "scatter",
+            "area",
+            "bar_grouped",
+            "bar_stacked",
+            "combination",
+            "pie",
+            "donut",
+        ],
+    )
+    def test_multi_series_chart_types_in_gate(self, chart_type):
+        """Chart types that use legend grounding are in the allowlist."""
+        assert chart_type in _LEGEND_GROUNDING_CHART_TYPES
+
+    @pytest.mark.parametrize("chart_type", ["table", "dashboard", "other", "unknown"])
+    def test_single_series_types_not_in_gate(self, chart_type):
+        """Chart types outside the legend-grounding allowlist are not gated in."""
+        assert chart_type not in _LEGEND_GROUNDING_CHART_TYPES
+
+    def test_gate_requires_more_than_one_legend_entry(self):
+        """Simulate the gate check from process_sample."""
+        ocr_legend = ["Only series"]
+        ocr_chart_type = "line"
+        grounder_mock = MagicMock()
+
+        should_ground = (
+            grounder_mock is not None and len(ocr_legend) > 1 and ocr_chart_type in _LEGEND_GROUNDING_CHART_TYPES
+        )
+        assert should_ground is False
+
+    def test_gate_passes_with_two_entries_and_line_chart(self):
+        """Two legend rows and a gated chart type enable grounding."""
+        ocr_legend = ["Series A", "Series B"]
+        ocr_chart_type = "line"
+        grounder_mock = MagicMock()
+
+        should_ground = (
+            grounder_mock is not None and len(ocr_legend) > 1 and ocr_chart_type in _LEGEND_GROUNDING_CHART_TYPES
+        )
+        assert should_ground is True
+
+    def test_gate_skips_when_grounder_is_none(self):
+        """No grounding when the grounder tool is absent (None)."""
+        ocr_legend = ["Series A", "Series B"]
+        ocr_chart_type = "line"
+        grounder = None
+        should_ground = grounder is not None and len(ocr_legend) > 1 and ocr_chart_type in _LEGEND_GROUNDING_CHART_TYPES
+        assert should_ground is False
+
+
+# ---------------------------------------------------------------------------
+# Compliance check logic
+# ---------------------------------------------------------------------------
+
+
+class TestComplianceCheck:
+    """Test the label-in-explanation compliance logic in isolation."""
+
+    def _compliance_passes(self, legend_map: list, explanation: str) -> bool:
+        """Return True if any non-empty legend label occurs in the explanation."""
+        expl = explanation.lower()
+        return any(entry.get("label", "").lower() in expl for entry in legend_map if entry.get("label"))
+
+    def test_passes_when_label_mentioned(self):
+        """Test compliance passes when a label is mentioned in the explanation."""
+        explanation = "Clayton Oliver shows the highest score in 2021."
+        assert self._compliance_passes(_SAMPLE_LEGEND_MAP, explanation) is True
+
+    def test_passes_when_any_label_mentioned(self):
+        """Test compliance passes when any valid label is mentioned."""
+        explanation = "The grey dashed line for Top-10 Player peaks in 2020."
+        assert self._compliance_passes(_SAMPLE_LEGEND_MAP, explanation) is True
+
+    def test_fails_when_no_label_mentioned(self):
+        """Test compliance fails when no labels are mentioned in explanation."""
+        explanation = "The orange line peaks at 95 in 2021."
+        assert self._compliance_passes(_SAMPLE_LEGEND_MAP, explanation) is False
+
+    def test_case_insensitive_match(self):
+        """Test compliance check is case-insensitive."""
+        explanation = "clayton oliver leads by a wide margin."
+        assert self._compliance_passes(_SAMPLE_LEGEND_MAP, explanation) is True
+
+    def test_empty_explanation_fails(self):
+        """Test compliance fails for an empty explanation."""
+        assert self._compliance_passes(_SAMPLE_LEGEND_MAP, "") is False
+
+    def test_empty_legend_map_always_fails(self):
+        """Test compliance passes never when the legend_map is empty."""
+        assert self._compliance_passes([], "Clayton Oliver scored 90.") is False
+
+    def test_entries_without_label_key_are_skipped(self):
+        """Test entries in the legend_map without a 'label' key are skipped."""
+        map_no_labels = [{"color_description": "orange"}]
+        assert self._compliance_passes(map_no_labels, "orange line peaks.") is False
+
+
+# ---------------------------------------------------------------------------
+# LegendGrounderTool — unit tests with mocked API calls
+# ---------------------------------------------------------------------------
+
+
+class TestLegendGrounderTool:
+    """Tests for ``LegendGrounderTool`` with mocked or invalid backends."""
+
+    def _make_tool(self) -> LegendGrounderTool:
+        """Instantiate a LegendGrounderTool for tests with test credentials."""
+        return LegendGrounderTool(backend="gemini", model="gemini-2.5-flash-lite", api_key="fake")
+
+    def test_pop_traces_returns_and_clears(self):
+        """Test that pop_traces returns and clears trace data."""
+        tool = self._make_tool()
+        tool._traces.append({"tool": "legend_grounder_tool", "elapsed_ms": 42.0})
+        traces = tool.pop_traces()
+        assert len(traces) == 1
+        assert traces[0]["tool"] == "legend_grounder_tool"
+        assert tool.pop_traces() == []
+
+    def test_unknown_backend_returns_error_json(self):
+        """Unknown backend returns JSON with ``error``, not an exception."""
+        img_bytes = _tiny_png_bytes()
+        with tempfile.NamedTemporaryFile(suffix=".png", delete=False) as f:
+            f.write(img_bytes)
+            tmp_path = f.name
+
+        tool = LegendGrounderTool(backend="unknown", model="m", api_key="k")
+        try:
+            raw = tool._run(image_path=tmp_path, legend_list=["A", "B"])
+        finally:
+            os.unlink(tmp_path)
+
+        parsed = json.loads(raw)
+        assert parsed["legend_map"] == []
+        assert "Unknown backend" in parsed.get("error", "")
+
+    @patch("agentfinvqa.tools.legend_grounder_tool.genai")
+    def test_gemini_backend_returns_raw_text_and_appends_trace(self, mock_genai):
+        """Gemini path returns model text and records one tool trace."""
+        # Arrange
+        expected_json = json.dumps(
+            {
+                "legend_map": [
+                    {"label": "Series A", "color_description": "red", "line_style": "solid", "confidence": 0.9}
+                ]
+            }
+        )
+        mock_response = MagicMock()
+        mock_response.text = expected_json
+        mock_response.candidates = [MagicMock(finish_reason="STOP")]
+        mock_client = MagicMock()
+        mock_client.models.generate_content.return_value = mock_response
+        mock_genai.Client.return_value = mock_client
+        mock_genai.types = MagicMock()
+
+        tool = self._make_tool()
+
+        img_bytes = _tiny_png_bytes(width=4, height=4)
+        with tempfile.NamedTemporaryFile(suffix=".png", delete=False) as f:
+            f.write(img_bytes)
+            tmp_path = f.name
+
+        try:
+            raw = tool._run(image_path=tmp_path, legend_list=["Series A"])
+        finally:
+            os.unlink(tmp_path)
+
+        assert raw == expected_json
+        traces = tool.pop_traces()
+        assert len(traces) == 1
+        assert traces[0]["tool"] == "legend_grounder_tool"
+        assert traces[0]["backend"] == "gemini"
+
+    @patch("agentfinvqa.tools.legend_grounder_tool.genai")
+    def test_api_error_returns_fallback_json(self, mock_genai):
+        """Test that errors during API calls are caught and return fallback JSON."""
+        mock_genai.Client.side_effect = RuntimeError("API unavailable")
+
+        img_bytes = _tiny_png_bytes(width=4, height=4)
+        with tempfile.NamedTemporaryFile(suffix=".png", delete=False) as f:
+            f.write(img_bytes)
+            tmp_path = f.name
+
+        tool = self._make_tool()
+        try:
+            raw = tool._run(image_path=tmp_path, legend_list=["Series A"])
+        finally:
+            os.unlink(tmp_path)
+
+        parsed = json.loads(raw)
+        assert parsed["legend_map"] == []
+        assert "error" in parsed
+
+    def test_prompt_contains_all_legend_entries(self):
+        """The prompt template lists every legend label and expected JSON keys."""
+        entries = ["Clayton Oliver", "Marcus Bontempelli", "Top-10 Player"]
+        legend_formatted = "\n".join(f"  - {e}" for e in entries)
+        prompt = _LEGEND_GROUNDER_PROMPT_TEMPLATE.format(legend_list=legend_formatted)
+
+        for entry in entries:
+            assert entry in prompt
+        assert "legend_map" in prompt
+        assert "color_description" in prompt
+        assert "line_style" in prompt
+        assert "confidence" in prompt

From 4304b506f55f70b1f5cb8aefe43bdacb8077af04 Mon Sep 17 00:00:00 2001
From: Aravind N <aravindn1308@outlook.com>
Date: Tue, 12 May 2026 11:58:41 -0400
Subject: [PATCH 04/15] feat(color-area): integrate OpenCV for chart color area
 measurement and enhance vision prompts

- Added  for pixel-counting of chart areas based on legend colors.
- Introduced  schema to capture color area measurement results.
- Updated vision agent and prompts to include color area information.
- Created scripts for repairing MEPs and handling confidence gating.
- Added unit tests for the new color area functionality.
---
 README.md                                   |  14 +-
 pyproject.toml                              |   1 +
 scripts/repair_meps_v6.py                   |  98 ++++++++
 scripts/repair_meps_v7.py                   | 101 +++++++++
 scripts/run_batch.py                        |  44 ++--
 scripts/run_finmme_fixes_v8_g3flash.sh      |  29 +++
 scripts/submit_pipeline.sh                  |   2 +-
 src/agentfinvqa/agents/prompts/vision.txt   |   1 +
 src/agentfinvqa/agents/vision_agent.py      |  11 +
 src/agentfinvqa/mep/schema.py               |  19 ++
 src/agentfinvqa/runner/run_generate_meps.py |  74 ++++++
 src/agentfinvqa/tools/__init__.py           |  21 +-
 src/agentfinvqa/tools/color_area_tool.py    | 238 ++++++++++++++++++++
 tests/agentfinvqa/test_color_area_tool.py   | 126 +++++++++++
 uv.lock                                     |  39 +++-
 15 files changed, 781 insertions(+), 37 deletions(-)
 create mode 100644 scripts/repair_meps_v6.py
 create mode 100644 scripts/repair_meps_v7.py
 create mode 100755 scripts/run_finmme_fixes_v8_g3flash.sh
 create mode 100644 src/agentfinvqa/tools/color_area_tool.py
 create mode 100644 tests/agentfinvqa/test_color_area_tool.py

diff --git a/README.md b/README.md
index 14ab7b0..a86d202 100644
--- a/README.md
+++ b/README.md
@@ -79,7 +79,7 @@ Input Sample (question, chart image, expected answer)
 
 ## Results
 
-### FinMME (250-sample train slice, judge-based accuracy)
+### FinMME (250-sample train slice; v8 scale-up to 1,250)
 
 | Run | Accuracy | Δ vs baseline | Key change |
 |-----|----------|---------------|------------|
@@ -90,16 +90,16 @@ Input Sample (question, chart image, expected answer)
 | `fixes_v4_g3flash` | 56.0% | +8.0 pp | Gemini 3 Flash, forced-choice retry, MCQ-aware planner |
 | `fixes_v5_multiselect` | **69.4%** | +21.4 pp | Full multi-select MCQ support |
 | `fixes_v7_g3flash_conf_gate` | **69.6%** | +21.6 pp | Confidence gate fix, fresh g3flash run |
+| `fixes_v8_g3flash_color_area` | **71.2%** *(n = 1,250)* | +23.2 pp | Color-area OpenCV pre-hint; see `results.md` §8b |
 
-**vs. FinMME paper (Table 3, Gemini Flash 2.0 = 51.85%):** our best run achieves **+17.8 pp**.
+**vs. FinMME paper (Table 3, Gemini Flash 2.0 = 51.85%):** our best **250-ID** ladder run achieves **+17.8 pp** (v7 mean `answer_accuracy` vs paper headline — metric families differ).
 
-**Fair same-model baseline (250 FinMME IDs):**
+**Fair same-model baseline (Gemini-3 Flash Preview structured zero-shot vs agent):**
 
-- Zero-shot `gemini-3-flash-preview` (structured): **52.8%** exact
-- Agent `fixes_v7_g3flash_conf_gate`: **62.8%** exact
-- Margin: **+10.0 pp**
+- **Primary (matched n = 1,250 train IDs):** zero-shot mean `answer_accuracy` **63.56%** vs agent **`fixes_v8_g3flash_color_area`** **71.24%** → **+7.68 pp** (exact-accuracy gap **+8.72 pp**; McNemar **p ≪ 0.001**). Full zero-shot train file: **11,099** rows — always join on `sample_id` before comparing.
+- **Legacy 250-ID snapshot (strict exact, ablation era):** zero-shot **52.8%** vs agent v7 **62.8%** → **+10.0 pp** — useful historically; see `results.md` §8b for context.
 
-> Note: the initial zero-shot Gemini-3 file had parser-related empty predictions; after robust answer extraction repair, 141 rows were recovered and re-scored.
+> Note: the initial zero-shot Gemini-3 export had parser-related empty predictions; robust extraction + repair recovered many rows before the full 11k re-run.
 
 Detailed per-run analysis, per-type breakdowns, and paper comparison are in [`notebooks/results_analysis.ipynb`](notebooks/results_analysis.ipynb).
 For camera-ready citation numbers, see [`markdown/camera_ready_metrics.md`](markdown/camera_ready_metrics.md).
diff --git a/pyproject.toml b/pyproject.toml
index de8d135..6f448ba 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -16,6 +16,7 @@ dependencies = [
     "jupyterlab>=4.4.8",
     "matplotlib>=3.10.5",
     "numpy>=1.26,<2.0",
+    "opencv-python-headless>=4.8.0",
     "openai>=2.8.0",
     "pandas>=2.3.2",
     "python-dotenv>=1.2.2",
diff --git a/scripts/repair_meps_v6.py b/scripts/repair_meps_v6.py
new file mode 100644
index 0000000..6413da9
--- /dev/null
+++ b/scripts/repair_meps_v6.py
@@ -0,0 +1,98 @@
+"""
+Repair fixes_v6_conf_gate MEPs: re-parse verifier.raw_text using the corrected
+required-keys list (confidence is optional, not required).
+
+Run:
+    python scripts/repair_meps_v6.py
+"""
+
+import json
+import sys
+from pathlib import Path
+
+
+sys.path.insert(0, str(Path(__file__).parent.parent / "src"))
+from agentfinvqa.utils.json_strict import parse_strict
+
+
+VERIFIER_REQUIRED_KEYS = ["verdict", "answer", "reasoning"]  # confidence is optional
+VALID_VERDICTS = {"confirmed", "revised"}
+
+MEP_DIR = Path("meps/gemini_gemini/finmme/fixes_v6_conf_gate/train")
+
+
+def repair_mep(path: Path) -> str:
+    """Return one of: 'fixed', 'already_ok', 'no_raw', 'unparsable'."""
+    data = json.loads(path.read_text())
+    verifier = data.get("verifier") or {}
+    verdict = verifier.get("verdict", "skipped")
+
+    if verdict in VALID_VERDICTS and verifier.get("parse_error") is False:
+        return "already_ok"
+
+    raw_text = (verifier.get("raw_text") or "").strip()
+    if not raw_text:
+        return "no_raw"
+
+    parsed, parse_ok = parse_strict(raw_text, required_keys=VERIFIER_REQUIRED_KEYS)
+    if not parsed:
+        return "unparsable"
+
+    # Normalise verdict
+    raw_verdict = str(parsed.get("verdict", "")).lower()
+    if raw_verdict not in VALID_VERDICTS:
+        raw_verdict = "confirmed"
+    parsed["verdict"] = raw_verdict
+
+    # Clamp optional confidence
+    try:
+        conf = float(parsed.get("confidence", 1.0))
+        parsed["confidence"] = max(0.0, min(1.0, conf))
+    except (TypeError, ValueError):
+        parsed["confidence"] = 1.0 if raw_verdict == "confirmed" else 0.5
+
+    # Apply confidence gate: downgrade low-confidence revisions
+    gated = False
+    if raw_verdict == "revised":
+        if parsed["confidence"] < 0.75:
+            old_reasoning = parsed.get("reasoning", "")[:80]
+            parsed["verdict"] = "confirmed"
+            parsed["answer"] = (data.get("vision") or {}).get("parsed", {}).get("answer", "")
+            parsed["reasoning"] = (
+                f"[Confidence gate: revision confidence {parsed['confidence']:.2f} < 0.75 — "
+                f"keeping vision answer. Original reasoning: {old_reasoning}]"
+            )
+            gated = True
+
+    # Update verifier block
+    verifier["parsed"] = parsed
+    verifier["verdict"] = parsed["verdict"]
+    verifier["parse_error"] = not parse_ok
+
+    # Clean up errors list: remove verifier_invalid_output entries
+    errors = [e for e in (data.get("errors") or []) if "verifier_invalid_output" not in str(e)]
+    if gated:
+        errors.append(f"verifier_revision_gated: confidence={parsed['confidence']:.2f}")
+    data["errors"] = errors
+
+    path.write_text(json.dumps(data, indent=2))
+    return "gated" if gated else "fixed"
+
+
+def main():
+    results = {"fixed": 0, "gated": 0, "already_ok": 0, "no_raw": 0, "unparsable": 0}
+    paths = sorted(MEP_DIR.glob("*.json"))
+    print(f"Repairing {len(paths)} MEPs in {MEP_DIR} ...")
+    for i, p in enumerate(paths, 1):
+        outcome = repair_mep(p)
+        results[outcome] += 1
+        if i % 50 == 0:
+            print(f"  {i}/{len(paths)} processed ...")
+
+    print("\nDone.")
+    for k, v in results.items():
+        print(f"  {k:<14}: {v}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/repair_meps_v7.py b/scripts/repair_meps_v7.py
new file mode 100644
index 0000000..a5f3305
--- /dev/null
+++ b/scripts/repair_meps_v7.py
@@ -0,0 +1,101 @@
+"""
+Repair fixes_v7_g3flash_conf_gate MEPs: the confidence gate incorrectly fired
+for all verifier revisions because the model never returned a 'confidence' field,
+causing the default of 0.0 to trigger the < 0.75 gate threshold.
+
+Fix: un-gate revisions where 'confidence' is NOT present in raw_text.
+Only keep gated if the model explicitly returned confidence < 0.75.
+
+Run:
+    python scripts/repair_meps_v7.py
+"""
+
+import json
+import sys
+from pathlib import Path
+
+
+sys.path.insert(0, str(Path(__file__).parent.parent / "src"))
+from agentfinvqa.utils.json_strict import parse_strict
+
+
+VERIFIER_REQUIRED_KEYS = ["verdict", "answer", "reasoning"]
+VALID_VERDICTS = {"confirmed", "revised"}
+CONFIDENCE_GATE_THRESHOLD = 0.75
+
+MEP_DIR = Path("meps/gemini_gemini/finmme/fixes_v7_g3flash_conf_gate/train")
+
+
+def repair_mep(path: Path) -> str:
+    """Return one of: 'ungated', 'gate_kept', 'already_ok', 'no_raw', 'unparsable'."""
+    data = json.loads(path.read_text())
+    errors = data.get("errors") or []
+    verifier = data.get("verifier") or {}
+
+    was_gated = any("verifier_revision_gated" in str(e) for e in errors)
+    if not was_gated:
+        return "already_ok"
+
+    raw_text = (verifier.get("raw_text") or "").strip()
+    if not raw_text:
+        return "no_raw"
+
+    parsed, parse_ok = parse_strict(raw_text, required_keys=VERIFIER_REQUIRED_KEYS)
+    if not parsed:
+        return "unparsable"
+
+    raw_verdict = str(parsed.get("verdict", "")).lower()
+    if raw_verdict not in VALID_VERDICTS:
+        raw_verdict = "confirmed"
+
+    # Check if the model explicitly returned a confidence value
+    confidence_in_raw = "confidence" in parsed
+    if confidence_in_raw:
+        try:
+            explicit_conf = float(parsed["confidence"])
+            explicit_conf = max(0.0, min(1.0, explicit_conf))
+        except (TypeError, ValueError):
+            explicit_conf = CONFIDENCE_GATE_THRESHOLD  # neutral if unparsable
+    else:
+        explicit_conf = CONFIDENCE_GATE_THRESHOLD  # model didn't return it → neutral, don't gate
+
+    # Only keep gated if confidence was explicit AND below threshold
+    should_gate = (raw_verdict == "revised") and confidence_in_raw and (explicit_conf < CONFIDENCE_GATE_THRESHOLD)
+
+    if should_gate:
+        # Gate is legitimately correct — leave as-is
+        return "gate_kept"
+
+    # Un-gate: restore the verifier's actual verdict/answer
+    parsed["verdict"] = raw_verdict
+    parsed["confidence"] = explicit_conf
+
+    verifier["parsed"] = parsed
+    verifier["verdict"] = raw_verdict
+    verifier["parse_error"] = not parse_ok
+
+    # Remove the incorrect gate error
+    errors = [e for e in errors if "verifier_revision_gated" not in str(e)]
+    data["errors"] = errors
+
+    path.write_text(json.dumps(data, indent=2))
+    return "ungated"
+
+
+def main():
+    results = {"ungated": 0, "gate_kept": 0, "already_ok": 0, "no_raw": 0, "unparsable": 0}
+    paths = sorted(MEP_DIR.glob("*.json"))
+    print(f"Repairing {len(paths)} MEPs in {MEP_DIR} ...")
+    for i, p in enumerate(paths, 1):
+        outcome = repair_mep(p)
+        results[outcome] += 1
+        if i % 50 == 0:
+            print(f"  {i}/{len(paths)} processed ...")
+
+    print("\nDone.")
+    for k, v in results.items():
+        print(f"  {k:<14}: {v}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/run_batch.py b/scripts/run_batch.py
index 54af2e4..f1353cb 100644
--- a/scripts/run_batch.py
+++ b/scripts/run_batch.py
@@ -7,7 +7,6 @@
 import argparse
 import json
 import sys
-import threading
 from typing import Any
 from collections import defaultdict
 from concurrent.futures import ThreadPoolExecutor, as_completed
@@ -149,16 +148,14 @@ def run_post_evaluation(
 
     judge_model = judge_model or config.get("vision_model") or config.get("planner_model") or "gemini-2.5-flash-lite"
     lf_client = get_client() if use_langfuse else None
-    metrics_list: list[dict] = []
-    taxonomy_rows = 0
-    write_lock = threading.Lock()
 
-    with (
-        open(metrics_path, "w") as f_met,
-        open(trace_path, "w") as f_trace,
-        open(taxonomy_path, "w") as f_tax,
-        ThreadPoolExecutor(max_workers=workers) as pool,
-    ):
+    # Accumulate all completed results in memory, then sort by sample_id and
+    # write at the end. ThreadPoolExecutor yields futures in completion order,
+    # which is non-deterministic across workers; sorting makes the on-disk
+    # artifacts deterministic and diff-friendly between runs.
+    results: list[tuple[str, dict, dict, dict | None]] = []
+
+    with ThreadPoolExecutor(max_workers=workers) as pool:
         all_meps = list(iter_meps(str(out_dir)))
         if mep_start > 0:
             print(f"[post-eval] Skipping first {mep_start} MEPs (mep_start={mep_start}, total={len(all_meps)})")
@@ -172,18 +169,27 @@ def run_post_evaluation(
             except Exception as exc:
                 print(f"  [eval] {sid} ERROR: {exc}")
                 continue
-            with write_lock:
-                metrics_list.append(row)
-                f_met.write(json.dumps(row) + "\n")
-                f_trace.write(json.dumps(trace_row) + "\n")
-                if tax_row:
-                    f_tax.write(json.dumps(tax_row) + "\n")
-                    taxonomy_rows += 1
-
-    if not metrics_list:
+            results.append((sid, row, trace_row, tax_row))
+
+    if not results:
         print("[post-eval] No metrics produced.")
         return
 
+    results.sort(key=lambda t: t[0])
+    metrics_list: list[dict] = [row for _, row, _, _ in results]
+    taxonomy_rows = sum(1 for _, _, _, tax in results if tax)
+
+    with (
+        open(metrics_path, "w") as f_met,
+        open(trace_path, "w") as f_trace,
+        open(taxonomy_path, "w") as f_tax,
+    ):
+        for _, row, trace_row, tax_row in results:
+            f_met.write(json.dumps(row) + "\n")
+            f_trace.write(json.dumps(trace_row) + "\n")
+            if tax_row:
+                f_tax.write(json.dumps(tax_row) + "\n")
+
     acc = sum(m.get("answer_accuracy", 0.0) for m in metrics_list) / len(metrics_list)
     print(f"[post-eval] Accuracy {acc:.1%} (n={len(metrics_list)})")
     qt_groups: dict[str, list[float]] = defaultdict(list)
diff --git a/scripts/run_finmme_fixes_v8_g3flash.sh b/scripts/run_finmme_fixes_v8_g3flash.sh
new file mode 100755
index 0000000..3a23131
--- /dev/null
+++ b/scripts/run_finmme_fixes_v8_g3flash.sh
@@ -0,0 +1,29 @@
+#!/usr/bin/env bash
+# FinMME train (1250 samples = original 250 + 1000 new, indices 250..1249):
+# Gemini 3 Flash preview (planner / vision / verifier) + Flash-Lite judge.
+# v8 — includes color-area (OpenCV) stage; distinct run_tag / out_label vs v7 conf_gate runs.
+#
+# --n 1250 + --resume: the first 250 samples already have MEPs in
+#   meps/gemini_gemini/finmme/fixes_v8_g3flash_color_area/train/ and are skipped;
+#   the runner only processes the new samples finmme_000250..finmme_001249.
+# After the chained judge batch eval, the metrics file rebuilds with 1250 rows.
+# Usage: ./scripts/run_finmme_fixes_v8_g3flash.sh
+# Remove --resume below for a full re-run from scratch.
+set -euo pipefail
+
+REPO_ROOT="$(cd -- "$(dirname "${BASH_SOURCE[0]}")"/.. && pwd)"
+cd "$REPO_ROOT"
+
+scripts/submit_pipeline.sh \
+    --dataset finmme \
+    --split train \
+    --n 1250 \
+    --config gemini_gemini \
+    --vision_model gemini-3-flash-preview \
+    --planner_model gemini-3-flash-preview \
+    --verifier_model gemini-3-flash-preview \
+    --judge_model gemini-2.5-flash-lite \
+    --run_tag fixes_v8_g3flash_color_area \
+    --out_label finmme_train_fixes_v8_g3flash_color_area \
+    --langfuse \
+    --resume
diff --git a/scripts/submit_pipeline.sh b/scripts/submit_pipeline.sh
index b8fc3ba..0ddb8e0 100755
--- a/scripts/submit_pipeline.sh
+++ b/scripts/submit_pipeline.sh
@@ -127,7 +127,7 @@ echo ""
 # Job 1: MEP generation (optionally held until AFTER_JOB completes)
 JOB1_DEP=""
 [[ -n "$AFTER_JOB" ]] && JOB1_DEP="--dependency=afterok:${AFTER_JOB}"
-JOB1=$(sbatch --parsable --export=ALL --job-name="${JOB_NAME}" $JOB1_DEP scripts/slurm_run_batch.slrm)
+JOB1=$(sbatch --parsable --export=ALL --job-name="${JOB_NAME}" --cpus-per-task="${WORKERS}" $JOB1_DEP scripts/slurm_run_batch.slrm)
 echo "Job 1 (generate) submitted: $JOB1"
 
 # Load SLURM module so sbatch is available
diff --git a/src/agentfinvqa/agents/prompts/vision.txt b/src/agentfinvqa/agents/prompts/vision.txt
index 7c1005a..561fb9f 100644
--- a/src/agentfinvqa/agents/prompts/vision.txt
+++ b/src/agentfinvqa/agents/prompts/vision.txt
@@ -7,6 +7,7 @@ Question: {question}
 {context_block}
 {ocr_block}
 {legend_grounding_block}
+{color_area_block}
 {caption_block}
 {multi_select_block}Inspection Plan — follow these steps in order:
 {plan_steps_block}
diff --git a/src/agentfinvqa/agents/vision_agent.py b/src/agentfinvqa/agents/vision_agent.py
index 9220b72..2bd5ecc 100644
--- a/src/agentfinvqa/agents/vision_agent.py
+++ b/src/agentfinvqa/agents/vision_agent.py
@@ -12,6 +12,8 @@
 
 from ..datasets.perceived_sample import PerceivedSample
 from ..langfuse_integration.tracing import close_span, open_llm_span
+from ..mep.schema import MEPColorArea
+from ..tools.color_area_tool import format_color_area_block_for_vision
 from ..tools.vision_qa_tool import VisionQATool
 from ..utils.json_strict import parse_strict
 from ..utils.model_compat import openai_temperature
@@ -179,6 +181,7 @@ def build_vision_task_description(
     plan: dict,
     ocr_result: Optional[dict] = None,
     legend_map: Optional[List[dict]] = None,
+    color_area: Optional[MEPColorArea] = None,
     prepend_instruction: Optional[str] = None,
 ) -> str:
     """
@@ -197,6 +200,8 @@ def build_vision_task_description(
         Pre-extracted text data from the chart image.
     legend_map : list of dict, optional
         Structured color-to-series mapping from LegendGrounderTool.
+    color_area : MEPColorArea, optional
+        Optional pixel-area breakdown from the color-area tool stage.
     prepend_instruction : str, optional
         Extra instruction to prepend to the prompt (used for compliance retry).
 
@@ -211,6 +216,7 @@ def build_vision_task_description(
     plan_steps_block = _format_plan_steps(plan)
     ocr_block = _format_ocr_block(ocr_result)
     legend_grounding_block = _format_legend_grounding_block(legend_map)
+    color_area_block = format_color_area_block_for_vision(color_area)
     caption_block = _format_caption_block(sample)
     multi_select_block = _format_multi_select_block(sample)
 
@@ -222,6 +228,7 @@ def build_vision_task_description(
         context_block=context_block,
         ocr_block=ocr_block,
         legend_grounding_block=legend_grounding_block,
+        color_area_block=color_area_block,
         caption_block=caption_block,
         multi_select_block=multi_select_block,
         plan_steps_block=plan_steps_block,
@@ -348,6 +355,7 @@ def run(
         lf_trace: Any = None,
         ocr_result: Optional[dict] = None,
         legend_map: Optional[List[dict]] = None,
+        color_area: Optional[MEPColorArea] = None,
         prepend_instruction: Optional[str] = None,
     ) -> Tuple[str, dict, bool, str, List[dict]]:
         """
@@ -368,6 +376,8 @@ def run(
             Ground-truth OCR data for grounding.
         legend_map : list of dict, optional
             Structured color-to-series mapping from LegendGrounderTool.
+        color_area : MEPColorArea, optional
+            Pixel-area breakdown for size-comparison questions.
         prepend_instruction : str, optional
             Extra instruction to prepend (used for compliance retry).
 
@@ -391,6 +401,7 @@ def run(
             plan,
             ocr_result=ocr_result,
             legend_map=legend_map,
+            color_area=color_area,
             prepend_instruction=prepend_instruction,
         )
 
diff --git a/src/agentfinvqa/mep/schema.py b/src/agentfinvqa/mep/schema.py
index 51fd40f..7066f3e 100644
--- a/src/agentfinvqa/mep/schema.py
+++ b/src/agentfinvqa/mep/schema.py
@@ -137,6 +137,24 @@ class MEPLegendGrounding:
     tool_trace: List[Dict] = field(default_factory=list)
 
 
+@dataclass
+class MEPColorArea:
+    """Trace of the color-area measurement stage inserted between legend grounding and vision.
+
+    Captures whether the stage was triggered, the per-label pixel-area breakdown,
+    the dominant label, and confidence/ambiguity flags.
+    """
+
+    triggered: bool = False
+    breakdown: Dict[str, float] = field(default_factory=dict)
+    largest: Optional[str] = None
+    total_pixels_matched: int = 0
+    low_confidence: bool = False
+    color_ambiguity: bool = False
+    parse_error: bool = False
+    tool_trace: List[Dict] = field(default_factory=list)
+
+
 @dataclass
 class MEPTimestamps:
     """Timestamps for the different steps of the agent run.
@@ -170,6 +188,7 @@ class MEP:
     plan: Optional[MEPPlan] = None
     ocr: Optional[MEPOcr] = None  # None when OCR step is skipped
     legend_grounding: Optional[MEPLegendGrounding] = None  # None when not triggered
+    color_area: Optional[MEPColorArea] = None  # None when not triggered
     vision: Optional[MEPVision] = None
     verifier: Optional[MEPVerifier] = None  # Pass 2.5 — None when skipped
     timestamps: Optional[MEPTimestamps] = None
diff --git a/src/agentfinvqa/runner/run_generate_meps.py b/src/agentfinvqa/runner/run_generate_meps.py
index 3826168..627d602 100644
--- a/src/agentfinvqa/runner/run_generate_meps.py
+++ b/src/agentfinvqa/runner/run_generate_meps.py
@@ -19,6 +19,7 @@
 from pathlib import Path
 from typing import Any, Callable, Optional, TypedDict
 
+import cv2
 from dotenv import load_dotenv
 
 from ..agents.planner_agent import PlannerAgent
@@ -37,6 +38,7 @@
 from ..mep.schema import (
     MEP,
     ImageRef,
+    MEPColorArea,
     MEPConfig,
     MEPLegendGrounding,
     MEPOcr,
@@ -47,6 +49,11 @@
     MEPVision,
 )
 from ..mep.writer import mep_dataset_split_relpath, write_mep
+from ..tools.color_area_tool import (
+    check_color_ambiguity,
+    color_area_tool,
+    should_trigger_color_area,
+)
 from ..tools.legend_grounder_tool import LegendGrounderTool
 from ..tools.ocr_reader_tool import OcrReaderTool
 from ..utils.hashing import sha256_file
@@ -159,6 +166,15 @@ class DatasetConfig(TypedDict):
 }
 
 
+def estimated_chart_area_pixels(image_path: str) -> int:
+    """Return an estimate of the chart region pixel count (top 85 % × left 75 %)."""
+    img = cv2.imread(image_path)
+    if img is None:
+        return 0
+    h, w = img.shape[:2]
+    return int(h * 0.85 * w * 0.75)
+
+
 def _run_verifier_stage(
     verifier_agent: Optional[VerifierAgent],
     sample: PerceivedSample,
@@ -387,6 +403,37 @@ def process_sample(  # noqa: PLR0912, PLR0915
                 legend_grounding_parse_error = True
                 traceback.print_exc()
 
+        # ---- Color area (optional; after legend grounding, before vision) ----
+        color_area_triggered = False
+        color_area_breakdown: dict = {}
+        color_area_largest: Optional[str] = None
+        color_area_total_pixels = 0
+        color_area_low_confidence = False
+        color_area_ambiguity = False
+        color_area_parse_error = False
+
+        _active_legend_map = legend_map if legend_grounding_triggered and not legend_grounding_parse_error else []
+        if should_trigger_color_area(ocr_chart_type, _active_legend_map, sample.question):
+            color_area_triggered = True
+            try:
+                if check_color_ambiguity(_active_legend_map):
+                    color_area_ambiguity = True
+                else:
+                    ca_result = color_area_tool(sample.image_path, _active_legend_map)
+                    color_area_breakdown = ca_result.get("breakdown", {})
+                    color_area_largest = ca_result.get("largest")
+                    color_area_total_pixels = ca_result.get("total_pixels_matched", 0)
+                    if ca_result.get("error"):
+                        color_area_parse_error = True
+                    else:
+                        chart_pixel_total = estimated_chart_area_pixels(sample.image_path)
+                        if chart_pixel_total > 0 and color_area_total_pixels < chart_pixel_total * 0.05:
+                            color_area_low_confidence = True
+            except Exception as exc:
+                errors.append(f"color_area_error: {exc}")
+                color_area_parse_error = True
+                traceback.print_exc()
+
         # ---- Vision ----
         vision_prompt = ""
         vision_parsed: dict = {}
@@ -396,6 +443,19 @@ def process_sample(  # noqa: PLR0912, PLR0915
         vision_ms = 0.0
 
         _vision_legend_map = legend_map if legend_grounding_triggered and not legend_grounding_parse_error else None
+        _vision_color_area = (
+            MEPColorArea(
+                triggered=color_area_triggered,
+                breakdown=color_area_breakdown,
+                largest=color_area_largest,
+                total_pixels_matched=color_area_total_pixels,
+                low_confidence=color_area_low_confidence,
+                color_ambiguity=color_area_ambiguity,
+                parse_error=color_area_parse_error,
+            )
+            if color_area_triggered
+            else None
+        )
 
         try:
             with timed() as vt:
@@ -411,6 +471,7 @@ def process_sample(  # noqa: PLR0912, PLR0915
                     lf_trace=lf_trace,
                     ocr_result=ocr_parsed if ocr_parsed else None,
                     legend_map=_vision_legend_map,
+                    color_area=_vision_color_area,
                 )
             vision_ms = vt.elapsed_ms
         except Exception as exc:
@@ -446,6 +507,7 @@ def process_sample(  # noqa: PLR0912, PLR0915
                         lf_trace=lf_trace,
                         ocr_result=ocr_parsed if ocr_parsed else None,
                         legend_map=_vision_legend_map,
+                        color_area=_vision_color_area,
                         prepend_instruction=retry_instruction,
                     )
                 except Exception as exc:
@@ -489,6 +551,7 @@ def process_sample(  # noqa: PLR0912, PLR0915
                     lf_trace=lf_trace,
                     ocr_result=ocr_parsed if ocr_parsed else None,
                     legend_map=_vision_legend_map,
+                    color_area=_vision_color_area,
                     prepend_instruction=_forced_instruction,
                 )
             except Exception as exc:
@@ -559,6 +622,17 @@ def process_sample(  # noqa: PLR0912, PLR0915
             )
             if legend_grounding_triggered
             else None,
+            color_area=MEPColorArea(
+                triggered=color_area_triggered,
+                breakdown=color_area_breakdown,
+                largest=color_area_largest,
+                total_pixels_matched=color_area_total_pixels,
+                low_confidence=color_area_low_confidence,
+                color_ambiguity=color_area_ambiguity,
+                parse_error=color_area_parse_error,
+            )
+            if color_area_triggered
+            else None,
             vision=MEPVision(
                 prompt=vision_prompt,
                 raw_text=vision_raw,
diff --git a/src/agentfinvqa/tools/__init__.py b/src/agentfinvqa/tools/__init__.py
index 747ca1a..1db5c4a 100644
--- a/src/agentfinvqa/tools/__init__.py
+++ b/src/agentfinvqa/tools/__init__.py
@@ -1,7 +1,22 @@
-"""Tools package: OCR reader and vision QA tools for chart analysis."""
+"""Tools package: OCR reader, vision QA, and optional chart analysis helpers."""
 
-from .ocr_reader_tool import OcrReaderTool
-from .vision_qa_tool import VisionQATool
+from typing import TYPE_CHECKING, Any
 
 
+if TYPE_CHECKING:
+    from .ocr_reader_tool import OcrReaderTool
+    from .vision_qa_tool import VisionQATool
+
 __all__ = ["OcrReaderTool", "VisionQATool"]
+
+
+def __getattr__(name: str) -> Any:
+    if name == "OcrReaderTool":
+        from .ocr_reader_tool import OcrReaderTool  # noqa: PLC0415
+
+        return OcrReaderTool
+    if name == "VisionQATool":
+        from .vision_qa_tool import VisionQATool  # noqa: PLC0415
+
+        return VisionQATool
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
diff --git a/src/agentfinvqa/tools/color_area_tool.py b/src/agentfinvqa/tools/color_area_tool.py
new file mode 100644
index 0000000..d9a99c7
--- /dev/null
+++ b/src/agentfinvqa/tools/color_area_tool.py
@@ -0,0 +1,238 @@
+"""color_area_tool — OpenCV pixel-counting tool for chart color area measurement.
+
+Objectively measures the fraction of chart area occupied by each legend color.
+Runs between legend grounding and vision stages; no VLM calls, pure CPU.
+"""
+
+import re
+from typing import Optional
+
+import cv2
+import numpy as np
+
+from ..mep.schema import MEPColorArea
+
+
+# Chart types where color-area measurement is meaningful
+_COLOR_AREA_CHART_TYPES = {"bar", "bar_stacked", "bar_grouped", "pie", "donut"}
+
+# Question keywords that indicate a size-comparison intent
+_COMPARISON_KEYWORDS = {
+    "largest",
+    "smallest",
+    "highest",
+    "lowest",
+    "most",
+    "least",
+    "greatest",
+    "fewest",
+    "dominant",
+    "majority",
+}
+
+
+# ---------------------------------------------------------------------------
+# Internal helpers
+# ---------------------------------------------------------------------------
+
+
+def _parse_rgb(rgb_val) -> Optional[tuple]:
+    """Parse rgb_approximate to a (R, G, B) int tuple.
+
+    Accepts a list/tuple of 3 ints or a string like "(70, 130, 180)".
+    Returns None on failure.
+    """
+    if isinstance(rgb_val, (list, tuple)) and len(rgb_val) >= 3:
+        try:
+            return tuple(int(v) for v in rgb_val[:3])
+        except (TypeError, ValueError):
+            return None
+    if isinstance(rgb_val, str):
+        nums = re.findall(r"\d+", rgb_val)
+        if len(nums) >= 3:
+            try:
+                return tuple(int(n) for n in nums[:3])
+            except ValueError:
+                return None
+    return None
+
+
+def _rgb_to_hsv(r: int, g: int, b: int) -> tuple:
+    """Convert a single RGB pixel to HSV using OpenCV conventions.
+
+    Returns (H, S, V) where H ∈ [0, 179], S/V ∈ [0, 255].
+    """
+    pixel = np.array([[[r, g, b]]], dtype=np.uint8)
+    hsv = cv2.cvtColor(pixel, cv2.COLOR_RGB2HSV)
+    return int(hsv[0, 0, 0]), int(hsv[0, 0, 1]), int(hsv[0, 0, 2])
+
+
+def _hue_distance(h1: int, h2: int) -> int:
+    """Circular distance between two hue values in [0, 179]."""
+    diff = abs(h1 - h2)
+    return min(diff, 180 - diff)
+
+
+# ---------------------------------------------------------------------------
+# Public API
+# ---------------------------------------------------------------------------
+
+
+def color_area_tool(image_path: str, legend_map: list) -> dict:
+    """Measure the chart area occupied by each legend color via pixel counting.
+
+    Parameters
+    ----------
+    image_path : str
+        Path to the chart image.
+    legend_map : list of dict
+        Each entry must have ``label`` (str) and ``rgb_approximate``
+        (list of 3 ints or string like "(R, G, B)").
+
+    Returns
+    -------
+    dict with keys:
+        breakdown : dict[label → percentage]  (sorted descending)
+        largest   : str | None
+        total_pixels_matched : int
+        error     : str | None
+    """
+    img = cv2.imread(image_path)
+    if img is None:
+        return {
+            "error": "image_load_failed",
+            "breakdown": {},
+            "largest": None,
+            "total_pixels_matched": 0,
+        }
+
+    h, w = img.shape[:2]
+    # Crop to chart region: top 85 % of height, left 75 % of width
+    crop_h = int(h * 0.85)
+    crop_w = int(w * 0.75)
+    chart_region = img[:crop_h, :crop_w]
+
+    hsv_img = cv2.cvtColor(chart_region, cv2.COLOR_BGR2HSV)
+
+    counts: dict[str, int] = {}
+
+    for entry in legend_map:
+        label = entry.get("label", "")
+        rgb = _parse_rgb(entry.get("rgb_approximate"))
+        if rgb is None:
+            counts[label] = 0
+            continue
+
+        r, g, b = rgb
+        target_h, target_s, target_v = _rgb_to_hsv(r, g, b)
+
+        # Build tolerance bounds; clamp to valid ranges
+        lo_h = max(0, target_h - 10)
+        hi_h = min(179, target_h + 10)
+        lo_s = max(0, target_s - 40)
+        hi_s = min(255, target_s + 40)
+        lo_v = max(0, target_v - 40)
+        hi_v = min(255, target_v + 40)
+
+        lower = np.array([lo_h, lo_s, lo_v], dtype=np.uint8)
+        upper = np.array([hi_h, hi_s, hi_v], dtype=np.uint8)
+        mask = cv2.inRange(hsv_img, lower, upper)
+
+        counts[label] = int(np.sum(mask > 0))
+
+    total_matched = sum(counts.values())
+    if total_matched == 0:
+        return {
+            "error": "no_pixels_matched",
+            "breakdown": {},
+            "largest": None,
+            "total_pixels_matched": 0,
+        }
+
+    breakdown = {
+        label: round(cnt / total_matched * 100, 1) for label, cnt in counts.items()
+    }
+    # Sort descending by percentage
+    breakdown = dict(sorted(breakdown.items(), key=lambda x: x[1], reverse=True))
+
+    largest = max(breakdown, key=lambda lbl: breakdown[lbl])
+
+    return {
+        "breakdown": breakdown,
+        "largest": largest,
+        "total_pixels_matched": total_matched,
+        "error": None,
+    }
+
+
+def should_trigger_color_area(chart_type: str, legend_map: list, question: str) -> bool:
+    """Return True only when color-area measurement is appropriate.
+
+    Gating conditions (ALL must be true):
+    - chart_type is a supported color-area type (bar, pie, donut variants)
+    - legend_map has more than one entry
+    - question contains at least one size-comparison keyword
+    """
+    if chart_type not in _COLOR_AREA_CHART_TYPES:
+        return False
+    if len(legend_map) <= 1:
+        return False
+    q_lower = question.lower()
+    return any(kw in q_lower for kw in _COMPARISON_KEYWORDS)
+
+
+def check_color_ambiguity(legend_map: list) -> bool:
+    """Return True if any two legend entries have HSV hues within 15 units.
+
+    Ambiguous colors cannot be reliably distinguished by pixel matching,
+    so the color_area stage is skipped when this returns True.
+
+    Parameters
+    ----------
+    legend_map : list of dict
+        Each entry needs ``rgb_approximate``.
+
+    Returns
+    -------
+    bool
+        True → colors too similar; False → colors are well-separated.
+    """
+    hues: list[tuple[int, str]] = []
+    for entry in legend_map:
+        label = entry.get("label", "")
+        rgb = _parse_rgb(entry.get("rgb_approximate"))
+        if rgb is None:
+            continue
+        h, _, _ = _rgb_to_hsv(*rgb)
+        hues.append((h, label))
+
+    for i in range(len(hues)):
+        for j in range(i + 1, len(hues)):
+            if _hue_distance(hues[i][0], hues[j][0]) <= 15:
+                return True
+    return False
+
+
+def format_color_area_block_for_vision(color_area: Optional[MEPColorArea]) -> str:
+    """Build vision prompt text from color-area results."""
+    if color_area is None or not color_area.triggered:
+        return ""
+    if color_area.low_confidence or color_area.color_ambiguity or color_area.parse_error:
+        return ""
+    if not color_area.breakdown:
+        return ""
+    lines = [
+        "Pre-computed color area measurement (pixel counting — treat as "
+        "objective measurement, more reliable than visual estimation for "
+        "size-comparison questions):",
+    ]
+    sorted_items = sorted(color_area.breakdown.items(), key=lambda x: x[1], reverse=True)
+    for label, pct in sorted_items:
+        lines.append(f"  {label} → {pct}% of chart area")
+    lines.append(
+        "\nINSTRUCTION: For size-comparison questions (largest, smallest, "
+        "most, least), use these pixel measurements as primary evidence. "
+        "Only override if measurements look clearly wrong (e.g. very low "
+        "total coverage)."
+    )
+    return "\n".join(lines)
diff --git a/tests/agentfinvqa/test_color_area_tool.py b/tests/agentfinvqa/test_color_area_tool.py
new file mode 100644
index 0000000..bc2a134
--- /dev/null
+++ b/tests/agentfinvqa/test_color_area_tool.py
@@ -0,0 +1,126 @@
+"""Unit tests for color_area_tool and vision color-area prompt block."""
+
+from unittest.mock import patch
+
+import numpy as np
+
+from agentfinvqa.mep.schema import MEP, MEPColorArea
+from agentfinvqa.tools.color_area_tool import (
+    check_color_ambiguity,
+    color_area_tool,
+    format_color_area_block_for_vision,
+    should_trigger_color_area,
+)
+
+
+def test_should_trigger_all_gated_types_with_keyword():
+    legend = [
+        {"label": "A", "rgb_approximate": [255, 0, 0]},
+        {"label": "B", "rgb_approximate": [0, 0, 255]},
+    ]
+    for ct in ("bar", "bar_stacked", "bar_grouped", "pie", "donut"):
+        assert should_trigger_color_area(ct, legend, "Which is the largest segment?") is True
+
+
+def test_should_trigger_false_non_comparison_question():
+    legend = [
+        {"label": "A", "rgb_approximate": [255, 0, 0]},
+        {"label": "B", "rgb_approximate": [0, 0, 255]},
+    ]
+    assert should_trigger_color_area("bar", legend, "What is the title of the chart?") is False
+
+
+def test_should_trigger_false_non_gated_chart():
+    legend = [
+        {"label": "A", "rgb_approximate": [255, 0, 0]},
+        {"label": "B", "rgb_approximate": [0, 0, 255]},
+    ]
+    assert should_trigger_color_area("line", legend, "Which is largest?") is False
+
+
+def test_should_trigger_false_single_legend():
+    legend = [{"label": "Only", "rgb_approximate": [255, 0, 0]}]
+    assert should_trigger_color_area("bar", legend, "Which is largest?") is False
+
+
+def test_check_color_ambiguity_true_similar_hue():
+    # Identical RGB → same hue → ambiguous by the hue-distance rule
+    legend = [
+        {"label": "A", "rgb_approximate": [200, 100, 50]},
+        {"label": "B", "rgb_approximate": [200, 100, 50]},
+    ]
+    assert check_color_ambiguity(legend) is True
+
+
+def test_check_color_ambiguity_false_well_separated():
+    legend = [
+        {"label": "A", "rgb_approximate": [255, 0, 0]},
+        {"label": "B", "rgb_approximate": [0, 255, 0]},
+    ]
+    assert check_color_ambiguity(legend) is False
+
+
+@patch("agentfinvqa.tools.color_area_tool.cv2.imread")
+def test_color_area_tool_no_pixels_matched_white(mock_imread):
+    mock_imread.return_value = np.full((100, 100, 3), 255, dtype=np.uint8)
+    legend = [
+        {"label": "X", "rgb_approximate": [255, 0, 0]},
+        {"label": "Y", "rgb_approximate": [0, 0, 255]},
+    ]
+    out = color_area_tool("/fake/path.png", legend)
+    assert out["error"] == "no_pixels_matched"
+    assert out["breakdown"] == {}
+    assert out["largest"] is None
+    assert out["total_pixels_matched"] == 0
+
+
+def test_mep_color_area_serializes_in_to_dict():
+    ca = MEPColorArea(
+        triggered=True,
+        breakdown={"A": 60.0, "B": 40.0},
+        largest="A",
+        total_pixels_matched=100,
+        low_confidence=False,
+        color_ambiguity=False,
+        parse_error=False,
+        tool_trace=[{"tool": "color_area"}],
+    )
+    mep = MEP(run_id="r1", color_area=ca)
+    d = mep.to_dict()
+    assert d["color_area"]["triggered"] is True
+    assert d["color_area"]["breakdown"] == {"A": 60.0, "B": 40.0}
+    assert d["color_area"]["largest"] == "A"
+    assert d["color_area"]["total_pixels_matched"] == 100
+    assert d["color_area"]["tool_trace"] == [{"tool": "color_area"}]
+
+
+def test_format_color_area_block_empty_when_low_confidence():
+    ca = MEPColorArea(
+        triggered=True,
+        breakdown={"A": 50.0},
+        largest="A",
+        total_pixels_matched=10,
+        low_confidence=True,
+        color_ambiguity=False,
+        parse_error=False,
+    )
+    assert format_color_area_block_for_vision(ca) == ""
+
+
+def test_format_color_area_block_correct_when_confident():
+    ca = MEPColorArea(
+        triggered=True,
+        breakdown={"B": 30.0, "A": 70.0},
+        largest="A",
+        total_pixels_matched=100,
+        low_confidence=False,
+        color_ambiguity=False,
+        parse_error=False,
+    )
+    block = format_color_area_block_for_vision(ca)
+    assert "Pre-computed color area measurement" in block
+    assert "A → 70.0% of chart area" in block
+    assert "B → 30.0% of chart area" in block
+    # Descending by percentage: A before B
+    assert block.index("A →") < block.index("B →")
+    assert "primary evidence" in block
diff --git a/uv.lock b/uv.lock
index cb2293c..0acce1d 100644
--- a/uv.lock
+++ b/uv.lock
@@ -4,13 +4,19 @@ requires-python = ">=3.12"
 resolution-markers = [
     "python_full_version >= '3.14' and sys_platform == 'win32'",
     "python_full_version >= '3.14' and sys_platform == 'emscripten'",
-    "python_full_version >= '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32'",
+    "python_full_version >= '3.14' and sys_platform == 'darwin'",
+    "python_full_version >= '3.14' and platform_machine == 'aarch64' and sys_platform == 'linux'",
+    "(python_full_version >= '3.14' and platform_machine != 'aarch64' and sys_platform == 'linux') or (python_full_version >= '3.14' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'linux' and sys_platform != 'win32')",
     "python_full_version == '3.13.*' and sys_platform == 'win32'",
     "python_full_version < '3.13' and sys_platform == 'win32'",
     "python_full_version == '3.13.*' and sys_platform == 'emscripten'",
     "python_full_version < '3.13' and sys_platform == 'emscripten'",
-    "python_full_version == '3.13.*' and sys_platform != 'emscripten' and sys_platform != 'win32'",
-    "python_full_version < '3.13' and sys_platform != 'emscripten' and sys_platform != 'win32'",
+    "python_full_version == '3.13.*' and sys_platform == 'darwin'",
+    "python_full_version == '3.13.*' and platform_machine == 'aarch64' and sys_platform == 'linux'",
+    "(python_full_version == '3.13.*' and platform_machine != 'aarch64' and sys_platform == 'linux') or (python_full_version == '3.13.*' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'linux' and sys_platform != 'win32')",
+    "python_full_version < '3.13' and sys_platform == 'darwin'",
+    "python_full_version < '3.13' and platform_machine == 'aarch64' and sys_platform == 'linux'",
+    "(python_full_version < '3.13' and platform_machine != 'aarch64' and sys_platform == 'linux') or (python_full_version < '3.13' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'linux' and sys_platform != 'win32')",
 ]
 
 [[package]]
@@ -30,6 +36,7 @@ dependencies = [
     { name = "mypy" },
     { name = "numpy" },
     { name = "openai" },
+    { name = "opencv-python-headless" },
     { name = "pandas" },
     { name = "pytest" },
     { name = "python-dotenv" },
@@ -83,6 +90,7 @@ requires-dist = [
     { name = "mypy", specifier = ">=1.19.1" },
     { name = "numpy", specifier = ">=1.26,<2.0" },
     { name = "openai", specifier = ">=2.8.0" },
+    { name = "opencv-python-headless", specifier = ">=4.8.0" },
     { name = "pandas", specifier = ">=2.3.2" },
     { name = "pytest", specifier = ">=9.0.2" },
     { name = "python-dotenv", specifier = ">=1.2.2" },
@@ -540,7 +548,7 @@ name = "build"
 version = "1.4.2"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "colorama", marker = "os_name == 'nt'" },
+    { name = "colorama", marker = "(os_name == 'nt' and platform_machine != 'aarch64' and sys_platform == 'linux') or (os_name == 'nt' and sys_platform != 'darwin' and sys_platform != 'linux')" },
     { name = "packaging" },
     { name = "pyproject-hooks" },
 ]
@@ -2070,7 +2078,7 @@ dependencies = [
     { name = "nbformat" },
     { name = "packaging" },
     { name = "prometheus-client" },
-    { name = "pywinpty", marker = "os_name == 'nt'" },
+    { name = "pywinpty", marker = "(os_name == 'nt' and platform_machine != 'aarch64' and sys_platform == 'linux') or (os_name == 'nt' and sys_platform != 'darwin' and sys_platform != 'linux')" },
     { name = "pyzmq" },
     { name = "send2trash" },
     { name = "terminado" },
@@ -2088,7 +2096,7 @@ name = "jupyter-server-terminals"
 version = "0.5.4"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "pywinpty", marker = "os_name == 'nt'" },
+    { name = "pywinpty", marker = "(os_name == 'nt' and platform_machine != 'aarch64' and sys_platform == 'linux') or (os_name == 'nt' and sys_platform != 'darwin' and sys_platform != 'linux')" },
     { name = "terminado" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/f4/a7/bcd0a9b0cbba88986fe944aaaf91bfda603e5a50bda8ed15123f381a3b2f/jupyter_server_terminals-0.5.4.tar.gz", hash = "sha256:bbda128ed41d0be9020349f9f1f2a4ab9952a73ed5f5ac9f1419794761fb87f5", size = 31770, upload-time = "2026-01-14T16:53:20.213Z" }
@@ -3166,6 +3174,23 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/d0/b1/35b6f9c8cf9318e3dbb7146cc82dab4cf61182a8d5406fc9b50864362895/openai-2.29.0-py3-none-any.whl", hash = "sha256:b7c5de513c3286d17c5e29b92c4c98ceaf0d775244ac8159aeb1bddf840eb42a", size = 1141533, upload-time = "2026-03-17T17:53:47.348Z" },
 ]
 
+[[package]]
+name = "opencv-python-headless"
+version = "4.11.0.86"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "numpy" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/36/2f/5b2b3ba52c864848885ba988f24b7f105052f68da9ab0e693cc7c25b0b30/opencv-python-headless-4.11.0.86.tar.gz", hash = "sha256:996eb282ca4b43ec6a3972414de0e2331f5d9cda2b41091a49739c19fb843798", size = 95177929, upload-time = "2025-01-16T13:53:40.22Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/dc/53/2c50afa0b1e05ecdb4603818e85f7d174e683d874ef63a6abe3ac92220c8/opencv_python_headless-4.11.0.86-cp37-abi3-macosx_13_0_arm64.whl", hash = "sha256:48128188ade4a7e517237c8e1e11a9cdf5c282761473383e77beb875bb1e61ca", size = 37326460, upload-time = "2025-01-16T13:52:57.015Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/43/68555327df94bb9b59a1fd645f63fafb0762515344d2046698762fc19d58/opencv_python_headless-4.11.0.86-cp37-abi3-macosx_13_0_x86_64.whl", hash = "sha256:a66c1b286a9de872c343ee7c3553b084244299714ebb50fbdcd76f07ebbe6c81", size = 56723330, upload-time = "2025-01-16T13:55:45.731Z" },
+    { url = "https://files.pythonhosted.org/packages/45/be/1438ce43ebe65317344a87e4b150865c5585f4c0db880a34cdae5ac46881/opencv_python_headless-4.11.0.86-cp37-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6efabcaa9df731f29e5ea9051776715b1bdd1845d7c9530065c7951d2a2899eb", size = 29487060, upload-time = "2025-01-16T13:51:59.625Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/5c/c139a7876099916879609372bfa513b7f1257f7f1a908b0bdc1c2328241b/opencv_python_headless-4.11.0.86-cp37-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0e0a27c19dd1f40ddff94976cfe43066fbbe9dfbb2ec1907d66c19caef42a57b", size = 49969856, upload-time = "2025-01-16T13:53:29.654Z" },
+    { url = "https://files.pythonhosted.org/packages/95/dd/ed1191c9dc91abcc9f752b499b7928aacabf10567bb2c2535944d848af18/opencv_python_headless-4.11.0.86-cp37-abi3-win32.whl", hash = "sha256:f447d8acbb0b6f2808da71fddd29c1cdd448d2bc98f72d9bb78a7a898fc9621b", size = 29324425, upload-time = "2025-01-16T13:52:49.048Z" },
+    { url = "https://files.pythonhosted.org/packages/86/8a/69176a64335aed183529207ba8bc3d329c2999d852b4f3818027203f50e6/opencv_python_headless-4.11.0.86-cp37-abi3-win_amd64.whl", hash = "sha256:6c304df9caa7a6a5710b91709dd4786bf20a74d57672b3c31f7033cc638174ca", size = 39402386, upload-time = "2025-01-16T13:52:56.418Z" },
+]
+
 [[package]]
 name = "openinference-instrumentation"
 version = "0.1.46"
@@ -5150,7 +5175,7 @@ version = "0.18.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "ptyprocess", marker = "os_name != 'nt'" },
-    { name = "pywinpty", marker = "os_name == 'nt'" },
+    { name = "pywinpty", marker = "(os_name == 'nt' and platform_machine != 'aarch64' and sys_platform == 'linux') or (os_name == 'nt' and sys_platform != 'darwin' and sys_platform != 'linux')" },
     { name = "tornado" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/8a/11/965c6fd8e5cc254f1fe142d547387da17a8ebfd75a3455f637c663fb38a0/terminado-0.18.1.tar.gz", hash = "sha256:de09f2c4b85de4765f7714688fff57d3e75bad1f909b589fde880460c753fd2e", size = 32701, upload-time = "2024-03-12T14:34:39.026Z" }

From dfd64955f0bb72f622d142326b8e33166fbcf2ba Mon Sep 17 00:00:00 2001
From: Aravind N <aravindn1308@outlook.com>
Date: Tue, 12 May 2026 15:31:47 -0400
Subject: [PATCH 05/15] feat(finmme): introduce verifier enhancements and
 related sentences handling (v9)

- Added a new script for running FinMME fixes with related sentences.
- Updated VerifierAgent to incorporate related sentences for improved verification context.
- Enhanced VerifierTool with a function to format source sentences for prompts.
- Adjusted verifier prompts to include source sentences in the evaluation process.
---
 scripts/run_finmme_fixes_v9.sh           | 30 +++++++++
 src/agentfinvqa/agents/verifier_agent.py | 37 +++++++----
 src/agentfinvqa/tools/verifier_tool.py   | 83 ++++++++++++++++++------
 3 files changed, 117 insertions(+), 33 deletions(-)
 create mode 100755 scripts/run_finmme_fixes_v9.sh

diff --git a/scripts/run_finmme_fixes_v9.sh b/scripts/run_finmme_fixes_v9.sh
new file mode 100755
index 0000000..23a673f
--- /dev/null
+++ b/scripts/run_finmme_fixes_v9.sh
@@ -0,0 +1,30 @@
+#!/usr/bin/env bash
+# FinMME train (1,250 samples): Gemini 3 Flash Preview (planner / vision / verifier) + Flash-Lite judge.
+# v9 — verifier now sees:
+#   - related_sentences (analyst source text from sample metadata) — new in v9
+#   - caption reframed from "background" to "cross-check the draft answer" — new in v9
+# Same 1,250-ID slice as v8 for a paired comparison.
+#
+# Output dir (run_tag): meps/gemini_gemini/finmme/fixes_v9_g3flash_related_sents/train/
+# Metrics dir         : output/final/finmme_fixes_v9_g3flash_related_sents/
+#
+# Usage: ./scripts/run_finmme_fixes_v9.sh
+# Remove --resume below for a full re-run from scratch.
+set -euo pipefail
+
+REPO_ROOT="$(cd -- "$(dirname "${BASH_SOURCE[0]}")"/.. && pwd)"
+cd "$REPO_ROOT"
+
+scripts/submit_pipeline.sh \
+    --dataset finmme \
+    --split train \
+    --n 1250 \
+    --config gemini_gemini \
+    --vision_model gemini-3-flash-preview \
+    --planner_model gemini-3-flash-preview \
+    --verifier_model gemini-3-flash-preview \
+    --judge_model gemini-2.5-flash-lite \
+    --run_tag fixes_v9_g3flash_related_sents \
+    --out_label finmme_train_fixes_v9_g3flash_related_sents \
+    --langfuse \
+    --resume
diff --git a/src/agentfinvqa/agents/verifier_agent.py b/src/agentfinvqa/agents/verifier_agent.py
index 77addea..05979f2 100644
--- a/src/agentfinvqa/agents/verifier_agent.py
+++ b/src/agentfinvqa/agents/verifier_agent.py
@@ -15,7 +15,7 @@
 
 from ..agents.vision_agent import _is_multi_select
 from ..langfuse_integration.tracing import close_span, open_llm_span
-from ..tools.verifier_tool import VerifierTool
+from ..tools.verifier_tool import VerifierTool, format_source_sentences_block
 from ..utils.json_strict import parse_strict
 from ..utils.model_compat import openai_temperature
 
@@ -106,6 +106,12 @@ def run(
             choices = list(sample.choices)
 
         caption = (meta.get("verified_caption") or "").strip()
+        # When the sample's metadata carries analyst-written source sentences in
+        # ``related_sentences``, pass them through to the verifier prompt so it can
+        # cross-check numeric / categorical claims in the draft answer against the
+        # original text grounding. Field is optional — datasets without this signal
+        # leave the block empty.
+        related_sentences = meta.get("related_sentences")
         is_ms = _is_multi_select(sample)
 
         # Compute min choice_analysis confidence from vision output
@@ -116,21 +122,23 @@ def run(
         steps_text = "\n".join(f"  {i + 1}. {s}" for i, s in enumerate(plan_steps)) or "  (none)"
         choices_text = ("\nMCQ Choices:\n" + "\n".join(f"  - {c}" for c in choices) + "\n") if choices else ""
         caption_text = (
-            f"\nChart context (analyst caption — use as background, not as the answer):\n  {caption}\n"
+            "\nChart context (analyst caption — cross-check the draft answer against this text; "
+            "REVISE if a value or category here clearly contradicts the draft, but do NOT revise "
+            f"on phrasing differences alone):\n  {caption}\n"
             if caption
             else ""
         )
-        # Reluctance hint when vision was highly confident
-        if vision_min_conf >= 0.95:
-            reluctance_note = (
-                "\n⚠ HIGH-CONFIDENCE VISION: the vision agent reported high confidence (≥0.95) on all choices. "
-                "Only REVISE if you can identify a specific, clear factual error with direct visual evidence. "
-                "If merely uncertain, set confidence < 0.75 and CONFIRM.\n"
-            )
-        elif vision_min_conf >= 0.85:
-            reluctance_note = "\n⚠ The vision agent was reasonably confident. REVISE only for clear, specific errors.\n"
-        else:
-            reluctance_note = ""
+        source_sentences_text = format_source_sentences_block(related_sentences, leading_newline=True)
+        # Reluctance hint when vision was highly confident (single expression to keep run() compact).
+        reluctance_note = (
+            "\n⚠ HIGH-CONFIDENCE VISION: the vision agent reported high confidence (≥0.95) on all choices. "
+            "Only REVISE if you can identify a specific, clear factual error with direct visual evidence. "
+            "If merely uncertain, set confidence < 0.75 and CONFIRM.\n"
+            if vision_min_conf >= 0.95
+            else "\n⚠ The vision agent was reasonably confident. REVISE only for clear, specific errors.\n"
+            if vision_min_conf >= 0.85
+            else ""
+        )
 
         multi_select_note = (
             "\n⚠ MULTI-SELECT: verify EACH choice independently. "
@@ -145,6 +153,7 @@ def run(
             f"Image path       : {image_path}\n"
             f"{choices_text}"
             f"{caption_text}"
+            f"{source_sentences_text}"
             f"{reluctance_note}"
             f"{multi_select_note}\n"
             f"Inspection plan the agent followed:\n{steps_text}\n\n"
@@ -188,6 +197,8 @@ def run(
                 "When calling verifier_tool, pass:\n"
                 "  - `choices`: MCQ choices listed above (empty list if none)\n"
                 "  - `caption`: analyst caption if shown above (empty string if none)\n"
+                "  - `related_sentences`: list of source sentences from the 'Source sentences' block above "
+                "(empty list if no such block was shown)\n"
                 + (
                     "  - `multi_select`: True — this is a multi-select question; answer must contain ALL correct letters.\n"
                     if is_ms
diff --git a/src/agentfinvqa/tools/verifier_tool.py b/src/agentfinvqa/tools/verifier_tool.py
index 7131e5c..7228fa0 100644
--- a/src/agentfinvqa/tools/verifier_tool.py
+++ b/src/agentfinvqa/tools/verifier_tool.py
@@ -22,13 +22,43 @@
 from ..utils.model_compat import openai_temperature
 
 
+def format_source_sentences_block(
+    related_sentences: Optional[Any],
+    *,
+    leading_newline: bool = False,
+) -> str:
+    """Render the analyst source-sentences block for a verifier prompt.
+
+    Accepts ``None``, a string, or a list of strings. Empty / blank-only inputs
+    collapse to ``""`` so the surrounding format string drops the block cleanly.
+    The block text is dataset-agnostic — any sample that carries
+    ``related_sentences`` in metadata gets the same treatment.
+    """
+    if not related_sentences:
+        return ""
+    if isinstance(related_sentences, str):
+        rs_items = [related_sentences.strip()] if related_sentences.strip() else []
+    else:
+        rs_items = [str(s).strip() for s in related_sentences if str(s).strip()]
+    if not rs_items:
+        return ""
+    rs_lines = "\n".join(f"  - {s}" for s in rs_items)
+    body = (
+        "Source sentences from the chart's accompanying analyst note "
+        "(may contain the specific values being asked about — cross-check "
+        "numeric and categorical facts against this text before confirming):\n"
+        f"{rs_lines}\n"
+    )
+    return f"\n{body}" if leading_newline else body
+
+
 _VERIFIER_PROMPT_SINGLE = """\
 You are a critical chart QA verifier. A vision agent has already attempted to answer
 the question below. Your job: look at the chart image carefully and audit the work.
 
 Question         : {question}
 Question Type    : {question_type}
-{choices_block}{caption_block}
+{choices_block}{caption_block}{source_sentences_block}
 Inspection plan the agent was supposed to follow:
 {plan_steps}
 
@@ -40,32 +70,33 @@
   REVISE  — you can see a clear, specific error; output the corrected answer
 
 Rules:
-- Only REVISE when you are confident you can point to a concrete error in the chart
-- If uncertain, CONFIRM — do not second-guess without visual evidence
+- Only REVISE when you are confident you can point to a concrete error in the chart OR a direct contradiction with the caption / source sentences above
+- If uncertain, CONFIRM — do not second-guess without visual or textual evidence
+- Stylistic / phrasing differences are NOT a reason to revise — only revise when a value or category is wrong
 - For MCQ questions: the answer must be one of the stated choices above
 - For MCQ questions: return exactly one of the provided choice texts or the precise letter/letter-combo (e.g., "AC")
 - UNANSWERABLE override: if the draft answer is "UNANSWERABLE" and MCQ choices are listed above,
-  you MUST systematically check EACH choice against the chart before confirming:
-    1. For each choice: is there visual evidence (bar height, line position, label, tick mark) that
+  you MUST systematically check EACH choice against the chart AND the source sentences before confirming:
+    1. For each choice: is there visual evidence (bar height, line position, label, tick mark) OR caption / source-sentence text that
        supports OR rules it out?
     2. If ANY choice can be supported or ruled out, REVISE to the best-supported choice.
-    3. Only confirm UNANSWERABLE when ALL choices are genuinely undeterminable from the chart.
+    3. Only confirm UNANSWERABLE when ALL choices are genuinely undeterminable from chart and text.
 - Keep answers concise — numbers, short phrases, or single words where appropriate
-- Always cite at least one numeric value or labeled element from the chart in your reasoning
+- Always cite at least one numeric value or labeled element from the chart, caption, or source sentences in your reasoning
 - For MCQ questions, compare the draft answer against at least one alternative choice before confirming
 - Limit the final answer to a short phrase (≤10 words) and keep the reasoning ≤2 sentences.
-- Add a `confidence` field (0.0–1.0): your confidence that your verdict and answer are correct based on what you can see in the chart.
-  Use ≥0.8 only when you can cite specific visual evidence (tick value, bar height, label). Use <0.6 when the chart is ambiguous or partially occluded.
+- Add a `confidence` field (0.0–1.0): your confidence that your verdict and answer are correct based on what you can see in the chart and any caption / source-sentence text.
+  Use ≥0.8 only when you can cite specific visual evidence (tick value, bar height, label) or a direct textual match. Use <0.6 when both chart and text are ambiguous.
 
 Output ONLY JSON, no markdown, no extra text:
-{{"verdict": "confirmed" | "revised", "answer": "<final answer>", "reasoning": "<one sentence grounded in what you see in the chart>", "confidence": 0.0}}"""
+{{"verdict": "confirmed" | "revised", "answer": "<final answer>", "reasoning": "<one sentence grounded in what you see in the chart or read in the caption/source sentences>", "confidence": 0.0}}"""
 
 _VERIFIER_PROMPT_MULTI = """\
 You are a critical chart QA verifier. This is a MULTI-SELECT question — multiple choices may be correct.
 
 Question         : {question}
 Question Type    : {question_type}
-{choices_block}{caption_block}
+{choices_block}{caption_block}{source_sentences_block}
 Inspection plan the agent was supposed to follow:
 {plan_steps}
 
@@ -77,21 +108,20 @@
   REVISE  — some letters are wrong, or correct letters were omitted
 
 Step-by-step verification (do this for EVERY choice listed above):
-  1. For each letter in the draft answer: is there clear visual evidence it is correct?
-     If NOT supported → it must be removed.
-  2. For each letter NOT in the draft answer: is there clear visual evidence it should be included?
-     If YES → it must be added.
-  3. Your final answer = all and only the letters with chart evidence.
+  1. For each letter in the draft answer: is there clear visual evidence in the chart, OR a supporting statement in the caption / source sentences? If NOT supported by either → it must be removed.
+  2. For each letter NOT in the draft answer: is there clear visual evidence in the chart, OR a supporting statement in the caption / source sentences that it should be included? If YES → it must be added.
+  3. Your final answer = all and only the letters with chart or text evidence.
 
 Rules:
 - NEVER collapse a multi-select answer to a single letter unless truly only one is correct
-- NEVER add letters you cannot visually confirm
+- NEVER add letters you cannot visually confirm or find textual support for in the caption / source sentences
+- Stylistic / phrasing differences in the caption are NOT a reason to add or remove a letter — only true factual support matters
 - If the draft already selected the right set, CONFIRM — do not change it
 - Return letters concatenated with no separator (e.g. "ABC")
-- Reasoning must cite specific chart evidence (values, labels, bar heights) for each included/excluded choice
+- Reasoning must cite specific chart evidence (values, labels, bar heights) and/or caption-or-source-sentence quotes for each included/excluded choice
 - Keep reasoning ≤3 sentences.
 - Add a `confidence` field (0.0–1.0): your confidence that your final letter set is correct.
-  Use ≥0.8 only when you have clear visual evidence for each included/excluded choice. Use <0.6 when the chart is ambiguous.
+  Use ≥0.8 only when you have clear visual evidence or direct textual support for each included/excluded choice. Use <0.6 when both chart and text are ambiguous.
 
 Output ONLY JSON, no markdown, no extra text:
 {{"verdict": "confirmed" | "revised", "answer": "<all correct letters concatenated, e.g. ABC>", "reasoning": "<evidence-grounded sentence(s)>", "confidence": 0.0}}"""
@@ -108,6 +138,14 @@ class VerifierInput(BaseModel):
     draft_explanation: str = Field(description="The draft explanation produced by the vision agent")
     choices: Optional[List[str]] = Field(default=None, description="MCQ answer choices if applicable")
     caption: Optional[str] = Field(default=None, description="Analyst-written chart caption for context")
+    related_sentences: Optional[List[str]] = Field(
+        default=None,
+        description=(
+            "Optional analyst-written source sentences attached to the sample. "
+            "May contain the specific numeric or categorical values being asked about — "
+            "cross-check the draft answer's facts against this text before confirming."
+        ),
+    )
     multi_select: bool = Field(default=False, description="True when multiple choices can be correct simultaneously")
 
 
@@ -145,6 +183,7 @@ def _run(
         draft_explanation: str,
         choices: Optional[List[str]] = None,
         caption: Optional[str] = None,
+        related_sentences: Optional[List[str]] = None,
         multi_select: bool = False,
     ) -> str:
         start_ts = datetime.now(timezone.utc).isoformat()
@@ -166,16 +205,20 @@ def _run(
         choices_block = "MCQ Choices:\n" + "\n".join(f"  - {c}" for c in choices) + "\n" if choices else ""
         if caption and caption.strip():
             caption_block = (
-                f"Chart context (analyst caption — use as background, not as the answer):\n  {caption.strip()}\n"
+                "Chart context (analyst caption — cross-check the draft answer against this text; "
+                "REVISE if a value or category here clearly contradicts the draft, but do NOT revise "
+                f"on phrasing differences alone):\n  {caption.strip()}\n"
             )
         else:
             caption_block = ""
+        source_sentences_block = format_source_sentences_block(related_sentences)
         template = _VERIFIER_PROMPT_MULTI if multi_select else _VERIFIER_PROMPT_SINGLE
         prompt = template.format(
             question=question,
             question_type=question_type,
             choices_block=choices_block,
             caption_block=caption_block,
+            source_sentences_block=source_sentences_block,
             plan_steps=steps_text,
             draft_answer=draft_answer,
             draft_explanation=draft_explanation,

From c5df819d48ef8ec8f9019a3ee61958c7ac392174 Mon Sep 17 00:00:00 2001
From: Aravind N <aravindn1308@outlook.com>
Date: Wed, 13 May 2026 12:56:02 -0400
Subject: [PATCH 06/15] feat(verifier): enhance ambiguity handling and
 evaluation resume functionality - v10

- Introduced functions to manage high-confidence choice analysis and format ambiguity blocks for the verifier.
- Updated VerifierAgent to include ambiguity hints based on vision agent confidence.
- Enhanced VerifierTool to support ambiguity flags in prompts and added handling for existing metrics during evaluation.
- Modified scripts to allow resuming evaluations by merging with existing metrics, improving efficiency in processing MEPs.
---
 README.md                                |   6 +-
 scripts/run_batch.py                     | 151 +++++++++++++++++++----
 src/agentfinvqa/agents/verifier_agent.py |  25 +++-
 src/agentfinvqa/tools/verifier_tool.py   |  77 +++++++++++-
 4 files changed, 226 insertions(+), 33 deletions(-)

diff --git a/README.md b/README.md
index a86d202..a689635 100644
--- a/README.md
+++ b/README.md
@@ -79,7 +79,7 @@ Input Sample (question, chart image, expected answer)
 
 ## Results
 
-### FinMME (250-sample train slice; v8 scale-up to 1,250)
+### FinMME (250-sample train slice; v8 / v9 / v10 scale-up to 1,250)
 
 | Run | Accuracy | Δ vs baseline | Key change |
 |-----|----------|---------------|------------|
@@ -91,12 +91,14 @@ Input Sample (question, chart image, expected answer)
 | `fixes_v5_multiselect` | **69.4%** | +21.4 pp | Full multi-select MCQ support |
 | `fixes_v7_g3flash_conf_gate` | **69.6%** | +21.6 pp | Confidence gate fix, fresh g3flash run |
 | `fixes_v8_g3flash_color_area` | **71.2%** *(n = 1,250)* | +23.2 pp | Color-area OpenCV pre-hint; see `results.md` §8b |
+| `fixes_v9_g3flash_related_sents` | **71.3%** *(n = 1,250)* | +23.3 pp | Verifier + `related_sentences` + caption cross-check; **~2.4× tighter latency tail** vs v8 (p95 87 s vs 209 s) |
+| `fixes_v10_g3flash_choice_conflict` | **71.1%** *(n = 1,250)* | +23.1 pp | v9 + high-confidence **choice-conflict** flag for verifier |
 
 **vs. FinMME paper (Table 3, Gemini Flash 2.0 = 51.85%):** our best **250-ID** ladder run achieves **+17.8 pp** (v7 mean `answer_accuracy` vs paper headline — metric families differ).
 
 **Fair same-model baseline (Gemini-3 Flash Preview structured zero-shot vs agent):**
 
-- **Primary (matched n = 1,250 train IDs):** zero-shot mean `answer_accuracy` **63.56%** vs agent **`fixes_v8_g3flash_color_area`** **71.24%** → **+7.68 pp** (exact-accuracy gap **+8.72 pp**; McNemar **p ≪ 0.001**). Full zero-shot train file: **11,099** rows — always join on `sample_id` before comparing.
+- **Primary (matched n = 1,250 train IDs):** zero-shot mean `answer_accuracy` **63.56%** vs agents — **v8** **71.24%** (**+7.68 pp**, exact **+8.72 pp**, McNemar χ² = 68.21, p ≈ 1.1×10⁻¹⁶); **v9** **71.28%** (**+7.72 pp**, exact **+8.16 pp**, χ² = 61.45, p ≈ 4.5×10⁻¹⁵); **v10** **71.08%** (**+7.52 pp**, exact **+7.84 pp**, χ² = 57.37, p ≈ 3.6×10⁻¹⁴). All three crush zero-shot; pairwise between agents nothing is significant (v9 vs v8 p = 0.56; v10 vs v8 p = 0.34; v9 vs v10 p = 0.75). v9's distinctive contribution is **latency-tail tightening**, not extra accuracy. Full zero-shot train file: **11,099** rows — always join on `sample_id` before comparing.
 - **Legacy 250-ID snapshot (strict exact, ablation era):** zero-shot **52.8%** vs agent v7 **62.8%** → **+10.0 pp** — useful historically; see `results.md` §8b for context.
 
 > Note: the initial zero-shot Gemini-3 export had parser-related empty predictions; robust extraction + repair recovered many rows before the full 11k re-run.
diff --git a/scripts/run_batch.py b/scripts/run_batch.py
index f1353cb..92488cf 100644
--- a/scripts/run_batch.py
+++ b/scripts/run_batch.py
@@ -82,6 +82,47 @@ def _append(flag: str, value: str | None) -> None:
     return cmd
 
 
+def _load_jsonl_by_sample_id(path: Path) -> dict[str, dict]:
+    """Last JSON object per ``sample_id`` from a JSONL file (for resume merges)."""
+    out: dict[str, dict] = {}
+    if not path.exists():
+        return out
+    for line in path.read_text().splitlines():
+        stripped = line.strip()
+        if not stripped:
+            continue
+        with contextlib.suppress(json.JSONDecodeError):
+            row = json.loads(stripped)
+            sid = row.get("sample_id")
+            if isinstance(sid, str) and sid:
+                out[sid] = row
+    return out
+
+
+def _merge_eval_resume(
+    existing_metrics: dict[str, dict],
+    existing_trace: dict[str, dict],
+    existing_tax: dict[str, dict],
+    new_results: list[tuple[str, dict, dict, dict | None]],
+    allowed_ids: set[str],
+) -> tuple[dict[str, dict], dict[str, dict], dict[str, dict]]:
+    merged_m = dict(existing_metrics)
+    merged_tr = dict(existing_trace)
+    merged_tx = dict(existing_tax)
+    for sid in {t[0] for t in new_results}:
+        merged_tx.pop(sid, None)
+    for sid, row, trace_row, tax_row in new_results:
+        merged_m[sid] = row
+        merged_tr[sid] = trace_row
+        if tax_row:
+            merged_tx[sid] = tax_row
+    if allowed_ids:
+        merged_m = {k: v for k, v in merged_m.items() if k in allowed_ids}
+        merged_tr = {k: v for k, v in merged_tr.items() if k in allowed_ids}
+        merged_tx = {k: v for k, v in merged_tx.items() if k in allowed_ids}
+    return merged_m, merged_tr, merged_tx
+
+
 def _eval_mep(
     mep: dict,
     config: dict,
@@ -123,6 +164,50 @@ def _eval_mep(
     return row, trace_row, tax_row
 
 
+def _collect_eval_results(
+    out_dir: Path,
+    config: dict,
+    use_judge: bool,
+    judge_model: str,
+    lf_client: Any,
+    workers: int,
+    mep_start: int,
+    resume_eval: bool,
+    existing_metrics: dict[str, dict],
+    metrics_path: Path,
+) -> tuple[list[tuple[str, dict, dict, dict | None]], list]:
+    """Run threaded MEP eval; return ``(results, all_meps_slice)``."""
+    results: list[tuple[str, dict, dict, dict | None]] = []
+    with ThreadPoolExecutor(max_workers=workers) as pool:
+        all_meps = list(iter_meps(str(out_dir)))
+        if mep_start > 0:
+            print(f"[post-eval] Skipping first {mep_start} MEPs (mep_start={mep_start}, total={len(all_meps)})")
+            all_meps = all_meps[mep_start:]
+
+        completed = set(existing_metrics.keys()) if resume_eval else set()
+        if resume_eval and completed:
+            meps_to_run = [m for m in all_meps if m.get("sample", {}).get("sample_id") not in completed]
+            skipped = len(all_meps) - len(meps_to_run)
+            if skipped:
+                print(f"[post-eval] resume: skipping {skipped} sample_ids already in {metrics_path.name}")
+        else:
+            meps_to_run = list(all_meps)
+
+        if not meps_to_run:
+            print("[post-eval] resume: no MEPs left to score in this pass.")
+        futures = {pool.submit(_eval_mep, mep, config, use_judge, judge_model, lf_client): mep for mep in meps_to_run}
+        for future in as_completed(futures):
+            mep = futures[future]
+            sid = mep.get("sample", {}).get("sample_id", "?")
+            try:
+                row, trace_row, tax_row = future.result()
+            except Exception as exc:
+                print(f"  [eval] {sid} ERROR: {exc}")
+                continue
+            results.append((sid, row, trace_row, tax_row))
+    return results, all_meps
+
+
 def run_post_evaluation(
     out_dir: Path,
     label: str,
@@ -133,6 +218,7 @@ def run_post_evaluation(
     workers: int = 4,
     judge_model: str | None = None,
     mep_start: int = 0,
+    resume_eval: bool = False,
 ) -> None:
     """Compute metrics, traces, taxonomy, and summary using a thread pool."""
     if not out_dir.exists():
@@ -149,46 +235,48 @@ def run_post_evaluation(
     judge_model = judge_model or config.get("vision_model") or config.get("planner_model") or "gemini-2.5-flash-lite"
     lf_client = get_client() if use_langfuse else None
 
-    # Accumulate all completed results in memory, then sort by sample_id and
-    # write at the end. ThreadPoolExecutor yields futures in completion order,
-    # which is non-deterministic across workers; sorting makes the on-disk
-    # artifacts deterministic and diff-friendly between runs.
-    results: list[tuple[str, dict, dict, dict | None]] = []
+    existing_metrics = _load_jsonl_by_sample_id(metrics_path) if resume_eval else {}
+    existing_trace = _load_jsonl_by_sample_id(trace_path) if resume_eval else {}
+    existing_tax = _load_jsonl_by_sample_id(taxonomy_path) if resume_eval else {}
+
+    results, all_meps = _collect_eval_results(
+        out_dir,
+        config,
+        use_judge,
+        judge_model,
+        lf_client,
+        workers,
+        mep_start,
+        resume_eval,
+        existing_metrics,
+        metrics_path,
+    )
 
-    with ThreadPoolExecutor(max_workers=workers) as pool:
-        all_meps = list(iter_meps(str(out_dir)))
-        if mep_start > 0:
-            print(f"[post-eval] Skipping first {mep_start} MEPs (mep_start={mep_start}, total={len(all_meps)})")
-            all_meps = all_meps[mep_start:]
-        futures = {pool.submit(_eval_mep, mep, config, use_judge, judge_model, lf_client): mep for mep in all_meps}
-        for future in as_completed(futures):
-            mep = futures[future]
-            sid = mep.get("sample", {}).get("sample_id", "?")
-            try:
-                row, trace_row, tax_row = future.result()
-            except Exception as exc:
-                print(f"  [eval] {sid} ERROR: {exc}")
-                continue
-            results.append((sid, row, trace_row, tax_row))
+    allowed = {m.get("sample", {}).get("sample_id") for m in all_meps if m.get("sample", {}).get("sample_id")}
+    merged_metrics, merged_trace, merged_tax = _merge_eval_resume(
+        existing_metrics, existing_trace, existing_tax, results, allowed
+    )
 
-    if not results:
+    if not merged_metrics:
         print("[post-eval] No metrics produced.")
         return
 
-    results.sort(key=lambda t: t[0])
-    metrics_list: list[dict] = [row for _, row, _, _ in results]
-    taxonomy_rows = sum(1 for _, _, _, tax in results if tax)
+    ordered_sids = sorted(merged_metrics.keys())
+    metrics_list: list[dict] = [merged_metrics[sid] for sid in ordered_sids]
+    taxonomy_rows = len(merged_tax)
 
     with (
         open(metrics_path, "w") as f_met,
         open(trace_path, "w") as f_trace,
         open(taxonomy_path, "w") as f_tax,
     ):
-        for _, row, trace_row, tax_row in results:
+        for sid in ordered_sids:
+            row = merged_metrics[sid]
+            trace_row = merged_trace.get(sid) or {"sample_id": sid, "resume_missing_trace": True}
             f_met.write(json.dumps(row) + "\n")
             f_trace.write(json.dumps(trace_row) + "\n")
-            if tax_row:
-                f_tax.write(json.dumps(tax_row) + "\n")
+        for tax_sid in sorted(merged_tax.keys()):
+            f_tax.write(json.dumps(merged_tax[tax_sid]) + "\n")
 
     acc = sum(m.get("answer_accuracy", 0.0) for m in metrics_list) / len(metrics_list)
     print(f"[post-eval] Accuracy {acc:.1%} (n={len(metrics_list)})")
@@ -243,6 +331,14 @@ def main() -> None:
     parser.add_argument("--mep_start", type=int, default=0, help="Skip first N MEPs (default: 0 = process all)")
     parser.add_argument("--post_eval", action="store_true", help="Run post-eval after generation")
     parser.add_argument("--eval_only", action="store_true", help="Skip generation, run post-eval on existing MEPs")
+    parser.add_argument(
+        "--eval_resume",
+        action="store_true",
+        help=(
+            "With --eval_only: load existing metrics JSONL and skip sample_ids already present; "
+            "merge new scores then rewrite metrics, trace, taxonomy, and summary."
+        ),
+    )
     parser.add_argument("--eval_dir", default="output", help="Directory for eval outputs")
     parser.add_argument("--eval_label", default=None, help="Label for eval files (defaults to config_n)")
     parser.add_argument("--env_file", default=".env", help=".env file to load before running")
@@ -276,6 +372,7 @@ def main() -> None:
             workers=args.workers,
             judge_model=args.judge_model,
             mep_start=args.mep_start,
+            resume_eval=args.eval_resume,
         )
 
 
diff --git a/src/agentfinvqa/agents/verifier_agent.py b/src/agentfinvqa/agents/verifier_agent.py
index 05979f2..f7393d5 100644
--- a/src/agentfinvqa/agents/verifier_agent.py
+++ b/src/agentfinvqa/agents/verifier_agent.py
@@ -15,7 +15,11 @@
 
 from ..agents.vision_agent import _is_multi_select
 from ..langfuse_integration.tracing import close_span, open_llm_span
-from ..tools.verifier_tool import VerifierTool, format_source_sentences_block
+from ..tools.verifier_tool import (
+    VerifierTool,
+    choice_analysis_ambiguity_labels,
+    format_source_sentences_block,
+)
 from ..utils.json_strict import parse_strict
 from ..utils.model_compat import openai_temperature
 
@@ -119,6 +123,20 @@ def run(
         ca_confs = [v.get("confidence", 1.0) for v in ca.values() if isinstance(v, dict)]
         vision_min_conf = min(ca_confs) if ca_confs else 1.0
 
+        high_labels = choice_analysis_ambiguity_labels(
+            ca if isinstance(ca, dict) else {},
+            multi_select=is_ms,
+            has_mcq_choices=bool(choices),
+        )
+        ambiguity_task_hint = (
+            f"\n⚠ When calling verifier_tool, pass high_confidence_choices exactly as: "
+            f"{high_labels!r}\n"
+            "  (Vision self-rated ≥0.95 confidence on multiple options; "
+            "single-select implies at most one is correct.)\n"
+            if len(high_labels) >= 2
+            else ""
+        )
+
         steps_text = "\n".join(f"  {i + 1}. {s}" for i, s in enumerate(plan_steps)) or "  (none)"
         choices_text = ("\nMCQ Choices:\n" + "\n".join(f"  - {c}" for c in choices) + "\n") if choices else ""
         caption_text = (
@@ -129,7 +147,7 @@ def run(
             else ""
         )
         source_sentences_text = format_source_sentences_block(related_sentences, leading_newline=True)
-        # Reluctance hint when vision was highly confident (single expression to keep run() compact).
+        # Reluctance hint from min choice confidence (keeps ``run()`` compact).
         reluctance_note = (
             "\n⚠ HIGH-CONFIDENCE VISION: the vision agent reported high confidence (≥0.95) on all choices. "
             "Only REVISE if you can identify a specific, clear factual error with direct visual evidence. "
@@ -154,6 +172,7 @@ def run(
             f"{choices_text}"
             f"{caption_text}"
             f"{source_sentences_text}"
+            f"{ambiguity_task_hint}"
             f"{reluctance_note}"
             f"{multi_select_note}\n"
             f"Inspection plan the agent followed:\n{steps_text}\n\n"
@@ -199,6 +218,8 @@ def run(
                 "  - `caption`: analyst caption if shown above (empty string if none)\n"
                 "  - `related_sentences`: list of source sentences from the 'Source sentences' block above "
                 "(empty list if no such block was shown)\n"
+                "  - `high_confidence_choices`: pass the list from the high_confidence_choices line "
+                "in the task when shown; otherwise pass an empty list `[]`\n"
                 + (
                     "  - `multi_select`: True — this is a multi-select question; answer must contain ALL correct letters.\n"
                     if is_ms
diff --git a/src/agentfinvqa/tools/verifier_tool.py b/src/agentfinvqa/tools/verifier_tool.py
index 7228fa0..11580d7 100644
--- a/src/agentfinvqa/tools/verifier_tool.py
+++ b/src/agentfinvqa/tools/verifier_tool.py
@@ -22,6 +22,37 @@
 from ..utils.model_compat import openai_temperature
 
 
+def format_ambiguity_block(
+    high_confidence_choices: Optional[List[str]],
+    *,
+    leading_newline: bool = False,
+) -> str:
+    """Render an ambiguity-flag block for the verifier VLM prompt.
+
+    When the vision agent self-rated ≥2 choices as high-confidence on a
+    single-select question, those choices cannot both be correct, and the verifier
+    should re-examine the chart for distinguishing evidence.
+
+    The block is a *meta-signal*: it tells the verifier WHICH choices are in conflict
+    without surfacing vision's full per-choice confidence dict (which would risk
+    anchoring the verifier on vision's self-assessment).
+    """
+    if not high_confidence_choices or len(high_confidence_choices) < 2:
+        return ""
+    labels = [str(c).strip() for c in high_confidence_choices if str(c).strip()]
+    if len(labels) < 2:
+        return ""
+    body = (
+        f"⚠ VISION AMBIGUITY FLAG: the vision agent rated multiple choices as "
+        f"high-confidence (≥0.95): {', '.join(labels)}. These cannot all be correct on a "
+        f"single-select question. Independently examine the chart and any caption / "
+        f"source-sentence evidence above to identify the distinguishing fact, then "
+        f"choose the single best-supported option. Do NOT default to the draft answer "
+        f"without verifying the distinguishing evidence.\n"
+    )
+    return f"\n{body}" if leading_newline else body
+
+
 def format_source_sentences_block(
     related_sentences: Optional[Any],
     *,
@@ -52,13 +83,44 @@ def format_source_sentences_block(
     return f"\n{body}" if leading_newline else body
 
 
+def choice_analysis_ambiguity_labels(
+    choice_analysis: Optional[dict],
+    *,
+    threshold: float = 0.95,
+    multi_select: bool = False,
+    has_mcq_choices: bool = False,
+) -> list[str]:
+    """Return labels for choices vision self-rated above ``threshold``.
+
+    When at least two labels qualify, a single-select MCQ cannot have two correct
+    answers, so the verifier should re-examine the chart.
+
+    Returns ``[]`` for multi-select or when there are no MCQ choices.
+    """
+    if multi_select or not has_mcq_choices or not choice_analysis:
+        return []
+    high: list[str] = []
+    for label, entry in choice_analysis.items():
+        if not isinstance(entry, dict):
+            continue
+        try:
+            conf = float(entry.get("confidence", 0.0))
+        except (TypeError, ValueError):
+            continue
+        if conf >= threshold:
+            lab = str(label).strip()
+            if lab:
+                high.append(lab)
+    return high if len(high) >= 2 else []
+
+
 _VERIFIER_PROMPT_SINGLE = """\
 You are a critical chart QA verifier. A vision agent has already attempted to answer
 the question below. Your job: look at the chart image carefully and audit the work.
 
 Question         : {question}
 Question Type    : {question_type}
-{choices_block}{caption_block}{source_sentences_block}
+{choices_block}{caption_block}{source_sentences_block}{ambiguity_block}
 Inspection plan the agent was supposed to follow:
 {plan_steps}
 
@@ -96,7 +158,7 @@ def format_source_sentences_block(
 
 Question         : {question}
 Question Type    : {question_type}
-{choices_block}{caption_block}{source_sentences_block}
+{choices_block}{caption_block}{source_sentences_block}{ambiguity_block}
 Inspection plan the agent was supposed to follow:
 {plan_steps}
 
@@ -146,6 +208,14 @@ class VerifierInput(BaseModel):
             "cross-check the draft answer's facts against this text before confirming."
         ),
     )
+    high_confidence_choices: Optional[List[str]] = Field(
+        default=None,
+        description=(
+            "When vision's choice_analysis shows ≥2 options at very high self-confidence on a "
+            "single-select MCQ, pass those labels (e.g. ['Choice A', 'Choice C']) so the verifier "
+            "gets an ambiguity flag — not the full choice_analysis dict."
+        ),
+    )
     multi_select: bool = Field(default=False, description="True when multiple choices can be correct simultaneously")
 
 
@@ -184,6 +254,7 @@ def _run(
         choices: Optional[List[str]] = None,
         caption: Optional[str] = None,
         related_sentences: Optional[List[str]] = None,
+        high_confidence_choices: Optional[List[str]] = None,
         multi_select: bool = False,
     ) -> str:
         start_ts = datetime.now(timezone.utc).isoformat()
@@ -212,6 +283,7 @@ def _run(
         else:
             caption_block = ""
         source_sentences_block = format_source_sentences_block(related_sentences)
+        ambiguity_block = format_ambiguity_block(high_confidence_choices)
         template = _VERIFIER_PROMPT_MULTI if multi_select else _VERIFIER_PROMPT_SINGLE
         prompt = template.format(
             question=question,
@@ -219,6 +291,7 @@ def _run(
             choices_block=choices_block,
             caption_block=caption_block,
             source_sentences_block=source_sentences_block,
+            ambiguity_block=ambiguity_block,
             plan_steps=steps_text,
             draft_answer=draft_answer,
             draft_explanation=draft_explanation,

From 2dbc5030bbe80494c406b278e1638f8ec052b8b5 Mon Sep 17 00:00:00 2001
From: Aravind N <aravindn1308@outlook.com>
Date: Wed, 13 May 2026 13:14:01 -0400
Subject: [PATCH 07/15] docs(finmme): v8/v9/v10 results at n=1,250; drop v9
 partial caveat
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- results.md §8b: v9 full-scale row, McNemar p-values, latency tail
- updates.md: v9 full-eval paragraph; fair-baseline now lists all three agents
- camera_ready_metrics.md: v9 added to headline table, verifier subsection
- README.md: v9 row updated, fair-baseline rewritten
- scripts: add v10 runner, eval-resume tweak to submit_eval.sh
---
 markdown/camera_ready_metrics.md | 122 ++++++++++
 results.md                       | 390 +++++++++++++++++++++++++++++++
 scripts/run_finmme_fixes_v10.sh  |  31 +++
 scripts/submit_eval.sh           |   6 +-
 updates.md                       | 126 ++++++++++
 5 files changed, 674 insertions(+), 1 deletion(-)
 create mode 100644 markdown/camera_ready_metrics.md
 create mode 100644 results.md
 create mode 100755 scripts/run_finmme_fixes_v10.sh
 create mode 100644 updates.md

diff --git a/markdown/camera_ready_metrics.md b/markdown/camera_ready_metrics.md
new file mode 100644
index 0000000..88bc034
--- /dev/null
+++ b/markdown/camera_ready_metrics.md
@@ -0,0 +1,122 @@
+# Camera-Ready Metrics (FinMME)
+
+This file captures the paper-safe numbers to cite from the current workspace state.
+
+Primary artifacts:
+
+- **Agent v8 (scale-up):** `output/final/finmme_fixes_v8_g3flash_color_area/metrics_finmme_train_fixes_v8_g3flash_color_area.jsonl` (**n = 1,250** train `sample_id`s)
+- **Agent v9 (verifier related sentences + caption cross-check):** `output/final/finmme_fixes_v9_g3flash_related_sents/metrics_finmme_train_fixes_v9_g3flash_related_sents.jsonl` (**n = 1,250** — same IDs as v8)
+- **Agent v10 (verifier choice-conflict meta-signal):** `output/final/finmme_fixes_v10_g3flash_choice_conflict/metrics_finmme_train_fixes_v10_g3flash_choice_conflict.jsonl` (**n = 1,250** — same IDs as v8)
+- **Agent v7 (ablation ladder):** `output/final/finmme_fixes_v7_g3flash_conf_gate/*` (**n = 250**)
+- **Zero-shot Gemini-3 Flash Preview (structured):** `output/baselines/metrics_finmme_train_zeroshot_structured_gemini_gemini_3_flash_preview.jsonl` (**n = 11,099** FinMME train rows — full train split coverage after the April 2026 re-run)
+- Earlier ladder runs (v4, v5): `output/final/finmme_fixes_v4_g3flash/*`, `output/final/finmme_v5_multiselect/*`
+
+Unless stated otherwise, **accuracy** means mean **`answer_accuracy`** (rule-based scorer with numeric tolerance + MCQ partial credit). **Exact** means the fraction of rows with **`answer_accuracy ≥ 0.999`**.
+
+## 1) Headline — fair same-model gain (matched IDs, **n = 1,250**)
+
+All **1,250** agent IDs (v8, v9, v10) appear in the full Gemini-3 zero-shot train file — join on `sample_id`.
+
+| System | Mean `answer_accuracy` | Exact (≥ 0.999) |
+|--------|----------------------:|----------------:|
+| Zero-shot `gemini-3-flash-preview` (structured) | **63.56%** | **56.40%** |
+| Agent `fixes_v8_g3flash_color_area` | **71.24%** | **65.12%** |
+| Agent `fixes_v9_g3flash_related_sents` | **71.28%** | **64.56%** |
+| Agent `fixes_v10_g3flash_choice_conflict` | **71.08%** | **64.24%** |
+| **Δ (v8 − zero-shot)** | **+7.68 pp** | **+8.72 pp** |
+| **Δ (v9 − zero-shot)** | **+7.72 pp** | **+8.16 pp** |
+| **Δ (v10 − zero-shot)** | **+7.52 pp** | **+7.84 pp** |
+
+Paired **McNemar** test (binary “strict correct” = `answer_accuracy == 1` vs `< 1`, scipy `chi2.cdf`):
+
+- **v8 vs zero-shot**: **χ² = 68.21**, **p ≈ 1.1 × 10⁻¹⁶**
+- **v9 vs zero-shot**: **χ² = 61.45**, **p ≈ 4.5 × 10⁻¹⁵**
+- **v10 vs zero-shot**: **χ² = 57.37**, **p ≈ 3.6 × 10⁻¹⁴**
+- **Pairwise between agents (all not significant)**: v9 vs v8 χ² = 0.34, p = 0.56; v10 vs v8 χ² = 0.90, p = 0.34; v9 vs v10 χ² = 0.10, p = 0.75.
+
+**By `question_type` on the same overlap (v8 / v9 / v10 vs zero-shot):**
+- mcq (n = 1,150): **+8.09 / +8.13 / +7.83 pp** mean
+- standard (n = 100): **+3.00 / +3.00 / +4.00 pp** — treat the standard delta as **exploratory** (wide CI).
+
+## 2) Ablations on the **250-ID** ladder (historical / controlled slice)
+
+| Comparison | Mean `answer_accuracy` | Exact |
+|---|---:|---:|
+| Zero-shot G3 (structured) on a **250-ID** snapshot after parser repair | *(see `*.bak` / notebook §14)* | **52.8%** |
+| Agent `fixes_v7_g3flash_conf_gate` (same 250 IDs) | **69.6%** | **62.8%** |
+| Δ (v7 agent − zero-shot) on that snapshot | — | **+10.0 pp** exact |
+
+Use **§1** for the main paper claim; keep **§2** only if you need to cite the original ablation-era strict-exact snapshot.
+
+## 3) Verifier effectiveness
+
+**v7 (n = 250)** — accuracy by `verifier_verdict` (exact):
+
+| Verdict | Count | Exact |
+|---|---:|---:|
+| `confirmed` | 180 | **68.33%** |
+| `revised` | 66 | **50.00%** |
+| `error` | 4 | **25.00%** |
+
+**v8 (n = 1,250)** — exact on subset:
+
+| Verdict | Count | Exact |
+|---|---:|---:|
+| `confirmed` | 986 | **68.15%** |
+| `revised` | 234 | **55.56%** |
+| `error` | 30 | *(rare slice — cite with care)* |
+
+**v9 (n = 1,250)** — exact on subset:
+
+| Verdict | Count | Exact |
+|---|---:|---:|
+| `confirmed` | 999 | **67.97%** |
+| `revised` | 215 | **52.09%** |
+| `error` | 36 | *(rare slice — cite with care)* |
+
+**v10 (n = 1,250)** — exact on subset:
+
+| Verdict | Count | Exact |
+|---|---:|---:|
+| `confirmed` | 982 | **69.04%** |
+| `revised` | 247 | **47.77%** |
+| `error` | 21 | *(rare slice — cite with care)* |
+
+## 4) Most defensible novelty lift (multi-select)
+
+From v4 to v5 on FinMME `multiple_choice` (`n=86`):
+
+- `fixes_v4_g3flash`: **30.23%**
+- `fixes_v5_multiselect`: **53.49%**
+- **Gain: `+23.26 pp`**
+
+## 5) Failure taxonomy snapshot (v7, n = 250)
+
+Top failure categories from `taxonomy_finmme_train_fixes_v7_g3flash_conf_gate.jsonl`:
+
+| Failure Type | Count | Share of Failures (n=93) |
+|---|---:|---:|
+| `question_misunderstanding` | 25 | **26.9%** |
+| `legend_confusion` | 18 | **19.4%** |
+| `extraction_error` | 17 | **18.3%** |
+
+## 6) Runtime context
+
+**v7** (from trace metrics on 250 IDs): mean **~32 s**, median **~18.7 s**, p95 **~147 s**.
+
+**v8 @ 1,250** (from metrics JSONL): mean **43.9 s**, median **30.1 s**, p95 **209.4 s** — agent wall-clock remains **several×** a single zero-shot call (see results memo for a head-to-head latency table).
+
+**v9 @ 1,250** (from metrics JSONL): mean **43.7 s**, median **31.0 s**, **p95 87.5 s** — **~2.4× tighter tail than v8/v10**; adding `related_sentences` + caption-as-cross-check gives the verifier enough textual grounding to converge without long retry chains. This is v9's clearest unambiguous gain at full scale even though headline accuracy is tied with v8.
+
+**v10 @ 1,250** (from metrics JSONL): mean **44.2 s**, median **29.6 s**, p95 **222.9 s** — same order of magnitude as v8.
+
+## 7) Important caveats (must keep in paper text)
+
+1. **Two different FinMME train sample counts** — the iterative ladder (v1–v7) is documented on **250** IDs; **`fixes_v8`**, **`fixes_v9`**, and **`fixes_v10`** are all evaluated on the same **1,250** train IDs. Compare systems only after **`sample_id` join**.
+2. **Zero-shot train file is full-split (11,099 rows)** — the headline fair comparison uses the **1,250-ID overlap** with v8/v9/v10, not the zero-shot mean over all 11k (that full mean is **~61.5%**, dominated by much harder **standard** questions than in the 1,250-ID slice).
+3. **Gemini-3 zero-shot file was parser-repaired** (141 rows recovered on an early snapshot) before the headline **52.8%** exact-on-250 number stabilized; the authoritative baseline file is the 11k-row JSONL above.
+4. **Mean vs exact** — do not mix them in the same delta sentence without labeling columns.
+
+## 8) Suggested one-line claim
+
+On **1,250** FinMME train questions where both systems have predictions, our Gemini-3-based agent (**`fixes_v8_g3flash_color_area`**) achieves **71.24%** mean `answer_accuracy` vs **63.56%** for a **fair same-model** Gemini-3 Flash Preview zero-shot baseline (**+7.68 pp**; McNemar **p ≪ 0.001**), with the clearest lift on **MCQ** (**+8.09 pp** on 1,150). Adding analyst `related_sentences` + caption-as-cross-check (**v9**, **71.28%**, **+7.72 pp**) or a choice-conflict meta-signal (**v10**, **71.08%**, **+7.52 pp**) leaves headline accuracy statistically tied with v8 (pairwise McNemar p ≥ 0.34), but **v9 cuts p95 latency by ~2.4×** (87.5 s vs v8's 209.4 s) — a real operational gain. The strongest **isolated** pipeline ablation remains multi-select MCQ support (**+23.3 pp** on `multiple_choice` from v4 → v5).
diff --git a/results.md b/results.md
new file mode 100644
index 0000000..37412f3
--- /dev/null
+++ b/results.md
@@ -0,0 +1,390 @@
+# AgentFinVQA — Initial results summary
+
+This note condenses numbers from `notebooks/results_analysis.ipynb` (saved cell outputs), `output/final/**/summary*.csv`, and `output/baselines/*.jsonl` as of the current workspace. Use it as a starting point for an internal or initial report; re-run the notebook to refresh figures and tables.
+
+---
+
+## Scope
+
+| Source | Rows (approx.) | Notes |
+|--------|----------------|--------|
+| ChartQAPro (test) | 8,107 metric rows across configs in the notebook load | Per-config *n* varies slightly (e.g. OpenAI 2,709 vs Gemini 2,708). |
+| FinMME (train) | 11,082 | Full Gemini agent run on the train split. |
+
+Primary models referenced: **Gemini 2.5 Flash** (agent and zero-shot) and **OpenAI GPT-4o** (ChartQAPro agent).
+
+---
+
+## 1. ChartQAPro — overall accuracy (full available test metrics)
+
+| System | Accuracy | n |
+|--------|----------|---|
+| Gemini (2.5-Flash) — full agent | **0.5343** | 2,708 |
+| Gemini — no verifier | **0.5264** | 2,690 |
+| OpenAI (GPT-4o) | **0.4186** | 2,709 |
+
+**By question type (ChartQAPro, Gemini vs OpenAI):** hypothetical is strongest for both; OpenAI is relatively weaker on **standard** questions (0.39 vs ~0.57 for Gemini).
+
+---
+
+## 2. ChartQAPro — zero-shot vs full agent (baseline file)
+
+From `output/baselines/metrics_chartqapro_test_zeroshot_gemini_gemini_2_5_flash.jsonl` (as loaded in the notebook):
+
+- **~2,689** rows  
+- Mean answer accuracy **~0.597**
+
+The full Gemini agent on the aggregated test metrics is **~0.534** (section 1), so on this aggregate, zero-shot is higher than the full pipeline on the same broad ChartQAPro evaluation — the notebook explores *where* the agent gains or loses (sample-level and by type).
+
+---
+
+## 3. ChartQAPro — 250-sample aligned slice (No-OCR ablation)
+
+Restricted to **250** samples where **no-OCR, no-verifier, full Gemini, planner v2, OpenAI**, and **zero-shot** all have results (see notebook §13).
+
+| System | Accuracy (n = 250) |
+|--------|---------------------|
+| Zero-shot | **0.6520** |
+| Agent (full Gemini) | **0.6360** |
+| Agent (planner v2) | **0.6320** |
+| Agent (no OCR) | **0.6280** |
+| Agent (no verifier) | **0.6120** |
+| OpenAI (full) | **0.5040** |
+
+On this slice, zero-shot is slightly above the full Gemini agent; planner v2 is close to full agent. Removing OCR or verifier hurts accuracy relative to full.
+
+---
+
+## 4. FinMME — full train split (Gemini agent)
+
+| System | Accuracy | n |
+|--------|----------|---|
+| Gemini (2.5-Flash) full agent | **0.5653** | 11,082 |
+
+**By question type:** MCQ **~0.63**, open **standard** **~0.23** (FinMME is much harder on non-MCQ items in this run).
+
+---
+
+## 5. FinMME — zero-shot vs agent vs planner v2 (matched IDs)
+
+Baseline: `output/baselines/metrics_finmme_train_zeroshot_structured_gemini_gemini_2_5_flash.jsonl` (**233** rows).  
+Planner v2 metrics: `output/final/finmme_planner_v2/` (**250** rows in the planner file).
+
+Evaluation uses the **intersection of IDs** present in both zero-shot and planner v2 → **n = 233** (not 250).
+
+| System | Accuracy (n = 233) |
+|--------|---------------------|
+| Zero-shot (structured) | **~0.547** |
+| Agent (Gemini full) | **~0.592** |
+| Agent (Planner v2) | **~0.526** |
+
+On this matched set, the **full Gemini agent beats zero-shot**; **planner v2 is below both** (numbers recomputed from JSONL; notebook shows bootstrap CIs on the same slice).
+
+**Planner v2 — official summary on all 250 FinMME train samples** (`output/final/finmme_planner_v2/summary_finmme_train_planner_v2.csv`):
+
+- **ALL:** accuracy **0.544** (250 samples), mean latency **~18.9 s**
+
+---
+
+## 6. ChartQAPro — planner v2 summary (250 samples)
+
+From `output/final/chartqapro_planner_v2/summary_chartqapro_test_planner_v2.csv`:
+
+- **ALL:** accuracy **0.632** (250 samples), mean latency **~16.2 s**
+
+---
+
+## 7. Latency vs accuracy (notebook)
+
+Illustrative means from the latency table in the notebook (ChartQAPro aggregates):
+
+| System | Mean latency (s) | Accuracy |
+|--------|-------------------|----------|
+| Zero-shot (Gemini) | ~3.20 | ~0.597 |
+| Agent (Gemini) | ~11.96 | ~0.534 |
+| Agent (Gemini — no verifier) | ~12.69 | ~0.526 |
+| Agent (OpenAI) | ~7.73 | ~0.419 |
+
+(Exact latency rows depend on which trace files were merged; see notebook output.)
+
+---
+
+## 8. Figures and artifacts (paths)
+
+Generated or referenced under `output/final/` (examples):
+
+- `fig_zeroshot_vs_agent.pdf`
+- `fig_latency_vs_accuracy_zs_with_no_verifier.pdf`
+- `fig_finmme_zeroshot_vs_agent_250.pdf`
+
+---
+
+## 8b. FinMME — iterative fixes experiments (train slice)
+
+Progressive runs on a shared FinMME **train** slice: **v1–v7** on **250** labeled train IDs; **`fixes_v8_g3flash_color_area`**, **`fixes_v9_g3flash_related_sents`**, and **`fixes_v10_g3flash_choice_conflict`** target the same **1,250** train IDs (superset of the original 250 — same pipeline and config).  
+Runs v1–v6 use **Gemini 2.5 Flash Lite** for all stages; v4, v7, v8, v9, and v10 use **Gemini 3 Flash Preview** for planner/vision/verifier.
+
+**Post-eval coverage:** v8, v9, and v10 all have full **`metrics_*.jsonl`** rows (**n = 1,250**) on the same FinMME train ID slice — direct paired comparison is supported across all three.
+
+### What changed in each run
+
+| Run | Changes vs previous |
+|-----|---------------------|
+| `no_legend_grounding` | Baseline — no legend grounding, no caption injection, default token limits |
+| `fixes_v1` | + token limits raised to 2 048 · + analyst-caption hint injected into vision prompt · + verifier UNANSWERABLE pushback · + legend grounding enabled |
+| `fixes_v2` | + Gemini `thinking_budget=0` (eliminates thinking tokens) · + `choice_analysis` trimmed · + MCQ choices passed explicitly to verifier |
+| `fixes_v3` | + `thinking_budget=512` (moderate reasoning without exhausting output budget) |
+| `fixes_v4_g3flash` | + Gemini 3 Flash Preview model · + forced-choice retry when vision returns UNANSWERABLE on MCQ · + caption injected into verifier task · + MCQ-aware planner (eliminate-wrong-options guidance) · + pie/donut legend grounding |
+| `fixes_v5_multiselect` | + full multi-select MCQ support (planner / vision / verifier each have separate prompts for select-all-that-apply questions) |
+| `fixes_v6_conf_gate` | + verifier self-confidence field · + reluctance hint when vision is high-confidence · + confidence gate (revisions with confidence < 0.75 downgraded) — *(MEPs repaired in-place after parse-key bug caused 244/250 parse failures on first run)* |
+| `fixes_v7_g3flash_conf_gate` | + confidence default fixed to 0.75 (neutral) so gate only fires on explicit low confidence · fresh re-run with Gemini 3 Flash Preview + gate correctly active |
+| `fixes_v8_g3flash_color_area` | + OpenCV pixel-counting `color_area_tool` inserted between legend grounding and vision · per-label pixel breakdown + dominant-label hint injected into vision prompt for bar/pie/donut charts · `MEPColorArea` field added to MEP schema · gated by chart type, legend availability, and ambiguity flags (`color_ambiguity`, `low_confidence`) |
+| `fixes_v9_g3flash_related_sents` | + verifier sees `related_sentences` from sample metadata · caption reframed from “background” to “cross-check the draft answer” (same g3flash stack as v8) |
+| `fixes_v10_g3flash_choice_conflict` | + everything in v9 · when vision `choice_analysis` marks **≥2** single-select options at confidence **≥0.95**, verifier prompt gets a **VISION AMBIGUITY FLAG** (conflicting choice labels only — not the full `choice_analysis` dict) |
+
+### Accuracy (mean `answer_accuracy` with MCQ partial credit; strict exact in “No-judge” column)
+
+| Run | n | Mean acc. | Exact (≥ 0.999) | Δ vs baseline |
+|-----|---:|----------:|----------------:|---------------|
+| `no_legend_grounding` | 250 | — | **0.480** | — |
+| `fixes_v1` | 250 | — | **0.504** | +2.4 pp |
+| `fixes_v2` | 250 | — | **0.516** | +3.6 pp |
+| `fixes_v3` | 250 | — | **0.516** | +3.6 pp |
+| `fixes_v4_g3flash` | 250 | — | **0.560** | +8.0 pp |
+| `fixes_v5_multiselect` | 250 | **0.694** | **0.624** | +14.4 pp |
+| `fixes_v6_conf_gate` | 250 | **0.610** | **0.624** | +14.4 pp *(repaired)* |
+| `fixes_v7_g3flash_conf_gate` | 250 | **0.696** | **0.628** | **+14.8 pp** |
+| `fixes_v8_g3flash_color_area` | **1,250** | **0.712** | **0.651** | **+17.1 pp** |
+| `fixes_v9_g3flash_related_sents` | **1,250** | **0.713** | **0.646** | **+16.6 pp** |
+| `fixes_v10_g3flash_choice_conflict` | **1,250** | **0.711** | **0.642** | **+16.2 pp** |
+
+Per-type **mean** `answer_accuracy` (**n = 1,250** each):
+- v8: **mcq 0.725** (1,150), **standard 0.570** (100)
+- v9: **mcq 0.725** (1,150), **standard 0.570** (100)
+- v10: **mcq 0.722** (1,150), **standard 0.580** (100)
+
+At full scale v8, v9, and v10 are within **±0.2 pp mean acc.** of each other; per-type breakdowns are essentially indistinguishable. Earlier v9-vs-v8 deltas reported on a 784-sample partial eval were selection bias from fast-finishing samples and disappear once the full **1,250** rows are scored.
+
+The earlier **standard 0.70 on n = 20** (250-ID slice) was a small-sample artifact; v7 vs v8 on the **paired 250 overlap** differ by **−0.2 pp** mean acc. (essentially tied).
+
+**Paired strict correctness (`answer_accuracy == 1`) on the full 1,250-ID overlap (continuity-corrected McNemar with scipy `chi2.cdf`):**
+- v10 vs v8 — **χ² = 0.90**, **p = 0.34** (no significant change)
+- **v9 vs v8** — **χ² = 0.34**, **p = 0.56** (no significant change; v9-only wins = 50, v8-only wins = 57)
+- **v9 vs v10** — **χ² = 0.10**, **p = 0.75** (no significant change)
+
+All three runs (v8, v9, v10) sit inside the same paired-significance band — additional verifier context (`related_sentences`, choice-conflict flag) doesn't move strict accuracy at this n. Their *behavior* differs (verifier verdict mix, latency tail — see below), but headline mean / exact accuracy does not.
+
+*Mean `answer_accuracy` is rule-based (numeric tolerance + MCQ partial credit). The “Exact” column is the share of rows with `answer_accuracy ≥ 0.999`. Auxiliary rubric dimensions from `gemini-2.5-flash-lite` are stored as `judge_*` fields (explanation quality, hallucination rate, etc.) — separate from `answer_accuracy`. v6 mean score is lower than v5 due to minor differences in the repaired MEP set; exact scores match v5.*
+
+**FinMME paper baseline (full 11k eval):** Gemini Flash 2.0 = 51.85% avg. Our v7 on 250 samples = **69.6%** mean acc. (+17.8 pp vs paper headline, different metric family).
+
+### MAX_TOKENS truncation
+
+| Run | Samples truncated | % of run |
+|-----|------------------:|---------:|
+| `no_legend_grounding` | 167 | 66.8 % *(n = 250)* |
+| `fixes_v1` | 129 | 51.6 % |
+| `fixes_v2` | 6 | 2.4 % |
+| `fixes_v3` | 3 | 1.2 % |
+| `fixes_v4_g3flash` | 9 | 3.6 % |
+| `fixes_v5_multiselect` | 16 | 6.4 % |
+| `fixes_v6_conf_gate` | 21 | 8.4 % |
+| `fixes_v7_g3flash_conf_gate` | 20 | 8.0 % |
+| `fixes_v8_g3flash_color_area` | **184** | **14.7 %** *(n = 1,250)* |
+| `fixes_v9_g3flash_related_sents` | **199** | **15.9 %** *(n = 1,250 MEPs; vision/verifier `tool_trace` `finish_reason`)* |
+| `fixes_v10_g3flash_choice_conflict` | **183** | **14.6 %** *(n = 1,250)* |
+
+Raising token limits in `fixes_v1` reduced truncation modestly. Disabling thinking tokens in `fixes_v2` cut it to near-zero; `fixes_v3` halves it further. Later runs are slightly higher due to richer prompts (multi-select blocks, caption injection, verifier tools). On the **1,250-ID** v8 eval, **14.7%** of MEPs hit MAX_TOKENS in at least one traced stage (vs **8.0%** on the 250-ID v7 row) — expect slice and prompt-stack differences; the long-tail risk remains real. v9 shows a slightly higher hit rate (**15.9%**); v10 is back in line with v8 (**14.6%**).
+
+### UNANSWERABLE over-refusal
+
+| Run | UA predicted | Notes |
+|-----|-------------|-------|
+| `no_legend_grounding` | 46 | High over-refusal |
+| `fixes_v1` | 34 | Verifier pushback helps |
+| `fixes_v2` | 37 | — |
+| `fixes_v3` | 38 | — |
+| `fixes_v4_g3flash` | 5 | Forced-choice retry eliminates most MCQ UNANSWERABLE |
+| `fixes_v5_multiselect` | 4 | — |
+| `fixes_v6_conf_gate` | 0 | — |
+| `fixes_v7_g3flash_conf_gate` | 2 | — |
+| `fixes_v8_g3flash_color_area` | **14** *(n = 1,250)* / 2 *(n = 250)* | At 1,250 IDs, a small rise in UNANSWERABLE predictions vs the 250-ID snapshot; still low vs early runs |
+| `fixes_v9_g3flash_related_sents` | **7** *(n = 1,250)* | Matches v10; both halve v8's UA rate, consistent with the new caption / source-sentence framing giving the verifier more text to ground on |
+| `fixes_v10_g3flash_choice_conflict` | **7** *(n = 1,250)* | Slightly lower than v8's 14 on the same ID slice |
+
+### Verifier verdicts
+
+| Run | Confirmed | Revised | Error | Gated |
+|-----|-----------|---------|-------|-------|
+| `no_legend_grounding` | 175 | 73 | 2 | — |
+| `fixes_v1` | 196 | 54 | 0 | — |
+| `fixes_v2` | 205 | 41 | 4 | — |
+| `fixes_v3` | 207 | 43 | 0 | — |
+| `fixes_v4_g3flash` | 193 | 50 | 7 | — |
+| `fixes_v5_multiselect` | 179 | 70 | 1 | — |
+| `fixes_v6_conf_gate` | 193 | 52 | 5 | 0 *(bug: 0.0 default gated all revisions; repaired)* |
+| `fixes_v7_g3flash_conf_gate` | 180 | 66 | 4 | 1 |
+| `fixes_v8_g3flash_color_area` | **986** | **234** | **30** | 0 *(n = 1,250)* |
+| `fixes_v9_g3flash_related_sents` | **999** | **215** | **36** | 0 *(n = 1,250)* |
+| `fixes_v10_g3flash_choice_conflict` | **982** | **247** | **21** | 0 *(n = 1,250)* |
+
+**Verifier effectiveness (v7, n = 250):**
+
+- Revised samples: **66**
+- Exact accuracy on revised subset: **50.0%** (33/66)
+- Exact accuracy on non-revised subset: **67.4%** (124/184)
+
+**Verifier effectiveness (v8, n = 1,250):**
+
+- Revised samples: **234**; exact on revised subset **55.6%**
+- Confirmed samples: **986**; exact on confirmed subset **68.2%**
+- At scale, revisions track harder items but are no longer a “coin flip” the way the tiny v7 revised slice suggested.
+
+**Verifier effectiveness (v9, n = 1,250):**
+
+- Revised samples: **215**; exact on revised subset **52.1%** (mean **62.6%**)
+- Confirmed samples: **999**; exact on confirmed subset **68.0%** (mean **73.8%**)
+- Adding `related_sentences` shifts the verifier toward **slightly more confirmations** (999 vs v8's 986) and **fewer revisions** (215 vs 234) — the new textual signal seems to resolve some uncertainty in place rather than triggering a revision. Revised-subset exact dips ~3.5 pp vs v8 but mean is essentially flat (62.6% vs 62.6%), suggesting the marginal revisions are partial-credit cases rather than fresh wins.
+
+**Verifier effectiveness (v10, n = 1,250):**
+
+- Revised samples: **247**; exact (≥ 0.999) on revised subset **47.8%**
+- Confirmed samples: **982**; exact on confirmed subset **69.0%**
+- Mean `answer_accuracy` is almost unchanged vs v8 (**71.08%** vs **71.24%**), but the revised tail is **weaker** under exact-match accounting — worth monitoring if v10’s ambiguity flag invites extra revisions.
+
+### Latency (250 samples for v1–v7; v8 / v9 / v10 at 1,250)
+
+| Run | p50 (s) | p95 (s) | mean (s) |
+|-----|---------|---------|----------|
+| `no_legend_grounding` | 18.9 | 27.4 | 21.6 |
+| `fixes_v1` | 21.2 | 38.9 | 24.4 |
+| `fixes_v2` | 15.4 | 27.1 | 21.6 |
+| `fixes_v3` | 18.7 | 30.7 | 20.1 |
+| `fixes_v4_g3flash` | 30.4 | 232.8 | 46.5 |
+| `fixes_v5_multiselect` | 32.0 | 247.7 | 49.0 |
+| `fixes_v6_conf_gate` | 33.6 | 256.7 | 52.4 |
+| `fixes_v7_g3flash_conf_gate` | 32.3 | 246.1 | 41.5 |
+| `fixes_v8_g3flash_color_area` | **30.1** | **209.4** | **43.9** *(n = 1,250)* |
+| `fixes_v9_g3flash_related_sents` | **31.0** | **87.5** | **43.7** *(n = 1,250)* |
+| `fixes_v10_g3flash_choice_conflict` | **29.6** | **222.9** | **44.2** *(n = 1,250)* |
+
+`fixes_v1` is slower than baseline (legend grounding adds a stage). `fixes_v2` is fastest (thinking tokens off). v4–v7 improve accuracy substantially but increase latency and tail risk due to richer prompts and additional verification logic. On the **250-ID** v8 snapshot, median latency dipped vs v7 while mean rose slightly. On **n = 1,250**, v8 shows **mean 43.9 s**, **p50 30.1 s**, **p95 209.4 s** — same long-tail story, slightly lower mean than the 250-ID v8 snapshot (46.9 s) partly because more cached judge scores shortened some eval paths. **v10** is similar (**mean 44.2 s**, **p50 29.6 s**, **p95 222.9 s**).
+
+**v9 is the clear latency winner**: **mean 43.7 s**, **p50 31.0 s**, but **p95 only 87.5 s** — a **~2.4× tighter tail** than v8/v10 (209–223 s). Adding `related_sentences` and reframing the caption as a cross-check seems to give the verifier enough textual grounding that it converges without long retry chains; the long tail of v8 where the verifier kept thrashing on ambiguous charts collapses. This is the strongest unambiguous v9 win even though headline accuracy is tied with v8.
+
+### Failure taxonomy by question type (v7)
+
+From `taxonomy_finmme_train_fixes_v7_g3flash_conf_gate.jsonl` joined with metrics:
+
+- Total failures: **93** (`mcq`: 87, `standard`: 6)
+- Top overall failure types:
+  - `question_misunderstanding`: **25** (26.9%)
+  - `legend_confusion`: **18** (19.4%)
+  - `extraction_error`: **17** (18.3%)
+
+**MCQ failure composition (n=87):**
+
+| Failure type | Count | Share |
+|-------------|-------|-------|
+| question_misunderstanding | 23 | 26.4% |
+| extraction_error | 17 | 19.5% |
+| legend_confusion | 16 | 18.4% |
+| hallucinated_element | 12 | 13.8% |
+| other | 9 | 10.3% |
+| axis_misread | 6 | 6.9% |
+| unanswerable_failure | 4 | 4.6% |
+
+Most residual errors in v7 are therefore comprehension/grounding issues in MCQ, not UNANSWERABLE over-refusal.
+
+### Fair baseline check: Gemini-3 zero-shot vs agent
+
+`output/baselines/metrics_finmme_train_zeroshot_structured_gemini_gemini_3_flash_preview.jsonl` now holds **11,099** FinMME train rows (Gemini-3 Flash Preview structured zero-shot, parser-repaired). The file was initially under-parsed (`parse_ok=false` for 142 rows on an early 250-row snapshot); after repair, a **historical** strict-exact snapshot on **250** IDs was **52.8%** zero-shot vs **62.8%** agent v7 (**+10.0 pp** exact) — useful as an ablation-era record; backups live next to the baseline file.
+
+**Matched overlap (recommended for the paper):** the **1,250** `sample_id`s in **`fixes_v8_g3flash_color_area`** / **`fixes_v9_g3flash_related_sents`** / **`fixes_v10_g3flash_choice_conflict`** metrics all exist in the full zero-shot file. On that overlap (same rule-based `answer_accuracy`, same judge stack for the agent traces):
+
+| System | Mean `answer_accuracy` | Exact (≥ 0.999) |
+|--------|----------------------:|----------------:|
+| Agent `fixes_v8_g3flash_color_area` | **71.24%** | **65.12%** |
+| Agent `fixes_v9_g3flash_related_sents` | **71.28%** | **64.56%** |
+| Agent `fixes_v10_g3flash_choice_conflict` | **71.08%** | **64.24%** |
+| Zero-shot Gemini-3 preview (structured) | **63.56%** | **56.40%** |
+| **Δ (v8 agent − zero-shot)** | **+7.68 pp** | **+8.72 pp** |
+| **Δ (v9 agent − zero-shot)** | **+7.72 pp** | **+8.16 pp** |
+| **Δ (v10 agent − zero-shot)** | **+7.52 pp** | **+7.84 pp** |
+
+Paired **McNemar** test on strict correctness (binary strict correct = `answer_accuracy == 1` vs `< 1`, scipy `chi2.cdf`):
+- **v8** vs zero-shot — **χ² = 68.21**, **p ≈ 1.1 × 10⁻¹⁶**
+- **v9** vs zero-shot — **χ² = 61.45**, **p ≈ 4.5 × 10⁻¹⁵**
+- **v10** vs zero-shot — **χ² = 57.37**, **p ≈ 3.6 × 10⁻¹⁴**
+
+All three are overwhelmingly significant against zero-shot. Pairwise between the agents, all comparisons are **not significant** (v9 vs v8 p = 0.56, v10 vs v8 p = 0.34, v9 vs v10 p = 0.75) — at this n, accuracy is statistically tied across v8 / v9 / v10.
+
+**By `question_type` on the same 1,250-ID overlap (v8 / v9 / v10 vs zero-shot):**
+- mcq (n = 1,150): **+8.09 pp / +8.13 pp / +7.83 pp** mean acc.
+- standard (n = 100): **+3.00 pp / +3.00 pp / +4.00 pp** — treat the standard slice as **directional only** (wide uncertainty).
+
+(v9 full-scale numbers are now in the table above; the historical "v9 partial @ n = 784" snapshot was a fast-finishing-sample selection bias and is no longer the operating estimate.)
+
+**Full-file zero-shot context (not matched to v8 / v10):** on all **11,099** train rows, mean zero-shot acc. is **~61.5%**, with **standard** questions much harder (**~24%** mean) than in the first-1,250-ID slice — so scaling the agent to the full train split may see a lower standard-type floor than this overlap suggests.
+
+### Version legend
+
+| Tag | Model (planner/vision/verifier) | OCR / judge |
+|-----|---------------------------------|-------------|
+| `no_legend_grounding` | gemini-2.5-flash-lite | gemini-2.5-flash-lite |
+| `fixes_v1` | gemini-2.5-flash-lite | gemini-2.5-flash-lite |
+| `fixes_v2` | gemini-2.5-flash-lite | gemini-2.5-flash-lite |
+| `fixes_v3` | gemini-2.5-flash-lite | gemini-2.5-flash-lite |
+| `fixes_v4_g3flash` | **gemini-3-flash-preview** | gemini-2.5-flash-lite |
+| `fixes_v5_multiselect` | gemini-2.5-flash-lite | gemini-2.5-flash-lite |
+| `fixes_v6_conf_gate` | gemini-2.5-flash-lite | gemini-2.5-flash-lite |
+| `fixes_v7_g3flash_conf_gate` | **gemini-3-flash-preview** | gemini-2.5-flash-lite |
+| `fixes_v8_g3flash_color_area` | **gemini-3-flash-preview** | gemini-2.5-flash-lite |
+| `fixes_v9_g3flash_related_sents` | **gemini-3-flash-preview** | gemini-2.5-flash-lite |
+| `fixes_v10_g3flash_choice_conflict` | **gemini-3-flash-preview** | gemini-2.5-flash-lite |
+
+v1–v7: **250** FinMME train samples; v8 / v9 / v10 all evaluated on the same **1,250** train samples (`gemini_gemini` config, FinMME train split).
+
+### Color-area stage activation (v8)
+
+`color_area_tool` is gated by chart type, legend availability, and ambiguity flags, so it does not fire on every sample.
+
+| Metric | v8 @ 250 IDs (snapshot) | v8 @ 1,250 IDs |
+|---|---:|---:|
+| Color-area stage triggered | 12 (4.8%) | **62 (5.0%)** |
+| ↳ flagged `color_ambiguity` (hint suppressed) | 10 | **52** |
+| ↳ flagged `low_confidence` (hint suppressed) | 2 | **3** |
+| Legend compliance retries fired | 5 | **165** *(13.2% of 1,250 MEPs)* |
+
+The stage is conservatively gated — many charts (lines, multi-axis, etc.) never qualify — but at **n = 1,250** it fires on **~5%** of samples, not “effectively never.” **Paired v7 vs v8 on the same 250 IDs** is still **≈0 pp** mean acc. (see `metrics_*.n250` backups). The headline **0.712** at **n = 1,250** is mainly a **more stable MCQ estimate** (**72.5%** on 1,150 mcq) than the small 250-ID window suggested; it is **not** a large paired gain over v7 on identical IDs.
+
+### Key takeaways
+
+- **+14.8 pp accuracy** over baseline achieved by `fixes_v7` (48.0% → 62.8% no-judge; **69.6% judge-based**). `fixes_v8` matches v7 within noise (69.4% judge / 62.8% no-judge); the color-area hint is correct in direction but only activates on ~5% of the slice, so it doesn't move the headline number.
+- **Multi-select MCQ**: largest single-run gain was v5 (+8.8 pp on multiple_choice type, 30.2% → 53.5%).
+- **UNANSWERABLE over-refusal**: 46 → 2 on the 250-ID ladder (forced-choice retry in v4); **14 / 1,250** on v8; **7 / 1,250** on both v9 and v10 (still low vs early runs; the v9/v10 verifier prompts cut UA-confirmations in half by giving the model more text to ground on).
+- **MAX_TOKENS**: near-eliminated by v2–v3 on the ladder; later prompts add some tail risk again (**184** hits at v8, **199** v9, **183** v10 — all at **n = 1,250** MEPs by `tool_trace` `finish_reason`).
+- **Fair same-model baseline (primary):** on the **1,250-ID** overlap with full Gemini-3 zero-shot train eval, all three g3flash agents beat zero-shot by ~7.5–7.7 pp mean acc. (v8 **+7.68 / +8.72 pp**; v9 **+7.72 / +8.16 pp**; v10 **+7.52 / +7.84 pp** — mean / exact). All three p ≤ 4.5 × 10⁻¹⁵ vs zero-shot. **Pairwise between agents, no comparison is significant** (v9 vs v8 p = 0.56, v10 vs v8 p = 0.34, v9 vs v10 p = 0.75). Legacy **250-ID** strict-exact headline was **+10.0 pp** (v7 vs repaired zero-shot snapshot) — cite as historical ablation only.
+- **v9 / v10 verifier prompts:** v9 adds analyst `related_sentences` + caption-as–cross-check framing; v10 adds a **choice-conflict** meta-signal when two high-confidence single-select options collide. At full n = 1,250 both are statistically tied with v8 on mean / exact accuracy (paired McNemar p ≥ 0.34); v9's distinctive win is a **2.4× tighter latency tail** (p95 87.5 s vs v8's 209.4 s).
+- **Confidence gate**: designed to block low-confidence verifier revisions; only fires when model explicitly returns `confidence < 0.75` (1 gate in v7). Bug in v6 where `confidence` was required in parse keys caused all revisions to fail; repaired in-place.
+- **Model upgrade (g3flash)**: v4, v7, v8, v9, and v10 use Gemini 3 Flash Preview — contributes meaningful gains over 2.5 Flash Lite.
+- **Verifier**: at v8 **n = 1,250**, revised rows remain harder but revised-subset exact rises to **~55.6%** (vs **50%** on 66 v7 revised IDs). **v10** increases revisions (**247** vs **234**) but **exact** on revised rows drops to **~47.8%** while headline mean acc. stays within **~0.2 pp** of v8 — monitor if the ambiguity flag trades calibration for exactness.
+- **OpenCV color-area (v8)**: opt-in stage between legend grounding and vision; **~5%** trigger rate at 1,250 IDs; `MEPColorArea` trace for audits.
+- **vs. paper baseline**: v7 **0.696** mean acc. on 250 IDs vs Gemini Flash 2.0 from FinMME paper (51.85%) = **+17.8 pp** (different metric family than the paper table).
+
+Full per-sample analysis, flip tables, taxonomy breakdowns, and charts are in `notebooks/results_analysis.ipynb` § 14–16.
+For paper-ready headline numbers, see `markdown/camera_ready_metrics.md`.
+
+---
+
+## 9. Caveats for the report
+
+1. **Different n across configs** — ChartQAPro row counts differ slightly by config; comparisons should note which subset is used.  
+2. **FinMME 233 vs 250** — Zero-shot baseline does not cover all 250 planner-v2 IDs; the fair three-way comparison uses **233** overlapping samples.  
+3. **FinMME v8 / v9 / v10 vs ladder (n)** — v1–v7 rows in §8b are **250** train IDs; **`fixes_v8`**, **`fixes_v9`**, and **`fixes_v10`** each ship **1,250** `metrics_*.jsonl` rows on the same ID slice — do not mix headline tables with the smaller ladder rows without a `sample_id` join.  
+4. **Slices vs full test** — The **250-sample** ChartQAPro block is a *controlled subset*; headline full-test numbers are in §1–2.  
+5. **Refresh** — Re-execute `results_analysis.ipynb` after new runs to update tables and PDFs.
+
+---
+
+*Generated to support an initial results memo; align wording with your paper’s definitions of accuracy and splits.*
diff --git a/scripts/run_finmme_fixes_v10.sh b/scripts/run_finmme_fixes_v10.sh
new file mode 100755
index 0000000..3dea2e7
--- /dev/null
+++ b/scripts/run_finmme_fixes_v10.sh
@@ -0,0 +1,31 @@
+#!/usr/bin/env bash
+# FinMME train (1,250 samples): Gemini 3 Flash Preview (planner / vision / verifier) + Flash-Lite judge.
+# v10 — everything in v9, plus verifier **choice-conflict meta-signal**:
+#   - related_sentences + caption cross-check (same as v9)
+#   - When vision's ``choice_analysis`` rates ≥2 single-select options at confidence ≥0.95,
+#     the verifier prompt gets a VISION AMBIGUITY FLAG (labels only — not the full dict).
+# Same 1,250-ID slice as v8/v9 for paired comparison.
+#
+# Output dir (run_tag): meps/gemini_gemini/finmme/fixes_v10_g3flash_choice_conflict/train/
+# Metrics dir         : output/final/finmme_fixes_v10_g3flash_choice_conflict/
+#
+# Usage: ./scripts/run_finmme_fixes_v10.sh
+# Remove --resume below for a full re-run from scratch.
+set -euo pipefail
+
+REPO_ROOT="$(cd -- "$(dirname "${BASH_SOURCE[0]}")"/.. && pwd)"
+cd "$REPO_ROOT"
+
+scripts/submit_pipeline.sh \
+    --dataset finmme \
+    --split train \
+    --n 1250 \
+    --config gemini_gemini \
+    --vision_model gemini-3-flash-preview \
+    --planner_model gemini-3-flash-preview \
+    --verifier_model gemini-3-flash-preview \
+    --judge_model gemini-2.5-flash-lite \
+    --run_tag fixes_v10_g3flash_choice_conflict \
+    --out_label finmme_train_fixes_v10_g3flash_choice_conflict \
+    --langfuse \
+    --resume
diff --git a/scripts/submit_eval.sh b/scripts/submit_eval.sh
index 54021b4..5cd3373 100755
--- a/scripts/submit_eval.sh
+++ b/scripts/submit_eval.sh
@@ -16,6 +16,7 @@
 #   --out_label LABEL      Label for output files (default: DATASET_SPLIT)
 #   --no_verifier          MEPs live under <dataset>/no_verifier/<split> (match generation)
 #   --no_ocr               MEPs live under <dataset>/no_ocr/<split> (match generation)
+#   --eval_resume          Merge with existing metrics_*.jsonl: skip sample_ids already scored
 #   --after JOB_ID         Hold until JOB_ID completes successfully (optional)
 
 set -euo pipefail
@@ -37,6 +38,7 @@ JUDGE_MODEL="gemini-2.5-flash-lite"
 MEP_START=0
 USE_JUDGE=0
 LANGFUSE=0
+EVAL_RESUME=0
 EVAL_DIR="output"
 OUT_LABEL=""
 AFTER_JOB=""
@@ -53,6 +55,7 @@ while [[ $# -gt 0 ]]; do
         --judge_model) JUDGE_MODEL="$2"; shift 2 ;;
         --mep_start)   MEP_START="$2";   shift 2 ;;
         --use_judge)   USE_JUDGE=1;      shift ;;
+        --eval_resume) EVAL_RESUME=1;    shift ;;
         --langfuse)  LANGFUSE=1;     shift ;;
         --no_verifier) NO_VERIFIER=1;  shift ;;
         --no_ocr)      NO_OCR=1;       shift ;;
@@ -66,7 +69,7 @@ done
 
 OUT_LABEL="${OUT_LABEL:-${DATASET}_${SPLIT}}"
 
-export DATASET SPLIT CONFIG WORKERS JUDGE_MODEL MEP_START USE_JUDGE LANGFUSE EVAL_DIR OUT_LABEL NO_VERIFIER NO_OCR RUN_TAG
+export DATASET SPLIT CONFIG WORKERS JUDGE_MODEL MEP_START USE_JUDGE LANGFUSE EVAL_RESUME EVAL_DIR OUT_LABEL NO_VERIFIER NO_OCR RUN_TAG
 
 echo "=== Submitting eval-only job ==="
 echo "  Dataset      : $DATASET"
@@ -75,6 +78,7 @@ echo "  Config       : $CONFIG"
 echo "  Workers      : $WORKERS"
 echo "  Judge model  : $JUDGE_MODEL"
 echo "  Use judge    : $USE_JUDGE"
+echo "  Eval resume  : $EVAL_RESUME"
 echo "  Langfuse     : $LANGFUSE"
 echo "  Eval dir     : $EVAL_DIR"
 echo "  Output label : $OUT_LABEL"
diff --git a/updates.md b/updates.md
new file mode 100644
index 0000000..d4caef7
--- /dev/null
+++ b/updates.md
@@ -0,0 +1,126 @@
+# Recent Codebase Updates
+
+For project-management tracking, see `markdown/clickup_worklog_v1_to_v7.md`.
+
+## FinMME Iterative Fixes — v4 through v10 (2026-04 / 2026-05)
+
+### Multi-select MCQ support (`fixes_v5_multiselect`)
+- Added `_is_multi_select(sample)` helper in `vision_agent.py` — checks `metadata.question_type_raw == "multiple_choice"` or keywords ("select all", "all that apply", etc.)
+- **Planner prompt** (`agents/prompts/planner.txt`): added distinct multi-select MCQ guidance — "Evaluate EACH choice independently", "Compile ALL choices supported", do not stop at first match
+- **Vision prompt** (`agents/prompts/vision.txt`): added `{multi_select_block}` placeholder; MCQ rules split into single-select vs multi-select paths; UNANSWERABLE override applies only when no choices are present
+- **Vision agent** (`agents/vision_agent.py`): `_format_multi_select_block()` generates a bold warning block; Task `expected_output` updated conditionally for multi-select
+- **Vision tool** (`tools/vision_qa_tool.py`): `VisionQAInput` has `multi_select: bool`; `_build_prompt()` has three branches for multi-select / single MCQ / open
+- **Verifier agent** (`agents/verifier_agent.py`): passes `multi_select_note` into task description; verifier tool called with `multi_select=True/False`
+- **Verifier tool** (`tools/verifier_tool.py`): two separate prompt templates `_VERIFIER_PROMPT_SINGLE` and `_VERIFIER_PROMPT_MULTI`; multi prompt enforces per-choice step-by-step verification and never collapsing to single letter
+- Result: multiple_choice accuracy 30.2% → 53.5% (+23.3 pp)
+
+### Verifier confidence gate (`fixes_v6_conf_gate` / `fixes_v7_g3flash_conf_gate`)
+- **Selective verifier**: `vision_min_conf` computed from `choice_analysis` confidence scores; if ≥ 0.95 a strong reluctance hint is added to verifier task; if ≥ 0.85 a soft hint
+- **Confidence gate** in `runner/run_generate_meps.py`: if verifier returns `verdict=revised` with `confidence < 0.75`, revision is downgraded to confirmed and vision answer retained; logged as `verifier_revision_gated`
+- **Bug (v6)**: `"confidence"` added to `VERIFIER_REQUIRED_KEYS` caused `parse_strict` to return `{}` for 244/250 samples (model rarely returns this field) → regression −8.8 pp
+- **Repair script** (`scripts/repair_meps_v6.py`): re-parsed `verifier.raw_text` for all 250 v6 MEPs using corrected required_keys `["verdict", "answer", "reasoning"]`; fixed 239 MEPs in-place
+- **Fix (v7)**: confidence default changed from `0.0` → `0.75` (neutral, passes gate) in both `verifier_agent.py` and `run_generate_meps.py`; gate now only fires on explicit model output `< 0.75`
+- **Repair script** (`scripts/repair_meps_v7.py`): un-gates revisions in v7 MEPs generated before the fix where `confidence` was absent from raw output
+- Result: v7 gate fired 1 time (correctly), 66 revisions passed through; judge accuracy 69.6% (+0.2 pp vs v5)
+
+### Pipeline additions (`fixes_v4_g3flash`)
+- **Forced-choice retry**: if VisionAgent returns UNANSWERABLE and MCQ choices exist, vision is re-called with "FORCED CHOICE" prepend; reduced UNANSWERABLE rate from 38 → 5
+- **Caption → verifier**: `verified_caption` from sample metadata injected into verifier task description
+- **MCQ-aware planner**: added eliminate-wrong-options guidance and verify-best-match step
+- **Pie/donut legend grounding**: `_LEGEND_GROUNDING_CHART_TYPES` extended to include `"pie"` and `"donut"`
+- **Model preset**: `gemini_gemini_flash` (gemini-2.5-flash) and `gemini_gemini_flash_preview` (gemini-2.5-flash-preview-04-17) added to runner config
+
+### FinMME verifier context upgrades — v9 / v10 (2026-05)
+
+- **`fixes_v9_g3flash_related_sents`** (`scripts/run_finmme_fixes_v9.sh`): verifier prompt now includes **`related_sentences`** from sample metadata (analyst source text) and reframes **`verified_caption`** from “background” to **cross-check the draft answer**; planner/vision/verifier remain **Gemini 3 Flash Preview** with **`gemini-2.5-flash-lite`** judge (`--run_tag fixes_v9_g3flash_related_sents`, `--out_label finmme_train_fixes_v9_g3flash_related_sents`).
+  - **Full post-eval (n = 1,250):** mean `answer_accuracy` **71.28%**, exact **64.56%**; mcq **72.52%** (1,150), standard **57.00%** (100). vs Gemini-3 zero-shot on the same overlap: **+7.72 pp** mean (**+8.16 pp** exact); McNemar vs zero-shot **χ² ≈ 61.45**, **p ≈ 4.5×10⁻¹⁵**; paired **v9 vs v8** strict correctness **χ² ≈ 0.34, p ≈ 0.56** (not significant). MAX_TOKENS: **199 / 1,250** (**15.9%**); UNANSWERABLE predictions **7 / 1,250**; verifier verdicts **999 / 215 / 36** (confirmed / revised / error — slightly more confirmations / fewer revisions than v8). Latency (metrics JSONL): mean **43.7 s**, p50 **31.0 s**, **p95 87.5 s** — the **~2.4× tighter tail vs v8 (p95 209 s)** is v9's clearest unambiguous gain.
+  - Earlier partial-eval read (n = 784) reported v9 at **70.60% mean** and **−1.47 pp vs v8** on that subset; that was selection bias from the fastest-finishing samples and disappears once the full 1,250 rows are scored.
+- **`fixes_v10_g3flash_choice_conflict`** (`scripts/run_finmme_fixes_v10.sh`): everything in v9 plus a **choice-conflict meta-signal** — when vision `choice_analysis` marks **≥2** single-select options at confidence **≥0.95**, the verifier sees **conflicting choice labels only** (not the full `choice_analysis` dict), via `format_ambiguity_block` / `choice_analysis_ambiguity_labels` in `src/agentfinvqa/tools/verifier_tool.py` and wiring in `src/agentfinvqa/agents/verifier_agent.py`.
+  - **Full post-eval (n = 1,250):** mean `answer_accuracy` **71.08%**, exact **64.24%**; mcq **72.22%** (1,150), standard **58.00%** (100). vs Gemini-3 zero-shot on the same overlap: **+7.52 pp** mean; McNemar vs zero-shot **χ² ≈ 57.4**, **p ≈ 3.6×10⁻¹⁴**; paired **v10 vs v8** strict correctness **p ≈ 0.34** (not significant). MAX_TOKENS: **183 / 1,250** (**14.6%**); UNANSWERABLE predictions **7 / 1,250**; verifier verdicts **982 / 247 / 21** (confirmed / revised / error). Latency (metrics JSONL): mean **44.2 s**, p50 **29.6 s**, p95 **222.9 s**.
+- **Eval-only resume:** `scripts/submit_eval.sh` supports **`--eval_resume`** for merging existing `metrics_*.jsonl` / trace / taxonomy by `sample_id` (see `scripts/run_batch.py`).
+
+### Color-area pre-hint (`fixes_v8_g3flash_color_area`)
+- **New tool** `src/agentfinvqa/tools/color_area_tool.py`: OpenCV/HSV pixel counter that masks each labeled series color in a chart region and returns a per-label pixel breakdown plus the dominant label.
+- **Gating** (`should_trigger_color_area`): the stage fires only when (a) `chart_type` is one of the supported color-area types (bar, pie, donut variants), (b) a legend map exists with ≥2 series, and (c) the question is plausibly a color-area / dominance question. All other charts skip the stage.
+- **Vision-prompt injection** (`format_color_area_block_for_vision`): when the OpenCV result is clean, the per-label pixel ranking and dominant-label hint are formatted as a context block and injected into the vision prompt; when `color_ambiguity` or `low_confidence` is set, the hint is suppressed so the vision agent isn't misled by a weak mask.
+- **MEP schema** (`mep/schema.py`): new `MEPColorArea` dataclass capturing `triggered`, `breakdown`, `largest`, `total_pixels_matched`, `low_confidence`, `color_ambiguity`, `parse_error`, and `tool_trace`; wired into the `MEP` dataclass as `color_area: Optional[MEPColorArea] = None`.
+- **Runner integration** (`runner/run_generate_meps.py`): color-area stage runs after legend grounding and before vision; the result is threaded into `build_vision_task_description` via the `color_area=` kwarg.
+- **Vision agent** (`agents/vision_agent.py`): `build_vision_task_description` now accepts `color_area: Optional[MEPColorArea]` and emits the formatted block (or nothing when suppressed).
+- **Tests** (`tests/agentfinvqa/test_color_area_tool.py`): unit suite covering the HSV-color helper, OpenCV-imread mocking, dominant-label selection, ambiguity flagging, and the `format_color_area_block_for_vision` formatter.
+- **Runner script** (`scripts/run_finmme_fixes_v8_g3flash.sh`): one-shot wrapper that calls `submit_pipeline.sh` with `--config gemini_gemini`, Gemini 3 Flash Preview models, `--resume`, and writes outputs under `output/final/finmme_fixes_v8_g3flash_color_area/`.
+- **Results — 250-ID snapshot (early eval, still valid for paired v7 comparison)**:
+  - Mean `answer_accuracy` **0.694** (v7: **0.696**, Δ **−0.2 pp** on the same 250 IDs — within noise)
+  - Exact (≥ 0.999) **0.628** (same as v7 on that slice)
+  - Verifier verdicts: confirmed **187** / revised **59** / error **4** / gated **0** — revision rate drops vs v7 on the same IDs
+  - Color-area triggered **12/250** (4.8%); **10** `color_ambiguity` / **2** `low_confidence` suppressions — only ~2 samples received a usable hint, so the 250-ID headline stayed flat
+  - MAX_TOKENS **16/250**; UNANSWERABLE **2/250**; legend compliance retries **5/250**
+  - Latency p50 **29.8 s** (v7: 32.3 s), mean **46.9 s** (v7: 41.5 s)
+- **Results — 1,250-ID scale-up (May 2026 post-eval)** — `metrics_finmme_train_fixes_v8_g3flash_color_area.jsonl`:
+  - Mean `answer_accuracy` **0.7124** (exact **65.12%**); by type: **mcq 0.7248** (n = 1,150), **standard 0.5700** (n = 100)
+  - `vision_parse_ok` **~0.930**, `has_errors` **~3.9%** (reliability improved vs the first 250-ID tail)
+  - Verifier verdicts: confirmed **986** / revised **234** / error **30**
+  - Color-area triggered **62/1,250** (**5.0%**); **52** ambiguity / **3** low-confidence suppressions (MEP-derived counts)
+  - MAX_TOKENS hits **184/1,250** (**14.7%**); UNANSWERABLE predictions **14/1,250** (**1.1%**); legend compliance retries **165/1,250** (**13.2%**)
+  - Latency mean **43.9 s**, p50 **30.1 s**, p95 **209.4 s**
+- **Fair same-model baseline (Gemini-3 zero-shot)** — `output/baselines/metrics_finmme_train_zeroshot_structured_gemini_gemini_3_flash_preview.jsonl` is the **full FinMME train** run (**11,099** rows). On the **1,250-ID overlap**, all three g3flash agents beat zero-shot by ~7.5–7.7 pp mean acc.: v8 **+7.68 pp** (McNemar χ² ≈ 68.2, p ≈ 1.1×10⁻¹⁶), v9 **+7.72 pp** (χ² ≈ 61.5, p ≈ 4.5×10⁻¹⁵), v10 **+7.52 pp** (χ² ≈ 57.4, p ≈ 3.6×10⁻¹⁴). Pairwise between agents nothing is significant (v9 vs v8 p = 0.56, v10 vs v8 p = 0.34, v9 vs v10 p = 0.75). The legacy **+10.0 pp on 250 IDs** (strict exact v7 vs repaired zero-shot snapshot) is superseded for the main paper claim — see `results.md` §8b and `markdown/camera_ready_metrics.md`.
+- **Artifact hygiene:** `scripts/run_batch.py` now **sorts** `metrics_*.jsonl`, `trace_metrics_*.jsonl`, and `taxonomy_*.jsonl` by `sample_id` before flush so reruns are diff-stable (results buffered in memory until workers finish — interrupted `--eval_only` runs may write nothing).
+
+### Notebook (`notebooks/results_analysis.ipynb`)
+- Section 14 expanded to 9-run comparison covering all runs through v8
+- Per-type breakdown (single_choice / multiple_choice / numerical), revision gated tracking, confidence field availability
+- Section 15 paper comparison table (Table 3 style from FinMME ACL 2025 paper) vs Gemini Flash 2.0, Qwen2.5-VL 72B, GPT-4o, Claude 3.5 Sonnet, GPT-4o Mini
+- Added fair 250-ID comparison cell for `fixes_v7_g3flash_conf_gate` vs zero-shot baselines (`gemini-2.5-flash` and `gemini-3-flash-preview`) with coverage-aware matched IDs
+- Added Section 16: failure taxonomy by question type (v5→v7), including v7 heatmap and trend plots for top failure categories
+- Section 14 / 15 / 16 cells extended to also load and report `fixes_v8_g3flash_color_area`, including per-type accuracy, MAX_TOKENS / UNANSWERABLE / verifier-verdict / latency rows, and a `color_area_triggered` activation breakdown
+
+### Zero-shot parser repair (Gemini 3 Flash Preview)
+- Root cause: `baselines/run_zeroshot.py` structured parser only accepted strict JSON, so fenced/truncated-but-recoverable responses were marked `parse_ok=false` with empty `predicted`.
+- Implemented robust extraction in `run_zeroshot.py`:
+  - code-fence stripping (` ```json ... ``` `)
+  - truncated JSON suffix recovery
+  - regex fallback for `"answer": "..."` extraction
+  - last-resort `Answer: ...` fallback
+- Mirrored same extraction improvements in `baselines/fix_zeroshot_scores.py`.
+- Repaired existing file in place:
+  - `output/baselines/metrics_finmme_train_zeroshot_structured_gemini_gemini_3_flash_preview.jsonl`
+  - Reparsed rows: **141**
+  - Exact accuracy moved from artificially low (~29.2%) to **52.8%** on 250 rows
+  - Backup written as `.jsonl.bak`
+
+### v7 verifier effectiveness snapshot
+- v7 verifier verdict counts: `confirmed=180`, `revised=66`, `error=4`
+- Exact accuracy by verdict:
+  - `confirmed`: **68.33%**
+  - `revised`: **50.00%**
+  - `error`: **25.00%**
+- Revised subset (`n=66`) remains harder than non-revised subset (`n=184`, 67.39% exact), so revision quality is still a key improvement target.
+
+---
+
+## Langfuse Integration
+- Added `_Instrumentor` protocol plus `_build_instrumentor` helper so Google/OpenAI telemetry hooks are instantiated only when their packages are installed; prevents assigning `None` to imported classes and keeps imports at module top for Ruff E402.
+- `get_client` now runs from a cached `_client` and `_initialised` flag exactly as before, but the instrumentation guards wrap `instrument()` calls in `contextlib.suppress` so failures never crash the service.
+- Switched `register_dataset` to accept `Sequence[PerceivedSample]`, iterate with an explicit `for` loop, and print success counts; the CLI now uses a typed `DatasetLoaderConfig` (loader/display/default image dir) so both dataset CLI and runner share one configuration source.
+- Introduced `DatasetConfig` TypedDict and `DatasetLoader` aliases inside the MEP runner, then reused them for CLI argument validation and to compute dataset slugs.
+- Extracted `_run_verifier_stage` from `process_sample` to encapsulate parsing, defaulting, and error tracking for Pass 2.5 output; reduces branching and keeps error messages consistent with the previous inlined logic.
+- Centralized dataset registration and Langfuse prompt pushes at runner start, so a single `get_client()` call now drives dataset creation, prompt versioning, and on-the-fly score logging without duplicated env handling between CLI utilities.
+- Added clearer log lines (dataset name, skip counts, Langfuse enablement) around runner startup so long-running pipeline executions expose their configuration at a glance.
+
+## Vision Agent Prompting
+- Split `build_vision_task_description` into `_format_choice_blocks`, `_format_context_block`, `_format_plan_steps`, and `_format_ocr_block` so each conditional block can be unit-tested independently and Ruff no longer reports PLR0912.
+- Each formatter mirrors the existing prompt structure (e.g., choice labels lines, context prefix, OCR axis formatting), so the generated prompt text is identical while the main builder simply fills the template.
+- The refactor keeps `VISION_PROMPT_PATH` templating untouched, guaranteeing that only formatting helpers change behavior; this makes prompt diffs easy to audit alongside prompt text stored in `agents/prompts/vision.txt`.
+
+## Evaluation & Taxonomy Pipeline
+- `_parse_choice_labels` now stores lookups in `maybe_label` before appending, eliminating assignments of `str | None` into a list of `str`; this appeases mypy and clarifies the branch logic.
+- Gemini helper functions in `error_taxonomy.py` and `eval_topk.py` now construct `genai.types.Part.from_bytes(...)` directly and only cast the `client.models` attribute to `Any`, removing redundant casts that mypy flagged while keeping compatibility with the google-genai stubs.
+- The Streamlit dashboard’s `sidebar_path_picker` docstring now starts with an imperative verb (“Select…”) matching Ruff D401 requirements.
+- The taxonomy classifier now shares the same prompt string but routes missing-image cases through explicit OpenAI/Gemini fallbacks, improving error messaging and making it simple to reason about when a multimodal call will actually occur.
+- Top-K evaluation continues to record Langfuse scores when available, but safer casting ensures those writes degrade gracefully if Langfuse credentials are absent.
+
+## Static Analysis & Tooling Hygiene
+- Added module docstring to `langfuse_integration/client.py`, docstrings to `DatasetLoaderConfig`/`DatasetConfig`, and removed blank lines per Ruff D1xx/D2xx suggestions.
+- Updated typing imports (e.g., using `collections.abc.Callable`, `TypedDict`, `Protocol`) to make mypy happy under `from __future__ import annotations`.
+- Verified all changes with `UV_CACHE_DIR=/tmp/uv-cache uv run ruff check ...` and `... uv run mypy`, ensuring the pre-commit hooks that originally failed now succeed locally.
+- Leveraged Ruff’s PLR checks as a forcing function to split logic-heavy helpers; the resulting structure also simplifies future unit test authoring because each helper has a single responsibility.
+- Documented the new behavior in `updates.md` so future reviewers can see at a glance why typing and linting changes were necessary (e.g., compatibility with google-genai release cadence).

From c622f5d3da11296b31537bddbb49bea1293b1a95 Mon Sep 17 00:00:00 2001
From: Aravind N <aravindn1308@outlook.com>
Date: Wed, 13 May 2026 13:15:02 -0400
Subject: [PATCH 08/15] chore: gitignore run artifacts (output/, meps/, logs/)

---
 .gitignore | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/.gitignore b/.gitignore
index c3955d2..e2558cb 100644
--- a/.gitignore
+++ b/.gitignore
@@ -44,3 +44,11 @@ logs/
 # Bash and SLURM scripts
 *.slrm
 *.backup
+
+# Run artifacts
+output/
+meps/
+logs/
+
+# Editor copies
+*copy*.ipynb

From e780cd3e6973d187ad57f6a4a5b14d1ac17b9306 Mon Sep 17 00:00:00 2001
From: Aravind N <aravindn1308@outlook.com>
Date: Thu, 11 Jun 2026 15:28:27 -0400
Subject: [PATCH 09/15] feat: enhance OpenAI compatibility and integrate vLLM
 support

- Added support for local OpenAI-compatible endpoints, allowing the use of vLLM for Qwen models.
- Refactored LLM initialization across agents to centralize API key and base URL handling.
- Updated various tools to utilize the new OpenAI compatibility functions, ensuring seamless integration with local servers.
- Improved JSON parsing to handle Qwen-specific output formats, including thinking blocks and markdown fences.
- Added unit tests for strict JSON extraction from LLM outputs to ensure robustness.
---
 .gitignore                                    |    1 +
 baselines/run_zeroshot.py                     |   26 +-
 pyproject.toml                                |    3 +
 src/agentfinvqa/agents/planner_agent.py       |   45 +-
 src/agentfinvqa/agents/verifier_agent.py      |   25 +-
 src/agentfinvqa/agents/vision_agent.py        |   54 +-
 src/agentfinvqa/mep/schema.py                 |    2 +-
 src/agentfinvqa/runner/run_generate_meps.py   |  121 +-
 src/agentfinvqa/tools/color_area_tool.py      |    4 +-
 src/agentfinvqa/tools/legend_grounder_tool.py |   10 +-
 src/agentfinvqa/tools/ocr_reader_tool.py      |   10 +-
 src/agentfinvqa/tools/verifier_tool.py        |   10 +-
 src/agentfinvqa/tools/vision_qa_tool.py       |   10 +-
 src/agentfinvqa/utils/json_strict.py          |  109 +-
 src/agentfinvqa/utils/openai_compat.py        |  110 +
 tests/agentfinvqa/test_json_strict.py         |   75 +
 tests/agentfinvqa/test_model_compat.py        |   16 +
 tests/agentfinvqa/test_openai_compat.py       |   87 +
 uv.lock                                       | 1908 ++++++++++++++++-
 19 files changed, 2405 insertions(+), 221 deletions(-)
 create mode 100644 src/agentfinvqa/utils/openai_compat.py
 create mode 100644 tests/agentfinvqa/test_json_strict.py
 create mode 100644 tests/agentfinvqa/test_model_compat.py
 create mode 100644 tests/agentfinvqa/test_openai_compat.py

diff --git a/.gitignore b/.gitignore
index e2558cb..1c86e1a 100644
--- a/.gitignore
+++ b/.gitignore
@@ -52,3 +52,4 @@ logs/
 
 # Editor copies
 *copy*.ipynb
+vllm_endpoint.txt
diff --git a/baselines/run_zeroshot.py b/baselines/run_zeroshot.py
index aa3b66b..0dd40a8 100644
--- a/baselines/run_zeroshot.py
+++ b/baselines/run_zeroshot.py
@@ -121,11 +121,11 @@ def _encode_image(image_path: str) -> tuple[str, str]:
     return b64, mime
 
 
-def _call_openai(model: str, prompt: str, image_path: str) -> tuple[str, float]:
-    from openai import OpenAI  # noqa: PLC0415
+def _call_openai(model: str, prompt: str, image_path: str, api_base: str = "") -> tuple[str, float]:
     from agentfinvqa.utils.model_compat import openai_temperature  # noqa: PLC0415
+    from agentfinvqa.utils.openai_compat import build_openai_client, qwen35_extra_body  # noqa: PLC0415
 
-    client = OpenAI(api_key=os.environ.get("OPENAI_API_KEY", ""))
+    client = build_openai_client(api_key=os.environ.get("OPENAI_API_KEY", ""), api_base=api_base)
     b64, mime = _encode_image(image_path)
     t0 = time.time()
     response = client.chat.completions.create(
@@ -140,6 +140,7 @@ def _call_openai(model: str, prompt: str, image_path: str) -> tuple[str, float]:
             }
         ],
         max_completion_tokens=1024,
+        extra_body=qwen35_extra_body(model),  # disables thinking on Qwen3.x; no-op otherwise
         **openai_temperature(model),
     )
     latency = time.time() - t0
@@ -222,6 +223,7 @@ def _run_sample(
     model: str,
     config_name: str,
     prompt_style: str = "structured",
+    api_base: str = "",
 ) -> dict:
     prompt = _build_prompt(sample, prompt_style)
     raw_text = ""
@@ -230,7 +232,7 @@ def _run_sample(
 
     try:
         if backend == "openai":
-            raw_text, latency = _call_openai(model, prompt, sample.image_path)
+            raw_text, latency = _call_openai(model, prompt, sample.image_path, api_base=api_base)
         else:
             raw_text, latency = _call_gemini(model, prompt, sample.image_path)
     except Exception as exc:
@@ -298,11 +300,22 @@ def main() -> None:  # noqa: PLR0915
         choices=["structured", "minimal"],
         help="structured: rules + JSON output (default); minimal: bare question only",
     )
+    parser.add_argument(
+        "--api_base",
+        default="",
+        help=(
+            "OpenAI-compatible base URL (e.g. local vLLM endpoint). When set with "
+            "--backend openai, routes calls to this server instead of api.openai.com. "
+            "Falls back to OPENAI_BASE_URL env var when blank."
+        ),
+    )
     args = parser.parse_args()
 
     ds_cfg = DATASET_CONFIGS[args.dataset]
     image_dir = args.image_dir or ds_cfg["default_image_dir"]
-    model_slug = args.model.replace("-", "_").replace(".", "_")
+    # Slugify the model name for filenames — replace separators that can't appear
+    # in filenames (`/` is the killer for HF org/name pairs like Qwen/Qwen3.6-...).
+    model_slug = args.model.replace("-", "_").replace(".", "_").replace("/", "_")
     config_name = f"zeroshot_{args.prompt_style}_{args.backend}_{model_slug}"
 
     out_dir = Path(args.out)
@@ -340,7 +353,8 @@ def main() -> None:  # noqa: PLR0915
     mode = "a" if args.resume else "w"
     with open(out_file, mode) as f_out, ThreadPoolExecutor(max_workers=args.workers) as pool:
         futures = {
-            pool.submit(_run_sample, s, args.backend, args.model, config_name, args.prompt_style): s for s in todo
+            pool.submit(_run_sample, s, args.backend, args.model, config_name, args.prompt_style, args.api_base): s
+            for s in todo
         }
         for future in as_completed(futures):
             try:
diff --git a/pyproject.toml b/pyproject.toml
index 6f448ba..172280b 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -27,6 +27,9 @@ dependencies = [
     "seaborn>=0.13.2",
     "mypy>=1.19.1",
     "pytest>=9.0.2",
+    "vllm>=0.14.0",
+    "qwen-vl-utils==0.0.14",
+    "litellm>=1.84.0",
 ]
 
 [build-system]
diff --git a/src/agentfinvqa/agents/planner_agent.py b/src/agentfinvqa/agents/planner_agent.py
index 4a4a24b..3f96e88 100644
--- a/src/agentfinvqa/agents/planner_agent.py
+++ b/src/agentfinvqa/agents/planner_agent.py
@@ -4,16 +4,15 @@
 that the VisionAgent will follow.
 """
 
-import os
 from pathlib import Path
 from typing import Any, Optional, Tuple
 
-from crewai import LLM, Agent, Crew, Task
+from crewai import Agent, Crew, Task
 
 from ..datasets.perceived_sample import PerceivedSample
 from ..langfuse_integration.tracing import close_span, open_llm_span
 from ..utils.json_strict import parse_strict
-from ..utils.model_compat import openai_temperature
+from ..utils.openai_compat import build_crewai_llm
 
 
 PLANNER_PROMPT_PATH = Path(__file__).parent / "prompts" / "planner.txt"
@@ -74,39 +73,6 @@ def build_planner_prompt(sample: PerceivedSample) -> str:
     )
 
 
-def _build_llm(backend: str, model: str, api_key: Optional[str]) -> LLM:
-    """
-    Configure the model interface for the planner.
-
-    Parameters
-    ----------
-    backend : {'openai', 'gemini'}
-        The language model provider.
-    model : str
-        The specific model name.
-    api_key : str, optional
-        Key for accessing the model.
-
-    Returns
-    -------
-    LLM
-        The initialized model controller.
-    """
-    if backend == "openai":
-        return LLM(
-            model=model,
-            api_key=api_key or os.environ.get("OPENAI_API_KEY", ""),
-            **openai_temperature(model),
-        )
-    if backend == "gemini":
-        return LLM(
-            model=f"gemini/{model}",
-            api_key=api_key or os.environ.get("GEMINI_API_KEY", ""),
-            temperature=0,
-        )
-    raise ValueError(f"Unknown planner backend: {backend!r}")
-
-
 class PlannerAgent:
     """
     An agent responsible for deriving a logical inspection strategy.
@@ -120,6 +86,7 @@ def __init__(
         backend: str = "gemini",
         model: str = "gemini-2.5-flash-lite",
         api_key: Optional[str] = None,
+        api_base: Optional[str] = None,
     ):
         """
         Initialize the planner with the desired backend and model.
@@ -132,11 +99,15 @@ def __init__(
             The model name.
         api_key : str, optional
             API key for the provider.
+        api_base : str, optional
+            OpenAI-compatible base URL (e.g. local vLLM serving Qwen2.5-VL).
+            Only honoured when ``backend == "openai"``.
         """
         self.backend = backend
         self.model = model
         self.api_key = api_key
-        self._llm = _build_llm(backend, model, api_key)
+        self.api_base = api_base
+        self._llm = build_crewai_llm(backend, model, api_key, api_base)
 
     def run(self, sample: PerceivedSample, lf_trace: Any = None) -> Tuple[str, dict, bool, str]:
         """
diff --git a/src/agentfinvqa/agents/verifier_agent.py b/src/agentfinvqa/agents/verifier_agent.py
index f7393d5..13c02e0 100644
--- a/src/agentfinvqa/agents/verifier_agent.py
+++ b/src/agentfinvqa/agents/verifier_agent.py
@@ -11,7 +11,7 @@
 import os
 from typing import Any, Optional, Tuple
 
-from crewai import LLM, Agent, Crew, Task
+from crewai import Agent, Crew, Task
 
 from ..agents.vision_agent import _is_multi_select
 from ..langfuse_integration.tracing import close_span, open_llm_span
@@ -21,28 +21,12 @@
     format_source_sentences_block,
 )
 from ..utils.json_strict import parse_strict
-from ..utils.model_compat import openai_temperature
+from ..utils.openai_compat import build_crewai_llm
 
 
 VERIFIER_REQUIRED_KEYS = ["verdict", "answer", "reasoning"]
 
 
-def _build_llm(backend: str, model: str, api_key: Optional[str]) -> LLM:
-    if backend == "openai":
-        return LLM(
-            model=model,
-            api_key=api_key or os.environ.get("OPENAI_API_KEY", ""),
-            **openai_temperature(model),
-        )
-    if backend == "gemini":
-        return LLM(
-            model=f"gemini/{model}",
-            api_key=api_key or os.environ.get("GEMINI_API_KEY", ""),
-            temperature=0,
-        )
-    raise ValueError(f"Unknown verifier backend: {backend!r}")
-
-
 class VerifierAgent:
     """
     A validation agent that critiques draft answers against visual evidence.
@@ -56,10 +40,12 @@ def __init__(
         backend: str = "gemini",
         model: str = "gemini-2.5-flash-lite",
         api_key: Optional[str] = None,
+        api_base: Optional[str] = None,
     ):
         self.backend = backend
         self.model = model
         self.api_key = api_key
+        self.api_base = api_base
 
     def _build_tool(self, lf_trace: Any = None) -> VerifierTool:
         key = self.api_key or (
@@ -69,6 +55,7 @@ def _build_tool(self, lf_trace: Any = None) -> VerifierTool:
             backend=self.backend,
             model=self.model,
             api_key=key,
+            api_base=self.api_base or "",
             lf_trace=lf_trace,
         )
 
@@ -182,7 +169,7 @@ def run(
         )
 
         tool = self._build_tool(lf_trace=lf_trace)
-        llm = _build_llm(self.backend, self.model, self.api_key)
+        llm = build_crewai_llm(self.backend, self.model, self.api_key, self.api_base)
 
         verifier_span = open_llm_span(
             lf_trace,
diff --git a/src/agentfinvqa/agents/vision_agent.py b/src/agentfinvqa/agents/vision_agent.py
index 2bd5ecc..cbb07fb 100644
--- a/src/agentfinvqa/agents/vision_agent.py
+++ b/src/agentfinvqa/agents/vision_agent.py
@@ -8,7 +8,7 @@
 from pathlib import Path
 from typing import Any, List, Optional, Tuple
 
-from crewai import LLM, Agent, Crew, Task
+from crewai import Agent, Crew, Task
 
 from ..datasets.perceived_sample import PerceivedSample
 from ..langfuse_integration.tracing import close_span, open_llm_span
@@ -16,7 +16,7 @@
 from ..tools.color_area_tool import format_color_area_block_for_vision
 from ..tools.vision_qa_tool import VisionQATool
 from ..utils.json_strict import parse_strict
-from ..utils.model_compat import openai_temperature
+from ..utils.openai_compat import build_crewai_llm
 
 
 VISION_PROMPT_PATH = Path(__file__).parent / "prompts" / "vision.txt"
@@ -240,44 +240,6 @@ def build_vision_task_description(
     return rendered
 
 
-def _build_llm(backend: str, model: str, api_key: Optional[str]) -> LLM:
-    """
-    Configure a CrewAI LLM instance based on the chosen provider.
-
-    Parameters
-    ----------
-    backend : {'openai', 'gemini'}
-        The model provider.
-    model : str
-        The specific model identifier (e.g., 'gpt-4o').
-    api_key : str, optional
-        The API key to use. Defaults to provider-specific env variables.
-
-    Returns
-    -------
-    LLM
-        The initialized model interface.
-
-    Raises
-    ------
-    ValueError
-        If an unsupported `backend` is specified.
-    """
-    if backend == "openai":
-        return LLM(
-            model=model,
-            api_key=api_key or os.environ.get("OPENAI_API_KEY", ""),
-            **openai_temperature(model),
-        )
-    if backend == "gemini":
-        return LLM(
-            model=f"gemini/{model}",
-            api_key=api_key or os.environ.get("GEMINI_API_KEY", ""),
-            temperature=0,
-        )
-    raise ValueError(f"Unknown vision agent backend: {backend!r}")
-
-
 class VisionAgent:
     """
     An agent that performs visual analysis using a tool-based architecture.
@@ -296,6 +258,8 @@ def __init__(
         vision_model: str = "gemini-2.5-flash-lite",
         agent_api_key: Optional[str] = None,
         vision_api_key: Optional[str] = None,
+        agent_api_base: Optional[str] = None,
+        vision_api_base: Optional[str] = None,
     ):
         """
         Set up the vision agent with its orchestration and vision backends.
@@ -314,6 +278,11 @@ def __init__(
             API key for the orchestrator.
         vision_api_key : str, optional
             API key for the vision tool.
+        agent_api_base : str, optional
+            OpenAI-compatible base URL for the orchestrator
+            (e.g. vLLM-served Qwen2.5-VL).
+        vision_api_base : str, optional
+            OpenAI-compatible base URL for the vision tool.
         """
         self.agent_backend = agent_backend
         self.agent_model = agent_model
@@ -321,6 +290,8 @@ def __init__(
         self.vision_model = vision_model
         self.agent_api_key = agent_api_key
         self.vision_api_key = vision_api_key
+        self.agent_api_base = agent_api_base
+        self.vision_api_base = vision_api_base
 
     def _build_tool(self, lf_trace: Any = None) -> VisionQATool:
         """
@@ -345,6 +316,7 @@ def _build_tool(self, lf_trace: Any = None) -> VisionQATool:
             backend=self.vision_backend,
             model=self.vision_model,
             api_key=key,
+            api_base=self.vision_api_base or "",
             lf_trace=lf_trace,
         )
 
@@ -395,7 +367,7 @@ def run(
             A log of tool interactions during the run.
         """
         tool = self._build_tool(lf_trace=lf_trace)
-        llm = _build_llm(self.agent_backend, self.agent_model, self.agent_api_key)
+        llm = build_crewai_llm(self.agent_backend, self.agent_model, self.agent_api_key, self.agent_api_base)
         task_description = build_vision_task_description(
             sample,
             plan,
diff --git a/src/agentfinvqa/mep/schema.py b/src/agentfinvqa/mep/schema.py
index 7066f3e..dc39692 100644
--- a/src/agentfinvqa/mep/schema.py
+++ b/src/agentfinvqa/mep/schema.py
@@ -139,7 +139,7 @@ class MEPLegendGrounding:
 
 @dataclass
 class MEPColorArea:
-    """Trace of the color-area measurement stage inserted between legend grounding and vision.
+    """Trace of the color-area measurement stage between legend grounding and vision.
 
     Captures whether the stage was triggered, the per-label pixel-area breakdown,
     the dominant label, and confidence/ambiguity flags.
diff --git a/src/agentfinvqa/runner/run_generate_meps.py b/src/agentfinvqa/runner/run_generate_meps.py
index 627d602..b7b8607 100644
--- a/src/agentfinvqa/runner/run_generate_meps.py
+++ b/src/agentfinvqa/runner/run_generate_meps.py
@@ -12,7 +12,6 @@
 
 import argparse
 import contextlib
-import json
 import traceback
 import uuid
 from concurrent.futures import ThreadPoolExecutor, as_completed
@@ -29,7 +28,6 @@
 from ..datasets.finmme_loader import load_finmme
 from ..datasets.perceived_sample import PerceivedSample
 from ..langfuse_integration.client import get_client
-from ..langfuse_integration.dataset import register_dataset
 from ..langfuse_integration.prompts import push_prompts
 from ..langfuse_integration.tracing import (
     log_trace_scores,
@@ -112,6 +110,53 @@
         "vision_model": "gpt-4o",
         "judge_backend": "gemini",
     },
+    # Open-source: Qwen2.5-VL served via a local vLLM OpenAI-compatible endpoint.
+    # vLLM speaks OpenAI's chat-completions dialect, so the "openai" tool/agent
+    # path can be reused verbatim — only `api_base` needs to point at the vLLM
+    # server (default: http://localhost:8000/v1; override at the CLI with
+    # `--api_base` or via the OPENAI_BASE_URL env var). Judge remains Gemini-Lite
+    # for fair-baseline consistency with the gemini_* presets.
+    "qwen_qwen": {
+        "planner_backend": "openai",
+        "planner_model": "Qwen/Qwen2.5-VL-32B-Instruct",
+        "vision_backend": "openai",
+        "vision_model": "Qwen/Qwen2.5-VL-32B-Instruct",
+        "judge_backend": "gemini",
+        "api_base": "http://localhost:8000/v1",
+    },
+    # Smaller Qwen variant for cheaper smoke-tests on a single A100-40G.
+    "qwen_qwen_7b": {
+        "planner_backend": "openai",
+        "planner_model": "Qwen/Qwen2.5-VL-7B-Instruct",
+        "vision_backend": "openai",
+        "vision_model": "Qwen/Qwen2.5-VL-7B-Instruct",
+        "judge_backend": "gemini",
+        "api_base": "http://localhost:8000/v1",
+    },
+    # Qwen3.5 dense 27B — newer generation with stronger chart benchmarks
+    # (CharXiv RQ ~79.5, MMMU 82.3). Requires vLLM nightly (main branch) +
+    # the `--reasoning-parser qwen3 --enable-auto-tool-choice
+    # --tool-call-parser qwen3_coder` flags (auto-applied by
+    # slurm_serve_qwen.slrm when MODEL contains "Qwen3.5"). Thinking mode is
+    # disabled per-request via the `qwen35_extra_body` helper.
+    "qwen35_27b": {
+        "planner_backend": "openai",
+        "planner_model": "Qwen/Qwen3.5-27B",
+        "vision_backend": "openai",
+        "vision_model": "Qwen/Qwen3.5-27B",
+        "judge_backend": "gemini",
+        "api_base": "http://localhost:8000/v1",
+    },
+    # Qwen3.6 dense 27B FP8 — official block-128 FP8 quant (~28 GB weights).
+    # Same vLLM flags as Qwen3.5; thinking disabled via `qwen35_extra_body`.
+    "qwen36_27b_fp8": {
+        "planner_backend": "openai",
+        "planner_model": "Qwen/Qwen3.6-27B-FP8",
+        "vision_backend": "openai",
+        "vision_model": "Qwen/Qwen3.6-27B-FP8",
+        "judge_backend": "gemini",
+        "api_base": "http://localhost:8000/v1",
+    },
 }
 
 DatasetLoader = Callable[..., list[PerceivedSample]]
@@ -740,11 +785,24 @@ def main() -> None:  # noqa: PLR0912, PLR0915
     parser.add_argument(
         "--resume", action="store_true", help="Skip samples that already have MEP JSONs in the output dir"
     )
+    parser.add_argument(
+        "--sample_ids_file",
+        default=None,
+        help="Path to a text file of sample_id lines (e.g. finmme_001250); run only these samples",
+    )
     parser.add_argument(
         "--ocr_model",
         default=None,
         help="Override OCR model (defaults to vision_model)",
     )
+    parser.add_argument(
+        "--api_base",
+        default=None,
+        help=(
+            "OpenAI-compatible base URL (e.g. local vLLM serving Qwen2.5-VL). "
+            "Overrides the preset's api_base; falls back to OPENAI_BASE_URL env var."
+        ),
+    )
     args = parser.parse_args()
 
     config = dict(BACKEND_CONFIGS[args.config])  # copy so we don't mutate the preset
@@ -752,6 +810,12 @@ def main() -> None:  # noqa: PLR0912, PLR0915
         config["planner_model"] = args.planner_model
     if args.vision_model:
         config["vision_model"] = args.vision_model
+    if args.api_base is not None:
+        config["api_base"] = args.api_base
+    # Single resolved value used to thread vLLM endpoint into every OpenAI-backed
+    # tool/agent. Empty string is the default ("use api.openai.com"); set on the
+    # `qwen_*` presets to point at the local vLLM server.
+    api_base: str = config.get("api_base", "") or ""
     run_id = str(uuid.uuid4())
     dataset_key = args.dataset.lower()
     ds_cfg = DATASET_CONFIGS[dataset_key]
@@ -778,15 +842,23 @@ def main() -> None:  # noqa: PLR0912, PLR0915
         image_dir=image_dir,
         cache_dir=args.cache_dir,
     )
+    if args.sample_ids_file:
+        allowed = {
+            line.strip()
+            for line in Path(args.sample_ids_file).read_text().splitlines()
+            if line.strip() and not line.strip().startswith("#")
+        }
+        before = len(samples)
+        samples = [s for s in samples if s.sample_id in allowed]
+        missing = allowed - {s.sample_id for s in samples}
+        print(f"Sample ID filter : {len(samples)}/{before} loaded from {args.sample_ids_file}")
+        if missing:
+            print(f"  warning: {len(missing)} ids in file not in split (first 5: {sorted(missing)[:5]})")
+        if not samples:
+            print("No samples left after --sample_ids_file filter; exiting.")
+            return
     if args.resume:
-        existing_ids: set[str] = set()
-        for p in Path(out_dir).glob("*.json"):
-            try:
-                data = json.loads(p.read_text())
-                sid = data.get("sample", {}).get("sample_id") or p.stem
-            except Exception:
-                sid = p.stem
-            existing_ids.add(sid)
+        existing_ids: set[str] = {p.stem for p in Path(out_dir).glob("*.json")}
         before = len(samples)
         samples = [s for s in samples if s.sample_id not in existing_ids]
         skipped = before - len(samples)
@@ -807,24 +879,39 @@ def main() -> None:  # noqa: PLR0912, PLR0915
         lf_client = get_client()
         if lf_client:
             print("Langfuse         : enabled")
-            register_dataset(samples, dataset_name=dataset_name, split=args.split)
             push_prompts()
         else:
             print("Langfuse         : not configured (set LANGFUSE_PUBLIC_KEY + LANGFUSE_SECRET_KEY to enable)")
 
     # Build agents once — run() creates fresh Crew/Tool per call so this is thread-safe
     print("Initialising agents …")
-    planner = PlannerAgent(backend=config["planner_backend"], model=config["planner_model"])
+    # api_base only applies to "openai"-backed stages (vLLM speaks OpenAI dialect);
+    # gemini-backed stages ignore it.
+    planner_api_base = api_base if config["planner_backend"] == "openai" else ""
+    vision_api_base = api_base if config["vision_backend"] == "openai" else ""
+    if api_base:
+        print(f"OpenAI base URL  : {api_base}")
+    planner = PlannerAgent(
+        backend=config["planner_backend"],
+        model=config["planner_model"],
+        api_base=planner_api_base or None,
+    )
     vision_agent = VisionAgent(
         agent_backend=config["planner_backend"],
         agent_model=config["planner_model"],
         vision_backend=config["vision_backend"],
         vision_model=config["vision_model"],
+        agent_api_base=planner_api_base or None,
+        vision_api_base=vision_api_base or None,
     )
     verifier: Optional[VerifierAgent] = None
     if not args.no_verifier:
         verifier_model = args.verifier_model or config["vision_model"]
-        verifier = VerifierAgent(backend=config["vision_backend"], model=verifier_model)
+        verifier = VerifierAgent(
+            backend=config["vision_backend"],
+            model=verifier_model,
+            api_base=vision_api_base or None,
+        )
         print(f"Verifier         : enabled ({config['vision_backend']} / {verifier_model})")
     else:
         print("Verifier         : disabled (--no_verifier)")
@@ -832,7 +919,7 @@ def main() -> None:  # noqa: PLR0912, PLR0915
     ocr: Optional[OcrReaderTool] = None
     if not args.no_ocr:
         ocr_model = args.ocr_model or config["vision_model"]
-        ocr = OcrReaderTool(backend=config["vision_backend"], model=ocr_model)
+        ocr = OcrReaderTool(backend=config["vision_backend"], model=ocr_model, api_base=vision_api_base)
         print(f"OCR pre-reader   : enabled ({config['vision_backend']} / {ocr_model})")
     else:
         print("OCR pre-reader   : disabled (--no_ocr)")
@@ -840,7 +927,7 @@ def main() -> None:  # noqa: PLR0912, PLR0915
     legend_grounder: Optional[LegendGrounderTool] = None
     if not args.no_ocr and not args.no_legend_grounding:
         lg_model = args.ocr_model or config["vision_model"]
-        legend_grounder = LegendGrounderTool(backend=config["vision_backend"], model=lg_model)
+        legend_grounder = LegendGrounderTool(backend=config["vision_backend"], model=lg_model, api_base=vision_api_base)
         print(f"Legend grounder  : enabled ({config['vision_backend']} / {lg_model})")
     else:
         reason = "--no_ocr" if args.no_ocr else "--no_legend_grounding"
@@ -890,9 +977,9 @@ def main() -> None:  # noqa: PLR0912, PLR0915
                 s = future_to_sample[future]
                 try:
                     path = future.result()
-                    print(f"[{done}/{len(samples)}] {s.sample_id} → {path}")
+                    print(f"[{done}/{len(samples)}] {s.sample_id} → {path}", flush=True)
                 except Exception as exc:
-                    print(f"[{done}/{len(samples)}] {s.sample_id} ERROR: {exc}")
+                    print(f"[{done}/{len(samples)}] {s.sample_id} ERROR: {exc}", flush=True)
 
     print(f"\nDone. MEPs written to: {out_dir}")
 
diff --git a/src/agentfinvqa/tools/color_area_tool.py b/src/agentfinvqa/tools/color_area_tool.py
index d9a99c7..5a2aa09 100644
--- a/src/agentfinvqa/tools/color_area_tool.py
+++ b/src/agentfinvqa/tools/color_area_tool.py
@@ -149,9 +149,7 @@ def color_area_tool(image_path: str, legend_map: list) -> dict:
             "total_pixels_matched": 0,
         }
 
-    breakdown = {
-        label: round(cnt / total_matched * 100, 1) for label, cnt in counts.items()
-    }
+    breakdown = {label: round(cnt / total_matched * 100, 1) for label, cnt in counts.items()}
     # Sort descending by percentage
     breakdown = dict(sorted(breakdown.items(), key=lambda x: x[1], reverse=True))
 
diff --git a/src/agentfinvqa/tools/legend_grounder_tool.py b/src/agentfinvqa/tools/legend_grounder_tool.py
index d18355b..5d812e5 100644
--- a/src/agentfinvqa/tools/legend_grounder_tool.py
+++ b/src/agentfinvqa/tools/legend_grounder_tool.py
@@ -15,11 +15,12 @@
 
 from crewai.tools import BaseTool
 from google import genai
-from openai import OpenAI
+from openai import OpenAI  # noqa: F401 — re-exported for backwards-compat / type hints
 from pydantic import BaseModel, Field, PrivateAttr
 
 from ..langfuse_integration.tracing import close_span, open_llm_span
 from ..utils.model_compat import openai_temperature
+from ..utils.openai_compat import build_openai_client, qwen35_extra_body
 
 
 _LEGEND_GROUNDER_PROMPT_TEMPLATE = """\
@@ -74,6 +75,10 @@ class LegendGrounderTool(BaseTool):
     backend: str = "gemini"
     model: str = "gemini-2.5-flash-lite"
     api_key: str = ""
+    # Optional OpenAI-compatible endpoint (e.g. local vLLM serving Qwen2.5-VL).
+    # When set together with backend="openai", the OpenAI client is pointed here
+    # instead of api.openai.com. Falls back to OPENAI_BASE_URL env var.
+    api_base: str = ""
     lf_trace: Optional[Any] = None
 
     _traces: list = PrivateAttr(default_factory=list)
@@ -175,7 +180,7 @@ def _encode_image(self, image_path: str) -> tuple:
     # ------------------------------------------------------------------
 
     def _call_openai(self, image_path: str, prompt: str) -> tuple:
-        client = OpenAI(api_key=self.api_key or os.environ.get("OPENAI_API_KEY", ""))
+        client = build_openai_client(self.api_key, self.api_base)
         b64, mime = self._encode_image(image_path)
 
         response = client.chat.completions.create(
@@ -193,6 +198,7 @@ def _call_openai(self, image_path: str, prompt: str) -> tuple:
                 }
             ],
             max_completion_tokens=512,
+            extra_body=qwen35_extra_body(self.model),
             **openai_temperature(self.model),
         )
 
diff --git a/src/agentfinvqa/tools/ocr_reader_tool.py b/src/agentfinvqa/tools/ocr_reader_tool.py
index 095a938..8a64a24 100644
--- a/src/agentfinvqa/tools/ocr_reader_tool.py
+++ b/src/agentfinvqa/tools/ocr_reader_tool.py
@@ -15,11 +15,12 @@
 
 from crewai.tools import BaseTool
 from google import genai
-from openai import OpenAI
+from openai import OpenAI  # noqa: F401 — re-exported for backwards-compat / type hints
 from pydantic import BaseModel, Field, PrivateAttr
 
 from ..langfuse_integration.tracing import close_span, open_llm_span
 from ..utils.model_compat import openai_temperature
+from ..utils.openai_compat import build_openai_client, qwen35_extra_body
 
 
 _OCR_PROMPT = """\
@@ -78,6 +79,10 @@ class OcrReaderTool(BaseTool):
     backend: str = "gemini"
     model: str = "gemini-2.5-flash-lite"
     api_key: str = ""
+    # Optional OpenAI-compatible endpoint (e.g. local vLLM serving Qwen2.5-VL).
+    # When set together with backend="openai", the OpenAI client is pointed here
+    # instead of api.openai.com. Falls back to OPENAI_BASE_URL env var.
+    api_base: str = ""
     lf_trace: Optional[Any] = None
 
     _traces: list = PrivateAttr(default_factory=list)
@@ -218,7 +223,7 @@ def _call_openai(self, image_path: str) -> tuple:
         provider_meta : dict
             API metadata.
         """
-        client = OpenAI(api_key=self.api_key or os.environ.get("OPENAI_API_KEY", ""))
+        client = build_openai_client(self.api_key, self.api_base)
         b64, mime = self._encode_image(image_path)
 
         response = client.chat.completions.create(
@@ -236,6 +241,7 @@ def _call_openai(self, image_path: str) -> tuple:
                 }
             ],
             max_completion_tokens=512,
+            extra_body=qwen35_extra_body(self.model),
             **openai_temperature(self.model),
         )
 
diff --git a/src/agentfinvqa/tools/verifier_tool.py b/src/agentfinvqa/tools/verifier_tool.py
index 11580d7..788dbde 100644
--- a/src/agentfinvqa/tools/verifier_tool.py
+++ b/src/agentfinvqa/tools/verifier_tool.py
@@ -15,11 +15,12 @@
 
 from crewai.tools import BaseTool
 from google import genai
-from openai import OpenAI
+from openai import OpenAI  # noqa: F401 — re-exported for backwards-compat / type hints
 from pydantic import BaseModel, Field, PrivateAttr
 
 from ..langfuse_integration.tracing import close_span, open_llm_span
 from ..utils.model_compat import openai_temperature
+from ..utils.openai_compat import build_openai_client, qwen35_extra_body
 
 
 def format_ambiguity_block(
@@ -233,6 +234,10 @@ class VerifierTool(BaseTool):
     backend: str = "gemini"
     model: str = "gemini-2.5-flash-lite"
     api_key: str = ""
+    # Optional OpenAI-compatible endpoint (e.g. local vLLM serving Qwen2.5-VL).
+    # When set together with backend="openai", the OpenAI client is pointed here
+    # instead of api.openai.com. Falls back to OPENAI_BASE_URL env var.
+    api_base: str = ""
     lf_trace: Optional[Any] = None
 
     _traces: list = PrivateAttr(default_factory=list)
@@ -358,7 +363,7 @@ def _encode_image(self, image_path: str) -> tuple:
         return b64, mime
 
     def _call_openai(self, prompt: str, image_path: str) -> tuple:
-        client = OpenAI(api_key=self.api_key or os.environ.get("OPENAI_API_KEY", ""))
+        client = build_openai_client(self.api_key, self.api_base)
         b64, mime = self._encode_image(image_path)
         response = client.chat.completions.create(
             model=self.model,
@@ -372,6 +377,7 @@ def _call_openai(self, prompt: str, image_path: str) -> tuple:
                 }
             ],
             max_completion_tokens=2048,
+            extra_body=qwen35_extra_body(self.model),
             **openai_temperature(self.model),
         )
         raw_text = response.choices[0].message.content or ""
diff --git a/src/agentfinvqa/tools/vision_qa_tool.py b/src/agentfinvqa/tools/vision_qa_tool.py
index b97fc30..20c9670 100644
--- a/src/agentfinvqa/tools/vision_qa_tool.py
+++ b/src/agentfinvqa/tools/vision_qa_tool.py
@@ -15,11 +15,12 @@
 
 from crewai.tools import BaseTool
 from google import genai
-from openai import OpenAI
+from openai import OpenAI  # noqa: F401 — re-exported for backwards-compat / type hints
 from pydantic import BaseModel, Field, PrivateAttr
 
 from ..langfuse_integration.tracing import close_span, open_llm_span
 from ..utils.model_compat import openai_temperature
+from ..utils.openai_compat import build_openai_client, qwen35_extra_body
 
 
 class VisionQAInput(BaseModel):
@@ -50,6 +51,10 @@ class VisionQATool(BaseTool):
     backend: str = "gemini"  # "openai" | "gemini"
     model: str = "gemini-2.5-flash-lite"
     api_key: str = ""
+    # Optional OpenAI-compatible endpoint (e.g. local vLLM serving Qwen2.5-VL).
+    # When set together with backend="openai", the OpenAI client is pointed here
+    # instead of api.openai.com. Falls back to OPENAI_BASE_URL env var.
+    api_base: str = ""
     lf_trace: Optional[Any] = None  # Langfuse Trace object for span creation
 
     # Private mutable trace storage (not a Pydantic field)
@@ -310,7 +315,7 @@ def _call_openai(
         provider_meta : dict
             Metadata including usage and request ID.
         """
-        client = OpenAI(api_key=self.api_key or os.environ.get("OPENAI_API_KEY", ""))
+        client = build_openai_client(self.api_key, self.api_base)
         prompt = self._build_prompt(question, plan_steps, choices, context, multi_select)
         b64, mime = self._encode_image(image_path)
 
@@ -329,6 +334,7 @@ def _call_openai(
                 }
             ],
             max_completion_tokens=2048,
+            extra_body=qwen35_extra_body(self.model),  # disables thinking on Qwen3.5 only
             **openai_temperature(self.model),
         )
 
diff --git a/src/agentfinvqa/utils/json_strict.py b/src/agentfinvqa/utils/json_strict.py
index 517488d..db226cf 100644
--- a/src/agentfinvqa/utils/json_strict.py
+++ b/src/agentfinvqa/utils/json_strict.py
@@ -7,6 +7,74 @@
 from json_repair import repair_json
 
 
+# Qwen3.x thinking blocks (vLLM reasoning parser / chat template variants).
+_LT, _GT = chr(60), chr(62)
+_THINKING_BLOCK_RE = re.compile(
+    r"(?s)\s*(?:"
+    + _LT
+    + r"think"
+    + _GT
+    + r".*?"
+    + _LT
+    + r"/think"
+    + _GT
+    + r"|"
+    + _LT
+    + r"redacted_thinking"
+    + _GT
+    + r".*?"
+    + _LT
+    + r"/redacted_thinking"
+    + _GT
+    + r")\s*",
+    re.IGNORECASE,
+)
+
+
+def _strip_thinking_blocks(text: str) -> str:
+    return _THINKING_BLOCK_RE.sub("", text).strip()
+
+
+def _strip_markdown_fences(text: str) -> str:
+    text = re.sub(r"^```(?:json)?\s*", "", text)
+    text = re.sub(r"\s*```$", "", text)
+    return text.strip()
+
+
+def _extract_last_json_object(text: str) -> Optional[str]:
+    """Return the longest top-level JSON object substring in *text*, if any.
+
+    Qwen3.x Crew agents often emit chain-of-thought, draft JSON fragments, then a
+    final JSON answer. Taking the *last* ``{`` can yield a nested fragment; the
+    longest valid top-level object is usually the intended payload.
+    """
+    decoder = json.JSONDecoder()
+    best: Optional[str] = None
+    best_len = 0
+    for i, ch in enumerate(text):
+        if ch != "{":
+            continue
+        candidate = text[i:]
+        try:
+            obj, end = decoder.raw_decode(candidate)
+            if isinstance(obj, dict) and end > best_len:
+                best = candidate[:end]
+                best_len = end
+        except json.JSONDecodeError:
+            continue
+    return best
+
+
+def _prepare_json_text(text: str) -> str:
+    text = _strip_thinking_blocks(text)
+    text = _strip_markdown_fences(text)
+    if not text.lstrip().startswith("{"):
+        extracted = _extract_last_json_object(text)
+        if extracted:
+            text = extracted
+    return text.strip()
+
+
 def parse_strict(
     text: str,
     required_keys: Optional[list[str]] = None,
@@ -14,7 +82,8 @@ def parse_strict(
     """
     Parse JSON data from a string with automatic cleanup and repair.
 
-    Handles markdown fences and extracts the first JSON block found.
+    Handles markdown fences, Qwen thinking blocks, and CoT preambles before the
+    final JSON object.
 
     Parameters
     ----------
@@ -30,12 +99,7 @@ def parse_strict(
     parse_ok : bool
         True if the JSON was valid without needing structural repairs.
     """
-    text = text.strip()
-
-    # Strip markdown code fences if present
-    text = re.sub(r"^```(?:json)?\s*", "", text)
-    text = re.sub(r"\s*```$", "", text)
-    text = text.strip()
+    text = _prepare_json_text(text)
 
     # 1. Direct parse
     try:
@@ -46,7 +110,17 @@ def parse_strict(
     except (json.JSONDecodeError, ValueError):
         pass
 
-    # 2. Extract first JSON block from surrounding text
+    # 2. Last JSON object (handles CoT + draft JSON + final JSON)
+    extracted = _extract_last_json_object(text)
+    if extracted and extracted != text:
+        try:
+            result = json.loads(extracted)
+            if _check_keys(result, required_keys):
+                return result, True
+        except (json.JSONDecodeError, ValueError):
+            pass
+
+    # 3. First JSON block (legacy path)
     match = re.search(r"\{.*\}", text, re.DOTALL)
     if match:
         try:
@@ -56,14 +130,17 @@ def parse_strict(
         except (json.JSONDecodeError, ValueError):
             pass
 
-    # 3. Repair fallback
-    try:
-        repaired = repair_json(text)
-        result = json.loads(repaired)
-        if _check_keys(result, required_keys):
-            return result, False  # parse_ok=False: needed repair
-    except Exception:
-        pass
+    # 4. Repair fallback
+    for candidate in (extracted, text):
+        if not candidate:
+            continue
+        try:
+            repaired = repair_json(candidate)
+            result = json.loads(repaired)
+            if _check_keys(result, required_keys):
+                return result, False  # parse_ok=False: needed repair
+        except Exception:
+            continue
 
     return {}, False
 
diff --git a/src/agentfinvqa/utils/openai_compat.py b/src/agentfinvqa/utils/openai_compat.py
new file mode 100644
index 0000000..6b51b7c
--- /dev/null
+++ b/src/agentfinvqa/utils/openai_compat.py
@@ -0,0 +1,110 @@
+"""OpenAI-compatible endpoint helpers.
+
+Centralizes the ``api_key`` / ``api_base`` resolution used by every backend
+caller (tools + CrewAI agent LLMs). Supports two deployment modes:
+
+1. **Hosted OpenAI** (default) — ``api_base`` is empty, ``OPENAI_API_KEY`` is
+   read from env; the official ``api.openai.com`` endpoint is used.
+2. **Local OpenAI-compatible server** (e.g. vLLM serving Qwen2.5-VL) — caller
+   supplies an explicit ``api_base`` (or sets ``OPENAI_BASE_URL`` in env);
+   ``api_key`` may be empty since vLLM ignores it, and we substitute a dummy
+   non-empty string so the OpenAI SDK constructor is happy.
+"""
+
+import os
+from typing import Any, Optional, Tuple
+
+from crewai import LLM
+from openai import OpenAI
+
+from .model_compat import openai_temperature
+
+
+def resolve_openai_endpoint(api_key: str = "", api_base: str = "") -> Tuple[str, Optional[str]]:
+    """Resolve effective (api_key, base_url) from explicit args + env fallbacks.
+
+    Parameters
+    ----------
+    api_key : str
+        Explicit key passed by the caller. May be empty.
+    api_base : str
+        Explicit base URL passed by the caller. May be empty.
+
+    Returns
+    -------
+    tuple of (str, Optional[str])
+        ``api_key`` (never empty — substitutes ``"EMPTY"`` for vLLM) and
+        ``base_url`` (``None`` when the default OpenAI endpoint should be used).
+    """
+    resolved_key = api_key or os.environ.get("OPENAI_API_KEY", "")
+    resolved_base = api_base or os.environ.get("OPENAI_BASE_URL", "") or None
+    if resolved_base and not resolved_key:
+        # vLLM accepts any non-empty key; the OpenAI SDK rejects "".
+        resolved_key = "EMPTY"
+    return resolved_key, resolved_base
+
+
+def build_openai_client(api_key: str = "", api_base: str = "") -> OpenAI:
+    """Construct an ``OpenAI`` client honouring explicit args + env fallbacks."""
+    key, base = resolve_openai_endpoint(api_key, api_base)
+    if base:
+        return OpenAI(api_key=key, base_url=base)
+    return OpenAI(api_key=key)
+
+
+def is_qwen35_model(model_name: str) -> bool:
+    """Return True iff the model name belongs to the Qwen3.5 / Qwen3.6 family.
+
+    These models enable thinking mode by default, prefixing responses with
+    ``<think>...</think>`` blocks that break our strict-JSON parsing path.
+    Callers should pass ``enable_thinking=False`` via ``extra_body`` to suppress.
+    """
+    name = (model_name or "").lower()
+    return "qwen3.5" in name or "qwen3_5" in name or "qwen3.6" in name or "qwen3_6" in name
+
+
+def qwen35_extra_body(model_name: str) -> dict:
+    """Return the ``extra_body`` kwarg needed to disable thinking on Qwen3.5 / Qwen3.6.
+
+    Empty dict for other models so the call site can always pass
+    ``extra_body=qwen35_extra_body(self.model)`` without conditionals.
+    """
+    if not is_qwen35_model(model_name):
+        return {}
+    return {"chat_template_kwargs": {"enable_thinking": False}}
+
+
+def build_crewai_llm(
+    backend: str,
+    model: str,
+    api_key: Optional[str] = None,
+    api_base: Optional[str] = None,
+) -> Any:
+    """Build a CrewAI ``LLM`` for OpenAI-compat / Gemini routing with Qwen thinking off.
+
+    Centralizes the duplicated ``_build_llm`` helpers in planner/vision/verifier agents.
+    For local vLLM, prefixes the model with ``openai/`` so LiteLLM uses the
+    custom base URL.
+    """
+    if backend == "openai":
+        resolved_key = api_key or os.environ.get("OPENAI_API_KEY", "")
+        resolved_base = api_base or os.environ.get("OPENAI_BASE_URL", "") or None
+        model_str = f"openai/{model}" if resolved_base and not model.startswith("openai/") else model
+        kwargs: dict[str, Any] = {
+            "model": model_str,
+            "api_key": resolved_key or "EMPTY",
+            **openai_temperature(model),
+        }
+        if resolved_base:
+            kwargs["base_url"] = resolved_base
+        extra = qwen35_extra_body(model)
+        if extra:
+            kwargs["extra_body"] = extra
+        return LLM(**kwargs)
+    if backend == "gemini":
+        return LLM(
+            model=f"gemini/{model}",
+            api_key=api_key or os.environ.get("GEMINI_API_KEY", ""),
+            temperature=0,
+        )
+    raise ValueError(f"Unknown LLM backend: {backend!r}")
diff --git a/tests/agentfinvqa/test_json_strict.py b/tests/agentfinvqa/test_json_strict.py
new file mode 100644
index 0000000..08b4d85
--- /dev/null
+++ b/tests/agentfinvqa/test_json_strict.py
@@ -0,0 +1,75 @@
+"""Tests for strict JSON extraction from LLM outputs."""
+
+from agentfinvqa.utils.json_strict import parse_strict
+
+
+def test_parse_cot_preamble_with_final_json():
+    raw = (
+        'The tool returned answer "A".\n'
+        '{"choice_analysis": {"A": {"evidence": "up", "confidence": 0.9}}, '
+        '"answer": "A", "explanation": "trend up"}'
+    )
+    parsed, ok = parse_strict(raw, required_keys=["choice_analysis", "answer", "explanation"])
+    assert ok
+    assert parsed["answer"] == "A"
+
+
+def test_parse_last_json_when_draft_precedes_final():
+    raw = (
+        "Draft:\n"
+        '{"answer": "wrong", "explanation": "draft"}\n'
+        "Final:\n"
+        '{"choice_analysis": {}, "answer": "B", "explanation": "final"}'
+    )
+    parsed, ok = parse_strict(raw, required_keys=["choice_analysis", "answer", "explanation"])
+    assert parsed["answer"] == "B"
+
+
+def test_parse_verifier_with_markdown_fence():
+    raw = (
+        'Wrapper text\n{"verdict": "revised", "answer": "Investment expenditure", "reasoning": "source says 43%"}\n```'
+    )
+    parsed, ok = parse_strict(raw, required_keys=["verdict", "answer", "reasoning"])
+    assert parsed["verdict"] == "revised"
+    assert parsed["answer"] == "Investment expenditure"
+
+
+def test_parse_qwen_thinking_block_stripped():
+    raw = (
+        "<think>Let me check the chart carefully. The bar for Q3 reaches 42%.</think>"
+        '{"verdict": "confirmed", "answer": "42%", "reasoning": "bar reaches 42%"}'
+    )
+    parsed, ok = parse_strict(raw, required_keys=["verdict", "answer", "reasoning"])
+    assert ok
+    assert parsed["answer"] == "42%"
+
+
+def test_parse_redacted_thinking_block_stripped():
+    raw = (
+        "<redacted_thinking>hidden reasoning</redacted_thinking>"
+        '{"verdict": "revised", "answer": "15", "reasoning": "corrected value"}'
+    )
+    parsed, ok = parse_strict(raw, required_keys=["verdict", "answer", "reasoning"])
+    assert ok
+    assert parsed["verdict"] == "revised"
+
+
+def test_repair_fallback_sets_parse_ok_false():
+    raw = '{"answer": "A", "explanation": "trend up",}'  # trailing comma — invalid JSON
+    parsed, ok = parse_strict(raw, required_keys=["answer", "explanation"])
+    assert not ok
+    assert parsed.get("answer") == "A"
+
+
+def test_missing_required_keys_returns_empty():
+    raw = '{"answer": "A"}'  # missing "explanation"
+    parsed, ok = parse_strict(raw, required_keys=["answer", "explanation"])
+    assert parsed == {}
+    assert not ok
+
+
+def test_no_required_keys_accepts_any_dict():
+    raw = '{"foo": 1, "bar": "baz"}'
+    parsed, ok = parse_strict(raw)
+    assert ok
+    assert parsed == {"foo": 1, "bar": "baz"}
diff --git a/tests/agentfinvqa/test_model_compat.py b/tests/agentfinvqa/test_model_compat.py
new file mode 100644
index 0000000..ffa0ba0
--- /dev/null
+++ b/tests/agentfinvqa/test_model_compat.py
@@ -0,0 +1,16 @@
+"""Tests for model compatibility helpers."""
+
+import pytest
+
+from agentfinvqa.utils.model_compat import openai_temperature
+
+
+@pytest.mark.parametrize("model", ["o1", "o1-mini", "o1-preview", "o3", "o3-mini", "gpt-5-mini"])
+def test_no_temperature_for_reasoning_models(model):
+    """Reasoning models reject temperature; helper must return empty dict."""
+    assert openai_temperature(model) == {}
+
+
+@pytest.mark.parametrize("model", ["gpt-4o", "gpt-4-turbo", "gemini-1.5-flash", "qwen3.5-72b"])
+def test_temperature_zero_for_standard_models(model):
+    assert openai_temperature(model) == {"temperature": 0}
diff --git a/tests/agentfinvqa/test_openai_compat.py b/tests/agentfinvqa/test_openai_compat.py
new file mode 100644
index 0000000..c59585e
--- /dev/null
+++ b/tests/agentfinvqa/test_openai_compat.py
@@ -0,0 +1,87 @@
+"""Tests for OpenAI-compat endpoint helpers."""
+
+import pytest
+
+from agentfinvqa.utils.openai_compat import (
+    is_qwen35_model,
+    qwen35_extra_body,
+    resolve_openai_endpoint,
+)
+
+
+# ---------------------------------------------------------------------------
+# resolve_openai_endpoint
+# ---------------------------------------------------------------------------
+
+
+def test_resolve_explicit_key_and_base():
+    key, base = resolve_openai_endpoint(api_key="sk-test", api_base="http://localhost:8000/v1")
+    assert key == "sk-test"
+    assert base == "http://localhost:8000/v1"
+
+
+def test_resolve_env_fallback(monkeypatch):
+    monkeypatch.setenv("OPENAI_API_KEY", "sk-from-env")
+    monkeypatch.delenv("OPENAI_BASE_URL", raising=False)
+    key, base = resolve_openai_endpoint()
+    assert key == "sk-from-env"
+    assert base is None
+
+
+def test_resolve_explicit_key_overrides_env(monkeypatch):
+    monkeypatch.setenv("OPENAI_API_KEY", "sk-from-env")
+    key, _ = resolve_openai_endpoint(api_key="sk-explicit")
+    assert key == "sk-explicit"
+
+
+def test_resolve_vllm_injects_empty_key_when_base_set(monkeypatch):
+    """VLLM base + no key → inject 'EMPTY' so the OpenAI SDK doesn't reject ''."""
+    monkeypatch.delenv("OPENAI_API_KEY", raising=False)
+    monkeypatch.delenv("OPENAI_BASE_URL", raising=False)
+    key, base = resolve_openai_endpoint(api_base="http://localhost:8000/v1")
+    assert key == "EMPTY"
+    assert base == "http://localhost:8000/v1"
+
+
+def test_resolve_no_args_no_env_returns_empty_key_and_no_base(monkeypatch):
+    monkeypatch.delenv("OPENAI_API_KEY", raising=False)
+    monkeypatch.delenv("OPENAI_BASE_URL", raising=False)
+    key, base = resolve_openai_endpoint()
+    assert key == ""
+    assert base is None
+
+
+# ---------------------------------------------------------------------------
+# is_qwen35_model
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.parametrize(
+    "name",
+    ["qwen3.5-72b-instruct", "Qwen3.5", "qwen3_5", "qwen3.6", "QWEN3_6-235B"],
+)
+def test_is_qwen35_model_true(name):
+    assert is_qwen35_model(name)
+
+
+@pytest.mark.parametrize(
+    "name",
+    ["gpt-4o", "gemini-1.5-flash", "qwen2.5-vl-72b", "qwen3-235b", ""],
+)
+def test_is_qwen35_model_false(name):
+    assert not is_qwen35_model(name)
+
+
+# ---------------------------------------------------------------------------
+# qwen35_extra_body
+# ---------------------------------------------------------------------------
+
+
+def test_qwen35_extra_body_disables_thinking():
+    extra = qwen35_extra_body("qwen3.5-72b-instruct")
+    assert extra == {"chat_template_kwargs": {"enable_thinking": False}}
+
+
+def test_qwen35_extra_body_empty_for_other_models():
+    assert qwen35_extra_body("gpt-4o") == {}
+    assert qwen35_extra_body("gemini-2.0-flash") == {}
diff --git a/uv.lock b/uv.lock
index 0acce1d..66b6e22 100644
--- a/uv.lock
+++ b/uv.lock
@@ -32,6 +32,7 @@ dependencies = [
     { name = "jupyter" },
     { name = "jupyterlab" },
     { name = "langfuse" },
+    { name = "litellm" },
     { name = "matplotlib" },
     { name = "mypy" },
     { name = "numpy" },
@@ -40,9 +41,11 @@ dependencies = [
     { name = "pandas" },
     { name = "pytest" },
     { name = "python-dotenv" },
+    { name = "qwen-vl-utils" },
     { name = "scikit-learn" },
     { name = "seaborn" },
     { name = "transformers" },
+    { name = "vllm" },
 ]
 
 [package.dev-dependencies]
@@ -86,6 +89,7 @@ requires-dist = [
     { name = "jupyter", specifier = ">=1.1.1" },
     { name = "jupyterlab", specifier = ">=4.4.8" },
     { name = "langfuse", specifier = ">=4" },
+    { name = "litellm", specifier = ">=1.84.0" },
     { name = "matplotlib", specifier = ">=3.10.5" },
     { name = "mypy", specifier = ">=1.19.1" },
     { name = "numpy", specifier = ">=1.26,<2.0" },
@@ -94,9 +98,11 @@ requires-dist = [
     { name = "pandas", specifier = ">=2.3.2" },
     { name = "pytest", specifier = ">=9.0.2" },
     { name = "python-dotenv", specifier = ">=1.2.2" },
+    { name = "qwen-vl-utils", specifier = "==0.0.14" },
     { name = "scikit-learn", specifier = ">=1.5.2" },
     { name = "seaborn", specifier = ">=0.13.2" },
     { name = "transformers", specifier = ">=4.47.0" },
+    { name = "vllm", specifier = ">=0.14.0" },
 ]
 
 [package.metadata.requires-dev]
@@ -271,6 +277,25 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53", size = 13643, upload-time = "2024-05-20T21:33:24.1Z" },
 ]
 
+[[package]]
+name = "anthropic"
+version = "0.71.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio" },
+    { name = "distro" },
+    { name = "docstring-parser" },
+    { name = "httpx" },
+    { name = "jiter" },
+    { name = "pydantic" },
+    { name = "sniffio" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/82/4f/70682b068d897841f43223df82d96ec1d617435a8b759c4a2d901a50158b/anthropic-0.71.0.tar.gz", hash = "sha256:eb8e6fa86d049061b3ef26eb4cbae0174ebbff21affa6de7b3098da857d8de6a", size = 489102, upload-time = "2025-10-16T15:54:40.08Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5d/77/073e8ac488f335aec7001952825275582fb8f433737e90f24eeef9d878f6/anthropic-0.71.0-py3-none-any.whl", hash = "sha256:85c5015fcdbdc728390f11b17642a65a4365d03b12b799b18b6cc57e71fdb327", size = 355035, upload-time = "2025-10-16T15:54:38.238Z" },
+]
+
 [[package]]
 name = "anyio"
 version = "4.13.0"
@@ -284,6 +309,29 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/da/42/e921fccf5015463e32a3cf6ee7f980a6ed0f395ceeaa45060b61d86486c2/anyio-4.13.0-py3-none-any.whl", hash = "sha256:08b310f9e24a9594186fd75b4f73f4a4152069e3853f1ed8bfbf58369f4ad708", size = 114353, upload-time = "2026-03-24T12:59:08.246Z" },
 ]
 
+[[package]]
+name = "apache-tvm-ffi"
+version = "0.1.11"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/6d/3d/4b9226cd45aa800a6904603dda9b323d728f3c3869952a673f3483b78b19/apache_tvm_ffi-0.1.11.tar.gz", hash = "sha256:153cd2c5a9717804cb0bcd9b2709f22a1e5f80ed05b5a490faf5949b136eedba", size = 2798354, upload-time = "2026-05-04T17:48:43.852Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/05/9d/0f81ca556e5836b3ca64818cdae3f47dc7822bd35d22ddef7a54106d801d/apache_tvm_ffi-0.1.11-cp312-abi3-macosx_11_0_arm64.whl", hash = "sha256:6ae51cc7df415b5f373a9df4baa1165a65608e519bea81e7dd23428f00eeb689", size = 2418793, upload-time = "2026-05-04T17:47:57.879Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/a9/f48e5dd4ae1f6f0c5ffac259c0a9531b7d6a7c0a4c45bc2229d55de6adf8/apache_tvm_ffi-0.1.11-cp312-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:da2c8d07fdc737d1ba75f4de25c29f156905b9dc980f1da90c395b4db525f522", size = 2605176, upload-time = "2026-05-04T17:47:59.676Z" },
+    { url = "https://files.pythonhosted.org/packages/36/99/2848df4e8ed5bf51df1d286d1718510584fa61e88adbc9c5b23d71b38f7c/apache_tvm_ffi-0.1.11-cp312-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:78aa1857b04a2ea718317041ab3f01288b3d496e6036eb1b99ebdc9da0fdaef5", size = 2725887, upload-time = "2026-05-04T17:48:01.381Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/80/963c991934a4eb0fa0c0178f51963333fe14a96b732009da642b6bf6b42e/apache_tvm_ffi-0.1.11-cp312-abi3-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a8b845c8dff498fb981c1dda36c954549204191b485a385845e604966594d0b2", size = 2513121, upload-time = "2026-05-04T17:48:03.43Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/18/95569107ee83619d61a3bb0d28743a0599f85c5161981e3e098c82c2b185/apache_tvm_ffi-0.1.11-cp312-abi3-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2843f084cdc94dedacd8b257a395a2b71b8a3dc7fc99711b148bf1d161983128", size = 2697683, upload-time = "2026-05-04T17:48:05.222Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/99/f352cf1cce8f6f05584c4adf11de9eca07e6d217229bad6af35fb372926c/apache_tvm_ffi-0.1.11-cp312-abi3-win_amd64.whl", hash = "sha256:bd67e03759d25ff59f4e0ed9c8630a16872afc9dd8792f46ac3c927554015e60", size = 2365545, upload-time = "2026-05-04T17:48:07.295Z" },
+    { url = "https://files.pythonhosted.org/packages/27/ae/09242a668eb75ea06282d7cdc3947004cda69040885c340005a23b0aefe3/apache_tvm_ffi-0.1.11-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:f47435e41bf8a2018ef126fad41f18e0c8fe8be4d25fb3ed04b615278b7806d4", size = 2481373, upload-time = "2026-05-04T17:48:09.388Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/d1/dc0c26cf68635a1184ba39cccb6cb3cf9675c7030f135f47205e56bdd2b6/apache_tvm_ffi-0.1.11-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:a05b36530d7cd5bb93b1a21a3b81ff060968c20456c4870b1a80d65966d5114f", size = 2639857, upload-time = "2026-05-04T17:48:11.1Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/ad/4e3d4c5ec36e2ecadf6e5eb81cde065c69218cf722606b73af0ea6fdab75/apache_tvm_ffi-0.1.11-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:9b158f93bdfc497ead9fce5ffdd4d132708de60970ffc97d890dd62fa39d9fb4", size = 2755683, upload-time = "2026-05-04T17:48:13.016Z" },
+    { url = "https://files.pythonhosted.org/packages/51/37/54deceea6bac0e93844bd572a2fae8549e86e6309c732a0acaeb07a88c6b/apache_tvm_ffi-0.1.11-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0f77406e2773ad18109369417b5ccf6aee3c813867dbd5d2d97170bfa7b491f1", size = 2552014, upload-time = "2026-05-04T17:48:14.692Z" },
+    { url = "https://files.pythonhosted.org/packages/14/e8/52c9544be5850c7c0e5edce08f2dc9d05c3ecb10b7ae9b3a9313d1b2857e/apache_tvm_ffi-0.1.11-cp314-cp314t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:78f0c9dc69727665de58faebacf6a3f4a1d75a355591e963e1bc691fc9bf5cd5", size = 2730358, upload-time = "2026-05-04T17:48:16.39Z" },
+    { url = "https://files.pythonhosted.org/packages/93/b2/afe8a6b8553f51255afdd8063c5d6fd3f4e1978aad424de706440c59fdba/apache_tvm_ffi-0.1.11-cp314-cp314t-win_amd64.whl", hash = "sha256:2f5d417da48dbabbe08933a4d0964b3d2f43d1a4a2c3a6c0092de670c71a8a87", size = 2476516, upload-time = "2026-05-04T17:48:18.022Z" },
+]
+
 [[package]]
 name = "appdirs"
 version = "1.4.4"
@@ -358,6 +406,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/ed/c9/d7977eaacb9df673210491da99e6a247e93df98c715fc43fd136ce1d3d33/arrow-1.4.0-py3-none-any.whl", hash = "sha256:749f0769958ebdc79c173ff0b0670d59051a535fa26e8eba02953dc19eb43205", size = 68797, upload-time = "2025-10-18T17:46:45.663Z" },
 ]
 
+[[package]]
+name = "astor"
+version = "0.8.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/5a/21/75b771132fee241dfe601d39ade629548a9626d1d39f333fde31bc46febe/astor-0.8.1.tar.gz", hash = "sha256:6a6effda93f4e1ce9f618779b2dd1d9d84f1e32812c23a29b3fff6fd7f63fa5e", size = 35090, upload-time = "2019-12-10T01:50:35.51Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c3/88/97eef84f48fa04fbd6750e62dcceafba6c63c81b7ac1420856c8dcc0a3f9/astor-0.8.1-py2.py3-none-any.whl", hash = "sha256:070a54e890cefb5b3739d19f30f5a5ec840ffc9c50ffa7d23cc9fc1a38ebbfc5", size = 27488, upload-time = "2019-12-10T01:50:33.628Z" },
+]
+
 [[package]]
 name = "asttokens"
 version = "3.0.1"
@@ -397,6 +454,30 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/9e/43/53afb8ba17218f19b77c7834128566c5bbb100a0ad9ba2e8e89d089d7079/autopep8-2.3.2-py2.py3-none-any.whl", hash = "sha256:ce8ad498672c845a0c3de2629c15b635ec2b05ef8177a6e7c91c74f3e9b51128", size = 45807, upload-time = "2025-01-14T14:46:15.466Z" },
 ]
 
+[[package]]
+name = "av"
+version = "17.0.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/4e/f0/8c8dca97ae0cf00e8e2a53bb5cb9aca5fd484f585ef3e9b412200aff3ebd/av-17.0.1.tar.gz", hash = "sha256:fbcbd4aa43bca6a8691816283112d1659a27f407bbeb66d1397023691339f5d4", size = 4411938, upload-time = "2026-04-18T17:12:34.29Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/4c/82/e7007dcef7bd2d2c377e2e85977701384f42d19fc808c2ccb3a99eaf58f2/av-17.0.1-cp311-abi3-macosx_11_0_x86_64.whl", hash = "sha256:987f4f46ceae4da6c614dcbd2b8149be9dbf680c3bb7a6841c58af9cff4d9230", size = 23238802, upload-time = "2026-04-18T17:11:51.166Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/aa/858b09a08ea6f83f91be44b5a5adad13ae8d9ac8b80fda27e73c24bfb160/av-17.0.1-cp311-abi3-macosx_14_0_arm64.whl", hash = "sha256:d97f54e55b18a74912f479c1978aadd1341d38d892dee95bb5c2f2dccfa72f32", size = 18709338, upload-time = "2026-04-18T17:11:53.286Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/8b/8de3fd21c4b0b74d44337421abeab0e71462337fb6a28fff888e0c356cbd/av-17.0.1-cp311-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:e6eee84afa48d0e9321047cd3e4facd44b401493f6bdc753e2e1d1e7c9e6d13e", size = 34007351, upload-time = "2026-04-18T17:11:56.116Z" },
+    { url = "https://files.pythonhosted.org/packages/02/28/167b291356c2cc315a2d62a95b0ceace72b5b0bf547de30b89313110f032/av-17.0.1-cp311-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:c58c71bffd9383908c85695ac61d3184c668accb04a5bd1b262e0fb8d09f60a5", size = 36345295, upload-time = "2026-04-18T17:11:59.125Z" },
+    { url = "https://files.pythonhosted.org/packages/04/fa/aae56f2ff2c204c408641e1120f5ca5ce9c3390cf5362245c6f1158704b5/av-17.0.1-cp311-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:42d6745d30a410ec9b22aef79a52a7ab5a001eb8f5adfd952946606a30983318", size = 35183754, upload-time = "2026-04-18T17:12:01.697Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/bd/776046f27093aef80155a204ca7d82a887ae4ee72ba4ef8411b46ea7898c/av-17.0.1-cp311-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:3ed6bcd7021fe55832f95b8ef78dd01a4cb21faf3cd71f1e1bf4f20bf100b278", size = 37430809, upload-time = "2026-04-18T17:12:04.231Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/d5/3261bd2c6b7f6c0aa8379fc970d1ecf496330990b992ad28607785074268/av-17.0.1-cp311-abi3-win_amd64.whl", hash = "sha256:9af524e8632a54032e361d6b88895bd3e7c6212ca560de60f5ccc525323c764c", size = 28889649, upload-time = "2026-04-18T17:12:07.04Z" },
+    { url = "https://files.pythonhosted.org/packages/98/39/381104e427a0c7231d2ec0d25d538d58fc20fc0458846b95860d3ef8073b/av-17.0.1-cp311-abi3-win_arm64.whl", hash = "sha256:50e58a473d65ea29b645e45c9fd8518a6783737135683ecc40571a91592bdfe4", size = 21918412, upload-time = "2026-04-18T17:12:09.312Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/8c/bb1498f031abb6157b30b7fc2379359176953821b6ba59fbd89dbb56f61f/av-17.0.1-cp314-cp314t-macosx_11_0_x86_64.whl", hash = "sha256:1d33871742d1e71562db3c8e752cacc5a62766d7efc3ae408bff1c3e26ebb46e", size = 23484157, upload-time = "2026-04-18T17:12:11.67Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/58/dedaef187b797243cd5762722e376c69c5ad95ab23db44127f09afc2cd66/av-17.0.1-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:1229e879f4b6431bc00f69d7f8891fe9a683b0a6e0e009e6c98eb7e449f0383d", size = 18920872, upload-time = "2026-04-18T17:12:14.826Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/26/5c550231651d6285e6a5c4f6f4a0e67459bfe2b622a7c9352be8cca8c819/av-17.0.1-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:4744837f4116964280bcc72285e3cdd51361e98a696205aadd924203440ef511", size = 37471077, upload-time = "2026-04-18T17:12:17.349Z" },
+    { url = "https://files.pythonhosted.org/packages/59/e4/9807b89a9d775c6f015677996c48bce48aaff70b5d95885adf39e59832a2/av-17.0.1-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:3d0a7d45d9599bf9df9f8249827113d4f36df1cd6b5356227b997f0552dbc98e", size = 39566981, upload-time = "2026-04-18T17:12:19.942Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/72/a22a657abc3de652f5b4f46cbbebdf7cba629752112791b81f05d340991d/av-17.0.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:9acd0b6a6e02af2b37f63d97a03ee2c47936d58e82425c3cd075a95245937c59", size = 38397369, upload-time = "2026-04-18T17:12:22.909Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/b2/f4e83e41c1e3c186f34b7df506779d0cd7e40499e2e19519c7ece148cd20/av-17.0.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:3d3a36204cb1f1e7691e6446afa8d6b7097b09946dae732c71c5d05ce09e506e", size = 40582445, upload-time = "2026-04-18T17:12:26.285Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/59/8676188b72eed09d48ce6cfaf0f22b0bb9f3cfd74d388ee2b7fdf960536d/av-17.0.1-cp314-cp314t-win_amd64.whl", hash = "sha256:b87b98afe971cde123953073bc9c95ab0b7efd2ecc082dd2dbd11f9d9abf190e", size = 29217136, upload-time = "2026-04-18T17:12:29.189Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/af/0a6e1d2a845988039f6c197fa7269b5e9abbe17354fb41cc9d75bb260fcb/av-17.0.1-cp314-cp314t-win_arm64.whl", hash = "sha256:a87a42c36e29f75e7dff7281944f2a6876a2c8875e225ccbf6c1ae62748b4caa", size = 22072676, upload-time = "2026-04-18T17:12:31.836Z" },
+]
+
 [[package]]
 name = "babel"
 version = "2.17.0"
@@ -508,6 +589,74 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/1a/39/47f9197bdd44df24d67ac8893641e16f386c984a0619ef2ee4c51fbbc019/beautifulsoup4-4.14.3-py3-none-any.whl", hash = "sha256:0918bfe44902e6ad8d57732ba310582e98da931428d231a5ecb9e7c703a735bb", size = 107721, upload-time = "2025-11-30T15:08:24.087Z" },
 ]
 
+[[package]]
+name = "blake3"
+version = "1.0.8"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/75/aa/abcd75e9600987a0bc6cfe9b6b2ff3f0e2cb08c170addc6e76035b5c4cb3/blake3-1.0.8.tar.gz", hash = "sha256:513cc7f0f5a7c035812604c2c852a0c1468311345573de647e310aca4ab165ba", size = 117308, upload-time = "2025-10-14T06:47:48.83Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ed/a0/b7b6dff04012cfd6e665c09ee446f749bd8ea161b00f730fe1bdecd0f033/blake3-1.0.8-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:d8da4233984d51471bd4e4366feda1d90d781e712e0a504ea54b1f2b3577557b", size = 347983, upload-time = "2025-10-14T06:45:47.214Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/a2/264091cac31d7ae913f1f296abc20b8da578b958ffb86100a7ce80e8bf5c/blake3-1.0.8-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:1257be19f2d381c868a34cc822fc7f12f817ddc49681b6d1a2790bfbda1a9865", size = 325415, upload-time = "2025-10-14T06:45:48.482Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/7d/85a4c0782f613de23d114a7a78fcce270f75b193b3ff3493a0de24ba104a/blake3-1.0.8-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:269f255b110840e52b6ce9db02217e39660ebad3e34ddd5bca8b8d378a77e4e1", size = 371296, upload-time = "2025-10-14T06:45:49.674Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/20/488475254976ed93fab57c67aa80d3b40df77f7d9db6528c9274bff53e08/blake3-1.0.8-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:66ca28a673025c40db3eba21a9cac52f559f83637efa675b3f6bd8683f0415f3", size = 374516, upload-time = "2025-10-14T06:45:51.23Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/21/2a1c47fedb77fb396512677ec6d46caf42ac6e9a897db77edd0a2a46f7bb/blake3-1.0.8-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:bcb04966537777af56c1f399b35525aa70a1225816e121ff95071c33c0f7abca", size = 447911, upload-time = "2025-10-14T06:45:52.637Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/7d/db0626df16029713e7e61b67314c4835e85c296d82bd907c21c6ea271da2/blake3-1.0.8-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e5b5da177d62cc4b7edf0cea08fe4dec960c9ac27f916131efa890a01f747b93", size = 505420, upload-time = "2025-10-14T06:45:54.445Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/55/6e737850c2d58a6d9de8a76dad2ae0f75b852a23eb4ecb07a0b165e6e436/blake3-1.0.8-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:38209b10482c97e151681ea3e91cc7141f56adbbf4820a7d701a923124b41e6a", size = 394189, upload-time = "2025-10-14T06:45:55.719Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/94/eafaa5cdddadc0c9c603a6a6d8339433475e1a9f60c8bb9c2eed2d8736b6/blake3-1.0.8-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:504d1399b7fb91dfe5c25722d2807990493185faa1917456455480c36867adb5", size = 388001, upload-time = "2025-10-14T06:45:57.067Z" },
+    { url = "https://files.pythonhosted.org/packages/17/81/735fa00d13de7f68b25e1b9cb36ff08c6f165e688d85d8ec2cbfcdedccc5/blake3-1.0.8-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:c84af132aa09abeadf9a0118c8fb26f4528f3f42c10ef8be0fcf31c478774ec4", size = 550302, upload-time = "2025-10-14T06:45:58.657Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/c6/d1fe8bdea4a6088bd54b5a58bc40aed89a4e784cd796af7722a06f74bae7/blake3-1.0.8-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:a25db3d36b55f5ed6a86470155cc749fc9c5b91c949b8d14f48658f9d960d9ec", size = 554211, upload-time = "2025-10-14T06:46:00.269Z" },
+    { url = "https://files.pythonhosted.org/packages/55/d1/ca74aa450cbe10e396e061f26f7a043891ffa1485537d6b30d3757e20995/blake3-1.0.8-cp312-cp312-win32.whl", hash = "sha256:e0fee93d5adcd44378b008c147e84f181f23715307a64f7b3db432394bbfce8b", size = 228343, upload-time = "2025-10-14T06:46:01.533Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/42/bbd02647169e3fbed27558555653ac2578c6f17ccacf7d1956c58ef1d214/blake3-1.0.8-cp312-cp312-win_amd64.whl", hash = "sha256:6a6eafc29e4f478d365a87d2f25782a521870c8514bb43734ac85ae9be71caf7", size = 215704, upload-time = "2025-10-14T06:46:02.79Z" },
+    { url = "https://files.pythonhosted.org/packages/55/b8/11de9528c257f7f1633f957ccaff253b706838d22c5d2908e4735798ec01/blake3-1.0.8-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:46dc20976bd6c235959ef0246ec73420d1063c3da2839a9c87ca395cf1fd7943", size = 347771, upload-time = "2025-10-14T06:46:04.248Z" },
+    { url = "https://files.pythonhosted.org/packages/50/26/f7668be55c909678b001ecacff11ad7016cd9b4e9c7cc87b5971d638c5a9/blake3-1.0.8-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:d17eb6382634b3a5bc0c0e0454d5265b0becaeeadb6801ed25150b39a999d0cc", size = 325431, upload-time = "2025-10-14T06:46:06.136Z" },
+    { url = "https://files.pythonhosted.org/packages/77/57/e8a85fa261894bf7ce7af928ff3408aab60287ab8d58b55d13a3f700b619/blake3-1.0.8-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:19fc6f2b7edab8acff6895fc6e38c19bd79f4c089e21153020c75dfc7397d52d", size = 370994, upload-time = "2025-10-14T06:46:07.398Z" },
+    { url = "https://files.pythonhosted.org/packages/62/cd/765b76bb48b8b294fea94c9008b0d82b4cfa0fa2f3c6008d840d01a597e4/blake3-1.0.8-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:4f54cff7f15d91dc78a63a2dd02a3dccdc932946f271e2adb4130e0b4cf608ba", size = 374372, upload-time = "2025-10-14T06:46:08.698Z" },
+    { url = "https://files.pythonhosted.org/packages/36/7a/32084eadbb28592bb07298f0de316d2da586c62f31500a6b1339a7e7b29b/blake3-1.0.8-cp313-cp313-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e7e12a777f6b798eb8d06f875d6e108e3008bd658d274d8c676dcf98e0f10537", size = 447627, upload-time = "2025-10-14T06:46:10.002Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/f4/3788a1d86e17425eea147e28d7195d7053565fc279236a9fd278c2ec495e/blake3-1.0.8-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ddfc59b0176fb31168f08d5dd536e69b1f4f13b5a0f4b0c3be1003efd47f9308", size = 507536, upload-time = "2025-10-14T06:46:11.614Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/01/4639cba48513b94192681b4da472cdec843d3001c5344d7051ee5eaef606/blake3-1.0.8-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a2336d5b2a801a7256da21150348f41610a6c21dae885a3acb1ebbd7333d88d8", size = 394105, upload-time = "2025-10-14T06:46:12.808Z" },
+    { url = "https://files.pythonhosted.org/packages/21/ae/6e55c19c8460fada86cd1306a390a09b0c5a2e2e424f9317d2edacea439f/blake3-1.0.8-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e4072196547484c95a5a09adbb952e9bb501949f03f9e2a85e7249ef85faaba8", size = 386928, upload-time = "2025-10-14T06:46:16.284Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/6c/05b7a5a907df1be53a8f19e7828986fc6b608a44119641ef9c0804fbef15/blake3-1.0.8-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:0eab3318ec02f8e16fe549244791ace2ada2c259332f0c77ab22cf94dfff7130", size = 550003, upload-time = "2025-10-14T06:46:17.791Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/03/f0ea4adfedc1717623be6460b3710fcb725ca38082c14274369803f727e1/blake3-1.0.8-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:a33b9a1fb6d1d559a8e0d04b041e99419a6bb771311c774f6ff57ed7119c70ed", size = 553857, upload-time = "2025-10-14T06:46:19.088Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/6f/e5410d2e2a30c8aba8389ffc1c0061356916bf5ecd0a210344e7b69b62ab/blake3-1.0.8-cp313-cp313-win32.whl", hash = "sha256:e171b169cb7ea618e362a4dddb7a4d4c173bbc08b9ba41ea3086dd1265530d4f", size = 228315, upload-time = "2025-10-14T06:46:20.391Z" },
+    { url = "https://files.pythonhosted.org/packages/79/ef/d9c297956dfecd893f29f59e7b22445aba5b47b7f6815d9ba5dcd73fcae6/blake3-1.0.8-cp313-cp313-win_amd64.whl", hash = "sha256:3168c457255b5d2a2fc356ba696996fcaff5d38284f968210d54376312107662", size = 215477, upload-time = "2025-10-14T06:46:21.542Z" },
+    { url = "https://files.pythonhosted.org/packages/20/ba/eaa7723d66dd8ab762a3e85e139bb9c46167b751df6e950ad287adb8fb61/blake3-1.0.8-cp313-cp313t-macosx_10_12_x86_64.whl", hash = "sha256:b4d672c24dc15ec617d212a338a4ca14b449829b6072d09c96c63b6e6b621aed", size = 347289, upload-time = "2025-10-14T06:46:22.772Z" },
+    { url = "https://files.pythonhosted.org/packages/47/b3/6957f6ee27f0d5b8c4efdfda68a1298926a88c099f4dd89c711049d16526/blake3-1.0.8-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:1af0e5a29aa56d4fba904452ae784740997440afd477a15e583c38338e641f41", size = 324444, upload-time = "2025-10-14T06:46:24.729Z" },
+    { url = "https://files.pythonhosted.org/packages/13/da/722cebca11238f3b24d3cefd2361c9c9ea47cfa0ad9288eeb4d1e0b7cf93/blake3-1.0.8-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ef153c5860d5bf1cc71aece69b28097d2a392913eb323d6b52555c875d0439fc", size = 370441, upload-time = "2025-10-14T06:46:26.29Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/d5/2f7440c8e41c0af995bad3a159e042af0f4ed1994710af5b4766ca918f65/blake3-1.0.8-cp313-cp313t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e8ae3689f0c7bfa6ce6ae45cab110e4c3442125c4c23b28f1f097856de26e4d1", size = 374312, upload-time = "2025-10-14T06:46:27.451Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/6c/fb6a7812e60ce3e110bcbbb11f167caf3e975c589572c41e1271f35f2c41/blake3-1.0.8-cp313-cp313t-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3fb83532f7456ddeb68dae1b36e1f7c52f9cb72852ac01159bbcb1a12b0f8be0", size = 447007, upload-time = "2025-10-14T06:46:29.056Z" },
+    { url = "https://files.pythonhosted.org/packages/13/3b/c99b43fae5047276ea9d944077c190fc1e5f22f57528b9794e21f7adedc6/blake3-1.0.8-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6ae7754c7d96e92a70a52e07c732d594cf9924d780f49fffd3a1e9235e0f5ba7", size = 507323, upload-time = "2025-10-14T06:46:30.661Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/bb/ba90eddd592f8c074a0694cb0a744b6bd76bfe67a14c2b490c8bdfca3119/blake3-1.0.8-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4bacaae75e98dee3b7da6c5ee3b81ee21a3352dd2477d6f1d1dbfd38cdbf158a", size = 393449, upload-time = "2025-10-14T06:46:31.805Z" },
+    { url = "https://files.pythonhosted.org/packages/25/ed/58a2acd0b9e14459cdaef4344db414d4a36e329b9720921b442a454dd443/blake3-1.0.8-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9456c829601d72852d8ba0af8dae0610f7def1d59f5942efde1e2ef93e8a8b57", size = 386844, upload-time = "2025-10-14T06:46:33.195Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/04/fed09845b18d90862100c8e48308261e2f663aab25d3c71a6a0bdda6618b/blake3-1.0.8-cp313-cp313t-musllinux_1_1_aarch64.whl", hash = "sha256:497ef8096ec4ac1ffba9a66152cee3992337cebf8ea434331d8fd9ce5423d227", size = 549550, upload-time = "2025-10-14T06:46:35.23Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/65/1859fddfabc1cc72548c2269d988819aad96d854e25eae00531517925901/blake3-1.0.8-cp313-cp313t-musllinux_1_1_x86_64.whl", hash = "sha256:511133bab85ff60ed143424ce484d08c60894ff7323f685d7a6095f43f0c85c3", size = 553805, upload-time = "2025-10-14T06:46:36.532Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/c7/2969352017f62378e388bb07bb2191bc9a953f818dc1cd6b9dd5c24916e1/blake3-1.0.8-cp313-cp313t-win32.whl", hash = "sha256:9c9fbdacfdeb68f7ca53bb5a7a5a593ec996eaf21155ad5b08d35e6f97e60877", size = 228068, upload-time = "2025-10-14T06:46:37.826Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/fc/923e25ac9cadfff1cd20038bcc0854d0f98061eb6bc78e42c43615f5982d/blake3-1.0.8-cp313-cp313t-win_amd64.whl", hash = "sha256:3cec94ed5676821cf371e9c9d25a41b4f3ebdb5724719b31b2749653b7cc1dfa", size = 215369, upload-time = "2025-10-14T06:46:39.054Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/2a/9f13ea01b03b1b4751a1cc2b6c1ef4b782e19433a59cf35b59cafb2a2696/blake3-1.0.8-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:2c33dac2c6112bc23f961a7ca305c7e34702c8177040eb98d0389d13a347b9e1", size = 347016, upload-time = "2025-10-14T06:46:40.318Z" },
+    { url = "https://files.pythonhosted.org/packages/06/8e/8458c4285fbc5de76414f243e4e0fcab795d71a8b75324e14959aee699da/blake3-1.0.8-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c445eff665d21c3b3b44f864f849a2225b1164c08654beb23224a02f087b7ff1", size = 324496, upload-time = "2025-10-14T06:46:42.355Z" },
+    { url = "https://files.pythonhosted.org/packages/49/fa/b913eb9cc4af708c03e01e6b88a8bb3a74833ba4ae4b16b87e2829198e06/blake3-1.0.8-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a47939f04b89c5c6ff1e51e883e5efab1ea1bf01a02f4d208d216dddd63d0dd8", size = 370654, upload-time = "2025-10-14T06:46:43.907Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/4f/245e0800c33b99c8f2b570d9a7199b51803694913ee4897f339648502933/blake3-1.0.8-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:73e0b4fa25f6e3078526a592fb38fca85ef204fd02eced6731e1cdd9396552d4", size = 374693, upload-time = "2025-10-14T06:46:45.186Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/a6/8cb182c8e482071dbdfcc6ec0048271fd48bcb78782d346119ff54993700/blake3-1.0.8-cp314-cp314-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4b0543c57eb9d6dac9d4bced63e9f7f7b546886ac04cec8da3c3d9c8f30cbbb7", size = 447673, upload-time = "2025-10-14T06:46:46.358Z" },
+    { url = "https://files.pythonhosted.org/packages/06/b7/1cbbb5574d2a9436d1b15e7eb5b9d82e178adcaca71a97b0fddaca4bfe3a/blake3-1.0.8-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ed972ebd553c0c25363459e9fc71a38c045d8419e365b59acd8cd791eff13981", size = 507233, upload-time = "2025-10-14T06:46:48.109Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/45/b55825d90af353b3e26c653bab278da9d6563afcf66736677f9397e465be/blake3-1.0.8-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3bafdec95dfffa3f6571e529644744e280337df15ddd9728f224ba70c5779b23", size = 393852, upload-time = "2025-10-14T06:46:49.511Z" },
+    { url = "https://files.pythonhosted.org/packages/34/73/9058a1a457dd20491d1b37de53d6876eff125e1520d9b2dd7d0acbc88de2/blake3-1.0.8-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2d78f06f3fb838b34c330e2987090376145cbe5944d8608a0c4779c779618f7b", size = 386442, upload-time = "2025-10-14T06:46:51.205Z" },
+    { url = "https://files.pythonhosted.org/packages/30/6d/561d537ffc17985e276e08bf4513f1c106f1fdbef571e782604dc4e44070/blake3-1.0.8-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:dd03ff08d1b6e4fdda1cd03826f971ae8966ef6f683a8c68aa27fb21904b5aa9", size = 549929, upload-time = "2025-10-14T06:46:52.494Z" },
+    { url = "https://files.pythonhosted.org/packages/03/2f/dbe20d2c57f1a67c63be4ba310bcebc707b945c902a0bde075d2a8f5cd5c/blake3-1.0.8-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:4e02a3c499e35bf51fc15b2738aca1a76410804c877bcd914752cac4f71f052a", size = 553750, upload-time = "2025-10-14T06:46:54.194Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/da/c6cb712663c869b2814870c2798e57289c4268c5ac5fb12d467fce244860/blake3-1.0.8-cp314-cp314-win32.whl", hash = "sha256:a585357d5d8774aad9ffc12435de457f9e35cde55e0dc8bc43ab590a6929e59f", size = 228404, upload-time = "2025-10-14T06:46:56.807Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/b6/c7dcd8bc3094bba1c4274e432f9e77a7df703532ca000eaa550bd066b870/blake3-1.0.8-cp314-cp314-win_amd64.whl", hash = "sha256:9ab5998e2abd9754819753bc2f1cf3edf82d95402bff46aeef45ed392a5468bf", size = 215460, upload-time = "2025-10-14T06:46:58.15Z" },
+    { url = "https://files.pythonhosted.org/packages/75/3c/6c8afd856c353176836daa5cc33a7989e8f54569e9d53eb1c53fc8f80c34/blake3-1.0.8-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:e2df12f295f95a804338bd300e8fad4a6f54fd49bd4d9c5893855a230b5188a8", size = 347482, upload-time = "2025-10-14T06:47:00.189Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/35/92cd5501ce8e1f5cabdc0c3ac62d69fdb13ff0b60b62abbb2b6d0a53a790/blake3-1.0.8-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:63379be58438878eeb76ebe4f0efbeaabf42b79f2cff23b6126b7991588ced67", size = 324376, upload-time = "2025-10-14T06:47:01.413Z" },
+    { url = "https://files.pythonhosted.org/packages/11/33/503b37220a3e2e31917ef13722efd00055af51c5e88ae30974c733d7ece6/blake3-1.0.8-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:88d527c247f9609dc1d45a08fd243e39f0d5300d54c57e048de24d4fa9240ebb", size = 370220, upload-time = "2025-10-14T06:47:02.573Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/df/fe817843adf59516c04d44387bd643b422a3b0400ea95c6ede6a49920737/blake3-1.0.8-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:506a47897a11ebe8f3cdeb52f1365d6a2f83959e98ccb0c830f8f73277d4d358", size = 373454, upload-time = "2025-10-14T06:47:03.784Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/4d/90a2a623575373dfc9b683f1bad1bf017feafa5a6d65d94fb09543050740/blake3-1.0.8-cp314-cp314t-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e5122a61b3b004bbbd979bdf83a3aaab432da3e2a842d7ddf1c273f2503b4884", size = 447102, upload-time = "2025-10-14T06:47:04.958Z" },
+    { url = "https://files.pythonhosted.org/packages/93/ff/4e8ce314f60115c4c657b1fdbe9225b991da4f5bcc5d1c1f1d151e2f39d6/blake3-1.0.8-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:0171e85d56dec1219abdae5f49a0ed12cb3f86a454c29160a64fd8a8166bba37", size = 506791, upload-time = "2025-10-14T06:47:06.82Z" },
+    { url = "https://files.pythonhosted.org/packages/44/88/2963a1f18aab52bdcf35379b2b48c34bbc462320c37e76960636b8602c36/blake3-1.0.8-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:003f61e8c41dd9931edddf1cc6a1bb680fb2ac0ad15493ef4a1df9adc59ce9df", size = 393717, upload-time = "2025-10-14T06:47:09.085Z" },
+    { url = "https://files.pythonhosted.org/packages/45/d1/a848ed8e8d4e236b9b16381768c9ae99d92890c24886bb4505aa9c3d2033/blake3-1.0.8-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d2c3151955efb09ba58cd3e1263521e15e9e3866a40d6bd3556d86fc968e8f95", size = 386150, upload-time = "2025-10-14T06:47:10.363Z" },
+    { url = "https://files.pythonhosted.org/packages/96/09/e3eb5d60f97c01de23d9f434e6e1fc117efb466eaa1f6ddbbbcb62580d6e/blake3-1.0.8-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:5eb25bca3cee2e0dd746a214784fb36be6a43640c01c55b6b4e26196e72d076c", size = 549120, upload-time = "2025-10-14T06:47:11.713Z" },
+    { url = "https://files.pythonhosted.org/packages/14/ad/3d9661c710febb8957dd685fdb3e5a861aa0ac918eda3031365ce45789e2/blake3-1.0.8-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:ab4e1dea4fa857944944db78e8f20d99ee2e16b2dea5a14f514fb0607753ac83", size = 553264, upload-time = "2025-10-14T06:47:13.317Z" },
+    { url = "https://files.pythonhosted.org/packages/11/55/e332a5b49edf377d0690e95951cca21a00c568f6e37315f9749efee52617/blake3-1.0.8-cp314-cp314t-win32.whl", hash = "sha256:67f1bc11bf59464ef092488c707b13dd4e872db36e25c453dfb6e0c7498df9f1", size = 228116, upload-time = "2025-10-14T06:47:14.516Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/5c/dbd00727a3dd165d7e0e8af40e630cd7e45d77b525a3218afaff8a87358e/blake3-1.0.8-cp314-cp314t-win_amd64.whl", hash = "sha256:421b99cdf1ff2d1bf703bc56c454f4b286fce68454dd8711abbcb5a0df90c19a", size = 215133, upload-time = "2025-10-14T06:47:16.069Z" },
+]
+
 [[package]]
 name = "bleach"
 version = "6.3.0"
@@ -584,6 +733,46 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/06/f3/39cf3367b8107baa44f861dc802cbf16263c945b62d8265d36034fc07bea/cachetools-7.0.5-py3-none-any.whl", hash = "sha256:46bc8ebefbe485407621d0a4264b23c080cedd913921bad7ac3ed2f26c183114", size = 13918, upload-time = "2026-03-09T20:51:27.33Z" },
 ]
 
+[[package]]
+name = "cbor2"
+version = "6.1.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/04/31/74b54539251d2c617875bee73df0b0473dc0b2eabcafa274a85eb69227f9/cbor2-6.1.0.tar.gz", hash = "sha256:7a988431ef0e0e24dab2c701d78b48d23389c24b96a7c82dbd90353af335e141", size = 85870, upload-time = "2026-05-12T21:09:56.047Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/96/5d/4d82bd835c130825b3ce0fa66339379d417d0379272e03773c230842c765/cbor2-6.1.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:3f9013b20e13441d8b9f535631d38b1ff654af7f45af6423c4b7ddd8c494a967", size = 409460, upload-time = "2026-05-12T21:08:59.097Z" },
+    { url = "https://files.pythonhosted.org/packages/95/a4/bf5a54cc6ccda2d5e8043f38f34c1eefd814cebf40b5812a40a39d1318c4/cbor2-6.1.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:386758adf697172aa40fe4c81172ba858f32a6409e7dffa8541fdd790505b372", size = 453687, upload-time = "2026-05-12T21:09:01.548Z" },
+    { url = "https://files.pythonhosted.org/packages/39/13/3089fb602f574c407c7047751162ec9c0dda74bc601332d2cf4ef5b65c99/cbor2-6.1.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:1e905a4bb44c2a5eb465cfef374e3d6866d5b1b8923f4d387e5fae5eb985ccfd", size = 466931, upload-time = "2026-05-12T21:09:03.633Z" },
+    { url = "https://files.pythonhosted.org/packages/59/20/0b67f0269583a0f6af9c9d22914b503515a74c78a40f737785cdf0fad00b/cbor2-6.1.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:ebf05e8086b5afa6d829dd19d3fd1680217f043ded24a49c510a064df02fc4ed", size = 520757, upload-time = "2026-05-12T21:09:05.234Z" },
+    { url = "https://files.pythonhosted.org/packages/de/57/8a6f64811d5b425ed93c247ae7415d9243a864462939c825763588fb4af3/cbor2-6.1.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:ba05594132277b4cadbb2e321ea6d1c84cc1cf1a38deaf2deb1a401f2e567d7f", size = 534182, upload-time = "2026-05-12T21:09:06.966Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/52/6914f4652cd0a14e96622688b54611519925d2dbf0f372bee225560317e3/cbor2-6.1.0-cp312-cp312-win32.whl", hash = "sha256:927b7effc7eabdccca64240f87248e41792430efb5cc9b578b793d0a7b3616e1", size = 282531, upload-time = "2026-05-12T21:09:09.129Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/13/713b2a59349b20915de7c9dbb0ded3a6ddeaedf541885d7b5ffd46799de4/cbor2-6.1.0-cp312-cp312-win_amd64.whl", hash = "sha256:190dd9631e800900ecab301745fd4278c530fdb1e7fb0a56000e568e272dd13b", size = 300184, upload-time = "2026-05-12T21:09:10.837Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/f0/423e1705946cf50f4c5e2b6bb1a806e0d28cd5e68561fb32c65fd79db151/cbor2-6.1.0-cp312-cp312-win_arm64.whl", hash = "sha256:23737b6a04a7cc0c216686c580cba70bc944ae8fcc13639c237489b4d693223c", size = 288383, upload-time = "2026-05-12T21:09:12.552Z" },
+    { url = "https://files.pythonhosted.org/packages/86/85/ec95a68b26199e218937836b3700177382a17dc9dc355fc6c687a3d8ebcd/cbor2-6.1.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:54d11fafdf6adf02c08c0ef20bdd11097c1a2c9a20b300c7fc66b07a85eb1a12", size = 408619, upload-time = "2026-05-12T21:09:13.923Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/d5/686b6d04157aec18a13a3bc185b68e5200e5cd93b78ad1f3b0dbc9dd5cdb/cbor2-6.1.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:0d3a629eb6747964e20132d78581177b3df381c345156751cc4cb4176a058ea4", size = 453023, upload-time = "2026-05-12T21:09:15.953Z" },
+    { url = "https://files.pythonhosted.org/packages/95/f7/2b84ead95cd71c30b85975e85bdfdcb70ac09679c52ea5af2354d3538ef7/cbor2-6.1.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:17f874920590da73d564092b813267c47493eec96e6765b72b5499500b9bff35", size = 465962, upload-time = "2026-05-12T21:09:17.947Z" },
+    { url = "https://files.pythonhosted.org/packages/74/39/89b749a9031b1b00c1373560a891bb25b2d282057fb3b157385dbd8744ed/cbor2-6.1.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a6f72aafa65184363e208aea5aacd81beafa07c9949e1c4d402ff46a76beb627", size = 520230, upload-time = "2026-05-12T21:09:19.812Z" },
+    { url = "https://files.pythonhosted.org/packages/97/3e/0ee1f52f83195f9a5e35fe7897360da1822c696712cdf265c44030db03ee/cbor2-6.1.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:032f06d4c04143db657c598470c3069406f897cd817c24c3b6aefb87cd1329b1", size = 533467, upload-time = "2026-05-12T21:09:22.183Z" },
+    { url = "https://files.pythonhosted.org/packages/30/13/8605f161ad89da2a67fcc03405a51bfbfd57d5bf234f1797703ba66a25f8/cbor2-6.1.0-cp313-cp313-win32.whl", hash = "sha256:dbe926724deb339f35b247f6e24d82966076ef2c41c00066576f4c3d3630d731", size = 281867, upload-time = "2026-05-12T21:09:23.715Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/5b/bad7006957b99ce12a17708cf3941feb75e39551da15b4dfd52ed93945f8/cbor2-6.1.0-cp313-cp313-win_amd64.whl", hash = "sha256:e9c35a71bf2f1d1405704839bfa590d1ea82125a2afda963e834c68548cad83f", size = 299569, upload-time = "2026-05-12T21:09:25.195Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/50/4bd8574f8a6c79ba328ca22b870274d83e57b1a8ec61c37bf7ad876ae9bd/cbor2-6.1.0-cp313-cp313-win_arm64.whl", hash = "sha256:e713bbbd025683a096f5dbcd958b1b172a224d7f0bdcab45c138870f712bf281", size = 287174, upload-time = "2026-05-12T21:09:26.717Z" },
+    { url = "https://files.pythonhosted.org/packages/db/aa/f0640584752ea4f6c575acc4b3e04d5e074e02e2aa8cd59b3bdc538f35d3/cbor2-6.1.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:634b6b9bd1197946a88fcc10e49eb205a3fe663dcbffc068949444bd4d1c3522", size = 407377, upload-time = "2026-05-12T21:09:28.197Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/3f/5db67547c6fb3b1fb74711d30cf0ea970b085295c4477959340f3e36ab6c/cbor2-6.1.0-cp314-cp314-manylinux_2_28_aarch64.whl", hash = "sha256:a313df1367d7f57259e59a86fa77ad6eaff957097738c12e860bee391558fe6a", size = 452597, upload-time = "2026-05-12T21:09:30.069Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/e6/38c5504a7d00a5803df70ebf840459693e94999c42790bf5ca18f9212bf7/cbor2-6.1.0-cp314-cp314-manylinux_2_28_x86_64.whl", hash = "sha256:780c5c769e8cdca5ea26e1b0835e7a339fa9bd514ccdcecc948c4b189d8bf426", size = 464480, upload-time = "2026-05-12T21:09:31.923Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/eb/54f5a2bbbf1eedbb4fec829978f5797b5950969f1aa8665c43b3572cd3c2/cbor2-6.1.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:32ca627b48114a47af97dc6f2ca55905835b8b1813e33efa4f9448cdfe5f9ec3", size = 519943, upload-time = "2026-05-12T21:09:33.584Z" },
+    { url = "https://files.pythonhosted.org/packages/21/3a/15a988a7ac392dee5a654e89937f9b36477595c0d76e7718c90d2ace8c19/cbor2-6.1.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:75ab21a66189c99f0007685c9c40c3e2f37aed7e9d5c9015b39e20a2df2f4be4", size = 531899, upload-time = "2026-05-12T21:09:35.51Z" },
+    { url = "https://files.pythonhosted.org/packages/50/55/6d1273a854467d4c06e390afd3984cb400a49fcf46db4da6e7eff2944e43/cbor2-6.1.0-cp314-cp314-win32.whl", hash = "sha256:b4ad2a13d11760045b32d74b662e3088635d81b3597c20e7ad41f4fd7da9271a", size = 285593, upload-time = "2026-05-12T21:09:37.44Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/32/fe8bd1e196673378782f635566e7c62fd54503b1c0d13dd4dd42ba9bbd2f/cbor2-6.1.0-cp314-cp314-win_amd64.whl", hash = "sha256:893acbe1e1de7f1e3ba172d8cf0d37e7a631167cf40bd760280a7e01ed60344f", size = 308902, upload-time = "2026-05-12T21:09:39.176Z" },
+    { url = "https://files.pythonhosted.org/packages/34/61/d6fc33c736d6cb992b5e177d654444a743f867c424549ef493bee7e1754f/cbor2-6.1.0-cp314-cp314-win_arm64.whl", hash = "sha256:29113addf431fd376fe6c269d2a7d16ef558f8575a450b83b3f433ed42b3d029", size = 299404, upload-time = "2026-05-12T21:09:40.858Z" },
+    { url = "https://files.pythonhosted.org/packages/47/7f/ffef5ce6e7eba7c663e1cb4dc37ec6552151026259e336d5053dde2dc302/cbor2-6.1.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:5be6ec0c838e429d02062b1252dca91086ace8849a6c61cfd3200e79192fc238", size = 402607, upload-time = "2026-05-12T21:09:42.745Z" },
+    { url = "https://files.pythonhosted.org/packages/06/c9/d3afb0db49cf98b0079a69f03cd757028392ca6f63fa7c106c0d1fdc04f2/cbor2-6.1.0-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:b001f272431555f9e61c93fd8fb76ced431e01fc6a672efc339a646d18a08fa5", size = 445869, upload-time = "2026-05-12T21:09:44.4Z" },
+    { url = "https://files.pythonhosted.org/packages/74/37/258163912225532acac508c2c0a6a534d2ad4cd14a29768b6006569bcc35/cbor2-6.1.0-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:9b691ae53eb6f708bc760685a72cc472fe21e899324d7a4bb0cd1a4aa64932cb", size = 459396, upload-time = "2026-05-12T21:09:46.218Z" },
+    { url = "https://files.pythonhosted.org/packages/07/c2/82df8d95f9bd0eed8154f2929df25ee5c488a8ba3067bc213ec0f349634b/cbor2-6.1.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:75532e16e8cd8f0637881ac254e689805f38cd7d08a1cbeeb09c21cb6a10d4f9", size = 511265, upload-time = "2026-05-12T21:09:47.856Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/60/ac09e9b2b115f788eb0e2af06c931e77ddbfd002200e071e8caccfd3ec99/cbor2-6.1.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:7310f218712795cb33432933d4c44cd0b2d455e4f822b59ce78d96a6a9714383", size = 526573, upload-time = "2026-05-12T21:09:49.582Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/28/221315e7ee92413de1dd2cb5962a1a589d8d6657ee12c2798d0e5049b0ba/cbor2-6.1.0-cp314-cp314t-win32.whl", hash = "sha256:c427f262ce7c3096a259c7dc599581d0a6648d84b268070cd4eaf8b3d0230753", size = 279481, upload-time = "2026-05-12T21:09:51.559Z" },
+    { url = "https://files.pythonhosted.org/packages/77/ca/0b2fa62b1e30b0c5f0fc7f3691b69bf57ced35425c314285e055b99a5b02/cbor2-6.1.0-cp314-cp314t-win_amd64.whl", hash = "sha256:ba12e97579d430f1169f853fa8e7b930cd7011abcdae63eb015f42856d0ea92f", size = 302218, upload-time = "2026-05-12T21:09:53.042Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/a1/48d9483ada705f60342c75522e3e37831e8eca6b18bd076a701dc0c7ad55/cbor2-6.1.0-cp314-cp314t-win_arm64.whl", hash = "sha256:3e8829dc8b3cd2000d5501018b1668162435eb56a5b77f5110c23b48547bd925", size = 289979, upload-time = "2026-05-12T21:09:54.774Z" },
+]
+
 [[package]]
 name = "certifi"
 version = "2025.11.12"
@@ -770,6 +959,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/98/78/01c019cdb5d6498122777c1a43056ebb3ebfeef2076d9d026bfe15583b2b/click-8.3.1-py3-none-any.whl", hash = "sha256:981153a64e25f12d547d3426c367a4857371575ee7ad18df2a6183ab0545b2a6", size = 108274, upload-time = "2025-11-15T20:45:41.139Z" },
 ]
 
+[[package]]
+name = "cloudpickle"
+version = "3.1.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/27/fb/576f067976d320f5f0114a8d9fa1215425441bb35627b1993e5afd8111e5/cloudpickle-3.1.2.tar.gz", hash = "sha256:7fda9eb655c9c230dab534f1983763de5835249750e85fbcef43aaa30a9a2414", size = 22330, upload-time = "2025-11-03T09:25:26.604Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/88/39/799be3f2f0f38cc727ee3b4f1445fe6d5e4133064ec2e4115069418a5bb6/cloudpickle-3.1.2-py3-none-any.whl", hash = "sha256:9acb47f6afd73f60dc1df93bb801b472f05ff42fa6c84167d25cb206be1fbf4a", size = 22228, upload-time = "2025-11-03T09:25:25.534Z" },
+]
+
 [[package]]
 name = "codecov"
 version = "2.1.13"
@@ -801,6 +999,21 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/60/97/891a0971e1e4a8c5d2b20bbe0e524dc04548d2307fee33cdeba148fd4fc7/comm-0.2.3-py3-none-any.whl", hash = "sha256:c615d91d75f7f04f095b30d1c1711babd43bdc6419c1be9886a85f2f4e489417", size = 7294, upload-time = "2025-07-25T14:02:02.896Z" },
 ]
 
+[[package]]
+name = "compressed-tensors"
+version = "0.13.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "loguru" },
+    { name = "pydantic" },
+    { name = "torch" },
+    { name = "transformers" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/fc/65/88dd1c58fb9d0ded51b5c86471b937a1525f91fad2211a6f051dc1ea822d/compressed_tensors-0.13.0.tar.gz", hash = "sha256:23893824d3498ea3f1a829f14a8fa85f9a5e76a34c711a038b8d7c619ca9a67c", size = 200995, upload-time = "2025-12-16T16:03:55.397Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0b/b5/61ac2563c62490922b603c09113a083fd74af3630ec3931e769484d6dcb5/compressed_tensors-0.13.0-py3-none-any.whl", hash = "sha256:3518799c9baf034eb642efb551db6b0537b8713d45a64fe4def26f7f8d6cabec", size = 192620, upload-time = "2025-12-16T16:03:53.041Z" },
+]
+
 [[package]]
 name = "contourpy"
 version = "1.3.3"
@@ -1029,6 +1242,65 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/48/ef/0c2f4a8e31018a986949d34a01115dd057bf536905dca38897bacd21fac3/cryptography-46.0.5-cp38-abi3-win_amd64.whl", hash = "sha256:556e106ee01aa13484ce9b0239bca667be5004efb0aabbed28d353df86445595", size = 3467050, upload-time = "2026-02-10T19:18:18.899Z" },
 ]
 
+[[package]]
+name = "cuda-bindings"
+version = "13.2.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "cuda-pathfinder" },
+]
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/52/c8/b2589d68acf7e3d63e2be330b84bc25712e97ed799affbca7edd7eae25d6/cuda_bindings-13.2.0-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e865447abfb83d6a98ad5130ed3c70b1fc295ae3eeee39fd07b4ddb0671b6788", size = 5722404, upload-time = "2026-03-11T00:12:44.041Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/92/f899f7bbb5617bb65ec52a6eac1e9a1447a86b916c4194f8a5001b8cde0c/cuda_bindings-13.2.0-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:46d8776a55d6d5da9dd6e9858fba2efcda2abe6743871dee47dd06eb8cb6d955", size = 6320619, upload-time = "2026-03-11T00:12:45.939Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/a5/d7f01a415e134546248cef612adad8153c9f1eb10ec79505a7cd8294370b/cuda_bindings-13.2.0-cp312-cp312-win_amd64.whl", hash = "sha256:45815daeb595bf3b405c52671a2542b1f8e9329f3b029494acbfcc74aeaa1f2d", size = 5840830, upload-time = "2026-03-11T00:12:48.43Z" },
+    { url = "https://files.pythonhosted.org/packages/df/93/eef988860a3ca985f82c4f3174fc0cdd94e07331ba9a92e8e064c260337f/cuda_bindings-13.2.0-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6629ca2df6f795b784752409bcaedbd22a7a651b74b56a165ebc0c9dcbd504d0", size = 5614610, upload-time = "2026-03-11T00:12:50.337Z" },
+    { url = "https://files.pythonhosted.org/packages/18/23/6db3aba46864aee357ab2415135b3fe3da7e9f1fa0221fa2a86a5968099c/cuda_bindings-13.2.0-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7dca0da053d3b4cc4869eff49c61c03f3c5dbaa0bcd712317a358d5b8f3f385d", size = 6149914, upload-time = "2026-03-11T00:12:52.374Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/84/d3b6220b51cbc02ca14db7387e97445126b4ff5125aaa6c5dd7dcb75e679/cuda_bindings-13.2.0-cp313-cp313-win_amd64.whl", hash = "sha256:8cebe3ce4aeeca5af9c490e175f76c4b569bbf4a35a62294b777bc77bf7ac4d8", size = 5796512, upload-time = "2026-03-11T00:12:54.483Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/87/87a014f045b77c6de5c8527b0757fe644417b184e5367db977236a141602/cuda_bindings-13.2.0-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a6464b30f46692d6c7f65d4a0e0450d81dd29de3afc1bb515653973d01c2cd6e", size = 5685673, upload-time = "2026-03-11T00:12:56.371Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/5e/c0fe77a73aaefd3fff25ffaccaac69c5a63eafdf8b9a4c476626ef0ac703/cuda_bindings-13.2.0-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f4af9f3e1be603fa12d5ad6cfca7844c9d230befa9792b5abdf7dd79979c3626", size = 6191386, upload-time = "2026-03-11T00:12:58.965Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/73/98bcb069778fe420226db75aff54b5dd6c3ecfd0912edabab723326e80b7/cuda_bindings-13.2.0-cp314-cp314-win_amd64.whl", hash = "sha256:bd658bb5c0e55b7b3e5dd0ed509c6addb298c665db26a9bfba35e1e626000ba2", size = 5938605, upload-time = "2026-03-11T00:13:01.639Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/58/ed2c3b39c8dd5f96aa7a4abef0d47a73932c7a988e30f5fa428f00ed0da1/cuda_bindings-13.2.0-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:df850a1ff8ce1b3385257b08e47b70e959932f5f432d0a4e46a355962b4e4771", size = 5507469, upload-time = "2026-03-11T00:13:04.063Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/01/0c941b112ceeb21439b05895eace78ca1aa2eaaf695c8521a068fd9b4c00/cuda_bindings-13.2.0-cp314-cp314t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e8a16384c6494e5485f39314b0b4afb04bee48d49edb16d5d8593fd35bbd231b", size = 6059693, upload-time = "2026-03-11T00:13:06.003Z" },
+    { url = "https://files.pythonhosted.org/packages/52/49/4e01cc06447d39476e138d1b1adec8d35c0d04eccd2c8d69befc08cd66e8/cuda_bindings-13.2.0-cp314-cp314t-win_amd64.whl", hash = "sha256:6ccf14e0c1def3b7200100aafff3a9f7e210ecb6e409329e92dcf6cd2c00d5c7", size = 6662637, upload-time = "2026-03-11T00:13:07.881Z" },
+]
+
+[[package]]
+name = "cuda-pathfinder"
+version = "1.5.4"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/11/d0/c177e29701cf1d3008d7d2b16b5fc626592ce13bd535f8795c5f57187e0e/cuda_pathfinder-1.5.4-py3-none-any.whl", hash = "sha256:9563d3175ce1828531acf4b94e1c1c7d67208c347ca002493e2654878b26f4b7", size = 51657, upload-time = "2026-04-27T22:42:07.712Z" },
+]
+
+[[package]]
+name = "cuda-python"
+version = "13.2.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "cuda-bindings" },
+    { name = "cuda-pathfinder" },
+]
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/4a/da/b4dbe129f941afe1c24a09ba53521b78875626763d96414798a74763282f/cuda_python-13.2.0-py3-none-any.whl", hash = "sha256:2f092b0ec13a860115fa595411889ee939ad203450ea4f91e9461b174ea7b084", size = 8145, upload-time = "2026-03-11T13:55:19.143Z" },
+]
+
+[[package]]
+name = "cupy-cuda12x"
+version = "13.6.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "fastrlock", marker = "sys_platform != 'darwin'" },
+    { name = "numpy", marker = "sys_platform != 'darwin'" },
+]
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/12/c5/7e7fc4816d0de0154e5d9053242c3a08a0ca8b43ee656a6f7b3b95055a7b/cupy_cuda12x-13.6.0-cp312-cp312-manylinux2014_aarch64.whl", hash = "sha256:a6970ceefe40f9acbede41d7fe17416bd277b1bd2093adcde457b23b578c5a59", size = 127334633, upload-time = "2025-08-18T08:24:43.065Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/95/d7e1295141e7d530674a3cc567e13ed0eb6b81524cb122d797ed996b5bea/cupy_cuda12x-13.6.0-cp312-cp312-manylinux2014_x86_64.whl", hash = "sha256:79b0cacb5e8b190ef409f9e03f06ac8de1b021b0c0dda47674d446f5557e0eb1", size = 112886268, upload-time = "2025-08-18T08:24:49.294Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/8c/14555b63fd78cfac7b88af0094cea0a3cb845d243661ec7da69f7b3ea0de/cupy_cuda12x-13.6.0-cp312-cp312-win_amd64.whl", hash = "sha256:ca06fede7b8b83ca9ad80062544ef2e5bb8d4762d1c4fc3ac8349376de9c8a5e", size = 89785108, upload-time = "2025-08-18T08:24:54.527Z" },
+    { url = "https://files.pythonhosted.org/packages/19/ec/f62cb991f11fb41291c4c15b6936d7b67ffa71ddb344ad6e8894e06ce58d/cupy_cuda12x-13.6.0-cp313-cp313-manylinux2014_aarch64.whl", hash = "sha256:e5426ae3b1b9cf59927481e457a89e3f0b50a35b114a8034ec9110e7a833434c", size = 126904601, upload-time = "2025-08-18T08:24:59.951Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/b8/30127bcdac53a25f94ee201bf4802fcd8d012145567d77c54174d6d01c01/cupy_cuda12x-13.6.0-cp313-cp313-manylinux2014_x86_64.whl", hash = "sha256:52d9e7f83d920da7d81ec2e791c2c2c747fdaa1d7b811971b34865ce6371e98a", size = 112654824, upload-time = "2025-08-18T08:25:05.944Z" },
+    { url = "https://files.pythonhosted.org/packages/72/36/c9e24acb19f039f814faea880b3704a3661edaa6739456b73b27540663e3/cupy_cuda12x-13.6.0-cp313-cp313-win_amd64.whl", hash = "sha256:297b4268f839de67ef7865c2202d3f5a0fb8d20bd43360bc51b6e60cb4406447", size = 89750580, upload-time = "2025-08-18T08:25:10.972Z" },
+]
+
 [[package]]
 name = "cycler"
 version = "0.12.1"
@@ -1118,6 +1390,19 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/07/6c/aa3f2f849e01cb6a001cd8554a88d4c77c5c1a31c95bdf1cf9301e6d9ef4/defusedxml-0.7.1-py2.py3-none-any.whl", hash = "sha256:a352e7e428770286cc899e2542b6cdaedb2b4953ff269a210103ec58f6198a61", size = 25604, upload-time = "2021-03-08T10:59:24.45Z" },
 ]
 
+[[package]]
+name = "depyf"
+version = "0.20.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "astor" },
+    { name = "dill" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/88/35/83fb0178212279aa0af031031905804c6de5618435d229f41ed21bb9ad2c/depyf-0.20.0.tar.gz", hash = "sha256:fb7683bd72c44f67b56029df2c47721e9a02ffa4d7b19095f1c54c4ebf797a98", size = 6168761, upload-time = "2025-10-13T12:33:38.589Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/cf/65/4df6936130b56e1429114e663e7c1576cf845f3aef1b2dd200c0a5d19dba/depyf-0.20.0-py3-none-any.whl", hash = "sha256:d31effad4261cebecb58955d832e448ace88f432328f95f82fd99c30fd9308d4", size = 39381, upload-time = "2025-10-13T12:33:33.647Z" },
+]
+
 [[package]]
 name = "dill"
 version = "0.4.1"
@@ -1154,6 +1439,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/12/b3/231ffd4ab1fc9d679809f356cebee130ac7daa00d6d6f3206dd4fd137e9e/distro-1.9.0-py3-none-any.whl", hash = "sha256:7bffd925d65168f85027d8da9af6bddab658135b840670a223589bc0c8ef02b2", size = 20277, upload-time = "2023-12-24T09:54:30.421Z" },
 ]
 
+[[package]]
+name = "dnspython"
+version = "2.8.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/8c/8b/57666417c0f90f08bcafa776861060426765fdb422eb10212086fb811d26/dnspython-2.8.0.tar.gz", hash = "sha256:181d3c6996452cb1189c4046c61599b84a5a86e099562ffde77d26984ff26d0f", size = 368251, upload-time = "2025-09-07T18:58:00.022Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ba/5a/18ad964b0086c6e62e2e7500f7edc89e3faa45033c71c1893d34eed2b2de/dnspython-2.8.0-py3-none-any.whl", hash = "sha256:01d9bbc4a2d76bf0db7c1f729812ded6d912bd318d3b1cf81d30c0f845dbf3af", size = 331094, upload-time = "2025-09-07T18:57:58.071Z" },
+]
+
 [[package]]
 name = "docstring-parser"
 version = "0.17.0"
@@ -1172,6 +1466,28 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/b0/0d/9feae160378a3553fa9a339b0e9c1a048e147a4127210e286ef18b730f03/durationpy-0.10-py3-none-any.whl", hash = "sha256:3b41e1b601234296b4fb368338fdcd3e13e0b4fb5b67345948f4f2bf9868b286", size = 3922, upload-time = "2025-05-17T13:52:36.463Z" },
 ]
 
+[[package]]
+name = "einops"
+version = "0.8.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/2c/77/850bef8d72ffb9219f0b1aac23fbc1bf7d038ee6ea666f331fa273031aa2/einops-0.8.2.tar.gz", hash = "sha256:609da665570e5e265e27283aab09e7f279ade90c4f01bcfca111f3d3e13f2827", size = 56261, upload-time = "2026-01-26T04:13:17.638Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2a/09/f8d8f8f31e4483c10a906437b4ce31bdf3d6d417b73fe33f1a8b59e34228/einops-0.8.2-py3-none-any.whl", hash = "sha256:54058201ac7087911181bfec4af6091bb59380360f069276601256a76af08193", size = 65638, upload-time = "2026-01-26T04:13:18.546Z" },
+]
+
+[[package]]
+name = "email-validator"
+version = "2.3.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "dnspython" },
+    { name = "idna" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/f5/22/900cb125c76b7aaa450ce02fd727f452243f2e91a61af068b40adba60ea9/email_validator-2.3.0.tar.gz", hash = "sha256:9fc05c37f2f6cf439ff414f8fc46d917929974a82244c20eb10231ba60c54426", size = 51238, upload-time = "2025-08-26T13:09:06.831Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/de/15/545e2b6cf2e3be84bc1ed85613edd75b8aea69807a71c26f4ca6a9258e82/email_validator-2.3.0-py3-none-any.whl", hash = "sha256:80f13f623413e6b197ae73bb10bf4eb0908faf509ad8362c5edeb0be7fd450b4", size = 35604, upload-time = "2025-08-26T13:09:05.858Z" },
+]
+
 [[package]]
 name = "et-xmlfile"
 version = "2.0.0"
@@ -1190,6 +1506,146 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/c1/ea/53f2148663b321f21b5a606bd5f191517cf40b7072c0497d3c92c4a13b1e/executing-2.2.1-py2.py3-none-any.whl", hash = "sha256:760643d3452b4d777d295bb167ccc74c64a81df23fb5e08eff250c425a4b2017", size = 28317, upload-time = "2025-09-01T09:48:08.5Z" },
 ]
 
+[[package]]
+name = "fastapi"
+version = "0.136.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "annotated-doc" },
+    { name = "pydantic" },
+    { name = "starlette" },
+    { name = "typing-extensions" },
+    { name = "typing-inspection" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/5d/45/c130091c2dfa061bbfe3150f2a5091ef1adf149f2a8d2ae769ecaf6e99a2/fastapi-0.136.1.tar.gz", hash = "sha256:7af665ad7acfa0a3baf8983d393b6b471b9da10ede59c60045f49fbc89a0fa7f", size = 397448, upload-time = "2026-04-23T16:49:44.046Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5a/ff/2e4eca3ade2c22fe1dea7043b8ee9dabe47753349eb1b56a202de8af6349/fastapi-0.136.1-py3-none-any.whl", hash = "sha256:a6e9d7eeada96c93a4d69cb03836b44fa34e2854accb7244a1ece36cd4781c3f", size = 117683, upload-time = "2026-04-23T16:49:42.437Z" },
+]
+
+[package.optional-dependencies]
+standard = [
+    { name = "email-validator" },
+    { name = "fastapi-cli", extra = ["standard"] },
+    { name = "fastar" },
+    { name = "httpx" },
+    { name = "jinja2" },
+    { name = "pydantic-extra-types" },
+    { name = "pydantic-settings" },
+    { name = "python-multipart" },
+    { name = "uvicorn", extra = ["standard"] },
+]
+
+[[package]]
+name = "fastapi-cli"
+version = "0.0.24"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "rich-toolkit" },
+    { name = "typer" },
+    { name = "uvicorn", extra = ["standard"] },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/6e/58/74797ae9e4610cfa0c6b34c8309096d3b20bb29be3b8b5fbf1004d10fa5f/fastapi_cli-0.0.24.tar.gz", hash = "sha256:1afc9c9e21d7ebc8a3ca5e31790cd8d837742be7e4f8b9236e99cb3451f0de00", size = 19043, upload-time = "2026-02-24T10:45:10.476Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c7/4b/68f9fe268e535d79c76910519530026a4f994ce07189ac0dded45c6af825/fastapi_cli-0.0.24-py3-none-any.whl", hash = "sha256:4a1f78ed798f106b4fee85ca93b85d8fe33c0a3570f775964d37edb80b8f0edc", size = 12304, upload-time = "2026-02-24T10:45:09.552Z" },
+]
+
+[package.optional-dependencies]
+standard = [
+    { name = "fastapi-cloud-cli" },
+    { name = "uvicorn", extra = ["standard"] },
+]
+
+[[package]]
+name = "fastapi-cloud-cli"
+version = "0.17.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "fastar" },
+    { name = "httpx" },
+    { name = "pydantic", extra = ["email"] },
+    { name = "rich-toolkit" },
+    { name = "rignore" },
+    { name = "sentry-sdk" },
+    { name = "typer" },
+    { name = "uvicorn", extra = ["standard"] },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/96/57/cee8e91b83f39e75ae5562a2237261442a8179dcb3b631c7398113157398/fastapi_cloud_cli-0.17.1.tar.gz", hash = "sha256:0baece208fa88063bec46dccb5fb512f3199162092165e57654b44e64adbc44d", size = 47409, upload-time = "2026-04-27T13:38:07.094Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e7/a0/e252b68cf155409afabea037ab2971f41509481838847f6503fe890884ea/fastapi_cloud_cli-0.17.1-py3-none-any.whl", hash = "sha256:325e0199bdac7cb86f5df4f4a1d2070054095588088ef7b923a60cec458dcd63", size = 34046, upload-time = "2026-04-27T13:38:08.319Z" },
+]
+
+[[package]]
+name = "fastar"
+version = "0.11.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/03/0f/0aeb3fc50046617702acc0078b277b58367fd62eb727b9ec733ae0e8bbcc/fastar-0.11.0.tar.gz", hash = "sha256:aa7f100f7313c03fdb20f1385927ba95671071ba308ad0c1763fef295e1895ce", size = 70238, upload-time = "2026-04-13T17:11:17.143Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0f/06/a5773706afc8bd496769786590bbc56d2d0ee419a299cc12ea3f5717fcf3/fastar-0.11.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:3c51f1c2cdddbd1420d2897ace7738e36c65e17f6ae84e0bfe763f8d1068bb97", size = 708394, upload-time = "2026-04-13T17:09:57.269Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/a6/d5e2a4e48495616440a21eed07558219ca90243ad00b0502586f95bd4833/fastar-0.11.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:0d9d6b052baf5380baea866675dab6ccd04ec2460d12b1c46f10ce3f4ee6a820", size = 628417, upload-time = "2026-04-13T17:09:42.145Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/69/9816d69ac8265c9e50456637a487ccfb7a9c566efd9dbcd673df9c2558c2/fastar-0.11.0-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:bd2f05666d4df7e14885b5c38fefd92a785917387513d33d837ff42ec143a22f", size = 863950, upload-time = "2026-04-13T17:09:11.506Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/0d/f88daad53aff2e754b6b5ff2a7113f72447a34f6ef17cc23ca99988117b7/fastar-0.11.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c1e6e74aba1ae77ca4aedcaf1697cd413319f4c88a5ccbe5b42c709517c5097e", size = 760737, upload-time = "2026-04-13T17:07:55.958Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/a6/82ef4ecd969d50d92ed3ed9dbd8fe77faa24be5e5736f716edc9f4ce8d62/fastar-0.11.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:38ef77fe940bbc9b37a98bd838727f844b11731cd39358a2640ff864fb385086", size = 757603, upload-time = "2026-04-13T17:08:10.623Z" },
+    { url = "https://files.pythonhosted.org/packages/03/35/50249f0d827251f8ac511495e2eacccebda80a00a0ad73e9615b8113b84f/fastar-0.11.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8955e61b32d6aff82c983217abf80933fd823b0e727586fc72f08043d996fd59", size = 923952, upload-time = "2026-04-13T17:08:25.526Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/d8/faee41659e9c379d906d24eaee6d6833ac8cfef0a5df480e5c2a8d3efb33/fastar-0.11.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:483532442cdb08fbff0169510224eae0836f2f672cea6aacb52847d90fefdc46", size = 816574, upload-time = "2026-04-13T17:08:56.076Z" },
+    { url = "https://files.pythonhosted.org/packages/22/47/0448ea7992b997dad2bf004bfd98eca74b5858630eae080b50c7b17d9ddc/fastar-0.11.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ef5a6071121e05d8287fc75bccb054bcbac8bb0501200a0c0a8feeace5303ea4", size = 819382, upload-time = "2026-04-13T17:09:26.66Z" },
+    { url = "https://files.pythonhosted.org/packages/33/ef/0d63eb43586831b7a6f8b22c4d77125a7c594423af1f4f090fa9541b9b40/fastar-0.11.0-cp312-cp312-manylinux_2_31_riscv64.whl", hash = "sha256:e45e598af5afe8412197d4786efd6cf29be02e7d3d4f6a3461149eae5d7e94f1", size = 885254, upload-time = "2026-04-13T17:08:40.9Z" },
+    { url = "https://files.pythonhosted.org/packages/01/25/edd584675d69e49a165052c3ee886df1c5d574f3e7d813c990306387c623/fastar-0.11.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:2e160919b1c47ddb8538e7e8eb4cd527281b40f0bf75110a75993838ef61f286", size = 971239, upload-time = "2026-04-13T17:10:12.997Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/37/e8bb24f506ba2b08fbaf36c5800e843bd4d542954e9331f00418e2d23349/fastar-0.11.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:4bb4dc0fc8f7a6807febcebce8a2f3626ba4955a9263d81ecc630aad83be84c0", size = 1035185, upload-time = "2026-04-13T17:10:30.207Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/bf/be753736296338149ee4cb3e92e2b5423d6ba17c7b951d15218fd7e99bbf/fastar-0.11.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:4ec95af56aa173f6e320e1183001bf108ba59beaf13edd1fc8200648db203588", size = 1072191, upload-time = "2026-04-13T17:10:47.072Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/cd/a81c1aaafb5a22ce57c98ae22f39c89413ed53e4ee6e1b1444b0bd666a6c/fastar-0.11.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:136cf342735464091c39dc3708168f9fdeb9ebea40b1ead937c61afaf46143d9", size = 1028054, upload-time = "2026-04-13T17:11:04.293Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/88/1ce4eed3d70627c95f49ca017f6bbbf2ddcc4b0c601d293259de7689bc20/fastar-0.11.0-cp312-cp312-win32.whl", hash = "sha256:35f23c11b556cc4d3704587faacbc0037f7bdf6c4525cd1d09c70bda4b1c6809", size = 454198, upload-time = "2026-04-13T17:11:45.168Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/1d/26ce92f4331cd61a69840db9ca6115829805eec24f285481a854f578e917/fastar-0.11.0-cp312-cp312-win_amd64.whl", hash = "sha256:920bc56c3c0b8a8ca492904941d1883c1c947c858cd93343356c29122a38f44c", size = 486697, upload-time = "2026-04-13T17:11:31.084Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/96/e6eda4480559c69b05d466e7b5ea9170e81fef3795a73e059959a3258319/fastar-0.11.0-cp312-cp312-win_arm64.whl", hash = "sha256:395248faf89e8a6bd5dc1fd544c8465113b627cb6d7c8b296796b60ebea33593", size = 462591, upload-time = "2026-04-13T17:11:20.577Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/d6/3be260037e86fb694e88d47f583bac3a0188c99cee1a6b257ac26cb6b53c/fastar-0.11.0-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:33f544b08b4541b678e53749b4552a44720d96761fb79c172b005b1089c443ed", size = 707975, upload-time = "2026-04-13T17:09:58.866Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/cd/7867aefb1784662554a335f2952c75a50f0c70585ed0d2210d6cc15e5627/fastar-0.11.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:91c1c792447e4a642745f347ff9847c52af39633071c57ee67ed53c157fc3506", size = 628460, upload-time = "2026-04-13T17:09:43.776Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/2b/d11d84bdd5e0e377771b955755771e3460b290da5809cb78c1b735ee2228/fastar-0.11.0-cp313-cp313-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:881247e6b6eaea59fc6569f9b61447aa6b9fc2ee864e048b4643d69c52745805", size = 863054, upload-time = "2026-04-13T17:09:13.048Z" },
+    { url = "https://files.pythonhosted.org/packages/25/39/d3f428b318fa940b1b6e785b8d54fc895dfb5d5b945ef8d5442ffa904fb2/fastar-0.11.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:863b7929845c9fec92ef6c8d59579cf46af5136655e5342f8df5cebe46cab06c", size = 760247, upload-time = "2026-04-13T17:07:57.396Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/04/03949aee82aabb8ede06ac5a4a5579ffaf98a8fe59ce958494508ff15513/fastar-0.11.0-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:96b4a57df12bf3211662627a3ea29d62ecb314a2434a0d0843f9fc23e47536e5", size = 756512, upload-time = "2026-04-13T17:08:12.415Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/0c/2ca1ae0a3828ca51047962d932b80daca2522db73e8cb9d040cb6ebe28d5/fastar-0.11.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ceef1c2c4df7b7b8ebd3f5d718bbf457b9bbdf25ce0bd07870211ec4fbd9aff4", size = 922183, upload-time = "2026-04-13T17:08:27.187Z" },
+    { url = "https://files.pythonhosted.org/packages/65/68/7fe808b1f73a68e686f25434f538c6dc10ef4dfb3db0ace22cd861744bf8/fastar-0.11.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b8e545918441910a779659d4759ad0eef349e935fbdb4668a666d3681567eb05", size = 816394, upload-time = "2026-04-13T17:08:57.657Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/17/07d086080f8a83b8d7966955e29bcdbd6a060f5bd949dc9d5abd3658cead/fastar-0.11.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:28095bb8f821e85fc2764e1a55f03e5e2876dee2abe7cd0ee9420d929905d643", size = 818983, upload-time = "2026-04-13T17:09:28.46Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/e2/2c4edf0910af2e814ff6d65b77a91196d472ca8a9fb2033bd983f6856caa/fastar-0.11.0-cp313-cp313-manylinux_2_31_riscv64.whl", hash = "sha256:0fafb95ecbe70f666a5e9b35dd63974ccdc9bb3d99ccdbd4014a823ec3e659b5", size = 884689, upload-time = "2026-04-13T17:08:42.763Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/ba/04fdcbd6558e60de4ced3b55230fac47675d181252582b2fcec3c74608e5/fastar-0.11.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:af48fed039b94016629dcdad1c95c90c486326dd068de2b0a4df419ee09b6821", size = 970677, upload-time = "2026-04-13T17:10:15.124Z" },
+    { url = "https://files.pythonhosted.org/packages/df/b3/2b860a9658550167dbd5824c85e88d0b4b912bf493e42a6322544d6e483d/fastar-0.11.0-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:74cd96163f39b8638ab4e8d49708ca887959672a22871d8170d01f067319533b", size = 1034026, upload-time = "2026-04-13T17:10:32.318Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/9b/fa42ea1188b144bac4b1b60753dfd449974a4d5eda132029ee7711569f94/fastar-0.11.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:4e8b993cb5613bab495ed482810bedc0986633fcb9a3b55c37ec88e0d6714f6a", size = 1071147, upload-time = "2026-04-13T17:10:48.833Z" },
+    { url = "https://files.pythonhosted.org/packages/95/c8/d2e501556dca9f1fbc9246111a31792fb49ad908fa4927f34938a97a3604/fastar-0.11.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:dfe39d91fc28e37e06162d94afe01050220edb7df554acb5b702b5503e564816", size = 1028377, upload-time = "2026-04-13T17:11:06.374Z" },
+    { url = "https://files.pythonhosted.org/packages/db/33/5f11f23eca0a569cd052507bc45dda2e5468697f8665728d25be44120f7d/fastar-0.11.0-cp313-cp313-win32.whl", hash = "sha256:c5f63d4d99ff4bfb37c659982ec413358bdee747005348756cc50a04d412d989", size = 454089, upload-time = "2026-04-13T17:11:46.821Z" },
+    { url = "https://files.pythonhosted.org/packages/da/2f/35ff03c939cba7a255a9132367873fec6c355fd06a7f84fedcbaf4c8129f/fastar-0.11.0-cp313-cp313-win_amd64.whl", hash = "sha256:8690ed1928d31ded3ada308e1086525fb3871f5fa81e1b69601a3f7774004583", size = 486312, upload-time = "2026-04-13T17:11:32.86Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/71/ee9246cbfcbfd4144558f35e7e9a306ffe0a7564730a5188c45f21d2dab8/fastar-0.11.0-cp313-cp313-win_arm64.whl", hash = "sha256:d977ded9d98a0719a305e0a4d5ee811f1d3e856d853a50acb8ae833c3cd6d5d2", size = 461975, upload-time = "2026-04-13T17:11:22.589Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/cd/3644c48ecac456f928c12d47ec3bed36c36555b17c3859856f1ff860265d/fastar-0.11.0-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:71375bd6f03c2a43eb47bd949ea38ff45434917f9cdac79675c5b9f60de4fa73", size = 707860, upload-time = "2026-04-13T17:10:00.371Z" },
+    { url = "https://files.pythonhosted.org/packages/69/ca/dee04476ae3626b2b040a60ad84628f77e1ffd8444232f2426b0ca1e0d7e/fastar-0.11.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:eddfd9cab16e19ae247fe44bf992cb403ccfe27d3931d6de29a4695d95ad386c", size = 628216, upload-time = "2026-04-13T17:09:45.355Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/5e/9395c7353d079cb4f5be0f7982ce0dc9f2e7dec5fd175eef466729d6023a/fastar-0.11.0-cp314-cp314-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:7c371f1d4386c699018bb64eb2fa785feacf32785559049d2bb72fe4af023f53", size = 864378, upload-time = "2026-04-13T17:09:14.611Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/ba/1e4f67148223ff219612b6281a6000357abbcc2417964fa5c83f11d68fce/fastar-0.11.0-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cad7fa41e3e66554387481c1a09365e4638becd322904932674159d5f4046728", size = 760921, upload-time = "2026-04-13T17:07:59.138Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/82/09d11fb6d12f17993ffaf32ffd30c3c121a11e2966e84f19fb6f66430118/fastar-0.11.0-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:cf36652fa71b83761717c9899b98732498f8a2cb6327ff16bbf07f6be85c3437", size = 757012, upload-time = "2026-04-13T17:08:14.186Z" },
+    { url = "https://files.pythonhosted.org/packages/52/1f/5aeeacc4cb65615e2c9292cd9c5b0cd6fb6d2e6ee472ca6adc6c1b1b22ef/fastar-0.11.0-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f68ff8c17833053da4841720e95edde80ce45bb994b6b7d51418dddaac70ee47", size = 924510, upload-time = "2026-04-13T17:08:28.741Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/1a/1e5bdabbeaf2e856928956292609f2ff6a650f94480fb8afaca30229e483/fastar-0.11.0-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4563ed37a12ea1cdc398af8571258d24b988bf342b7b3bf5451bd5891243280c", size = 816602, upload-time = "2026-04-13T17:08:59.461Z" },
+    { url = "https://files.pythonhosted.org/packages/87/24/f960147910da3bed41a3adfcb026e17d5f50f4cf467a3324237a7088f61a/fastar-0.11.0-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cee63c9875cba3b70dc44338c560facc5d6e763047dcc4a30501f9a68cf5f890", size = 819452, upload-time = "2026-04-13T17:09:29.926Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/f4/3e77d7901d5707fd7f8a352e153c8ae09ea974e6fabad0b7c4eb9944b8d4/fastar-0.11.0-cp314-cp314-manylinux_2_31_riscv64.whl", hash = "sha256:bd76bfffae6d0a91f4ac4a612f721e7aec108db97dccdd120ae063cd66959f27", size = 885254, upload-time = "2026-04-13T17:08:44.285Z" },
+    { url = "https://files.pythonhosted.org/packages/47/01/1585edd5ec47782ae93cd94edf05828e0ab02ef00aec00aea4194a600464/fastar-0.11.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:8f5b707501ec01c1bc0518f741f01d322e50c9adc19a451aa24f67a2316e9397", size = 971496, upload-time = "2026-04-13T17:10:17.024Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/e9/6874c9d1236ded565a0bed54b320ac9f165f287b1d89490fb70f9f323c81/fastar-0.11.0-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:37c0b5a88a657839aad98b0a6c9e4ac4c2c15d6b49c44ee3935c6b08e9d3e479", size = 1034685, upload-time = "2026-04-13T17:10:34.063Z" },
+    { url = "https://files.pythonhosted.org/packages/14/d8/4ab20613ce2983427aee958e39be878dba874aa227c530a845e32429c4f6/fastar-0.11.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:6c55f536c62a6efb180c1af0d5182948bff576bbfe6276e8e1359c9c7d2215d8", size = 1072675, upload-time = "2026-04-13T17:10:50.53Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/ae/5ac3b7c20ce4b08f011dd2b979f96caabe64f9b10b157f211ea91bdfadca/fastar-0.11.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:3082eeca59e189b9039335862f4c2780c0c8871d656bfdf559db4414a105b251", size = 1029330, upload-time = "2026-04-13T17:11:08.138Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/e7/37cd6a1d4e288292170b64e19d79ecce2a7de8bb76790323399a2abc4619/fastar-0.11.0-cp314-cp314-win32.whl", hash = "sha256:b201a0a4e29f9fec2a177e13154b8725ec65ab9f83bd6415483efaa2aa18344b", size = 453940, upload-time = "2026-04-13T17:11:48.713Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/1c/795c878b1ee29d79021cf8ed81f18f2b25ccde58453b0d34b9bdc7e025ea/fastar-0.11.0-cp314-cp314-win_amd64.whl", hash = "sha256:868fddb26072a43e870a8819134b9f80ee602931be5a76e6fb873e04da343637", size = 486334, upload-time = "2026-04-13T17:11:34.882Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/a4/113f104301df8bddcc0b3775b611a30cb7610baa3add933c7ccac9386467/fastar-0.11.0-cp314-cp314-win_arm64.whl", hash = "sha256:3db39c9cc42abb0c780a26b299f24dfbc8be455985e969e15336d70d7b2f833b", size = 461534, upload-time = "2026-04-13T17:11:24.329Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/a6/5c5f2c2c8e0c63e56a5636ebc7721589c889e94c0092cec7eb28ae7207e6/fastar-0.11.0-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:49c3299dec5e125e7ebaa27545714da9c7391777366015427e0ae62d548b442b", size = 707156, upload-time = "2026-04-13T17:10:02.176Z" },
+    { url = "https://files.pythonhosted.org/packages/df/f7/982c01b61f0fc135ad2b16d01e6d0ee53cf8791e68827f5f7c5a65b2e5b1/fastar-0.11.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:3328ed1ed56d31f5198350b17dd60449b8d6b9d47abb4688bab6aef4450a165b", size = 627032, upload-time = "2026-04-13T17:09:46.978Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/c3/38f1dac77ae0c71c37b176277c96d830796b8ce2fe69705f917829b53829/fastar-0.11.0-cp314-cp314t-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:bd3eca3bbfec84a614bcb4143b4ad4f784d0895babc26cfc88436af88ca23c7a", size = 864403, upload-time = "2026-04-13T17:09:16.58Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/f0/e69c363bdb3e5a5848e937b662b5469581ee6682c51bc1c0556494773929/fastar-0.11.0-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ff86a967acb0d621dd24063dda090daa67bf4993b9570e97fe156de88a9006ca", size = 759480, upload-time = "2026-04-13T17:08:00.599Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/29/4d8737590c2a6357d614d7cc7288e8f68e7e449680b8922997cc4349e65e/fastar-0.11.0-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:86eaf7c0e985d93a7734168be2fb232b2a8cca53e41431c2782d7c12b12c03b1", size = 756219, upload-time = "2026-04-13T17:08:15.699Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/ec/400de7b3b7d48801908f19cf5462177104395799472671b3e8152b2b04ca/fastar-0.11.0-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:91f07b0b8eb67e2f177733a1f884edad7dfb9f8977ffef15927b20cb9604027d", size = 923669, upload-time = "2026-04-13T17:08:30.574Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/01/8926c53da923fed7ab4b96e7fbf7f73b663beb4f02095b654d6fab46f9ad/fastar-0.11.0-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f85c896885eb4abf1a635d54dea22cac6ae48d04fc2ea26ae652fcf1febe1220", size = 815729, upload-time = "2026-04-13T17:09:01.204Z" },
+    { url = "https://files.pythonhosted.org/packages/89/f0/5fef4c7946e352651b504b1a4235dac3505e7cfd24020788ab50552e84bf/fastar-0.11.0-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:075c07095c8de4b774ba8f28b9c0a02b1a2cd254da50cbe464dd3bb2432e9158", size = 819812, upload-time = "2026-04-13T17:09:31.907Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/c8/0ebc3298b4a45e7bddc50b169ae6a6f5b80c939394d4befe6e60de535ee7/fastar-0.11.0-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:07f028933820c65750baf3383b807ecce1cd9385cf00ce192b79d263ad6b856c", size = 884074, upload-time = "2026-04-13T17:08:45.802Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/9f/7baa4cdff8d6fbca41fa5c764b48a941fed8a9ec6c4cc92de65895a28299/fastar-0.11.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:039f875efa0f01fa43c20bf4e2fc7305489c61d0ac76eda991acfba7820a0e63", size = 969450, upload-time = "2026-04-13T17:10:18.667Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/dc/1ebbfb58a47056ba866494f19efbcdd2ba2897096b94f36e796594b4d05b/fastar-0.11.0-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:fff12452a9a5c6814a012445f26365541cc3d99dcca61f09762e6a389f7a32ea", size = 1033775, upload-time = "2026-04-13T17:10:36.165Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/5f/ce4e3914066f08c99eb8c32952cc07c1a013e81b1db1b0f598130bf6b974/fastar-0.11.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:2bf733e09f942b6fa876efe30a90508d1f4caef5630c00fb2a84fba355873712", size = 1072158, upload-time = "2026-04-13T17:10:52.497Z" },
+    { url = "https://files.pythonhosted.org/packages/03/2a/6bca72992c84151c387cc6558f3867f5ebe5fb3684ee6fa9b76280ba4b8e/fastar-0.11.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:d1531fa848fdd3677d2dce0a4b436ea64d9ae38fb8babe2ddbc180dd153cb7a3", size = 1028577, upload-time = "2026-04-13T17:11:09.934Z" },
+    { url = "https://files.pythonhosted.org/packages/83/18/7a7c15657a3da5569b26fc51cde6a80f8d84cb54b3b1aea6d74a103db4ad/fastar-0.11.0-cp314-cp314t-win32.whl", hash = "sha256:5744551bc67c6fc6581cbd0e34a0fd6e2cd0bd30b43e94b1c3119cf35064b162", size = 453601, upload-time = "2026-04-13T17:11:53.726Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/d8/331b59a6de279f3ad75c10c02c40a12f21d64a437d9c3d6f1af2dcbd7a76/fastar-0.11.0-cp314-cp314t-win_amd64.whl", hash = "sha256:f4ce44e3b56c47cf38244b98d29f269b259740a580c47a2552efa5b96a5458fb", size = 486436, upload-time = "2026-04-13T17:11:40.089Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/fd/5390ec4f49100f3ecb9968a392f9e6d039f1e3fe0ecd28443716ff01e589/fastar-0.11.0-cp314-cp314t-win_arm64.whl", hash = "sha256:76c1359314355eafbc6989f20fb1ad565a3d10200117923b9da765a17e2f6f11", size = 461049, upload-time = "2026-04-13T17:11:25.918Z" },
+]
+
 [[package]]
 name = "fastjsonschema"
 version = "2.21.2"
@@ -1199,6 +1655,65 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/cb/a8/20d0723294217e47de6d9e2e40fd4a9d2f7c4b6ef974babd482a59743694/fastjsonschema-2.21.2-py3-none-any.whl", hash = "sha256:1c797122d0a86c5cace2e54bf4e819c36223b552017172f32c5c024a6b77e463", size = 24024, upload-time = "2025-08-14T18:49:34.776Z" },
 ]
 
+[[package]]
+name = "fastrlock"
+version = "0.8.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/73/b1/1c3d635d955f2b4bf34d45abf8f35492e04dbd7804e94ce65d9f928ef3ec/fastrlock-0.8.3.tar.gz", hash = "sha256:4af6734d92eaa3ab4373e6c9a1dd0d5ad1304e172b1521733c6c3b3d73c8fa5d", size = 79327, upload-time = "2024-12-17T11:03:39.638Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/57/21/ea1511b0ef0d5457efca3bf1823effb9c5cad4fc9dca86ce08e4d65330ce/fastrlock-0.8.3-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:85a49a1f1e020097d087e1963e42cea6f307897d5ebe2cb6daf4af47ffdd3eed", size = 52201, upload-time = "2024-12-17T11:02:19.512Z" },
+    { url = "https://files.pythonhosted.org/packages/80/07/cdecb7aa976f34328372f1c4efd6c9dc1b039b3cc8d3f38787d640009a25/fastrlock-0.8.3-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5f13ec08f1adb1aa916c384b05ecb7dbebb8df9ea81abd045f60941c6283a670", size = 53924, upload-time = "2024-12-17T11:02:20.85Z" },
+    { url = "https://files.pythonhosted.org/packages/88/6d/59c497f8db9a125066dd3a7442fab6aecbe90d6fec344c54645eaf311666/fastrlock-0.8.3-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:0ea4e53a04980d646def0f5e4b5e8bd8c7884288464acab0b37ca0c65c482bfe", size = 52140, upload-time = "2024-12-17T11:02:22.263Z" },
+    { url = "https://files.pythonhosted.org/packages/62/04/9138943c2ee803d62a48a3c17b69de2f6fa27677a6896c300369e839a550/fastrlock-0.8.3-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:38340f6635bd4ee2a4fb02a3a725759fe921f2ca846cb9ca44531ba739cc17b4", size = 53261, upload-time = "2024-12-17T11:02:24.418Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/4b/db35a52589764c7745a613b6943bbd018f128d42177ab92ee7dde88444f6/fastrlock-0.8.3-cp312-cp312-win_amd64.whl", hash = "sha256:da06d43e1625e2ffddd303edcd6d2cd068e1c486f5fd0102b3f079c44eb13e2c", size = 31235, upload-time = "2024-12-17T11:02:25.708Z" },
+    { url = "https://files.pythonhosted.org/packages/06/77/f06a907f9a07d26d0cca24a4385944cfe70d549a2c9f1c3e3217332f4f12/fastrlock-0.8.3-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4a98ba46b3e14927550c4baa36b752d0d2f7387b8534864a8767f83cce75c160", size = 50954, upload-time = "2024-12-17T11:02:32.12Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/4e/94480fb3fd93991dd6f4e658b77698edc343f57caa2870d77b38c89c2e3b/fastrlock-0.8.3-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:dbdea6deeccea1917c6017d353987231c4e46c93d5338ca3e66d6cd88fbce259", size = 52535, upload-time = "2024-12-17T11:02:33.402Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/a7/ee82bb55b6c0ca30286dac1e19ee9417a17d2d1de3b13bb0f20cefb86086/fastrlock-0.8.3-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:c6e5bfecbc0d72ff07e43fed81671747914d6794e0926700677ed26d894d4f4f", size = 50942, upload-time = "2024-12-17T11:02:34.688Z" },
+    { url = "https://files.pythonhosted.org/packages/63/1d/d4b7782ef59e57dd9dde69468cc245adafc3674281905e42fa98aac30a79/fastrlock-0.8.3-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:2a83d558470c520ed21462d304e77a12639859b205759221c8144dd2896b958a", size = 52044, upload-time = "2024-12-17T11:02:36.613Z" },
+    { url = "https://files.pythonhosted.org/packages/28/a3/2ad0a0a69662fd4cf556ab8074f0de978ee9b56bff6ddb4e656df4aa9e8e/fastrlock-0.8.3-cp313-cp313-win_amd64.whl", hash = "sha256:8d1d6a28291b4ace2a66bd7b49a9ed9c762467617febdd9ab356b867ed901af8", size = 30472, upload-time = "2024-12-17T11:02:37.983Z" },
+]
+
+[[package]]
+name = "fastuuid"
+version = "0.14.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/c3/7d/d9daedf0f2ebcacd20d599928f8913e9d2aea1d56d2d355a93bfa2b611d7/fastuuid-0.14.0.tar.gz", hash = "sha256:178947fc2f995b38497a74172adee64fdeb8b7ec18f2a5934d037641ba265d26", size = 18232, upload-time = "2025-10-19T22:19:22.402Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/02/a2/e78fcc5df65467f0d207661b7ef86c5b7ac62eea337c0c0fcedbeee6fb13/fastuuid-0.14.0-cp312-cp312-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:77e94728324b63660ebf8adb27055e92d2e4611645bf12ed9d88d30486471d0a", size = 510164, upload-time = "2025-10-19T22:31:45.635Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/b3/c846f933f22f581f558ee63f81f29fa924acd971ce903dab1a9b6701816e/fastuuid-0.14.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:caa1f14d2102cb8d353096bc6ef6c13b2c81f347e6ab9d6fbd48b9dea41c153d", size = 261837, upload-time = "2025-10-19T22:38:38.53Z" },
+    { url = "https://files.pythonhosted.org/packages/54/ea/682551030f8c4fa9a769d9825570ad28c0c71e30cf34020b85c1f7ee7382/fastuuid-0.14.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:d23ef06f9e67163be38cece704170486715b177f6baae338110983f99a72c070", size = 251370, upload-time = "2025-10-19T22:40:26.07Z" },
+    { url = "https://files.pythonhosted.org/packages/14/dd/5927f0a523d8e6a76b70968e6004966ee7df30322f5fc9b6cdfb0276646a/fastuuid-0.14.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0c9ec605ace243b6dbe3bd27ebdd5d33b00d8d1d3f580b39fdd15cd96fd71796", size = 277766, upload-time = "2025-10-19T22:37:23.779Z" },
+    { url = "https://files.pythonhosted.org/packages/16/6e/c0fb547eef61293153348f12e0f75a06abb322664b34a1573a7760501336/fastuuid-0.14.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:808527f2407f58a76c916d6aa15d58692a4a019fdf8d4c32ac7ff303b7d7af09", size = 278105, upload-time = "2025-10-19T22:26:56.821Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/b1/b9c75e03b768f61cf2e84ee193dc18601aeaf89a4684b20f2f0e9f52b62c/fastuuid-0.14.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2fb3c0d7fef6674bbeacdd6dbd386924a7b60b26de849266d1ff6602937675c8", size = 301564, upload-time = "2025-10-19T22:30:31.604Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/fa/f7395fdac07c7a54f18f801744573707321ca0cee082e638e36452355a9d/fastuuid-0.14.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:ab3f5d36e4393e628a4df337c2c039069344db5f4b9d2a3c9cea48284f1dd741", size = 459659, upload-time = "2025-10-19T22:31:32.341Z" },
+    { url = "https://files.pythonhosted.org/packages/66/49/c9fd06a4a0b1f0f048aacb6599e7d96e5d6bc6fa680ed0d46bf111929d1b/fastuuid-0.14.0-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:b9a0ca4f03b7e0b01425281ffd44e99d360e15c895f1907ca105854ed85e2057", size = 478430, upload-time = "2025-10-19T22:26:22.962Z" },
+    { url = "https://files.pythonhosted.org/packages/be/9c/909e8c95b494e8e140e8be6165d5fc3f61fdc46198c1554df7b3e1764471/fastuuid-0.14.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:3acdf655684cc09e60fb7e4cf524e8f42ea760031945aa8086c7eae2eeeabeb8", size = 450894, upload-time = "2025-10-19T22:27:01.647Z" },
+    { url = "https://files.pythonhosted.org/packages/90/eb/d29d17521976e673c55ef7f210d4cdd72091a9ec6755d0fd4710d9b3c871/fastuuid-0.14.0-cp312-cp312-win32.whl", hash = "sha256:9579618be6280700ae36ac42c3efd157049fe4dd40ca49b021280481c78c3176", size = 154374, upload-time = "2025-10-19T22:29:19.879Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/fc/f5c799a6ea6d877faec0472d0b27c079b47c86b1cdc577720a5386483b36/fastuuid-0.14.0-cp312-cp312-win_amd64.whl", hash = "sha256:d9e4332dc4ba054434a9594cbfaf7823b57993d7d8e7267831c3e059857cf397", size = 156550, upload-time = "2025-10-19T22:27:49.658Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/83/ae12dd39b9a39b55d7f90abb8971f1a5f3c321fd72d5aa83f90dc67fe9ed/fastuuid-0.14.0-cp313-cp313-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:77a09cb7427e7af74c594e409f7731a0cf887221de2f698e1ca0ebf0f3139021", size = 510720, upload-time = "2025-10-19T22:42:34.633Z" },
+    { url = "https://files.pythonhosted.org/packages/53/b0/a4b03ff5d00f563cc7546b933c28cb3f2a07344b2aec5834e874f7d44143/fastuuid-0.14.0-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:9bd57289daf7b153bfa3e8013446aa144ce5e8c825e9e366d455155ede5ea2dc", size = 262024, upload-time = "2025-10-19T22:30:25.482Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/6d/64aee0a0f6a58eeabadd582e55d0d7d70258ffdd01d093b30c53d668303b/fastuuid-0.14.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:ac60fc860cdf3c3f327374db87ab8e064c86566ca8c49d2e30df15eda1b0c2d5", size = 251679, upload-time = "2025-10-19T22:36:14.096Z" },
+    { url = "https://files.pythonhosted.org/packages/60/f5/a7e9cda8369e4f7919d36552db9b2ae21db7915083bc6336f1b0082c8b2e/fastuuid-0.14.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ab32f74bd56565b186f036e33129da77db8be09178cd2f5206a5d4035fb2a23f", size = 277862, upload-time = "2025-10-19T22:36:23.302Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/d3/8ce11827c783affffd5bd4d6378b28eb6cc6d2ddf41474006b8d62e7448e/fastuuid-0.14.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:33e678459cf4addaedd9936bbb038e35b3f6b2061330fd8f2f6a1d80414c0f87", size = 278278, upload-time = "2025-10-19T22:29:43.809Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/51/680fb6352d0bbade04036da46264a8001f74b7484e2fd1f4da9e3db1c666/fastuuid-0.14.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:1e3cc56742f76cd25ecb98e4b82a25f978ccffba02e4bdce8aba857b6d85d87b", size = 301788, upload-time = "2025-10-19T22:36:06.825Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/7c/2014b5785bd8ebdab04ec857635ebd84d5ee4950186a577db9eff0fb8ff6/fastuuid-0.14.0-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:cb9a030f609194b679e1660f7e32733b7a0f332d519c5d5a6a0a580991290022", size = 459819, upload-time = "2025-10-19T22:35:31.623Z" },
+    { url = "https://files.pythonhosted.org/packages/01/d2/524d4ceeba9160e7a9bc2ea3e8f4ccf1ad78f3bde34090ca0c51f09a5e91/fastuuid-0.14.0-cp313-cp313-musllinux_1_1_i686.whl", hash = "sha256:09098762aad4f8da3a888eb9ae01c84430c907a297b97166b8abc07b640f2995", size = 478546, upload-time = "2025-10-19T22:26:03.023Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/17/354d04951ce114bf4afc78e27a18cfbd6ee319ab1829c2d5fb5e94063ac6/fastuuid-0.14.0-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:1383fff584fa249b16329a059c68ad45d030d5a4b70fb7c73a08d98fd53bcdab", size = 450921, upload-time = "2025-10-19T22:31:02.151Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/be/d7be8670151d16d88f15bb121c5b66cdb5ea6a0c2a362d0dcf30276ade53/fastuuid-0.14.0-cp313-cp313-win32.whl", hash = "sha256:a0809f8cc5731c066c909047f9a314d5f536c871a7a22e815cc4967c110ac9ad", size = 154559, upload-time = "2025-10-19T22:36:36.011Z" },
+    { url = "https://files.pythonhosted.org/packages/22/1d/5573ef3624ceb7abf4a46073d3554e37191c868abc3aecd5289a72f9810a/fastuuid-0.14.0-cp313-cp313-win_amd64.whl", hash = "sha256:0df14e92e7ad3276327631c9e7cec09e32572ce82089c55cb1bb8df71cf394ed", size = 156539, upload-time = "2025-10-19T22:33:35.898Z" },
+    { url = "https://files.pythonhosted.org/packages/16/c9/8c7660d1fe3862e3f8acabd9be7fc9ad71eb270f1c65cce9a2b7a31329ab/fastuuid-0.14.0-cp314-cp314-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:b852a870a61cfc26c884af205d502881a2e59cc07076b60ab4a951cc0c94d1ad", size = 510600, upload-time = "2025-10-19T22:43:44.17Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/f4/a989c82f9a90d0ad995aa957b3e572ebef163c5299823b4027986f133dfb/fastuuid-0.14.0-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:c7502d6f54cd08024c3ea9b3514e2d6f190feb2f46e6dbcd3747882264bb5f7b", size = 262069, upload-time = "2025-10-19T22:43:38.38Z" },
+    { url = "https://files.pythonhosted.org/packages/da/6c/a1a24f73574ac995482b1326cf7ab41301af0fabaa3e37eeb6b3df00e6e2/fastuuid-0.14.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1ca61b592120cf314cfd66e662a5b54a578c5a15b26305e1b8b618a6f22df714", size = 251543, upload-time = "2025-10-19T22:32:22.537Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/20/2a9b59185ba7a6c7b37808431477c2d739fcbdabbf63e00243e37bd6bf49/fastuuid-0.14.0-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:aa75b6657ec129d0abded3bec745e6f7ab642e6dba3a5272a68247e85f5f316f", size = 277798, upload-time = "2025-10-19T22:33:53.821Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/33/4105ca574f6ded0af6a797d39add041bcfb468a1255fbbe82fcb6f592da2/fastuuid-0.14.0-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a8a0dfea3972200f72d4c7df02c8ac70bad1bb4c58d7e0ec1e6f341679073a7f", size = 278283, upload-time = "2025-10-19T22:29:02.812Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/8c/fca59f8e21c4deb013f574eae05723737ddb1d2937ce87cb2a5d20992dc3/fastuuid-0.14.0-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:1bf539a7a95f35b419f9ad105d5a8a35036df35fdafae48fb2fd2e5f318f0d75", size = 301627, upload-time = "2025-10-19T22:35:54.985Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/e2/f78c271b909c034d429218f2798ca4e89eeda7983f4257d7865976ddbb6c/fastuuid-0.14.0-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:9a133bf9cc78fdbd1179cb58a59ad0100aa32d8675508150f3658814aeefeaa4", size = 459778, upload-time = "2025-10-19T22:28:00.999Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/f0/5ff209d865897667a2ff3e7a572267a9ced8f7313919f6d6043aed8b1caa/fastuuid-0.14.0-cp314-cp314-musllinux_1_1_i686.whl", hash = "sha256:f54d5b36c56a2d5e1a31e73b950b28a0d83eb0c37b91d10408875a5a29494bad", size = 478605, upload-time = "2025-10-19T22:36:21.764Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/c8/2ce1c78f983a2c4987ea865d9516dbdfb141a120fd3abb977ae6f02ba7ca/fastuuid-0.14.0-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:ec27778c6ca3393ef662e2762dba8af13f4ec1aaa32d08d77f71f2a70ae9feb8", size = 450837, upload-time = "2025-10-19T22:34:37.178Z" },
+    { url = "https://files.pythonhosted.org/packages/df/60/dad662ec9a33b4a5fe44f60699258da64172c39bd041da2994422cdc40fe/fastuuid-0.14.0-cp314-cp314-win32.whl", hash = "sha256:e23fc6a83f112de4be0cc1990e5b127c27663ae43f866353166f87df58e73d06", size = 154532, upload-time = "2025-10-19T22:35:18.217Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/f6/da4db31001e854025ffd26bc9ba0740a9cbba2c3259695f7c5834908b336/fastuuid-0.14.0-cp314-cp314-win_amd64.whl", hash = "sha256:df61342889d0f5e7a32f7284e55ef95103f2110fee433c2ae7c2c0956d76ac8a", size = 156457, upload-time = "2025-10-19T22:33:44.579Z" },
+]
+
 [[package]]
 name = "filelock"
 version = "3.25.2"
@@ -1208,6 +1723,30 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/a4/a5/842ae8f0c08b61d6484b52f99a03510a3a72d23141942d216ebe81fefbce/filelock-3.25.2-py3-none-any.whl", hash = "sha256:ca8afb0da15f229774c9ad1b455ed96e85a81373065fb10446672f64444ddf70", size = 26759, upload-time = "2026-03-11T20:45:37.437Z" },
 ]
 
+[[package]]
+name = "flashinfer-python"
+version = "0.5.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "apache-tvm-ffi" },
+    { name = "click" },
+    { name = "einops" },
+    { name = "ninja" },
+    { name = "numpy" },
+    { name = "nvidia-cudnn-frontend" },
+    { name = "nvidia-cutlass-dsl" },
+    { name = "nvidia-ml-py" },
+    { name = "packaging" },
+    { name = "requests" },
+    { name = "tabulate" },
+    { name = "torch" },
+    { name = "tqdm" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b4/91/cca69baeff24bb3efd12c7479a026432c8717ee47193694010494c528b22/flashinfer_python-0.5.3.tar.gz", hash = "sha256:100d59b0ede47878d2808cd3a1b9039d7a952d66338bc9f68dac192ae1b2e3f1", size = 4682367, upload-time = "2025-11-20T21:22:46.976Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/76/78/6dc7e7da8cb87c9965644ea0d2439457a1bc9256c45ceda0044595be4143/flashinfer_python-0.5.3-py3-none-any.whl", hash = "sha256:b601293b72f9138bad173edc28df84b9f239a013be974e2e79d4ba98aeb38cf5", size = 6998069, upload-time = "2025-11-20T21:22:45.104Z" },
+]
+
 [[package]]
 name = "flatbuffers"
 version = "25.12.19"
@@ -1369,6 +1908,21 @@ http = [
     { name = "aiohttp" },
 ]
 
+[[package]]
+name = "gguf"
+version = "0.19.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "numpy" },
+    { name = "pyyaml" },
+    { name = "requests" },
+    { name = "tqdm" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/48/ae/17f1308ae45cd7b08ebb521747d5b23f4efc4d172038a4e228dd5106c3ff/gguf-0.19.0.tar.gz", hash = "sha256:dbadcd6cc7ccd44256f2229fe7c2dff5e8aa5cf0612ab987fd2b1a57e428923f", size = 111220, upload-time = "2026-05-06T13:04:03.667Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b3/bb/d71d6da82763528c2c2ed6b59a9d6142c6595545a4c448e2085d155e88c2/gguf-0.19.0-py3-none-any.whl", hash = "sha256:70bcd10edfe697fb2dad6e40af2234b9d8ece9a41a99761405121ebda1c3c1cd", size = 118475, upload-time = "2026-05-06T13:04:02.588Z" },
+]
+
 [[package]]
 name = "ghp-import"
 version = "2.1.0"
@@ -1506,6 +2060,19 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/48/b2/b096ccce418882fbfda4f7496f9357aaa9a5af1896a9a7f60d9f2b275a06/grpcio-1.78.0-cp314-cp314-win_amd64.whl", hash = "sha256:dce09d6116df20a96acfdbf85e4866258c3758180e8c49845d6ba8248b6d0bbb", size = 4929852, upload-time = "2026-02-06T09:56:45.885Z" },
 ]
 
+[[package]]
+name = "grpcio-reflection"
+version = "1.78.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "grpcio" },
+    { name = "protobuf" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/31/06/337546aae558675f79cae2a8c1ce0c9b1952cbc5c28b01878f68d040f5bb/grpcio_reflection-1.78.0.tar.gz", hash = "sha256:e6e60c0b85dbcdf963b4d4d150c0f1d238ba891d805b575c52c0365d07fc0c40", size = 19098, upload-time = "2026-02-06T10:01:52.225Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/df/6d/4d095d27ccd049865ecdafc467754e9e47ad0f677a30dda969c3590f6582/grpcio_reflection-1.78.0-py3-none-any.whl", hash = "sha256:06fcfde9e6888cdd12e9dd1cf6dc7c440c2e9acf420f696ccbe008672ed05b60", size = 22800, upload-time = "2026-02-06T10:01:33.822Z" },
+]
+
 [[package]]
 name = "h11"
 version = "0.16.0"
@@ -1615,22 +2182,21 @@ wheels = [
 
 [[package]]
 name = "huggingface-hub"
-version = "1.7.2"
+version = "0.36.2"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "filelock" },
     { name = "fsspec" },
-    { name = "hf-xet", marker = "platform_machine == 'AMD64' or platform_machine == 'aarch64' or platform_machine == 'amd64' or platform_machine == 'arm64' or platform_machine == 'x86_64'" },
-    { name = "httpx" },
+    { name = "hf-xet", marker = "platform_machine == 'aarch64' or platform_machine == 'amd64' or platform_machine == 'arm64' or platform_machine == 'x86_64'" },
     { name = "packaging" },
     { name = "pyyaml" },
+    { name = "requests" },
     { name = "tqdm" },
-    { name = "typer" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/19/15/eafc1c57bf0f8afffb243dcd4c0cceb785e956acc17bba4d9bf2ae21fc9c/huggingface_hub-1.7.2.tar.gz", hash = "sha256:7f7e294e9bbb822e025bdb2ada025fa4344d978175a7f78e824d86e35f7ab43b", size = 724684, upload-time = "2026-03-20T10:36:08.767Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/7c/b7/8cb61d2eece5fb05a83271da168186721c450eb74e3c31f7ef3169fa475b/huggingface_hub-0.36.2.tar.gz", hash = "sha256:1934304d2fb224f8afa3b87007d58501acfda9215b334eed53072dd5e815ff7a", size = 649782, upload-time = "2026-02-06T09:24:13.098Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/08/de/3ad061a05f74728927ded48c90b73521b9a9328c85d841bdefb30e01fb85/huggingface_hub-1.7.2-py3-none-any.whl", hash = "sha256:288f33a0a17b2a73a1359e2a5fd28d1becb2c121748c6173ab8643fb342c850e", size = 618036, upload-time = "2026-03-20T10:36:06.824Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/af/48ac8483240de756d2438c380746e7130d1c6f75802ef22f3c6d49982787/huggingface_hub-0.36.2-py3-none-any.whl", hash = "sha256:48f0c8eac16145dfce371e9d2d7772854a4f591bcb56c9cf548accf531d54270", size = 566395, upload-time = "2026-02-06T09:24:11.133Z" },
 ]
 
 [[package]]
@@ -1651,6 +2217,69 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/0e/61/66938bbb5fc52dbdf84594873d5b51fb1f7c7794e9c0f5bd885f30bc507b/idna-3.11-py3-none-any.whl", hash = "sha256:771a87f49d9defaf64091e6e6fe9c18d4833f140bd19464795bc32d966ca37ea", size = 71008, upload-time = "2025-10-12T14:55:18.883Z" },
 ]
 
+[[package]]
+name = "ijson"
+version = "3.5.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f4/57/60d1a6a512f2f0508d0bc8b4f1cc5616fd3196619b66bd6a01f9155a1292/ijson-3.5.0.tar.gz", hash = "sha256:94688760720e3f5212731b3cb8d30267f9a045fb38fb3870254e7b9504246f31", size = 68658, upload-time = "2026-02-24T03:58:30.974Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/aa/17/9c63c7688025f3a8c47ea717b8306649c8c7244e49e20a2be4e3515dc75c/ijson-3.5.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:1ebefbe149a6106cc848a3eaf536af51a9b5ccc9082de801389f152dba6ab755", size = 88536, upload-time = "2026-02-24T03:57:06.809Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/dd/e15c2400244c117b06585452ebc63ae254f5a6964f712306afd1422daae0/ijson-3.5.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:19e30d9f00f82e64de689c0b8651b9cfed879c184b139d7e1ea5030cec401c21", size = 60499, upload-time = "2026-02-24T03:57:09.155Z" },
+    { url = "https://files.pythonhosted.org/packages/77/a9/bf4fe3538a0c965f16b406f180a06105b875da83f0743e36246be64ef550/ijson-3.5.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:a04a33ee78a6f27b9b8528c1ca3c207b1df3b8b867a4cf2fcc4109986f35c227", size = 60330, upload-time = "2026-02-24T03:57:10.574Z" },
+    { url = "https://files.pythonhosted.org/packages/31/76/6f91bdb019dd978fce1bc5ea1cd620cfc096d258126c91db2c03a20a7f34/ijson-3.5.0-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:7d48dc2984af02eb3c56edfb3f13b3f62f2f3e4fe36f058c8cfc75d93adf4fed", size = 138977, upload-time = "2026-02-24T03:57:11.932Z" },
+    { url = "https://files.pythonhosted.org/packages/11/be/bbc983059e48a54b0121ee60042979faed7674490bbe7b2c41560db3f436/ijson-3.5.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f1e73a44844d9adbca9cf2c4132cd875933e83f3d4b23881fcaf82be83644c7d", size = 149785, upload-time = "2026-02-24T03:57:13.255Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/81/2fee58f9024a3449aee83edfa7167fb5ccd7e1af2557300e28531bb68e16/ijson-3.5.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7389a56b8562a19948bdf1d7bae3a2edc8c7f86fb59834dcb1c4c722818e645a", size = 149729, upload-time = "2026-02-24T03:57:14.191Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/56/f1706761fcc096c9d414b3dcd000b1e6e5c24364c21cfba429837f98ee8d/ijson-3.5.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3176f23f8ebec83f374ed0c3b4e5a0c4db7ede54c005864efebbed46da123608", size = 150697, upload-time = "2026-02-24T03:57:15.855Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/6e/ee0d9c875a0193b632b3e9ccd1b22a50685fb510256ad57ba483b6529f77/ijson-3.5.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:6babd88e508630c6ef86c9bebaaf13bb2fb8ec1d8f8868773a03c20253f599bc", size = 142873, upload-time = "2026-02-24T03:57:16.831Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/bf/f9d4399d0e6e3fd615035290a71e97c843f17f329b43638c0a01cf112d73/ijson-3.5.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:dc1b3836b174b6db2fa8319f1926fb5445abd195dc963368092103f8579cb8ed", size = 151583, upload-time = "2026-02-24T03:57:17.757Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/71/a7254a065933c0e2ffd3586f46187d84830d3d7b6f41cfa5901820a4f87d/ijson-3.5.0-cp312-cp312-win32.whl", hash = "sha256:6673de9395fb9893c1c79a43becd8c8fbee0a250be6ea324bfd1487bb5e9ee4c", size = 53079, upload-time = "2026-02-24T03:57:18.703Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/7b/2edca79b359fc9f95d774616867a03ecccdf333797baf5b3eea79733918c/ijson-3.5.0-cp312-cp312-win_amd64.whl", hash = "sha256:f4f7fabd653459dcb004175235f310435959b1bb5dfa8878578391c6cc9ad944", size = 55500, upload-time = "2026-02-24T03:57:20.428Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/71/d67e764a712c3590627480643a3b51efcc3afa4ef3cb54ee4c989073c97e/ijson-3.5.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:e9cedc10e40dd6023c351ed8bfc7dcfce58204f15c321c3c1546b9c7b12562a4", size = 88544, upload-time = "2026-02-24T03:57:21.293Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/39/f1c299371686153fa3cf5c0736b96247a87a1bee1b7145e6d21f359c505a/ijson-3.5.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:3647649f782ee06c97490b43680371186651f3f69bebe64c6083ee7615d185e5", size = 60495, upload-time = "2026-02-24T03:57:22.501Z" },
+    { url = "https://files.pythonhosted.org/packages/16/94/b1438e204d75e01541bebe3e668fe3e68612d210e9931ae1611062dd0a56/ijson-3.5.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:90e74be1dce05fce73451c62d1118671f78f47c9f6be3991c82b91063bf01fc9", size = 60325, upload-time = "2026-02-24T03:57:23.332Z" },
+    { url = "https://files.pythonhosted.org/packages/30/e2/4aa9c116fa86cc8b0f574f3c3a47409edc1cd4face05d0e589a5a176b05d/ijson-3.5.0-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:78e9ad73e7be2dd80627504bd5cbf512348c55ce2c06e362ed7683b5220e8568", size = 138774, upload-time = "2026-02-24T03:57:24.683Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/d2/738b88752a70c3be1505faa4dcd7110668c2712e582a6a36488ed1e295d4/ijson-3.5.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9577449313cc94be89a4fe4b3e716c65f09cc19636d5a6b2861c4e80dddebd58", size = 149820, upload-time = "2026-02-24T03:57:26.062Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/df/0b3ab9f393ca8f72ea03bc896ba9fdc987e90ae08cdb51c32a4ee0c14d5e/ijson-3.5.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3e4c1178fb50aff5f5701a30a5152ead82a14e189ce0f6102fa1b5f10b2f54ff", size = 149747, upload-time = "2026-02-24T03:57:27.308Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/a3/b0037119f75131b78cb00acc2657b1a9d0435475f1f2c5f8f5a170b66b9c/ijson-3.5.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:0eb402ab026ffb37a918d75af2b7260fe6cfbce13232cc83728a714dd30bd81d", size = 151027, upload-time = "2026-02-24T03:57:28.522Z" },
+    { url = "https://files.pythonhosted.org/packages/22/a0/cb344de1862bf09d8f769c9d25c944078c87dd59a1b496feec5ad96309a4/ijson-3.5.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:5b08ee08355f9f729612a8eb9bf69cc14f9310c3b2a487c6f1c3c65d85216ec4", size = 142996, upload-time = "2026-02-24T03:57:29.774Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/32/a8ffd67182e02ea61f70f62daf43ded4fa8a830a2520a851d2782460aba8/ijson-3.5.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:bda62b6d48442903e7bf56152108afb7f0f1293c2b9bef2f2c369defea76ab18", size = 152068, upload-time = "2026-02-24T03:57:30.969Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/d1/3578df8e75d446aab0ae92e27f641341f586b85e1988536adebc65300cb4/ijson-3.5.0-cp313-cp313-win32.whl", hash = "sha256:8d073d9b13574cfa11083cc7267c238b7a6ed563c2661e79192da4a25f09c82c", size = 53065, upload-time = "2026-02-24T03:57:31.93Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/a2/f7cdaf5896710da3e69e982e44f015a83d168aa0f3a89b6f074b5426779d/ijson-3.5.0-cp313-cp313-win_amd64.whl", hash = "sha256:2419f9e32e0968a876b04d8f26aeac042abd16f582810b576936bbc4c6015069", size = 55499, upload-time = "2026-02-24T03:57:32.773Z" },
+    { url = "https://files.pythonhosted.org/packages/42/65/13e2492d17e19a2084523e18716dc2809159f2287fd2700c735f311e76c4/ijson-3.5.0-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:4d4b0cd676b8c842f7648c1a783448fac5cd3b98289abd83711b3e275e143524", size = 93019, upload-time = "2026-02-24T03:57:33.976Z" },
+    { url = "https://files.pythonhosted.org/packages/33/92/483fc97ece0c3f1cecabf48f6a7a36e89d19369eec462faaeaa34c788992/ijson-3.5.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:252dec3680a48bb82d475e36b4ae1b3a9d7eb690b951bb98a76c5fe519e30188", size = 62714, upload-time = "2026-02-24T03:57:34.819Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/88/793fe020a0fe9d9eed4c285cf4a5cfdb0a935708b3bde0d72f35c794b513/ijson-3.5.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:aa1b5dca97d323931fde2501172337384c958914d81a9dac7f00f0d4bfc76bc7", size = 62460, upload-time = "2026-02-24T03:57:35.874Z" },
+    { url = "https://files.pythonhosted.org/packages/51/69/f1a2690aa8d4df1f4e262b385e65a933ffdc250b091531bac9a449c19e16/ijson-3.5.0-cp313-cp313t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:7a5ec7fd86d606094bba6f6f8f87494897102fa4584ef653f3005c51a784c320", size = 199273, upload-time = "2026-02-24T03:57:37.07Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/a2/f1346d5299e79b988ab472dc773d5381ec2d57c23cb2f1af3ede4a810e62/ijson-3.5.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:009f41443e1521847701c6d87fa3923c0b1961be3c7e7de90947c8cb92ea7c44", size = 216884, upload-time = "2026-02-24T03:57:38.346Z" },
+    { url = "https://files.pythonhosted.org/packages/28/3c/8b637e869be87799e6c2c3c275a30a546f086b1aed77e2b7f11512168c5a/ijson-3.5.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e4c3651d1f9fe2839a93fdf8fd1d5ca3a54975349894249f3b1b572bcc4bd577", size = 207306, upload-time = "2026-02-24T03:57:39.718Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/7c/18b1c1df6951ca056782d7580ec40cea4ff9a27a0947d92640d1cc8c4ae3/ijson-3.5.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:945b7abcfcfeae2cde17d8d900870f03536494245dda7ad4f8d056faa303256c", size = 211364, upload-time = "2026-02-24T03:57:40.953Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/55/e795812e82851574a9dba8a53fde045378f531ef14110c6fb55dbd23b443/ijson-3.5.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:0574b0a841ff97495c13e9d7260fbf3d85358b061f540c52a123db9dbbaa2ed6", size = 200608, upload-time = "2026-02-24T03:57:42.272Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/cd/013c85b4749b57a4cb4c2670014d1b32b8db4ab1a7be92ea7aeb5d7fe7b5/ijson-3.5.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:f969ffb2b89c5cdf686652d7fb66252bc72126fa54d416317411497276056a18", size = 205127, upload-time = "2026-02-24T03:57:43.286Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/7c/faf643733e3ab677f180018f6a855c4ef70b7c46540987424c563c959e42/ijson-3.5.0-cp313-cp313t-win32.whl", hash = "sha256:59d3f9f46deed1332ad669518b8099920512a78bda64c1f021fcd2aff2b36693", size = 55282, upload-time = "2026-02-24T03:57:44.353Z" },
+    { url = "https://files.pythonhosted.org/packages/69/22/94ddb47c24b491377aca06cd8fc9202cad6ab50619842457d2beefde21ea/ijson-3.5.0-cp313-cp313t-win_amd64.whl", hash = "sha256:5c2839fa233746d8aad3b8cd2354e441613f5df66d721d59da4a09394bd1db2b", size = 58016, upload-time = "2026-02-24T03:57:45.237Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/93/0868efe753dc1df80cc405cf0c1f2527a6991643607c741bff8dcb899b3b/ijson-3.5.0-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:25a5a6b2045c90bb83061df27cfa43572afa43ba9408611d7bfe237c20a731a9", size = 89094, upload-time = "2026-02-24T03:57:46.115Z" },
+    { url = "https://files.pythonhosted.org/packages/24/94/fd5a832a0df52ef5e4e740f14ac8640725d61034a1b0c561e8b5fb424706/ijson-3.5.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:8976c54c0b864bc82b951bae06567566ac77ef63b90a773a69cd73aab47f4f4f", size = 60715, upload-time = "2026-02-24T03:57:47.552Z" },
+    { url = "https://files.pythonhosted.org/packages/70/79/1b9a90af5732491f9eec751ee211b86b11011e1158c555c06576d52c3919/ijson-3.5.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:859eb2038f7f1b0664df4241957694cc35e6295992d71c98659b22c69b3cbc10", size = 60638, upload-time = "2026-02-24T03:57:48.428Z" },
+    { url = "https://files.pythonhosted.org/packages/23/6f/2c551ea980fe56f68710a8d5389cfbd015fc45aaafd17c3c52c346db6aa1/ijson-3.5.0-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:c911aa02991c7c0d3639b6619b93a93210ff1e7f58bf7225d613abea10adc78e", size = 140667, upload-time = "2026-02-24T03:57:49.314Z" },
+    { url = "https://files.pythonhosted.org/packages/25/0e/27b887879ba6a5bc29766e3c5af4942638c952220fd63e1e442674f7883a/ijson-3.5.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:903cbdc350173605220edc19796fbea9b2203c8b3951fb7335abfa8ed37afda8", size = 149850, upload-time = "2026-02-24T03:57:50.329Z" },
+    { url = "https://files.pythonhosted.org/packages/da/1e/23e10e1bc04bf31193b21e2960dce14b17dbd5d0c62204e8401c59d62c08/ijson-3.5.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a4549d96ded5b8efa71639b2160235415f6bdb8c83367615e2dbabcb72755c33", size = 149206, upload-time = "2026-02-24T03:57:51.261Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/90/e552f6495063b235cf7fa2c592f6597c057077195e517b842a0374fd470c/ijson-3.5.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:6b2dcf6349e6042d83f3f8c39ce84823cf7577eba25bac5aae5e39bbbbbe9c1c", size = 150438, upload-time = "2026-02-24T03:57:52.198Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/18/45bf8f297c41b42a1c231d261141097babd953d2c28a07be57ae4c3a1a02/ijson-3.5.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:e44af39e6f8a17e5627dcd89715d8279bf3474153ff99aae031a936e5c5572e5", size = 144369, upload-time = "2026-02-24T03:57:53.22Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/3a/deb9772bb2c0cead7ad64f00c3598eec9072bdf511818e70e2c512eeabbe/ijson-3.5.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:9260332304b7e7828db56d43f08fc970a3ab741bf84ff10189361ea1b60c395b", size = 151352, upload-time = "2026-02-24T03:57:54.375Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/51/67f4d80cd58ad7eab0cd1af5fe28b961886338956b2f88c0979e21914346/ijson-3.5.0-cp314-cp314-win32.whl", hash = "sha256:63bc8121bb422f6969ced270173a3fa692c29d4ae30c860a2309941abd81012a", size = 53610, upload-time = "2026-02-24T03:57:55.655Z" },
+    { url = "https://files.pythonhosted.org/packages/70/d3/263672ea22983ba3940f1534316dbc9200952c1c2a2332d7a664e4eaa7ae/ijson-3.5.0-cp314-cp314-win_amd64.whl", hash = "sha256:01b6dad72b7b7df225ef970d334556dfad46c696a2c6767fb5d9ed8889728bca", size = 56301, upload-time = "2026-02-24T03:57:56.584Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/d9/86f7fac35e0835faa188085ae0579e813493d5261ce056484015ad533445/ijson-3.5.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:2ea4b676ec98e374c1df400a47929859e4fa1239274339024df4716e802aa7e4", size = 93069, upload-time = "2026-02-24T03:57:57.849Z" },
+    { url = "https://files.pythonhosted.org/packages/33/d2/e7366ed9c6e60228d35baf4404bac01a126e7775ea8ce57f560125ed190a/ijson-3.5.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:014586eec043e23c80be9a923c56c3a0920a0f1f7d17478ce7bc20ba443968ef", size = 62767, upload-time = "2026-02-24T03:57:58.758Z" },
+    { url = "https://files.pythonhosted.org/packages/35/8b/3e703e8cc4b3ada79f13b28070b51d9550c578f76d1968657905857b2ddd/ijson-3.5.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:d5b8b886b0248652d437f66e7c5ac318bbdcb2c7137a7e5327a68ca00b286f5f", size = 62467, upload-time = "2026-02-24T03:58:00.261Z" },
+    { url = "https://files.pythonhosted.org/packages/21/42/0c91af32c1ee8a957fdac2e051b5780756d05fd34e4b60d94a08d51bac1d/ijson-3.5.0-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:498fd46ae2349297e43acf97cdc421e711dbd7198418677259393d2acdc62d78", size = 200447, upload-time = "2026-02-24T03:58:01.591Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/80/796ea0e391b7e2d45c5b1b451734bba03f81c2984cf955ea5eaa6c4920ad/ijson-3.5.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:22a51b4f9b81f12793731cf226266d1de2112c3c04ba4a04117ad4e466897e05", size = 217820, upload-time = "2026-02-24T03:58:02.598Z" },
+    { url = "https://files.pythonhosted.org/packages/38/14/52b6613fdda4078c62eb5b4fe3efc724ddc55a4ad524c93de51830107aa3/ijson-3.5.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9636c710dc4ac4a281baa266a64f323b4cc165cec26836af702c44328b59a515", size = 208310, upload-time = "2026-02-24T03:58:04.759Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/ad/8b3105a78774fd4a65e534a21d975ef3a77e189489fe3029ebcaeba5e243/ijson-3.5.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:f7168a39e8211107666d71b25693fd1b2bac0b33735ef744114c403c6cac21e1", size = 211843, upload-time = "2026-02-24T03:58:05.836Z" },
+    { url = "https://files.pythonhosted.org/packages/36/ab/a2739f6072d6e1160581bc3ed32da614c8cced023dcd519d9c5fa66e0425/ijson-3.5.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:8696454245415bc617ab03b0dc3ae4c86987df5dc6a90bad378fe72c5409d89e", size = 200906, upload-time = "2026-02-24T03:58:07.788Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/5e/e06c2de3c3d4a9cfb655c1ad08a68fb72838d271072cdd3196576ac4431a/ijson-3.5.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:c21bfb61f71f191565885bf1bc29e0a186292d866b4880637b833848360bdc1b", size = 205495, upload-time = "2026-02-24T03:58:09.163Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/11/778201eb2e202ddd76b36b0fb29bf3d8e3c167389d8aa883c62524e49f47/ijson-3.5.0-cp314-cp314t-win32.whl", hash = "sha256:a2619460d6795b70d0155e5bf016200ac8a63ab5397aa33588bb02b6c21759e6", size = 56280, upload-time = "2026-02-24T03:58:10.116Z" },
+    { url = "https://files.pythonhosted.org/packages/23/28/96711503245339084c8086b892c47415895eba49782d6cc52d9f4ee50301/ijson-3.5.0-cp314-cp314t-win_amd64.whl", hash = "sha256:4f24b78d4ef028d17eb57ad1b16c0aed4a17bdd9badbf232dc5d9305b7e13854", size = 58965, upload-time = "2026-02-24T03:58:11.278Z" },
+]
+
 [[package]]
 name = "importlib-metadata"
 version = "8.7.1"
@@ -1704,6 +2333,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/45/04/e442e1356c97b03a6d30d2b462f7c0bdfbf207e75f6833815fd1225a75b4/instructor-1.14.5-py3-none-any.whl", hash = "sha256:2a5a31222b008c0989be1cc001e33a237f49506e80ac5833f6d36d7690bae7b1", size = 177445, upload-time = "2026-01-29T14:18:53.641Z" },
 ]
 
+[[package]]
+name = "interegular"
+version = "0.3.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/dc/9d/8b6dde58a028a3962ce17e84d5fe73758df61378e00ef8ac3d85da34b0ff/interegular-0.3.3.tar.gz", hash = "sha256:d9b697b21b34884711399ba0f0376914b81899ce670032486d0d048344a76600", size = 24705, upload-time = "2024-01-06T23:01:22.372Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c4/01/72d6472f80651673716d1deda2a5bbb633e563ecf94f4479da5519d69d25/interegular-0.3.3-py37-none-any.whl", hash = "sha256:b0c07007d48c89d6d19f7204972d369b2a77222722e126b6aa63aa721dc3b19c", size = 23635, upload-time = "2024-01-06T23:01:20.829Z" },
+]
+
 [[package]]
 name = "ipykernel"
 version = "7.2.0"
@@ -1881,6 +2519,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/d9/71/71408b02c6133153336d29fa3ba53000f1e1a3f78bb2fc2d1a1865d2e743/jiter-0.11.1-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:18c77aaa9117510d5bdc6a946baf21b1f0cfa58ef04d31c8d016f206f2118960", size = 343697, upload-time = "2025-10-17T11:31:13.773Z" },
 ]
 
+[[package]]
+name = "jmespath"
+version = "1.1.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d3/59/322338183ecda247fb5d1763a6cbe46eff7222eaeebafd9fa65d4bf5cb11/jmespath-1.1.0.tar.gz", hash = "sha256:472c87d80f36026ae83c6ddd0f1d05d4e510134ed462851fd5f754c8c3cbb88d", size = 27377, upload-time = "2026-01-22T16:35:26.279Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/14/2f/967ba146e6d58cf6a652da73885f52fc68001525b4197effc174321d70b4/jmespath-1.1.0-py3-none-any.whl", hash = "sha256:a5663118de4908c91729bea0acadca56526eb2698e83de10cd116ae0f4e97c64", size = 20419, upload-time = "2026-01-22T16:35:24.919Z" },
+]
+
 [[package]]
 name = "joblib"
 version = "1.5.3"
@@ -2292,11 +2939,11 @@ wheels = [
 
 [[package]]
 name = "lark"
-version = "1.3.1"
+version = "1.2.2"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/da/34/28fff3ab31ccff1fd4f6c7c7b0ceb2b6968d8ea4950663eadcb5720591a0/lark-1.3.1.tar.gz", hash = "sha256:b426a7a6d6d53189d318f2b6236ab5d6429eaf09259f1ca33eb716eed10d2905", size = 382732, upload-time = "2025-10-27T18:25:56.653Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/af/60/bc7622aefb2aee1c0b4ba23c1446d3e30225c8770b38d7aedbfb65ca9d5a/lark-1.2.2.tar.gz", hash = "sha256:ca807d0162cd16cef15a8feecb862d7319e7a09bdb13aef927968e45040fed80", size = 252132, upload-time = "2024-08-13T19:49:00.652Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/82/3d/14ce75ef66813643812f3093ab17e46d3a206942ce7376d31ec2d36229e7/lark-1.3.1-py3-none-any.whl", hash = "sha256:c629b661023a014c37da873b4ff58a817398d12635d3bbb2c5a03be7fe5d1e12", size = 113151, upload-time = "2025-10-27T18:25:54.882Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/00/d90b10b962b4277f5e64a78b6609968859ff86889f5b898c1a778c06ec00/lark-1.2.2-py3-none-any.whl", hash = "sha256:c2276486b02f0f1b90be155f2c8ba4a8e194d42775786db622faccd652d8e80c", size = 111036, upload-time = "2024-08-13T19:48:58.603Z" },
 ]
 
 [[package]]
@@ -2363,6 +3010,88 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/af/40/791891d4c0c4dab4c5e187c17261cedc26285fd41541577f900470a45a4d/license_expression-30.4.4-py3-none-any.whl", hash = "sha256:421788fdcadb41f049d2dc934ce666626265aeccefddd25e162a26f23bcbf8a4", size = 120615, upload-time = "2025-07-22T11:13:31.217Z" },
 ]
 
+[[package]]
+name = "litellm"
+version = "1.84.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "aiohttp" },
+    { name = "click" },
+    { name = "fastuuid" },
+    { name = "httpx" },
+    { name = "importlib-metadata" },
+    { name = "jinja2" },
+    { name = "jsonschema" },
+    { name = "openai" },
+    { name = "pydantic" },
+    { name = "python-dotenv" },
+    { name = "tiktoken" },
+    { name = "tokenizers" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/dd/e9/8941b7e72a187000561d932c0f2f2ed2b0fd080dfc33ba6e05961d45ca7d/litellm-1.84.0.tar.gz", hash = "sha256:b8ad0cbea11a5941b18d5af973017a340abd3d3ab41cb86e5401b970626d71a6", size = 15103206, upload-time = "2026-05-14T05:45:53.017Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/01/a6/77fa1bbf5e42eb596b06318b3f7e6af5d0f44028046d1d598c6a595d028f/litellm-1.84.0-py3-none-any.whl", hash = "sha256:2a58d6041e6aa27d1a28dc8d8828ab500fef1a00ef74ca65e60899035010c2f2", size = 16735062, upload-time = "2026-05-14T05:45:49.927Z" },
+]
+
+[[package]]
+name = "llguidance"
+version = "1.3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/95/48/3f7a9d3ff1b36bba92b5107a3a21286821227afe9ea464736133994d61fb/llguidance-1.3.0.tar.gz", hash = "sha256:861249afd51dc325646834462ea827e57a5c2b2042e108e6aae7059fdad9104d", size = 1070460, upload-time = "2025-10-20T19:58:44.164Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3b/33/be5acb85cd8cdc4afde33d9c234eece9f318e087920255af3c05864cd3e7/llguidance-1.3.0-cp39-abi3-macosx_10_12_x86_64.whl", hash = "sha256:f7685222660a762e481ac633d49cc559c64980fe2ee59c8f932a5bb5cbc0c2c2", size = 3220647, upload-time = "2025-10-20T19:58:42.542Z" },
+    { url = "https://files.pythonhosted.org/packages/82/e6/b48bda5b15efeaeb62bd0dba8fc6a01d4ae5457a85dbb5d18632385fe15c/llguidance-1.3.0-cp39-abi3-macosx_11_0_arm64.whl", hash = "sha256:098030ff0687261a3f1bd54cf21fe951fc861d56d37a0671250dd36677eaf224", size = 3099830, upload-time = "2025-10-20T19:58:40.826Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/11/44389d3d1526d7a5c38ffd587a5ebc61d7bee443ac1dea95f2089ad58f5f/llguidance-1.3.0-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6f6caca5d78db7f76e1fbb0fff8607b861c32d47fa3d5dee2fc49de27ee269df", size = 2835242, upload-time = "2025-10-20T19:58:34.518Z" },
+    { url = "https://files.pythonhosted.org/packages/83/a8/1ff2bedb8f9acb46a2d2d603415d272bb622c142ea86f5b95445cc6e366c/llguidance-1.3.0-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bc17e9dd602c3879bf91664a64bf72f54c74dbfbeb24ccfab6a5fe435b12f7aa", size = 3033133, upload-time = "2025-10-20T19:58:38.721Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/7e/809349638231f469b9056c0e1bfd924d5ef5558b3b3ec72d093b6fad33b1/llguidance-1.3.0-cp39-abi3-win_amd64.whl", hash = "sha256:1d1cd1c8618d1a13605d3e057c978651e551c8c469b481ee4041f1d6c436002d", size = 2789946, upload-time = "2025-10-20T19:58:45.958Z" },
+]
+
+[[package]]
+name = "llvmlite"
+version = "0.44.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/89/6a/95a3d3610d5c75293d5dbbb2a76480d5d4eeba641557b69fe90af6c5b84e/llvmlite-0.44.0.tar.gz", hash = "sha256:07667d66a5d150abed9157ab6c0b9393c9356f229784a4385c02f99e94fc94d4", size = 171880, upload-time = "2025-01-20T11:14:41.342Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/15/86/e3c3195b92e6e492458f16d233e58a1a812aa2bfbef9bdd0fbafcec85c60/llvmlite-0.44.0-cp312-cp312-macosx_10_14_x86_64.whl", hash = "sha256:1d671a56acf725bf1b531d5ef76b86660a5ab8ef19bb6a46064a705c6ca80aad", size = 28132297, upload-time = "2025-01-20T11:13:32.57Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/53/373b6b8be67b9221d12b24125fd0ec56b1078b660eeae266ec388a6ac9a0/llvmlite-0.44.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:5f79a728e0435493611c9f405168682bb75ffd1fbe6fc360733b850c80a026db", size = 26201105, upload-time = "2025-01-20T11:13:38.744Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/da/8341fd3056419441286c8e26bf436923021005ece0bff5f41906476ae514/llvmlite-0.44.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c0143a5ef336da14deaa8ec26c5449ad5b6a2b564df82fcef4be040b9cacfea9", size = 42361901, upload-time = "2025-01-20T11:13:46.711Z" },
+    { url = "https://files.pythonhosted.org/packages/53/ad/d79349dc07b8a395a99153d7ce8b01d6fcdc9f8231355a5df55ded649b61/llvmlite-0.44.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d752f89e31b66db6f8da06df8b39f9b91e78c5feea1bf9e8c1fba1d1c24c065d", size = 41184247, upload-time = "2025-01-20T11:13:56.159Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/3b/a9a17366af80127bd09decbe2a54d8974b6d8b274b39bf47fbaedeec6307/llvmlite-0.44.0-cp312-cp312-win_amd64.whl", hash = "sha256:eae7e2d4ca8f88f89d315b48c6b741dcb925d6a1042da694aa16ab3dd4cbd3a1", size = 30332380, upload-time = "2025-01-20T11:14:02.442Z" },
+    { url = "https://files.pythonhosted.org/packages/89/24/4c0ca705a717514c2092b18476e7a12c74d34d875e05e4d742618ebbf449/llvmlite-0.44.0-cp313-cp313-macosx_10_14_x86_64.whl", hash = "sha256:319bddd44e5f71ae2689859b7203080716448a3cd1128fb144fe5c055219d516", size = 28132306, upload-time = "2025-01-20T11:14:09.035Z" },
+    { url = "https://files.pythonhosted.org/packages/01/cf/1dd5a60ba6aee7122ab9243fd614abcf22f36b0437cbbe1ccf1e3391461c/llvmlite-0.44.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:9c58867118bad04a0bb22a2e0068c693719658105e40009ffe95c7000fcde88e", size = 26201090, upload-time = "2025-01-20T11:14:15.401Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/1b/656f5a357de7135a3777bd735cc7c9b8f23b4d37465505bd0eaf4be9befe/llvmlite-0.44.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:46224058b13c96af1365290bdfebe9a6264ae62fb79b2b55693deed11657a8bf", size = 42361904, upload-time = "2025-01-20T11:14:22.949Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/e1/12c5f20cb9168fb3464a34310411d5ad86e4163c8ff2d14a2b57e5cc6bac/llvmlite-0.44.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:aa0097052c32bf721a4efc03bd109d335dfa57d9bffb3d4c24cc680711b8b4fc", size = 41184245, upload-time = "2025-01-20T11:14:31.731Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/81/e66fc86539293282fd9cb7c9417438e897f369e79ffb62e1ae5e5154d4dd/llvmlite-0.44.0-cp313-cp313-win_amd64.whl", hash = "sha256:2fb7c4f2fb86cbae6dca3db9ab203eeea0e22d73b99bc2341cdf9de93612e930", size = 30331193, upload-time = "2025-01-20T11:14:38.578Z" },
+]
+
+[[package]]
+name = "lm-format-enforcer"
+version = "0.11.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "interegular" },
+    { name = "packaging" },
+    { name = "pydantic" },
+    { name = "pyyaml" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/84/d5/41cd417ba7dfdbbcfe46cebf81fb3dfd7c591b89897560ad05bb410a465d/lm_format_enforcer-0.11.3.tar.gz", hash = "sha256:e68081c108719cce284a9bcc889709b26ffb085a1945b5eba3a12cfa96d528da", size = 40258, upload-time = "2025-08-24T19:37:47.527Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a0/ef/11292bb0b85cf4c93447cab5a29f64576ed14d3ab4280e35ddd23486594a/lm_format_enforcer-0.11.3-py3-none-any.whl", hash = "sha256:cf586350875def1ae7a8fba84fcbbfc8371424b6c9d05c1fcba70aa233fbf06f", size = 45418, upload-time = "2025-08-24T19:37:46.325Z" },
+]
+
+[[package]]
+name = "loguru"
+version = "0.7.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+    { name = "win32-setctime", marker = "sys_platform == 'win32'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/3a/05/a1dae3dffd1116099471c643b8924f5aa6524411dc6c63fdae648c4f1aca/loguru-0.7.3.tar.gz", hash = "sha256:19480589e77d47b8d85b2c827ad95d49bf31b0dcde16593892eb51dd18706eb6", size = 63559, upload-time = "2024-12-06T11:20:56.608Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0c/29/0348de65b8cc732daa3e33e67806420b2ae89bdce2b04af740289c5c6c8c/loguru-0.7.3-py3-none-any.whl", hash = "sha256:31a33c10c8e1e10422bfd431aeb5d351c7cf7fa671e3c4df004162264b28220c", size = 61595, upload-time = "2024-12-06T11:20:54.538Z" },
+]
+
 [[package]]
 name = "markdown"
 version = "3.10"
@@ -2556,6 +3285,30 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/2c/19/04f9b178c2d8a15b076c8b5140708fa6ffc5601fb6f1e975537072df5b2a/mergedeep-1.3.4-py3-none-any.whl", hash = "sha256:70775750742b25c0d8f36c55aed03d24c3384d17c951b3175d898bd778ef0307", size = 6354, upload-time = "2021-02-05T18:55:29.583Z" },
 ]
 
+[[package]]
+name = "mistral-common"
+version = "1.11.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "jsonschema" },
+    { name = "numpy" },
+    { name = "pillow" },
+    { name = "pydantic" },
+    { name = "pydantic-extra-types", extra = ["pycountry"] },
+    { name = "requests" },
+    { name = "tiktoken" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c2/eb/12167a1bea9714582e5b4f539f9c019323363e314a499c72855ff0e5ad43/mistral_common-1.11.2.tar.gz", hash = "sha256:79f68fc2d1190f28637f40e053f919c8c2697e00b2aa679ddee562a95183f4ad", size = 6357845, upload-time = "2026-05-04T19:47:40.413Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/47/f0/6a5d604b972e442b9d36c117d01788feddad099e4965699e3516ee6fefc3/mistral_common-1.11.2-py3-none-any.whl", hash = "sha256:ebb42062cd705a0aa2bc69b4cde2b83d446ae58150b7e29322c90cb08fcfca6c", size = 6531968, upload-time = "2026-05-04T19:47:37.718Z" },
+]
+
+[package.optional-dependencies]
+image = [
+    { name = "opencv-python-headless" },
+]
+
 [[package]]
 name = "mistune"
 version = "3.2.0"
@@ -2679,6 +3432,53 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/32/28/79f0f8de97cce916d5ae88a7bee1ad724855e83e6019c0b4d5b3fabc80f3/mkdocstrings_python-2.0.3-py3-none-any.whl", hash = "sha256:0b83513478bdfd803ff05aa43e9b1fca9dd22bcd9471f09ca6257f009bc5ee12", size = 104779, upload-time = "2026-02-20T10:38:34.517Z" },
 ]
 
+[[package]]
+name = "mlx"
+version = "0.31.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "mlx-metal", marker = "sys_platform == 'darwin'" },
+]
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c3/47/5f33906cb03d6a378a697cd2d2641a26b37dea17ee3d9124d7e39e8eca01/mlx-0.31.2-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:e5067aaf2be1f3d7bba5be52348775804f111173c1ed04639618fd713b1a530f", size = 584863, upload-time = "2026-04-22T03:14:38.211Z" },
+    { url = "https://files.pythonhosted.org/packages/08/e7/a851a451b1327af9fb4df3991b9ae87d066b6f6630e854af55c288b0995a/mlx-0.31.2-cp312-cp312-macosx_15_0_arm64.whl", hash = "sha256:edb9797db7d852477ca1c99708058654ee860d4148fe5765f0d55528e2b1aa22", size = 584860, upload-time = "2026-04-22T03:14:39.746Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/15/0d1dc0597644e5e7b011ca954ba0c47e13cd880a3b909b0c3f1b4d8bf8f1/mlx-0.31.2-cp312-cp312-macosx_26_0_arm64.whl", hash = "sha256:51ca102db641b01e7cb083ce8ecb580e281530a141a7ca12544bb370641630ae", size = 584887, upload-time = "2026-04-22T03:14:41.585Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/3f/888f8664d4f8e23a1363a5f50024be5216e199ab7ad0ba20988c7ed6d729/mlx-0.31.2-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:1b3fb0dda955b0d552ce57bdd6f42b3309ab21b067e40587d6848443d307e91f", size = 584796, upload-time = "2026-04-22T03:14:47.215Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/14/e9cd18b51f9e1dbcb060eec0fafc2d2428c8e1eacd9b0a02d7c5ce75b661/mlx-0.31.2-cp313-cp313-macosx_15_0_arm64.whl", hash = "sha256:34b0171cd9eb5c43fdd82091f6135d6ccc5a065363a4a3e68fac64fb4e53d37c", size = 584790, upload-time = "2026-04-22T03:14:48.519Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/20/c6c5fb998c7834d094b2bfb9f003b5246cb270f0266da055c55546c34999/mlx-0.31.2-cp313-cp313-macosx_26_0_arm64.whl", hash = "sha256:c05981684279a8935d58b0dde3ea5b02d210c3bad3319aa0e9934ec2df165752", size = 584795, upload-time = "2026-04-22T03:14:49.904Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/f5/e63f6a9316ded2d14a8ebc7a9ca25734c784e8c54d064a78b4dceeacec0e/mlx-0.31.2-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:a13c9ce23c3deef6aa5a09315e7953e1a5dc311e851fa16fc74c81fb2509c0b9", size = 588417, upload-time = "2026-04-22T03:14:54.094Z" },
+    { url = "https://files.pythonhosted.org/packages/31/50/9d0c03ea3134cd85c132df7b0e4b75e6344bd8b4881a0b9c465cfa27f724/mlx-0.31.2-cp314-cp314-macosx_15_0_arm64.whl", hash = "sha256:b0764bf11fc3a71dee988e19275eef67775cab63112d8bb7ef173ca8b2a1247c", size = 588421, upload-time = "2026-04-22T03:14:55.898Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/5b/d364cc793bcb504621313acb55627cf0d5403ab2e0a594aa081cdbe4591f/mlx-0.31.2-cp314-cp314-macosx_26_0_arm64.whl", hash = "sha256:59ccbd0f0044d4f97f11ebcbf0c480bc9e962935fd96275f120954afea65be8a", size = 588384, upload-time = "2026-04-22T03:14:57.439Z" },
+]
+
+[[package]]
+name = "mlx-lm"
+version = "0.29.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "jinja2", marker = "sys_platform == 'darwin'" },
+    { name = "mlx", marker = "sys_platform == 'darwin'" },
+    { name = "numpy", marker = "sys_platform == 'darwin'" },
+    { name = "protobuf", marker = "sys_platform == 'darwin'" },
+    { name = "pyyaml", marker = "sys_platform == 'darwin'" },
+    { name = "sentencepiece", marker = "sys_platform == 'darwin'" },
+    { name = "transformers", marker = "sys_platform == 'darwin'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/e3/62/f46e1355256a114808517947f8e83ad6be310c7288c551db0fa678f47923/mlx_lm-0.29.1.tar.gz", hash = "sha256:b99180d8f33d33a077b814e550bfb2d8a59ae003d668fd1f4b3fff62a381d34b", size = 232302, upload-time = "2025-12-16T16:58:27.959Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e5/53/913099c91d384e115ea078325efd9a0bc1ea3eb3458c694b4596cbd267f2/mlx_lm-0.29.1-py3-none-any.whl", hash = "sha256:440941b3054c2a2216e97615de584cc90fa1ea874782e20699b9895721fad8dc", size = 324884, upload-time = "2025-12-16T16:58:26.36Z" },
+]
+
+[[package]]
+name = "mlx-metal"
+version = "0.31.2"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3f/69/fe3b783ebe999f3118234e1e940feb622518bfb1dea6ac5d13b1d36a8449/mlx_metal-0.31.2-py3-none-macosx_14_0_arm64.whl", hash = "sha256:b25385bcee18fc194092255b8b53b9a3d8489eb650e59160f1b57aadd07aa2dc", size = 40055588, upload-time = "2026-04-22T03:14:14.43Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/5d/4c690d5b93c30ba002656c37363159d978705bf8eb801b8481840fb942c2/mlx_metal-0.31.2-py3-none-macosx_15_0_arm64.whl", hash = "sha256:e9d4e5fce6ca10a87a0e388597f99519ad594d09e674708b5312bd8bd4f5997d", size = 40053220, upload-time = "2026-04-22T03:14:18.048Z" },
+    { url = "https://files.pythonhosted.org/packages/99/82/11fd62a8d7a3e96e5c43220b17de0151e3f10101f8bb3b865f5bd9cdd074/mlx_metal-0.31.2-py3-none-macosx_26_0_arm64.whl", hash = "sha256:84ffb60ee503f03eb684f5fb168d5cff31e2a16b7f27c1731eaf7662bd6e9b46", size = 55792151, upload-time = "2026-04-22T03:14:22.059Z" },
+]
+
 [[package]]
 name = "mmh3"
 version = "5.2.1"
@@ -2761,6 +3561,24 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/a0/0f/59204bf136d1201f8d7884cfbaf7498c5b4674e87a4c693f9bde63741ce1/mmh3-5.2.1-cp314-cp314t-win_arm64.whl", hash = "sha256:dfd51b4c56b673dfbc43d7d27ef857dd91124801e2806c69bb45585ce0fa019b", size = 40391, upload-time = "2026-03-05T15:55:56.697Z" },
 ]
 
+[[package]]
+name = "model-hosting-container-standards"
+version = "0.1.15"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "fastapi" },
+    { name = "httpx" },
+    { name = "jmespath" },
+    { name = "pydantic" },
+    { name = "setuptools" },
+    { name = "starlette" },
+    { name = "supervisor" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/03/5a/d669bdeb5ba96db42c6ef010835a25119b05f8c35ee5f1c3f715626625fe/model_hosting_container_standards-0.1.15.tar.gz", hash = "sha256:ae8dd74d3250545c14f0a7068186c7b0f0ab6563d31e7137f556b6b660c8a6a9", size = 93994, upload-time = "2026-05-05T18:22:29.357Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/61/26/c7aea197f1719f31d0dd686eb4475982fe9efd7668ce259cb52b62c676b6/model_hosting_container_standards-0.1.15-py3-none-any.whl", hash = "sha256:849e08c4732203ee861c8c24966b4e916ea4420fa324b430f7f74a1e1fe8811a", size = 125418, upload-time = "2026-05-05T18:22:27.819Z" },
+]
+
 [[package]]
 name = "mpmath"
 version = "1.3.0"
@@ -2814,6 +3632,46 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/81/f2/08ace4142eb281c12701fc3b93a10795e4d4dc7f753911d836675050f886/msgpack-1.1.2-cp314-cp314t-win_arm64.whl", hash = "sha256:d99ef64f349d5ec3293688e91486c5fdb925ed03807f64d98d205d2713c60b46", size = 70868, upload-time = "2025-10-08T09:15:44.959Z" },
 ]
 
+[[package]]
+name = "msgspec"
+version = "0.21.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e3/60/f79b9b013a16fa3a58350c9295ddc6789f2e335f36ea61ed10a21b215364/msgspec-0.21.1.tar.gz", hash = "sha256:2313508e394b0d208f8f56892ca9b2799e2561329de9763b19619595a6c0f72c", size = 319193, upload-time = "2026-04-12T21:44:50.394Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/6e/cf/317224852c00248c620a9bcf4b26e2e4ab8afd752f18d2a6ef73ebd423b6/msgspec-0.21.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:d4248cf0b6129b7d230eacd493c17cc2d4f3989f3bb7f633a928a85b7dcfa251", size = 196188, upload-time = "2026-04-12T21:44:07.181Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/81/074612945c0666078f7366f40000013de9f6ba687491d450df699bceebc9/msgspec-0.21.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:5102c7e9b3acff82178449b85006d96310e690291bb1ea0142f1b24bcb8aabcb", size = 188473, upload-time = "2026-04-12T21:44:08.736Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/37/655101799590bcc5fddb2bd3fe0e6194e816c2d1da7c361725f5eb89a910/msgspec-0.21.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:846758412e9518252b2ac9bffd6f0e54d9ff614f5f9488df7749f81ff5c80920", size = 218871, upload-time = "2026-04-12T21:44:09.917Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/d1/d4cd9fe89c7d400d7a18f86ccc94daa3f0927f53558846fcb60791dce5d6/msgspec-0.21.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:21995e74b5c598c2e004110ad66ec7f1b8c20bf2bcf3b2de8fd9a3094422d3ff", size = 225025, upload-time = "2026-04-12T21:44:11.191Z" },
+    { url = "https://files.pythonhosted.org/packages/24/bf/e20549e602b9edccadeeff98760345a416f9cce846a657e8b18e3396b212/msgspec-0.21.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:6129f0cca52992e898fd5344187f7c8127b63d810b2fd73e36fca73b4c6475ee", size = 222672, upload-time = "2026-04-12T21:44:12.481Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/68/04d7a8f0f786545cf9b8c280c57aa6befb5977af6e884b8b54191cbe44b3/msgspec-0.21.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:ef3ec2296248d1f8b9231acb051b6d471dfde8f21819e86c9adaaa9f42918521", size = 227303, upload-time = "2026-04-12T21:44:13.709Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/4d/619866af2840875be408047bf9e70ceafbae6ab50660de7134ed1b25eb86/msgspec-0.21.1-cp312-cp312-win_amd64.whl", hash = "sha256:d4ab834a054c6f0cbeef6df9e7e1b33d5f1bc7b86dea1d2fd7cad003873e783d", size = 190017, upload-time = "2026-04-12T21:44:14.977Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/2e/a8f9eca8fd00e097d7a9e99ba8a4685db994494448e3d4f0b7f6e9a3c0f7/msgspec-0.21.1-cp312-cp312-win_arm64.whl", hash = "sha256:628aaa35c74950a8c59da330d7e98917e1c7188f983745782027748ee4ca573e", size = 175345, upload-time = "2026-04-12T21:44:16.431Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/74/f11ede02839b19ff459f88e3145df5d711626ca84da4e23520cebf819367/msgspec-0.21.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:764173717a01743f007e9f74520ed281f24672c604514f7d76c1c3a10e8edb66", size = 196176, upload-time = "2026-04-12T21:44:17.613Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/40/4476c1bd341418a046c4955aff632ec769315d1e3cb94e6acf86d461f9ed/msgspec-0.21.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:344c7cd0eaed1fb81d7959f99100ef71ec9b536881a376f11b9a6c4803365697", size = 188524, upload-time = "2026-04-12T21:44:18.815Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/d9/9e9d7d7e5061b47540d03d640fab9b3965ba7ae49c1b2154861c8f007518/msgspec-0.21.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:48943e278b3854c2f89f955ddc6f9f430d3f0784b16e47d10604ee0463cd21f5", size = 218880, upload-time = "2026-04-12T21:44:20.028Z" },
+    { url = "https://files.pythonhosted.org/packages/74/66/2bb344f34abb4b57e60c7c9c761994e0417b9718ec1460bf00c296f2a7ea/msgspec-0.21.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a9aa659ebb0101b1cbc31461212b87e341d961f0ab0772aaf068a99e001ec4aa", size = 225050, upload-time = "2026-04-12T21:44:21.577Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/84/7c1e412f76092277bf760cef12b7979d03314d259ab5b5cafde5d0c1722d/msgspec-0.21.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f7b27d1a8ead2b6f5b0c4f2d07b8be1ccfcc041c8a0e704781edebe3ae13c484", size = 222713, upload-time = "2026-04-12T21:44:22.83Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/27/0bba04b2b4ef05f3d068429410bc71d2cea925f1596a8f41152cccd5edb8/msgspec-0.21.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:38fe93e86b61328fe544cb7fd871fad5a27c8734bfda90f65e5dbe288ae50f61", size = 227259, upload-time = "2026-04-12T21:44:24.11Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/2d/09574b0eea02fed2c2c1383dbaae2c7f79dc16dcd6487a886000afb5d7c4/msgspec-0.21.1-cp313-cp313-win_amd64.whl", hash = "sha256:8bc666331c35fcce05a7cd2d6221adbe0f6058f8e750711413d22793c080ac6a", size = 189857, upload-time = "2026-04-12T21:44:25.359Z" },
+    { url = "https://files.pythonhosted.org/packages/46/34/105b1576ad182879914f0c821f17ee1d13abb165cb060448f96fe2aff078/msgspec-0.21.1-cp313-cp313-win_arm64.whl", hash = "sha256:42bb1241e0750c1a4346f2aa84db26c5ffd99a4eb3a954927d9f149ff2f42898", size = 175403, upload-time = "2026-04-12T21:44:26.608Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/ad/86954e987d1d6a5c579e2c2e7832b65e0fff194179fdac4f581536086024/msgspec-0.21.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:fab48eb45fdbfbdb2c0edfec00ffc53b6b6085beefc6b50b61e01659f9f8757f", size = 196261, upload-time = "2026-04-12T21:44:27.807Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/a1/c5e46c3e42b866199365e35d11dddfd1fbd8bba4fdb3c52f965b1607ce94/msgspec-0.21.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:3cb779ea0c35bc807ff941d415875c1f69ca0be91a2e907ab99a171811d86a9a", size = 188729, upload-time = "2026-04-12T21:44:28.99Z" },
+    { url = "https://files.pythonhosted.org/packages/85/7d/1e29a319d678d6cb962ae5bdf32a6858ebdf38f73bc654c0e9c742a0c2c8/msgspec-0.21.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:68604db36b3b4dd9bf160e436e12798a4738848144cea1aca1cb984011eb160f", size = 219866, upload-time = "2026-04-12T21:44:31.104Z" },
+    { url = "https://files.pythonhosted.org/packages/25/1f/cca084ca2572810fff12ea9dbdcbe39eac048f40daf4a9077b49fcbe8cee/msgspec-0.21.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3d6b9dc50948eaf65df54d2fd0ff66e6d8c32f116037209ee861810eb9b676cb", size = 224993, upload-time = "2026-04-12T21:44:32.649Z" },
+    { url = "https://files.pythonhosted.org/packages/71/94/d2120fc9d419a89a3a7c13e5b7078798c4b392a96a02a6e2b3ce43a8766c/msgspec-0.21.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:52c5e21930942302394429c5a582ce7e6b62c7f983b3760834c2ce107e0dd6df", size = 223535, upload-time = "2026-04-12T21:44:33.839Z" },
+    { url = "https://files.pythonhosted.org/packages/75/17/42418b66a3ad972a89bab73dd78b79cc6282bb488a25e73c853cee7443b9/msgspec-0.21.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:abbb39d65681fa24ed394e01af3d59d869068324f900c61d06062b7fb9980f2f", size = 227222, upload-time = "2026-04-12T21:44:35.093Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/33/265c894268cca88ff67b144ca2b4c522fc8b9a6f1966a3640c70516e78e1/msgspec-0.21.1-cp314-cp314-win_amd64.whl", hash = "sha256:5666b1b560b97b6ec2eb3fca8a502298ebac56e13bbca1f88523538ce83d01ea", size = 193810, upload-time = "2026-04-12T21:44:36.612Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/8f/a6d35f25bf1fc63c492fdd88fdce01ba0875ead48c2b91f90f33653b4131/msgspec-0.21.1-cp314-cp314-win_arm64.whl", hash = "sha256:d8b8578e4c83b14ceea4cef0d0b747e31d9330fe4b03b2b2ad4063866a178f93", size = 179125, upload-time = "2026-04-12T21:44:38.198Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/39/74839641e64b99d87da55af0fc472854d42b46e2183b9e2a67fe1bb2a512/msgspec-0.21.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:15f523d51c00ebad412213bfe9f06f0a50ec2b93e0c19e824a2d267cabb48ea2", size = 200171, upload-time = "2026-04-12T21:44:39.414Z" },
+    { url = "https://files.pythonhosted.org/packages/70/9b/ce0cca6d2d87fcd4b6ff97600790494e64f26a2c55d61507cd2755c16193/msgspec-0.21.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:4e47390360583ba3d5c6cb44cf0a9f61b0a06a899d3c2c00627cedebb2e2884b", size = 192879, upload-time = "2026-04-12T21:44:40.882Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/08/673a7bb05e5702dc787ddd3011195b509f9867927970da59052211929987/msgspec-0.21.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f60800e6299b798142dc40b0644da77ceac5ea0568be58228417eae14135c847", size = 226281, upload-time = "2026-04-12T21:44:42.181Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/45/86508cf57283e9070b3c447e3ab25b792a7a0855a3ea4e0c6d111ac34c97/msgspec-0.21.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5f8e9dfcd98419cf7568808470c4317a3fb30bef0e3715b568730a2b272a20d7", size = 229863, upload-time = "2026-04-12T21:44:43.442Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/62/e7c9367cd08d590559faacd711edbae36840342843e669440363f33c7d36/msgspec-0.21.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:92d89dfad13bd1ea640dc3e37e724ed380da1030b272bdf5ecafb983c3ad7c75", size = 230445, upload-time = "2026-04-12T21:44:44.806Z" },
+    { url = "https://files.pythonhosted.org/packages/42/b4/c0f54632103846b658a10930025f4de41c8724b5e4805a5f3b395586cb7e/msgspec-0.21.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:0d03867786e5d7ba25d666df4b11320c27170f4aeafcb8e3a8b0a50a4fb742ca", size = 231822, upload-time = "2026-04-12T21:44:46.343Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/1d/0d85cc79d0ccf5508e9c846cc66552a6a16bf92abd1dbd8362617f7b35cd/msgspec-0.21.1-cp314-cp314t-win_amd64.whl", hash = "sha256:740fbf1c9d59992ca3537d6fbe9ebbf9eaf726a65fbf31448e0ecbc710697a63", size = 206650, upload-time = "2026-04-12T21:44:47.601Z" },
+    { url = "https://files.pythonhosted.org/packages/90/91/56c5d560f20e6c20e9e4f55bd0e458f7f162aa689ee350346c04c48eac0b/msgspec-0.21.1-cp314-cp314t-win_arm64.whl", hash = "sha256:0d2cc73df6058d811a126ac3a8ad63a4dfa210c82f9cf5a004802eaf4712de90", size = 183149, upload-time = "2026-04-12T21:44:48.833Z" },
+]
+
 [[package]]
 name = "multidict"
 version = "6.7.1"
@@ -3018,99 +3876,347 @@ dependencies = [
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/38/47/81f886b699450d0569f7bc551df2b1673d18df7ff25cc0c21ca36ed8a5ff/nbconvert-7.17.0.tar.gz", hash = "sha256:1b2696f1b5be12309f6c7d707c24af604b87dfaf6d950794c7b07acab96dda78", size = 862855, upload-time = "2026-01-29T16:37:48.478Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/0d/4b/8d5f796a792f8a25f6925a96032f098789f448571eb92011df1ae59e8ea8/nbconvert-7.17.0-py3-none-any.whl", hash = "sha256:4f99a63b337b9a23504347afdab24a11faa7d86b405e5c8f9881cd313336d518", size = 261510, upload-time = "2026-01-29T16:37:46.322Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/4b/8d5f796a792f8a25f6925a96032f098789f448571eb92011df1ae59e8ea8/nbconvert-7.17.0-py3-none-any.whl", hash = "sha256:4f99a63b337b9a23504347afdab24a11faa7d86b405e5c8f9881cd313336d518", size = 261510, upload-time = "2026-01-29T16:37:46.322Z" },
+]
+
+[[package]]
+name = "nbformat"
+version = "5.10.4"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "fastjsonschema" },
+    { name = "jsonschema" },
+    { name = "jupyter-core" },
+    { name = "traitlets" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/6d/fd/91545e604bc3dad7dca9ed03284086039b294c6b3d75c0d2fa45f9e9caf3/nbformat-5.10.4.tar.gz", hash = "sha256:322168b14f937a5d11362988ecac2a4952d3d8e3a2cbeb2319584631226d5b3a", size = 142749, upload-time = "2024-04-04T11:20:37.371Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a9/82/0340caa499416c78e5d8f5f05947ae4bc3cba53c9f038ab6e9ed964e22f1/nbformat-5.10.4-py3-none-any.whl", hash = "sha256:3b48d6c8fbca4b299bf3982ea7db1af21580e4fec269ad087b9e81588891200b", size = 78454, upload-time = "2024-04-04T11:20:34.895Z" },
+]
+
+[[package]]
+name = "nbqa"
+version = "1.9.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "autopep8" },
+    { name = "ipython" },
+    { name = "tokenize-rt" },
+    { name = "tomli" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/aa/76/62d2609924cf34445148cd6b5de694cf64c179cc416cac93182579620e57/nbqa-1.9.1.tar.gz", hash = "sha256:a1f4bcf587c597302fed295951001fc4e1be4ce0e77e1ab1b25ac2fbe3db0cdd", size = 38348, upload-time = "2024-11-10T12:21:58.333Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/28/88/4789719fbbe166d12d345b3ac66b96105f10001b16e00a9765ba29261a21/nbqa-1.9.1-py3-none-any.whl", hash = "sha256:95552d2f6c2c038136252a805aa78d85018aef922586270c3a074332737282e5", size = 35259, upload-time = "2024-11-10T12:21:56.731Z" },
+]
+
+[[package]]
+name = "nest-asyncio"
+version = "1.6.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/83/f8/51569ac65d696c8ecbee95938f89d4abf00f47d58d48f6fbabfe8f0baefe/nest_asyncio-1.6.0.tar.gz", hash = "sha256:6f172d5449aca15afd6c646851f4e31e02c598d553a667e38cafa997cfec55fe", size = 7418, upload-time = "2024-01-21T14:25:19.227Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a0/c4/c2971a3ba4c6103a3d10c4b0f24f461ddc027f0f09763220cf35ca1401b3/nest_asyncio-1.6.0-py3-none-any.whl", hash = "sha256:87af6efd6b5e897c81050477ef65c62e2b2f35d51703cae01aff2905b1852e1c", size = 5195, upload-time = "2024-01-21T14:25:17.223Z" },
+]
+
+[[package]]
+name = "networkx"
+version = "3.6.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/6a/51/63fe664f3908c97be9d2e4f1158eb633317598cfa6e1fc14af5383f17512/networkx-3.6.1.tar.gz", hash = "sha256:26b7c357accc0c8cde558ad486283728b65b6a95d85ee1cd66bafab4c8168509", size = 2517025, upload-time = "2025-12-08T17:02:39.908Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9e/c9/b2622292ea83fbb4ec318f5b9ab867d0a28ab43c5717bb85b0a5f6b3b0a4/networkx-3.6.1-py3-none-any.whl", hash = "sha256:d47fbf302e7d9cbbb9e2555a0d267983d2aa476bac30e90dfbe5669bd57f3762", size = 2068504, upload-time = "2025-12-08T17:02:38.159Z" },
+]
+
+[[package]]
+name = "ninja"
+version = "1.13.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/43/73/79a0b22fc731989c708068427579e840a6cf4e937fe7ae5c5d0b7356ac22/ninja-1.13.0.tar.gz", hash = "sha256:4a40ce995ded54d9dc24f8ea37ff3bf62ad192b547f6c7126e7e25045e76f978", size = 242558, upload-time = "2025-08-11T15:10:19.421Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3c/74/d02409ed2aa865e051b7edda22ad416a39d81a84980f544f8de717cab133/ninja-1.13.0-py3-none-macosx_10_9_universal2.whl", hash = "sha256:fa2a8bfc62e31b08f83127d1613d10821775a0eb334197154c4d6067b7068ff1", size = 310125, upload-time = "2025-08-11T15:09:50.971Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/de/6e1cd6b84b412ac1ef327b76f0641aeb5dcc01e9d3f9eee0286d0c34fd93/ninja-1.13.0-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:3d00c692fb717fd511abeb44b8c5d00340c36938c12d6538ba989fe764e79630", size = 177467, upload-time = "2025-08-11T15:09:52.767Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/83/49320fb6e58ae3c079381e333575fdbcf1cca3506ee160a2dcce775046fa/ninja-1.13.0-py3-none-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:be7f478ff9f96a128b599a964fc60a6a87b9fa332ee1bd44fa243ac88d50291c", size = 187834, upload-time = "2025-08-11T15:09:54.115Z" },
+    { url = "https://files.pythonhosted.org/packages/56/c7/ba22748fb59f7f896b609cd3e568d28a0a367a6d953c24c461fe04fc4433/ninja-1.13.0-py3-none-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:60056592cf495e9a6a4bea3cd178903056ecb0943e4de45a2ea825edb6dc8d3e", size = 202736, upload-time = "2025-08-11T15:09:55.745Z" },
+    { url = "https://files.pythonhosted.org/packages/79/22/d1de07632b78ac8e6b785f41fa9aad7a978ec8c0a1bf15772def36d77aac/ninja-1.13.0-py3-none-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:1c97223cdda0417f414bf864cfb73b72d8777e57ebb279c5f6de368de0062988", size = 179034, upload-time = "2025-08-11T15:09:57.394Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/de/0e6edf44d6a04dabd0318a519125ed0415ce437ad5a1ec9b9be03d9048cf/ninja-1.13.0-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:fb46acf6b93b8dd0322adc3a4945452a4e774b75b91293bafcc7b7f8e6517dfa", size = 180716, upload-time = "2025-08-11T15:09:58.696Z" },
+    { url = "https://files.pythonhosted.org/packages/54/28/938b562f9057aaa4d6bfbeaa05e81899a47aebb3ba6751e36c027a7f5ff7/ninja-1.13.0-py3-none-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:4be9c1b082d244b1ad7ef41eb8ab088aae8c109a9f3f0b3e56a252d3e00f42c1", size = 146843, upload-time = "2025-08-11T15:10:00.046Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/fb/d06a3838de4f8ab866e44ee52a797b5491df823901c54943b2adb0389fbb/ninja-1.13.0-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:6739d3352073341ad284246f81339a384eec091d9851a886dfa5b00a6d48b3e2", size = 154402, upload-time = "2025-08-11T15:10:01.657Z" },
+    { url = "https://files.pythonhosted.org/packages/31/bf/0d7808af695ceddc763cf251b84a9892cd7f51622dc8b4c89d5012779f06/ninja-1.13.0-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:11be2d22027bde06f14c343f01d31446747dbb51e72d00decca2eb99be911e2f", size = 552388, upload-time = "2025-08-11T15:10:03.349Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/70/c99d0c2c809f992752453cce312848abb3b1607e56d4cd1b6cded317351a/ninja-1.13.0-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:aa45b4037b313c2f698bc13306239b8b93b4680eb47e287773156ac9e9304714", size = 472501, upload-time = "2025-08-11T15:10:04.735Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/43/c217b1153f0e499652f5e0766da8523ce3480f0a951039c7af115e224d55/ninja-1.13.0-py3-none-musllinux_1_2_i686.whl", hash = "sha256:5f8e1e8a1a30835eeb51db05cf5a67151ad37542f5a4af2a438e9490915e5b72", size = 638280, upload-time = "2025-08-11T15:10:06.512Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/45/9151bba2c8d0ae2b6260f71696330590de5850e5574b7b5694dce6023e20/ninja-1.13.0-py3-none-musllinux_1_2_ppc64le.whl", hash = "sha256:3d7d7779d12cb20c6d054c61b702139fd23a7a964ec8f2c823f1ab1b084150db", size = 642420, upload-time = "2025-08-11T15:10:08.35Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/fb/95752eb635bb8ad27d101d71bef15bc63049de23f299e312878fc21cb2da/ninja-1.13.0-py3-none-musllinux_1_2_riscv64.whl", hash = "sha256:d741a5e6754e0bda767e3274a0f0deeef4807f1fec6c0d7921a0244018926ae5", size = 585106, upload-time = "2025-08-11T15:10:09.818Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/31/aa56a1a286703800c0cbe39fb4e82811c277772dc8cd084f442dd8e2938a/ninja-1.13.0-py3-none-musllinux_1_2_s390x.whl", hash = "sha256:e8bad11f8a00b64137e9b315b137d8bb6cbf3086fbdc43bf1f90fd33324d2e96", size = 707138, upload-time = "2025-08-11T15:10:11.366Z" },
+    { url = "https://files.pythonhosted.org/packages/34/6f/5f5a54a1041af945130abdb2b8529cbef0cdcbbf9bcf3f4195378319d29a/ninja-1.13.0-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:b4f2a072db3c0f944c32793e91532d8948d20d9ab83da9c0c7c15b5768072200", size = 581758, upload-time = "2025-08-11T15:10:13.295Z" },
+    { url = "https://files.pythonhosted.org/packages/95/97/51359c77527d45943fe7a94d00a3843b81162e6c4244b3579fe8fc54cb9c/ninja-1.13.0-py3-none-win32.whl", hash = "sha256:8cfbb80b4a53456ae8a39f90ae3d7a2129f45ea164f43fadfa15dc38c4aef1c9", size = 267201, upload-time = "2025-08-11T15:10:15.158Z" },
+    { url = "https://files.pythonhosted.org/packages/29/45/c0adfbfb0b5895aa18cec400c535b4f7ff3e52536e0403602fc1a23f7de9/ninja-1.13.0-py3-none-win_amd64.whl", hash = "sha256:fb8ee8719f8af47fed145cced4a85f0755dd55d45b2bddaf7431fa89803c5f3e", size = 309975, upload-time = "2025-08-11T15:10:16.697Z" },
+    { url = "https://files.pythonhosted.org/packages/df/93/a7b983643d1253bb223234b5b226e69de6cda02b76cdca7770f684b795f5/ninja-1.13.0-py3-none-win_arm64.whl", hash = "sha256:3c0b40b1f0bba764644385319028650087b4c1b18cdfa6f45cb39a3669b81aa9", size = 290806, upload-time = "2025-08-11T15:10:18.018Z" },
+]
+
+[[package]]
+name = "nodeenv"
+version = "1.9.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/43/16/fc88b08840de0e0a72a2f9d8c6bae36be573e475a6326ae854bcc549fc45/nodeenv-1.9.1.tar.gz", hash = "sha256:6ec12890a2dab7946721edbfbcd91f3319c6ccc9aec47be7c7e6b7011ee6645f", size = 47437, upload-time = "2024-06-04T18:44:11.171Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d2/1d/1b658dbd2b9fa9c4c9f32accbfc0205d532c8c6194dc0f2a4c0428e7128a/nodeenv-1.9.1-py2.py3-none-any.whl", hash = "sha256:ba11c9782d29c27c70ffbdda2d7415098754709be8a7056d79a737cd901155c9", size = 22314, upload-time = "2024-06-04T18:44:08.352Z" },
+]
+
+[[package]]
+name = "notebook"
+version = "7.5.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "jupyter-server" },
+    { name = "jupyterlab" },
+    { name = "jupyterlab-server" },
+    { name = "notebook-shim" },
+    { name = "tornado" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/1f/6d/41052c48d6f6349ca0a7c4d1f6a78464de135e6d18f5829ba2510e62184c/notebook-7.5.5.tar.gz", hash = "sha256:dc0bfab0f2372c8278c457423d3256c34154ac2cc76bf20e9925260c461013c3", size = 14169167, upload-time = "2026-03-11T16:32:51.922Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f8/aa/cbd1deb9f07446241e88f8d5fecccd95b249bca0b4e5482214a4d1714c49/notebook-7.5.5-py3-none-any.whl", hash = "sha256:a7c14dbeefa6592e87f72290ca982e0c10f5bbf3786be2a600fda9da2764a2b8", size = 14578929, upload-time = "2026-03-11T16:32:48.021Z" },
+]
+
+[[package]]
+name = "notebook-shim"
+version = "0.2.4"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "jupyter-server" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/54/d2/92fa3243712b9a3e8bafaf60aac366da1cada3639ca767ff4b5b3654ec28/notebook_shim-0.2.4.tar.gz", hash = "sha256:b4b2cfa1b65d98307ca24361f5b30fe785b53c3fd07b7a47e89acb5e6ac638cb", size = 13167, upload-time = "2024-02-14T23:35:18.353Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f9/33/bd5b9137445ea4b680023eb0469b2bb969d61303dedb2aac6560ff3d14a1/notebook_shim-0.2.4-py3-none-any.whl", hash = "sha256:411a5be4e9dc882a074ccbcae671eda64cceb068767e9a3419096986560e1cef", size = 13307, upload-time = "2024-02-14T23:35:16.286Z" },
+]
+
+[[package]]
+name = "numba"
+version = "0.61.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "llvmlite" },
+    { name = "numpy" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/1c/a0/e21f57604304aa03ebb8e098429222722ad99176a4f979d34af1d1ee80da/numba-0.61.2.tar.gz", hash = "sha256:8750ee147940a6637b80ecf7f95062185ad8726c8c28a2295b8ec1160a196f7d", size = 2820615, upload-time = "2025-04-09T02:58:07.659Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b4/a0/c6b7b9c615cfa3b98c4c63f4316e3f6b3bbe2387740277006551784218cd/numba-0.61.2-cp312-cp312-macosx_10_14_x86_64.whl", hash = "sha256:34fba9406078bac7ab052efbf0d13939426c753ad72946baaa5bf9ae0ebb8dd2", size = 2776626, upload-time = "2025-04-09T02:57:51.857Z" },
+    { url = "https://files.pythonhosted.org/packages/92/4a/fe4e3c2ecad72d88f5f8cd04e7f7cff49e718398a2fac02d2947480a00ca/numba-0.61.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:4ddce10009bc097b080fc96876d14c051cc0c7679e99de3e0af59014dab7dfe8", size = 2779287, upload-time = "2025-04-09T02:57:53.658Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/2d/e518df036feab381c23a624dac47f8445ac55686ec7f11083655eb707da3/numba-0.61.2-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:5b1bb509d01f23d70325d3a5a0e237cbc9544dd50e50588bc581ba860c213546", size = 3885928, upload-time = "2025-04-09T02:57:55.206Z" },
+    { url = "https://files.pythonhosted.org/packages/10/0f/23cced68ead67b75d77cfcca3df4991d1855c897ee0ff3fe25a56ed82108/numba-0.61.2-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:48a53a3de8f8793526cbe330f2a39fe9a6638efcbf11bd63f3d2f9757ae345cd", size = 3577115, upload-time = "2025-04-09T02:57:56.818Z" },
+    { url = "https://files.pythonhosted.org/packages/68/1d/ddb3e704c5a8fb90142bf9dc195c27db02a08a99f037395503bfbc1d14b3/numba-0.61.2-cp312-cp312-win_amd64.whl", hash = "sha256:97cf4f12c728cf77c9c1d7c23707e4d8fb4632b46275f8f3397de33e5877af18", size = 2831929, upload-time = "2025-04-09T02:57:58.45Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/f3/0fe4c1b1f2569e8a18ad90c159298d862f96c3964392a20d74fc628aee44/numba-0.61.2-cp313-cp313-macosx_10_14_x86_64.whl", hash = "sha256:3a10a8fc9afac40b1eac55717cece1b8b1ac0b946f5065c89e00bde646b5b154", size = 2771785, upload-time = "2025-04-09T02:57:59.96Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/71/91b277d712e46bd5059f8a5866862ed1116091a7cb03bd2704ba8ebe015f/numba-0.61.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:7d3bcada3c9afba3bed413fba45845f2fb9cd0d2b27dd58a1be90257e293d140", size = 2773289, upload-time = "2025-04-09T02:58:01.435Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/e0/5ea04e7ad2c39288c0f0f9e8d47638ad70f28e275d092733b5817cf243c9/numba-0.61.2-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:bdbca73ad81fa196bd53dc12e3aaf1564ae036e0c125f237c7644fe64a4928ab", size = 3893918, upload-time = "2025-04-09T02:58:02.933Z" },
+    { url = "https://files.pythonhosted.org/packages/17/58/064f4dcb7d7e9412f16ecf80ed753f92297e39f399c905389688cf950b81/numba-0.61.2-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:5f154aaea625fb32cfbe3b80c5456d514d416fcdf79733dd69c0df3a11348e9e", size = 3584056, upload-time = "2025-04-09T02:58:04.538Z" },
+    { url = "https://files.pythonhosted.org/packages/af/a4/6d3a0f2d3989e62a18749e1e9913d5fa4910bbb3e3311a035baea6caf26d/numba-0.61.2-cp313-cp313-win_amd64.whl", hash = "sha256:59321215e2e0ac5fa928a8020ab00b8e57cda8a97384963ac0dfa4d4e6aa54e7", size = 2831846, upload-time = "2025-04-09T02:58:06.125Z" },
+]
+
+[[package]]
+name = "numpy"
+version = "1.26.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/65/6e/09db70a523a96d25e115e71cc56a6f9031e7b8cd166c1ac8438307c14058/numpy-1.26.4.tar.gz", hash = "sha256:2a02aba9ed12e4ac4eb3ea9421c420301a0c6460d9830d74a9df87efa4912010", size = 15786129, upload-time = "2024-02-06T00:26:44.495Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/95/12/8f2020a8e8b8383ac0177dc9570aad031a3beb12e38847f7129bacd96228/numpy-1.26.4-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:b3ce300f3644fb06443ee2222c2201dd3a89ea6040541412b8fa189341847218", size = 20335901, upload-time = "2024-02-05T23:55:32.801Z" },
+    { url = "https://files.pythonhosted.org/packages/75/5b/ca6c8bd14007e5ca171c7c03102d17b4f4e0ceb53957e8c44343a9546dcc/numpy-1.26.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:03a8c78d01d9781b28a6989f6fa1bb2c4f2d51201cf99d3dd875df6fbd96b23b", size = 13685868, upload-time = "2024-02-05T23:55:56.28Z" },
+    { url = "https://files.pythonhosted.org/packages/79/f8/97f10e6755e2a7d027ca783f63044d5b1bc1ae7acb12afe6a9b4286eac17/numpy-1.26.4-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9fad7dcb1aac3c7f0584a5a8133e3a43eeb2fe127f47e3632d43d677c66c102b", size = 13925109, upload-time = "2024-02-05T23:56:20.368Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/50/de23fde84e45f5c4fda2488c759b69990fd4512387a8632860f3ac9cd225/numpy-1.26.4-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:675d61ffbfa78604709862923189bad94014bef562cc35cf61d3a07bba02a7ed", size = 17950613, upload-time = "2024-02-05T23:56:56.054Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/0c/9c603826b6465e82591e05ca230dfc13376da512b25ccd0894709b054ed0/numpy-1.26.4-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:ab47dbe5cc8210f55aa58e4805fe224dac469cde56b9f731a4c098b91917159a", size = 13572172, upload-time = "2024-02-05T23:57:21.56Z" },
+    { url = "https://files.pythonhosted.org/packages/76/8c/2ba3902e1a0fc1c74962ea9bb33a534bb05984ad7ff9515bf8d07527cadd/numpy-1.26.4-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:1dda2e7b4ec9dd512f84935c5f126c8bd8b9f2fc001e9f54af255e8c5f16b0e0", size = 17786643, upload-time = "2024-02-05T23:57:56.585Z" },
+    { url = "https://files.pythonhosted.org/packages/28/4a/46d9e65106879492374999e76eb85f87b15328e06bd1550668f79f7b18c6/numpy-1.26.4-cp312-cp312-win32.whl", hash = "sha256:50193e430acfc1346175fcbdaa28ffec49947a06918b7b92130744e81e640110", size = 5677803, upload-time = "2024-02-05T23:58:08.963Z" },
+    { url = "https://files.pythonhosted.org/packages/16/2e/86f24451c2d530c88daf997cb8d6ac622c1d40d19f5a031ed68a4b73a374/numpy-1.26.4-cp312-cp312-win_amd64.whl", hash = "sha256:08beddf13648eb95f8d867350f6a018a4be2e5ad54c8d8caed89ebca558b2818", size = 15517754, upload-time = "2024-02-05T23:58:36.364Z" },
+]
+
+[[package]]
+name = "nvidia-cublas-cu12"
+version = "12.8.4.1"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/dc/61/e24b560ab2e2eaeb3c839129175fb330dfcfc29e5203196e5541a4c44682/nvidia_cublas_cu12-12.8.4.1-py3-none-manylinux_2_27_x86_64.whl", hash = "sha256:8ac4e771d5a348c551b2a426eda6193c19aa630236b418086020df5ba9667142", size = 594346921, upload-time = "2025-03-07T01:44:31.254Z" },
+]
+
+[[package]]
+name = "nvidia-cuda-cupti-cu12"
+version = "12.8.90"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f8/02/2adcaa145158bf1a8295d83591d22e4103dbfd821bcaf6f3f53151ca4ffa/nvidia_cuda_cupti_cu12-12.8.90-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:ea0cb07ebda26bb9b29ba82cda34849e73c166c18162d3913575b0c9db9a6182", size = 10248621, upload-time = "2025-03-07T01:40:21.213Z" },
+]
+
+[[package]]
+name = "nvidia-cuda-nvrtc-cu12"
+version = "12.8.93"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/05/6b/32f747947df2da6994e999492ab306a903659555dddc0fbdeb9d71f75e52/nvidia_cuda_nvrtc_cu12-12.8.93-py3-none-manylinux2010_x86_64.manylinux_2_12_x86_64.whl", hash = "sha256:a7756528852ef889772a84c6cd89d41dfa74667e24cca16bb31f8f061e3e9994", size = 88040029, upload-time = "2025-03-07T01:42:13.562Z" },
+]
+
+[[package]]
+name = "nvidia-cuda-runtime-cu12"
+version = "12.8.90"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0d/9b/a997b638fcd068ad6e4d53b8551a7d30fe8b404d6f1804abf1df69838932/nvidia_cuda_runtime_cu12-12.8.90-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:adade8dcbd0edf427b7204d480d6066d33902cab2a4707dcfc48a2d0fd44ab90", size = 954765, upload-time = "2025-03-07T01:40:01.615Z" },
+]
+
+[[package]]
+name = "nvidia-cudnn-cu12"
+version = "9.10.2.21"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "nvidia-cublas-cu12", marker = "(platform_machine != 'aarch64' and sys_platform == 'linux') or (sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'linux' and sys_platform != 'win32')" },
+]
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ba/51/e123d997aa098c61d029f76663dedbfb9bc8dcf8c60cbd6adbe42f76d049/nvidia_cudnn_cu12-9.10.2.21-py3-none-manylinux_2_27_x86_64.whl", hash = "sha256:949452be657fa16687d0930933f032835951ef0892b37d2d53824d1a84dc97a8", size = 706758467, upload-time = "2025-06-06T21:54:08.597Z" },
+]
+
+[[package]]
+name = "nvidia-cudnn-frontend"
+version = "1.23.0"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e9/88/fbcfeb1826806a3f6e5ca6670700b4a7da758436ec2ce9b56f113cc15263/nvidia_cudnn_frontend-1.23.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:32b2ba9ef8e2c97536dd7fed3985f22e93c2c13d30a3d12543bd3c1ef8b25cdd", size = 2936016, upload-time = "2026-04-29T19:14:13.027Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/78/35832dc0b32995a0418533749f9d01c0fcd0b55b89abdaeb30195ad27712/nvidia_cudnn_frontend-1.23.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:36c9bbaeae94e40157c6119cdd9eb52dbdfdb0cedb195984910ea32827029198", size = 3082860, upload-time = "2026-04-29T19:14:41.481Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/9d/e3f68f9c03b51bb63ca8fd5796b48593e64e5ab24d8df2d85a8e32ec5369/nvidia_cudnn_frontend-1.23.0-cp312-cp312-win_amd64.whl", hash = "sha256:b864b498c1330979b54e6509c1d69a064cc47622661408837dc872cb6bb7ea1c", size = 2494915, upload-time = "2026-04-29T19:14:56.614Z" },
+    { url = "https://files.pythonhosted.org/packages/55/bc/eed9ae32a00a7c501f6ca3b93782fe50b3c9fd9168d500586b761f42f2bd/nvidia_cudnn_frontend-1.23.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:aa35283da087d65cdc1ea12a7872f90ed5a725e8ed0d8009b82d801bf92ad0ae", size = 2935910, upload-time = "2026-04-29T19:15:20.96Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/14/4e0b66650d68f32d4c7b46e8b33cb98e69497f3fc1a9f63a02328a45d694/nvidia_cudnn_frontend-1.23.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a8b817a0deb94f394b082f1ca389829ec0c9c85411a1092f08719c66bbaa1e39", size = 3082233, upload-time = "2026-04-29T19:15:48.864Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/c8/f5fad0e91e43df3a85e7c29b15bd11b587f27a096b7096abd3b3fbc8f761/nvidia_cudnn_frontend-1.23.0-cp313-cp313-win_amd64.whl", hash = "sha256:b78c70b40c389f9e844eae73f5686bb72b15763399aede5c3995d81e78c5547c", size = 2494849, upload-time = "2026-04-29T19:16:11.571Z" },
+    { url = "https://files.pythonhosted.org/packages/72/40/b7604cb8aac79405c03102570800c62689110d6df77c844a22eecefdf46d/nvidia_cudnn_frontend-1.23.0-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0a309e6a3ae3932943a50fa1e25f73f384fa9062c653ef79269741079b24c69f", size = 2937026, upload-time = "2026-04-29T19:16:31.103Z" },
+    { url = "https://files.pythonhosted.org/packages/db/46/89130d26afff6f95330bb271aeb6180c8fd2d1e1ef6ab22d115fa8e68ef3/nvidia_cudnn_frontend-1.23.0-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0aa008cc386089b9d11bed6ddc5e8b294679611da85ed33be3fb4bfe9a66d744", size = 3082954, upload-time = "2026-04-29T19:16:54.608Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/b2/e7519d264a665a5940d5f34438d0000e75083a576915af21997223d78442/nvidia_cudnn_frontend-1.23.0-cp314-cp314-win_amd64.whl", hash = "sha256:873569d2eeaff62fc4279e7722f1ee071448f9c492c7c17f3a856c3cf1f7ae11", size = 2496340, upload-time = "2026-04-29T19:17:17.069Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/45/8666a48f092ff7217a19ae14b6d354e747d3f963ac302e7eecda5438d955/nvidia_cudnn_frontend-1.23.0-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:40c6c13c0af42778779d667fbcc422c81be40a7eb2b97458d5147f2e7549c550", size = 2938384, upload-time = "2026-04-29T19:17:45.503Z" },
+    { url = "https://files.pythonhosted.org/packages/16/6d/b35239ec7ae0d3700bbcb1149cd2e08e1f5b0fb2867a79d6b505dc80d8c6/nvidia_cudnn_frontend-1.23.0-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fbfac68eb48af0b011f2410d22bd70c9a495174b4f6509358a04994a02a1465e", size = 3086506, upload-time = "2026-04-29T19:18:09.159Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/55/6f34b3b453060c251d40f41ee44fe742170c9271305f23b0879d1604e0f8/nvidia_cudnn_frontend-1.23.0-cp314-cp314t-win_amd64.whl", hash = "sha256:c6990ab239367487c4f135f6aa9cea41d8114a7c6ac03927df3c240c7589d000", size = 2520867, upload-time = "2026-04-29T19:18:30.147Z" },
+]
+
+[[package]]
+name = "nvidia-cufft-cu12"
+version = "11.3.3.83"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "nvidia-nvjitlink-cu12", marker = "(platform_machine != 'aarch64' and sys_platform == 'linux') or (sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'linux' and sys_platform != 'win32')" },
+]
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1f/13/ee4e00f30e676b66ae65b4f08cb5bcbb8392c03f54f2d5413ea99a5d1c80/nvidia_cufft_cu12-11.3.3.83-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:4d2dd21ec0b88cf61b62e6b43564355e5222e4a3fb394cac0db101f2dd0d4f74", size = 193118695, upload-time = "2025-03-07T01:45:27.821Z" },
+]
+
+[[package]]
+name = "nvidia-cufile-cu12"
+version = "1.13.1.3"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/bb/fe/1bcba1dfbfb8d01be8d93f07bfc502c93fa23afa6fd5ab3fc7c1df71038a/nvidia_cufile_cu12-1.13.1.3-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:1d069003be650e131b21c932ec3d8969c1715379251f8d23a1860554b1cb24fc", size = 1197834, upload-time = "2025-03-07T01:45:50.723Z" },
+]
+
+[[package]]
+name = "nvidia-curand-cu12"
+version = "10.3.9.90"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/fb/aa/6584b56dc84ebe9cf93226a5cde4d99080c8e90ab40f0c27bda7a0f29aa1/nvidia_curand_cu12-10.3.9.90-py3-none-manylinux_2_27_x86_64.whl", hash = "sha256:b32331d4f4df5d6eefa0554c565b626c7216f87a06a4f56fab27c3b68a830ec9", size = 63619976, upload-time = "2025-03-07T01:46:23.323Z" },
+]
+
+[[package]]
+name = "nvidia-cusolver-cu12"
+version = "11.7.3.90"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "nvidia-cublas-cu12", marker = "(platform_machine != 'aarch64' and sys_platform == 'linux') or (sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'linux' and sys_platform != 'win32')" },
+    { name = "nvidia-cusparse-cu12", marker = "(platform_machine != 'aarch64' and sys_platform == 'linux') or (sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'linux' and sys_platform != 'win32')" },
+    { name = "nvidia-nvjitlink-cu12", marker = "(platform_machine != 'aarch64' and sys_platform == 'linux') or (sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'linux' and sys_platform != 'win32')" },
+]
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/85/48/9a13d2975803e8cf2777d5ed57b87a0b6ca2cc795f9a4f59796a910bfb80/nvidia_cusolver_cu12-11.7.3.90-py3-none-manylinux_2_27_x86_64.whl", hash = "sha256:4376c11ad263152bd50ea295c05370360776f8c3427b30991df774f9fb26c450", size = 267506905, upload-time = "2025-03-07T01:47:16.273Z" },
+]
+
+[[package]]
+name = "nvidia-cusparse-cu12"
+version = "12.5.8.93"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "nvidia-nvjitlink-cu12", marker = "(platform_machine != 'aarch64' and sys_platform == 'linux') or (sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'linux' and sys_platform != 'win32')" },
+]
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c2/f5/e1854cb2f2bcd4280c44736c93550cc300ff4b8c95ebe370d0aa7d2b473d/nvidia_cusparse_cu12-12.5.8.93-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:1ec05d76bbbd8b61b06a80e1eaf8cf4959c3d4ce8e711b65ebd0443bb0ebb13b", size = 288216466, upload-time = "2025-03-07T01:48:13.779Z" },
+]
+
+[[package]]
+name = "nvidia-cusparselt-cu12"
+version = "0.7.1"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/56/79/12978b96bd44274fe38b5dde5cfb660b1d114f70a65ef962bcbbed99b549/nvidia_cusparselt_cu12-0.7.1-py3-none-manylinux2014_x86_64.whl", hash = "sha256:f1bb701d6b930d5a7cea44c19ceb973311500847f81b634d802b7b539dc55623", size = 287193691, upload-time = "2025-02-26T00:15:44.104Z" },
 ]
 
 [[package]]
-name = "nbformat"
-version = "5.10.4"
+name = "nvidia-cutlass-dsl"
+version = "4.5.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "fastjsonschema" },
-    { name = "jsonschema" },
-    { name = "jupyter-core" },
-    { name = "traitlets" },
+    { name = "nvidia-cutlass-dsl-libs-base" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/6d/fd/91545e604bc3dad7dca9ed03284086039b294c6b3d75c0d2fa45f9e9caf3/nbformat-5.10.4.tar.gz", hash = "sha256:322168b14f937a5d11362988ecac2a4952d3d8e3a2cbeb2319584631226d5b3a", size = 142749, upload-time = "2024-04-04T11:20:37.371Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/a9/82/0340caa499416c78e5d8f5f05947ae4bc3cba53c9f038ab6e9ed964e22f1/nbformat-5.10.4-py3-none-any.whl", hash = "sha256:3b48d6c8fbca4b299bf3982ea7db1af21580e4fec269ad087b9e81588891200b", size = 78454, upload-time = "2024-04-04T11:20:34.895Z" },
+    { url = "https://files.pythonhosted.org/packages/71/a3/46fdf77d373b06bc65a0eda6c921c746985fb3e496c90a09be476291ea80/nvidia_cutlass_dsl-4.5.0-py3-none-any.whl", hash = "sha256:3b051fe02ca69422ab840e64d9865667aba288a3984a7ca4ccd038a82aef1344", size = 10178, upload-time = "2026-05-06T01:17:33.592Z" },
 ]
 
 [[package]]
-name = "nbqa"
-version = "1.9.1"
+name = "nvidia-cutlass-dsl-libs-base"
+version = "4.5.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "autopep8" },
-    { name = "ipython" },
-    { name = "tokenize-rt" },
-    { name = "tomli" },
+    { name = "cuda-python" },
+    { name = "numpy" },
+    { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/aa/76/62d2609924cf34445148cd6b5de694cf64c179cc416cac93182579620e57/nbqa-1.9.1.tar.gz", hash = "sha256:a1f4bcf587c597302fed295951001fc4e1be4ce0e77e1ab1b25ac2fbe3db0cdd", size = 38348, upload-time = "2024-11-10T12:21:58.333Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/28/88/4789719fbbe166d12d345b3ac66b96105f10001b16e00a9765ba29261a21/nbqa-1.9.1-py3-none-any.whl", hash = "sha256:95552d2f6c2c038136252a805aa78d85018aef922586270c3a074332737282e5", size = 35259, upload-time = "2024-11-10T12:21:56.731Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/d0/924048cfa43e1cb546735cb332b05a4fb92c63c1a1ac566f06445f9eca58/nvidia_cutlass_dsl_libs_base-4.5.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:3f7c133d31fa82ae7db697fd6943a5f9a2c97c8a40ee1056c67ef29fe00974d8", size = 75630723, upload-time = "2026-05-06T01:24:49.842Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/8b/2c187400d85f7d2acb328f20499b7b05745dca8485cf6ad247d5f2b434cf/nvidia_cutlass_dsl_libs_base-4.5.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:bd18322d9247f8c033a10ed4e519c4985ca6b4fb578ade382e5a264422ebd915", size = 74505487, upload-time = "2026-05-06T01:26:52.755Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/2c/21d5fc62e030a43c0f1a3dab6749fb632026a27d6a60f59975cd29a5d165/nvidia_cutlass_dsl_libs_base-4.5.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:90a4d802a03963fa36eb287fbc9b40a1374590fc7e8cc1b9673dee8872f75713", size = 75632646, upload-time = "2026-05-06T01:24:19.623Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/79/0dca3b465711ffb4c44b4252940cc5f51d2d4905e405707e5c6c2a83d3d6/nvidia_cutlass_dsl_libs_base-4.5.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:8e58b016da5bb09bd1d809d0c025433edb36b279adfbcd107e96361b214bd8bc", size = 74505936, upload-time = "2026-05-06T01:25:52.728Z" },
+    { url = "https://files.pythonhosted.org/packages/59/85/2799e4de2fe7070cc4126ac501443d1cd7796b07ed880118e31956ae266a/nvidia_cutlass_dsl_libs_base-4.5.0-cp314-cp314-manylinux_2_28_aarch64.whl", hash = "sha256:2e121b20f0a48122c9b48227d00a7d681189e1de2fd4d211f9661a4e1658f066", size = 75634241, upload-time = "2026-05-06T01:22:48.964Z" },
+    { url = "https://files.pythonhosted.org/packages/04/c6/5aaa2dff6dfc615a83687df4462a91dad2ac1af85d6a9c91d9a6b9760a02/nvidia_cutlass_dsl_libs_base-4.5.0-cp314-cp314-manylinux_2_28_x86_64.whl", hash = "sha256:0a60dfce3349984315306ef719ed1edf0e225527158f26019a5cf266e06cc45d", size = 74504851, upload-time = "2026-05-06T01:23:48.613Z" },
 ]
 
 [[package]]
-name = "nest-asyncio"
-version = "1.6.0"
+name = "nvidia-ml-py"
+version = "13.595.45"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/83/f8/51569ac65d696c8ecbee95938f89d4abf00f47d58d48f6fbabfe8f0baefe/nest_asyncio-1.6.0.tar.gz", hash = "sha256:6f172d5449aca15afd6c646851f4e31e02c598d553a667e38cafa997cfec55fe", size = 7418, upload-time = "2024-01-21T14:25:19.227Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/ce/49/c29f6e30d8662d2e94fef17739ea7309cc76aba269922ae999e4cc07f268/nvidia_ml_py-13.595.45.tar.gz", hash = "sha256:c9f34897fe0441ff35bc8f35baf80f830a20b0f4e6ce71e0a325bc0e66acf079", size = 50780, upload-time = "2026-03-19T16:59:44.956Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/a0/c4/c2971a3ba4c6103a3d10c4b0f24f461ddc027f0f09763220cf35ca1401b3/nest_asyncio-1.6.0-py3-none-any.whl", hash = "sha256:87af6efd6b5e897c81050477ef65c62e2b2f35d51703cae01aff2905b1852e1c", size = 5195, upload-time = "2024-01-21T14:25:17.223Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/24/fc256107d23597fa33d319505ce77160fa1a2349c096d01901ffc7cb7fc4/nvidia_ml_py-13.595.45-py3-none-any.whl", hash = "sha256:b65a7977f503d56154b14d683710125ef93594adb63fbf7e559336e3318f1376", size = 51776, upload-time = "2026-03-19T16:59:43.603Z" },
 ]
 
 [[package]]
-name = "nodeenv"
-version = "1.9.1"
+name = "nvidia-nccl-cu12"
+version = "2.27.5"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/43/16/fc88b08840de0e0a72a2f9d8c6bae36be573e475a6326ae854bcc549fc45/nodeenv-1.9.1.tar.gz", hash = "sha256:6ec12890a2dab7946721edbfbcd91f3319c6ccc9aec47be7c7e6b7011ee6645f", size = 47437, upload-time = "2024-06-04T18:44:11.171Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/d2/1d/1b658dbd2b9fa9c4c9f32accbfc0205d532c8c6194dc0f2a4c0428e7128a/nodeenv-1.9.1-py2.py3-none-any.whl", hash = "sha256:ba11c9782d29c27c70ffbdda2d7415098754709be8a7056d79a737cd901155c9", size = 22314, upload-time = "2024-06-04T18:44:08.352Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/89/f7a07dc961b60645dbbf42e80f2bc85ade7feb9a491b11a1e973aa00071f/nvidia_nccl_cu12-2.27.5-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:ad730cf15cb5d25fe849c6e6ca9eb5b76db16a80f13f425ac68d8e2e55624457", size = 322348229, upload-time = "2025-06-26T04:11:28.385Z" },
 ]
 
 [[package]]
-name = "notebook"
-version = "7.5.5"
+name = "nvidia-nvjitlink-cu12"
+version = "12.8.93"
 source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "jupyter-server" },
-    { name = "jupyterlab" },
-    { name = "jupyterlab-server" },
-    { name = "notebook-shim" },
-    { name = "tornado" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/1f/6d/41052c48d6f6349ca0a7c4d1f6a78464de135e6d18f5829ba2510e62184c/notebook-7.5.5.tar.gz", hash = "sha256:dc0bfab0f2372c8278c457423d3256c34154ac2cc76bf20e9925260c461013c3", size = 14169167, upload-time = "2026-03-11T16:32:51.922Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/f8/aa/cbd1deb9f07446241e88f8d5fecccd95b249bca0b4e5482214a4d1714c49/notebook-7.5.5-py3-none-any.whl", hash = "sha256:a7c14dbeefa6592e87f72290ca982e0c10f5bbf3786be2a600fda9da2764a2b8", size = 14578929, upload-time = "2026-03-11T16:32:48.021Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/74/86a07f1d0f42998ca31312f998bd3b9a7eff7f52378f4f270c8679c77fb9/nvidia_nvjitlink_cu12-12.8.93-py3-none-manylinux2010_x86_64.manylinux_2_12_x86_64.whl", hash = "sha256:81ff63371a7ebd6e6451970684f916be2eab07321b73c9d244dc2b4da7f73b88", size = 39254836, upload-time = "2025-03-07T01:49:55.661Z" },
 ]
 
 [[package]]
-name = "notebook-shim"
-version = "0.2.4"
+name = "nvidia-nvshmem-cu12"
+version = "3.3.20"
 source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "jupyter-server" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/54/d2/92fa3243712b9a3e8bafaf60aac366da1cada3639ca767ff4b5b3654ec28/notebook_shim-0.2.4.tar.gz", hash = "sha256:b4b2cfa1b65d98307ca24361f5b30fe785b53c3fd07b7a47e89acb5e6ac638cb", size = 13167, upload-time = "2024-02-14T23:35:18.353Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/f9/33/bd5b9137445ea4b680023eb0469b2bb969d61303dedb2aac6560ff3d14a1/notebook_shim-0.2.4-py3-none-any.whl", hash = "sha256:411a5be4e9dc882a074ccbcae671eda64cceb068767e9a3419096986560e1cef", size = 13307, upload-time = "2024-02-14T23:35:16.286Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/6c/99acb2f9eb85c29fc6f3a7ac4dccfd992e22666dd08a642b303311326a97/nvidia_nvshmem_cu12-3.3.20-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d00f26d3f9b2e3c3065be895e3059d6479ea5c638a3f38c9fec49b1b9dd7c1e5", size = 124657145, upload-time = "2025-08-04T20:25:19.995Z" },
 ]
 
 [[package]]
-name = "numpy"
-version = "1.26.4"
+name = "nvidia-nvtx-cu12"
+version = "12.8.90"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/65/6e/09db70a523a96d25e115e71cc56a6f9031e7b8cd166c1ac8438307c14058/numpy-1.26.4.tar.gz", hash = "sha256:2a02aba9ed12e4ac4eb3ea9421c420301a0c6460d9830d74a9df87efa4912010", size = 15786129, upload-time = "2024-02-06T00:26:44.495Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/95/12/8f2020a8e8b8383ac0177dc9570aad031a3beb12e38847f7129bacd96228/numpy-1.26.4-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:b3ce300f3644fb06443ee2222c2201dd3a89ea6040541412b8fa189341847218", size = 20335901, upload-time = "2024-02-05T23:55:32.801Z" },
-    { url = "https://files.pythonhosted.org/packages/75/5b/ca6c8bd14007e5ca171c7c03102d17b4f4e0ceb53957e8c44343a9546dcc/numpy-1.26.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:03a8c78d01d9781b28a6989f6fa1bb2c4f2d51201cf99d3dd875df6fbd96b23b", size = 13685868, upload-time = "2024-02-05T23:55:56.28Z" },
-    { url = "https://files.pythonhosted.org/packages/79/f8/97f10e6755e2a7d027ca783f63044d5b1bc1ae7acb12afe6a9b4286eac17/numpy-1.26.4-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9fad7dcb1aac3c7f0584a5a8133e3a43eeb2fe127f47e3632d43d677c66c102b", size = 13925109, upload-time = "2024-02-05T23:56:20.368Z" },
-    { url = "https://files.pythonhosted.org/packages/0f/50/de23fde84e45f5c4fda2488c759b69990fd4512387a8632860f3ac9cd225/numpy-1.26.4-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:675d61ffbfa78604709862923189bad94014bef562cc35cf61d3a07bba02a7ed", size = 17950613, upload-time = "2024-02-05T23:56:56.054Z" },
-    { url = "https://files.pythonhosted.org/packages/4c/0c/9c603826b6465e82591e05ca230dfc13376da512b25ccd0894709b054ed0/numpy-1.26.4-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:ab47dbe5cc8210f55aa58e4805fe224dac469cde56b9f731a4c098b91917159a", size = 13572172, upload-time = "2024-02-05T23:57:21.56Z" },
-    { url = "https://files.pythonhosted.org/packages/76/8c/2ba3902e1a0fc1c74962ea9bb33a534bb05984ad7ff9515bf8d07527cadd/numpy-1.26.4-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:1dda2e7b4ec9dd512f84935c5f126c8bd8b9f2fc001e9f54af255e8c5f16b0e0", size = 17786643, upload-time = "2024-02-05T23:57:56.585Z" },
-    { url = "https://files.pythonhosted.org/packages/28/4a/46d9e65106879492374999e76eb85f87b15328e06bd1550668f79f7b18c6/numpy-1.26.4-cp312-cp312-win32.whl", hash = "sha256:50193e430acfc1346175fcbdaa28ffec49947a06918b7b92130744e81e640110", size = 5677803, upload-time = "2024-02-05T23:58:08.963Z" },
-    { url = "https://files.pythonhosted.org/packages/16/2e/86f24451c2d530c88daf997cb8d6ac622c1d40d19f5a031ed68a4b73a374/numpy-1.26.4-cp312-cp312-win_amd64.whl", hash = "sha256:08beddf13648eb95f8d867350f6a018a4be2e5ad54c8d8caed89ebca558b2818", size = 15517754, upload-time = "2024-02-05T23:58:36.364Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/eb/86626c1bbc2edb86323022371c39aa48df6fd8b0a1647bc274577f72e90b/nvidia_nvtx_cu12-12.8.90-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:5b17e2001cc0d751a5bc2c6ec6d26ad95913324a4adb86788c944f8ce9ba441f", size = 89954, upload-time = "2025-03-07T01:42:44.131Z" },
 ]
 
 [[package]]
@@ -3174,6 +4280,29 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/d0/b1/35b6f9c8cf9318e3dbb7146cc82dab4cf61182a8d5406fc9b50864362895/openai-2.29.0-py3-none-any.whl", hash = "sha256:b7c5de513c3286d17c5e29b92c4c98ceaf0d775244ac8159aeb1bddf840eb42a", size = 1141533, upload-time = "2026-03-17T17:53:47.348Z" },
 ]
 
+[[package]]
+name = "openai-harmony"
+version = "0.0.8"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pydantic" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/3e/92/2d038d096f29179c7c9571b431f9e739f87a487121901725e23fe338dd9d/openai_harmony-0.0.8.tar.gz", hash = "sha256:6e43f98e6c242fa2de6f8ea12eab24af63fa2ed3e89c06341fb9d92632c5cbdf", size = 284777, upload-time = "2025-11-05T19:07:06.727Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/45/c6/2502f416d46be3ec08bb66d696cccffb57781a499e3ff2e4d7c174af4e8f/openai_harmony-0.0.8-cp38-abi3-macosx_11_0_arm64.whl", hash = "sha256:029ec25ca74abe48fdb58eb9fdd2a8c1618581fc33ce8e5653f8a1ffbfbd9326", size = 2627806, upload-time = "2025-11-05T19:06:57.063Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/d2/ce6953ca87db9cae3e775024184da7d1c5cb88cead19a2d75b42f00a959c/openai_harmony-0.0.8-cp38-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e4f709815924ec325b9a890e6ab2bbb0ceec8e319a4e257328eb752cf36b2efc", size = 2948463, upload-time = "2025-11-05T19:06:48.17Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/4c/b553c9651662d6ce102ca7f3629d268b23df1abe5841e24bed81e8a8e949/openai_harmony-0.0.8-cp38-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:5cfcfd963b50a41fc656c84d3440ca6eecdccd6c552158ce790b8f2e33dfb5a9", size = 2704083, upload-time = "2025-11-05T19:06:50.205Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/af/4eec8f9ab9c27bcdb444460c72cf43011d176fc44c79d6e113094ca1e152/openai_harmony-0.0.8-cp38-abi3-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0a3a16972aa1cee38ea958470cd04ac9a2d5ac38fdcf77ab686611246220c158", size = 2959765, upload-time = "2025-11-05T19:06:53.62Z" },
+    { url = "https://files.pythonhosted.org/packages/11/3c/33f3374e4624e0e776f6b13b73c45a7ead7f9c4529f8369ed5bfcaa30cac/openai_harmony-0.0.8-cp38-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b4d5cfa168e74d08f8ba6d58a7e49bc7daef4d58951ec69b66b0d56f4927a68d", size = 3427031, upload-time = "2025-11-05T19:06:51.829Z" },
+    { url = "https://files.pythonhosted.org/packages/25/3f/1a192b93bb47c6b44cd98ba8cc1d3d2a9308f1bb700c3017e6352da11bda/openai_harmony-0.0.8-cp38-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c007d277218a50db8839e599ed78e0fffe5130f614c3f6d93ae257f282071a29", size = 2953260, upload-time = "2025-11-05T19:06:55.406Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/f8/93b582cad3531797c3db7c2db5400fd841538ccddfd9f5e3df61be99a630/openai_harmony-0.0.8-cp38-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:8565d4f5a0638da1bffde29832ed63c9e695c558611053add3b2dc0b56c92dbc", size = 3127044, upload-time = "2025-11-05T19:06:59.553Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/10/4327dbf87f75ae813405fd9a9b4a5cde63d506ffed0a096a440a4cabd89c/openai_harmony-0.0.8-cp38-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:cbaa3bda75ef0d8836e1f8cc84af62f971b1d756d740efc95c38c3e04c0bfde2", size = 2932931, upload-time = "2025-11-05T19:07:01.437Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/c8/1774eec4f6f360ef57618fb8f52e3d3af245b2491bd0297513aa09eec04b/openai_harmony-0.0.8-cp38-abi3-musllinux_1_2_i686.whl", hash = "sha256:772922a9bd24e133950fad71eb1550836f415a88e8c77870e12d0c3bd688ddc2", size = 2996140, upload-time = "2025-11-05T19:07:03.438Z" },
+    { url = "https://files.pythonhosted.org/packages/60/c3/3d1e01e2dba517a91760e4a03e4f20ffc75039a6fe584d0e6f9b5c78fd15/openai_harmony-0.0.8-cp38-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:007b0476a1f331f8130783f901f1da6f5a7057af1a4891f1b6a31dec364189b5", size = 3205080, upload-time = "2025-11-05T19:07:05.078Z" },
+    { url = "https://files.pythonhosted.org/packages/14/63/119de431572d7c70a7bf1037034a9be6ed0a7502a7498ba7302bca5b3242/openai_harmony-0.0.8-cp38-abi3-win32.whl", hash = "sha256:a9b5f893326b28d9e935ade14b4f655f5a840942473bc89b201c25f7a15af9cf", size = 2082457, upload-time = "2025-11-05T19:07:09.631Z" },
+    { url = "https://files.pythonhosted.org/packages/40/1f/c83cf5a206c263ee70448a5ae4264682555f4d0b5bed0d2cc6ca1108103d/openai_harmony-0.0.8-cp38-abi3-win_amd64.whl", hash = "sha256:39d44f0d8f466bd56698e7ead708bead3141e27b9b87e3ab7d5a6d0e4a869ee5", size = 2438369, upload-time = "2025-11-05T19:07:08.1Z" },
+]
+
 [[package]]
 name = "opencv-python-headless"
 version = "4.11.0.86"
@@ -3430,6 +4559,30 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/6f/1c/f2a8d8a1b17514660a614ce5f7aac74b934e69f5abc2700cc7ced882a009/orjson-3.11.7-cp314-cp314-win_arm64.whl", hash = "sha256:4a2e9c5be347b937a2e0203866f12bba36082e89b402ddb9e927d5822e43088d", size = 126038, upload-time = "2026-02-02T15:38:47.703Z" },
 ]
 
+[[package]]
+name = "outlines-core"
+version = "0.2.11"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/1a/d3/e04e9145f8f806723dec9b9e5227ad695a3efcd3ced7794cf7c22b15df5e/outlines_core-0.2.11.tar.gz", hash = "sha256:dfce56f717ff5083e54cbcfdb66cad243365437fccbb5509adaa7e31e030f1d8", size = 197263, upload-time = "2025-05-19T10:12:51.719Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5f/2c/c7636823244c70e2960060bf9bd978248dffb55c5e7c91c46d18354b2a24/outlines_core-0.2.11-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:4a9db4872bae083631d720994f4cee603bce0536b33d5a988814576863b657cf", size = 1957668, upload-time = "2025-05-19T10:12:18.29Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/09/5c62047da139d722317a444a4d01cd5f11943a8c2eaecce784341dd0844a/outlines_core-0.2.11-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:8359a45c59f6a8f2eb717245806501a59044c75f6ea8bd08faaa131cc8cdec45", size = 2130493, upload-time = "2025-05-19T10:12:19.537Z" },
+    { url = "https://files.pythonhosted.org/packages/89/7a/d6a2810f90e37d550168e0c0a9a915086ea721444727e3ca2c630898d1ef/outlines_core-0.2.11-cp312-cp312-macosx_15_0_arm64.whl", hash = "sha256:5d26a46591377340e0b870b8a96ea8341058341a62ee0bded9098e0c88dd24f4", size = 1956804, upload-time = "2025-05-19T10:12:20.755Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/ea/339e6c273b5581128c3b7ca27d428d8993c3085912af1a467aa32ef0e9d1/outlines_core-0.2.11-cp312-cp312-macosx_15_0_x86_64.whl", hash = "sha256:ae460a34675fb11d92a5c605a480fbae4cd6c1b2d11b3698da64a7fcaba64dcf", size = 2127085, upload-time = "2025-05-19T10:12:22.02Z" },
+    { url = "https://files.pythonhosted.org/packages/92/c7/a65d1fddf49830ebc41422294eacde35286d9f68994a8aa905cb14f5aade/outlines_core-0.2.11-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:86df9740368866295077346440d911df4972da2b3f1f54b8125e6f329e8a8891", size = 2287677, upload-time = "2025-05-19T10:12:24.24Z" },
+    { url = "https://files.pythonhosted.org/packages/23/79/8795aed8be9b77dd69d78e7cfbfcf28c179e6b08da6e56bbbf48a09fe55f/outlines_core-0.2.11-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:96ce4dd78f106799be4a0a5795cefd1352806162973756a4b6fce4bb6eddd7e4", size = 2113000, upload-time = "2025-05-19T10:12:25.446Z" },
+    { url = "https://files.pythonhosted.org/packages/59/e3/cbe9294b06d92ee1892dbb6f2125d833d68e8629d45d080d6daba54eec2d/outlines_core-0.2.11-cp312-cp312-win32.whl", hash = "sha256:358db161cce3650ba822e118dcf0a1efa571c7deb4864ab9d64ca2c9cca7425d", size = 1765703, upload-time = "2025-05-19T10:12:26.693Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/c9/ed3cf362515fac16e313368b9b2f2497051f4ded88679205830b6f889f54/outlines_core-0.2.11-cp312-cp312-win_amd64.whl", hash = "sha256:231f9d20d2630c70665345821780d7808b29539620a75c99f65113b518c51032", size = 2060945, upload-time = "2025-05-19T10:12:28.294Z" },
+    { url = "https://files.pythonhosted.org/packages/11/58/df6f57546f7792c990a4380ceaf99243a0b26b24c199e34e0a9277c89976/outlines_core-0.2.11-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:0907ff25d79edbf8650268028de85a1b41b38696f147059e007da4626a1031f1", size = 1957172, upload-time = "2025-05-19T10:12:29.737Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/cf/b07e33c44544e7865ec481554788807dfa6ad10fd86191ad21f2200f145e/outlines_core-0.2.11-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:f4146da5957f97550eebd19e80635e48035886fd10f03e9735cc111caaf74e93", size = 2130284, upload-time = "2025-05-19T10:12:31.408Z" },
+    { url = "https://files.pythonhosted.org/packages/83/70/8f981706e2620914c48fd1edb42f9409d76b84c72149d48e89d14820fab6/outlines_core-0.2.11-cp313-cp313-macosx_15_0_arm64.whl", hash = "sha256:8776a6db8843187c90e4c54bf94510cda68ca7a11c9b48d90587179fd3224bc2", size = 1956727, upload-time = "2025-05-19T10:12:32.996Z" },
+    { url = "https://files.pythonhosted.org/packages/89/de/fba234a9c3984408f017ee0b1ca2e9d6191f8086afa649d3e4b04ed055e2/outlines_core-0.2.11-cp313-cp313-macosx_15_0_x86_64.whl", hash = "sha256:d44f38a89028bed50494420b47d08ebefa78f34b129e2ea6383c801e5ba62c26", size = 2126905, upload-time = "2025-05-19T10:12:34.261Z" },
+    { url = "https://files.pythonhosted.org/packages/87/96/7dcdc5198844145ab35528f9f93a58c3d47b87e54d0f79357c631d7b7a9a/outlines_core-0.2.11-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:daef6eaaf8c3403455ab5cbf265cb5c6838df571eb7c4b23cddac19cfc701726", size = 2287320, upload-time = "2025-05-19T10:12:35.515Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/68/b420b6a3beaadbf8e9f2a82132120027efd6424634013fbeca8c2fed7467/outlines_core-0.2.11-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:76b2512417c68863f8f227a080e87f755682dfd895e23b021121318be11da579", size = 2112861, upload-time = "2025-05-19T10:12:36.742Z" },
+    { url = "https://files.pythonhosted.org/packages/78/d6/7c2a016f7a5eab2f3df2b3a258f270872c78fe0dd7d9fbee87429f1b6b1f/outlines_core-0.2.11-cp313-cp313-win32.whl", hash = "sha256:707eeb3d190485f55a27ad9a6ad70df86688fa2bf405894a118283be7f59bd55", size = 1765574, upload-time = "2025-05-19T10:12:37.98Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/39/4c07f1d1f8e6ed85db9fe73a021113795a05aae8a84f36f0bdebb08bfde8/outlines_core-0.2.11-cp313-cp313-win_amd64.whl", hash = "sha256:ad46698564c9b13cbfbc744067de12be73bd740d7b2de20ec6b979ad7511f7c9", size = 2060567, upload-time = "2025-05-19T10:12:39.228Z" },
+]
+
 [[package]]
 name = "overrides"
 version = "7.7.0"
@@ -3531,6 +4684,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/16/32/f8e3c85d1d5250232a5d3477a2a28cc291968ff175caeadaf3cc19ce0e4a/parso-0.8.5-py2.py3-none-any.whl", hash = "sha256:646204b5ee239c396d040b90f9e272e9a8017c630092bf59980beb62fd033887", size = 106668, upload-time = "2025-08-23T15:15:25.663Z" },
 ]
 
+[[package]]
+name = "partial-json-parser"
+version = "0.2.1.1.post7"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/6a/6d/eed37d7ebc1e0bcd27b831c0cf1fe94881934316187c4b30d23f29ea0bd4/partial_json_parser-0.2.1.1.post7.tar.gz", hash = "sha256:86590e1ba6bcb6739a2dfc17d2323f028cb5884f4c6ce23db376999132c9a922", size = 10296, upload-time = "2025-11-17T07:27:41.202Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/42/32/658973117bf0fd82a24abbfb94fe73a5e86216e49342985e10acce54775a/partial_json_parser-0.2.1.1.post7-py3-none-any.whl", hash = "sha256:145119e5eabcf80cbb13844a6b50a85c68bf99d376f8ed771e2a3c3b03e653ae", size = 10877, upload-time = "2025-11-17T07:27:40.457Z" },
+]
+
 [[package]]
 name = "pathspec"
 version = "0.12.1"
@@ -3774,6 +4936,19 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/74/c3/24a2f845e3917201628ecaba4f18bab4d18a337834c1df2a159ee9d22a42/prometheus_client-0.24.1-py3-none-any.whl", hash = "sha256:150db128af71a5c2482b36e588fc8a6b95e498750da4b17065947c16070f4055", size = 64057, upload-time = "2026-01-14T15:26:24.42Z" },
 ]
 
+[[package]]
+name = "prometheus-fastapi-instrumentator"
+version = "7.1.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "prometheus-client" },
+    { name = "starlette" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/69/6d/24d53033cf93826aa7857699a4450c1c67e5b9c710e925b1ed2b320c04df/prometheus_fastapi_instrumentator-7.1.0.tar.gz", hash = "sha256:be7cd61eeea4e5912aeccb4261c6631b3f227d8924542d79eaf5af3f439cbe5e", size = 20220, upload-time = "2025-03-19T19:35:05.351Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/27/72/0824c18f3bc75810f55dacc2dd933f6ec829771180245ae3cc976195dec0/prometheus_fastapi_instrumentator-7.1.0-py3-none-any.whl", hash = "sha256:978130f3c0bb7b8ebcc90d35516a6fe13e02d2eb358c8f83887cdef7020c31e9", size = 19296, upload-time = "2025-03-19T19:35:04.323Z" },
+]
+
 [[package]]
 name = "prompt-toolkit"
 version = "3.0.52"
@@ -3929,6 +5104,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/8e/37/efad0257dc6e593a18957422533ff0f87ede7c9c6ea010a2177d738fb82f/pure_eval-0.2.3-py3-none-any.whl", hash = "sha256:1db8e35b67b3d218d818ae653e27f06c3aa420901fa7b081ca98cbedc874e0d0", size = 11842, upload-time = "2024-07-21T12:58:20.04Z" },
 ]
 
+[[package]]
+name = "py-cpuinfo"
+version = "9.0.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/37/a8/d832f7293ebb21690860d2e01d8115e5ff6f2ae8bbdc953f0eb0fa4bd2c7/py-cpuinfo-9.0.0.tar.gz", hash = "sha256:3cdbbf3fac90dc6f118bfd64384f309edeadd902d7c8fb17f02ffa1fc3f49690", size = 104716, upload-time = "2022-10-25T20:38:06.303Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e0/a9/023730ba63db1e494a271cb018dcd361bd2c917ba7004c3e49d5daf795a2/py_cpuinfo-9.0.0-py3-none-any.whl", hash = "sha256:859625bc251f64e21f077d099d4162689c762b5d6a4c3c97553d56241c9674d5", size = 22335, upload-time = "2022-10-25T20:38:27.636Z" },
+]
+
 [[package]]
 name = "py-serializable"
 version = "2.1.0"
@@ -4132,6 +5316,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/d7/27/a58ddaf8c588a3ef080db9d0b7e0b97215cee3a45df74f3a94dbbf5c893a/pycodestyle-2.14.0-py2.py3-none-any.whl", hash = "sha256:dd6bf7cb4ee77f8e016f9c8e74a35ddd9f67e1d5fd4184d86c3b98e07099f42d", size = 31594, upload-time = "2025-06-20T18:49:47.491Z" },
 ]
 
+[[package]]
+name = "pycountry"
+version = "26.2.16"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/de/1d/061b9e7a48b85cfd69f33c33d2ef784a531c359399ad764243399673c8f5/pycountry-26.2.16.tar.gz", hash = "sha256:5b6027d453fcd6060112b951dd010f01f168b51b4bf8a1f1fc8c95c8d94a0801", size = 7711342, upload-time = "2026-02-17T03:42:52.367Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9c/42/7703bd45b62fecd44cd7d3495423097e2f7d28bc2e99e7c1af68892ab157/pycountry-26.2.16-py3-none-any.whl", hash = "sha256:115c4baf7cceaa30f59a4694d79483c9167dbce7a9de4d3d571c5f3ea77c305a", size = 8044600, upload-time = "2026-02-17T03:42:49.777Z" },
+]
+
 [[package]]
 name = "pycparser"
 version = "2.23"
@@ -4156,6 +5349,11 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/5a/87/b70ad306ebb6f9b585f114d0ac2137d792b48be34d732d60e597c2f8465a/pydantic-2.12.5-py3-none-any.whl", hash = "sha256:e561593fccf61e8a20fc46dfc2dfe075b8be7d0188df33f221ad1f0139180f9d", size = 463580, upload-time = "2025-11-26T15:11:44.605Z" },
 ]
 
+[package.optional-dependencies]
+email = [
+    { name = "email-validator" },
+]
+
 [[package]]
 name = "pydantic-core"
 version = "2.41.5"
@@ -4227,6 +5425,24 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/f7/07/34573da085946b6a313d7c42f82f16e8920bfd730665de2d11c0c37a74b5/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:76d0819de158cd855d1cbb8fcafdf6f5cf1eb8e470abe056d5d161106e38062b", size = 2139017, upload-time = "2025-11-04T13:42:59.471Z" },
 ]
 
+[[package]]
+name = "pydantic-extra-types"
+version = "2.11.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pydantic" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/66/71/dba38ee2651f84f7842206adbd2233d8bbdb59fb85e9fa14232486a8c471/pydantic_extra_types-2.11.1.tar.gz", hash = "sha256:46792d2307383859e923d8fcefa82108b1a141f8a9c0198982b3832ab5ef1049", size = 172002, upload-time = "2026-03-16T08:08:03.92Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/17/c1/3226e6d7f5a4f736f38ac11a6fbb262d701889802595cdb0f53a885ac2e0/pydantic_extra_types-2.11.1-py3-none-any.whl", hash = "sha256:1722ea2bddae5628ace25f2aa685b69978ef533123e5638cfbddb999e0100ec1", size = 79526, upload-time = "2026-03-16T08:08:02.533Z" },
+]
+
+[package.optional-dependencies]
+pycountry = [
+    { name = "pycountry" },
+]
+
 [[package]]
 name = "pydantic-settings"
 version = "2.13.1"
@@ -4584,6 +5800,53 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/81/d6/4bfbb40c9a0b42fc53c7cf442f6385db70b40f74a783130c5d0a5aa62228/pyzmq-27.1.0-cp314-cp314t-win_arm64.whl", hash = "sha256:dc5dbf68a7857b59473f7df42650c621d7e8923fb03fa74a526890f4d33cc4d7", size = 575170, upload-time = "2025-09-08T23:09:01.418Z" },
 ]
 
+[[package]]
+name = "qwen-vl-utils"
+version = "0.0.14"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "av" },
+    { name = "packaging" },
+    { name = "pillow" },
+    { name = "requests" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b6/b1/ad4fc2260a3badd278b38d642f3b987412f1f6682f0ef2b31b0572d5caa8/qwen_vl_utils-0.0.14.tar.gz", hash = "sha256:9c7cad5ae803b3a10f8bb7194deb12aeacdd032f92f4224e880c73587a7346ad", size = 8453, upload-time = "2025-09-23T09:38:57.532Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c4/43/80f67e0336cb2fc725f8e06f7fe35c1d0fe946f4d2b8b2175e797e07349e/qwen_vl_utils-0.0.14-py3-none-any.whl", hash = "sha256:5e28657bfd031e56bd447c5901b58ddfc3835285ed100f4c56580e0ade054e96", size = 8120, upload-time = "2025-09-23T09:38:56.297Z" },
+]
+
+[[package]]
+name = "ray"
+version = "2.55.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "click" },
+    { name = "filelock" },
+    { name = "jsonschema" },
+    { name = "msgpack" },
+    { name = "packaging" },
+    { name = "protobuf" },
+    { name = "pyyaml" },
+    { name = "requests" },
+]
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ac/3a/4d34f471a68b958b7f94c974c19ad6836a61a2dc16393df4294169a2e4b0/ray-2.55.1-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:137f9006eee28caab8260803cca314f37bbda3fc94fdfa31c770b5d019626ad8", size = 65822379, upload-time = "2026-04-22T20:09:58.064Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/13/0db535102d0256b350ca116d8987588aca1a1f9ebb4638e1e1ff88bbcef8/ray-2.55.1-cp312-cp312-manylinux2014_aarch64.whl", hash = "sha256:26541f69bb55607ef8335baac75b2ed12ff2ce02d56313219b29eda003039221", size = 72910802, upload-time = "2026-04-22T20:10:04.382Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/f8/fffadf3f4285eebd460e4d7f2ed1c0cd641ed89613c3f49eb881ee9fa7e2/ray-2.55.1-cp312-cp312-manylinux2014_x86_64.whl", hash = "sha256:263705f6bab29e7622a94f82da25fd7f9cead76cdf89a07aab28f79cdf8f9d95", size = 73765203, upload-time = "2026-04-22T20:10:10.495Z" },
+    { url = "https://files.pythonhosted.org/packages/10/f7/5acb86fc9625a0e6bbc40e1c7d42c60770e78585439a921c32738b6d675a/ray-2.55.1-cp312-cp312-win_amd64.whl", hash = "sha256:9ad56704c8bd7e92130162f9c58e4ef473609515637673d5a36e761f95335206", size = 27865547, upload-time = "2026-04-22T20:10:15.364Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/95/898699cc1a6a5f304ea95376d079843b5c05f4c8c1ec7e55a5cc7ffcea50/ray-2.55.1-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:f9844a9272ef2e6eb5771025866072cf4234cf4c7cc1a31e235b7de7111864be", size = 65766823, upload-time = "2026-04-22T20:10:20.786Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/13/87deecc090c672e45a0cf6f5eef511de448b93f37ef18fd10eb8e8557a0d/ray-2.55.1-cp313-cp313-manylinux2014_aarch64.whl", hash = "sha256:b415d590e062f248907e0fe42994943f11726b7178fcf4b1cf5546721fb1a5f8", size = 72818676, upload-time = "2026-04-22T20:10:26.705Z" },
+    { url = "https://files.pythonhosted.org/packages/71/d7/fc95d3b8824c62105c64aa1b59c59600b581f608d78a2af753e010936dc9/ray-2.55.1-cp313-cp313-manylinux2014_x86_64.whl", hash = "sha256:1380e043eb57cde69b7e9199c6f2558ceeb8f0fc41c97d1d5e50ea042115f302", size = 73678908, upload-time = "2026-04-22T20:10:32.795Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/03/7e552325572e067b23a4584bda8dc6a67af8bd7e03c424d2610bfa93112d/ray-2.55.1-cp314-cp314-macosx_12_0_arm64.whl", hash = "sha256:b062045c64c2bce39a51661624f7292c7bbf30f2a9d878627aae31d46da5712d", size = 65774106, upload-time = "2026-04-22T20:10:39.885Z" },
+    { url = "https://files.pythonhosted.org/packages/94/62/607a8859520ce350861425f11f8e15d66c15ee33e6aac812f9e2889b5df4/ray-2.55.1-cp314-cp314-manylinux2014_aarch64.whl", hash = "sha256:4e618d61e1b14b6fde9a586151f3fd9d435b0b85048b997bcaa7f4a533747b2b", size = 72814044, upload-time = "2026-04-22T20:10:46.985Z" },
+    { url = "https://files.pythonhosted.org/packages/04/5a/0699bef04a72d7dc54462960d07ef7a19cd8b1e09979880aba2b6d13cca2/ray-2.55.1-cp314-cp314-manylinux2014_x86_64.whl", hash = "sha256:156ed3e72ad95b645d2006cd71a8dddbcc89b56bfc00027f6225adf78bd9cb74", size = 73644244, upload-time = "2026-04-22T20:10:52.973Z" },
+]
+
+[package.optional-dependencies]
+cgraph = [
+    { name = "cupy-cuda12x", marker = "sys_platform != 'darwin'" },
+]
+
 [[package]]
 name = "referencing"
 version = "0.37.0"
@@ -4760,6 +6023,88 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/25/7a/b0178788f8dc6cafce37a212c99565fa1fe7872c70c6c9c1e1a372d9d88f/rich-14.2.0-py3-none-any.whl", hash = "sha256:76bc51fe2e57d2b1be1f96c524b890b816e334ab4c1e45888799bfaab0021edd", size = 243393, upload-time = "2025-10-09T14:16:51.245Z" },
 ]
 
+[[package]]
+name = "rich-toolkit"
+version = "0.19.9"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "click" },
+    { name = "rich" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/8f/10/dc6e64e85244971671981dc26b09353a1564f5e61b977c80180dc42ad90b/rich_toolkit-0.19.9.tar.gz", hash = "sha256:fce5c6f41f79382ecf60a79851b2543f627568e3e07c78ab4b8542e1ca247d1c", size = 197653, upload-time = "2026-05-13T09:55:04.286Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/8f/60/5a7de329d0b5b619757c169bbf8a5146c20fe49bd4d74045937fcd45a7d0/rich_toolkit-0.19.9-py3-none-any.whl", hash = "sha256:a1341f88feed5f295f001bb1c6b6cf1e208674187dd900416a30fd9d6f74fcce", size = 33711, upload-time = "2026-05-13T09:55:05.345Z" },
+]
+
+[[package]]
+name = "rignore"
+version = "0.7.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e5/f5/8bed2310abe4ae04b67a38374a4d311dd85220f5d8da56f47ae9361be0b0/rignore-0.7.6.tar.gz", hash = "sha256:00d3546cd793c30cb17921ce674d2c8f3a4b00501cb0e3dd0e82217dbeba2671", size = 57140, upload-time = "2025-11-05T21:41:21.968Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0b/0e/012556ef3047a2628842b44e753bb15f4dc46806780ff090f1e8fe4bf1eb/rignore-0.7.6-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:03e82348cb7234f8d9b2834f854400ddbbd04c0f8f35495119e66adbd37827a8", size = 883488, upload-time = "2025-11-05T20:42:41.359Z" },
+    { url = "https://files.pythonhosted.org/packages/93/b0/d4f1f3fe9eb3f8e382d45ce5b0547ea01c4b7e0b4b4eb87bcd66a1d2b888/rignore-0.7.6-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:b9e624f6be6116ea682e76c5feb71ea91255c67c86cb75befe774365b2931961", size = 820411, upload-time = "2025-11-05T20:42:24.782Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/c8/dea564b36dedac8de21c18e1851789545bc52a0c22ece9843444d5608a6a/rignore-0.7.6-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bda49950d405aa8d0ebe26af807c4e662dd281d926530f03f29690a2e07d649a", size = 897821, upload-time = "2025-11-05T20:40:52.613Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/2b/ee96db17ac1835e024c5d0742eefb7e46de60020385ac883dd3d1cde2c1f/rignore-0.7.6-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:b5fd5ab3840b8c16851d327ed06e9b8be6459702a53e5ab1fc4073b684b3789e", size = 873963, upload-time = "2025-11-05T20:41:07.49Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/8c/ad5a57bbb9d14d5c7e5960f712a8a0b902472ea3f4a2138cbf70d1777b75/rignore-0.7.6-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ced2a248352636a5c77504cb755dc02c2eef9a820a44d3f33061ce1bb8a7f2d2", size = 1169216, upload-time = "2025-11-05T20:41:23.73Z" },
+    { url = "https://files.pythonhosted.org/packages/80/e6/5b00bc2a6bc1701e6878fca798cf5d9125eb3113193e33078b6fc0d99123/rignore-0.7.6-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a04a3b73b75ddc12c9c9b21efcdaab33ca3832941d6f1d67bffd860941cd448a", size = 942942, upload-time = "2025-11-05T20:41:39.393Z" },
+    { url = "https://files.pythonhosted.org/packages/85/e5/7f99bd0cc9818a91d0e8b9acc65b792e35750e3bdccd15a7ee75e64efca4/rignore-0.7.6-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d24321efac92140b7ec910ac7c53ab0f0c86a41133d2bb4b0e6a7c94967f44dd", size = 959787, upload-time = "2025-11-05T20:42:09.765Z" },
+    { url = "https://files.pythonhosted.org/packages/55/54/2ffea79a7c1eabcede1926347ebc2a81bc6b81f447d05b52af9af14948b9/rignore-0.7.6-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:73c7aa109d41e593785c55fdaa89ad80b10330affa9f9d3e3a51fa695f739b20", size = 984245, upload-time = "2025-11-05T20:41:54.062Z" },
+    { url = "https://files.pythonhosted.org/packages/41/f7/e80f55dfe0f35787fa482aa18689b9c8251e045076c35477deb0007b3277/rignore-0.7.6-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:1734dc49d1e9501b07852ef44421f84d9f378da9fbeda729e77db71f49cac28b", size = 1078647, upload-time = "2025-11-05T21:40:13.463Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/cf/2c64f0b6725149f7c6e7e5a909d14354889b4beaadddaa5fff023ec71084/rignore-0.7.6-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:5719ea14ea2b652c0c0894be5dfde954e1853a80dea27dd2fbaa749618d837f5", size = 1139186, upload-time = "2025-11-05T21:40:31.27Z" },
+    { url = "https://files.pythonhosted.org/packages/75/95/a86c84909ccc24af0d094b50d54697951e576c252a4d9f21b47b52af9598/rignore-0.7.6-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:8e23424fc7ce35726854f639cb7968151a792c0c3d9d082f7f67e0c362cfecca", size = 1117604, upload-time = "2025-11-05T21:40:48.07Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/5e/13b249613fd5d18d58662490ab910a9f0be758981d1797789913adb4e918/rignore-0.7.6-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3efdcf1dd84d45f3e2bd2f93303d9be103888f56dfa7c3349b5bf4f0657ec696", size = 1127725, upload-time = "2025-11-05T21:41:05.804Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/28/fa5dcd1e2e16982c359128664e3785f202d3eca9b22dd0b2f91c4b3d242f/rignore-0.7.6-cp312-cp312-win32.whl", hash = "sha256:ccca9d1a8b5234c76b71546fc3c134533b013f40495f394a65614a81f7387046", size = 646145, upload-time = "2025-11-05T21:41:51.096Z" },
+    { url = "https://files.pythonhosted.org/packages/26/87/69387fb5dd81a0f771936381431780b8cf66fcd2cfe9495e1aaf41548931/rignore-0.7.6-cp312-cp312-win_amd64.whl", hash = "sha256:c96a285e4a8bfec0652e0bfcf42b1aabcdda1e7625f5006d188e3b1c87fdb543", size = 726090, upload-time = "2025-11-05T21:41:36.485Z" },
+    { url = "https://files.pythonhosted.org/packages/24/5f/e8418108dcda8087fb198a6f81caadbcda9fd115d61154bf0df4d6d3619b/rignore-0.7.6-cp312-cp312-win_arm64.whl", hash = "sha256:a64a750e7a8277a323f01ca50b7784a764845f6cce2fe38831cb93f0508d0051", size = 656317, upload-time = "2025-11-05T21:41:25.305Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/8a/a4078f6e14932ac7edb171149c481de29969d96ddee3ece5dc4c26f9e0c3/rignore-0.7.6-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:2bdab1d31ec9b4fb1331980ee49ea051c0d7f7bb6baa28b3125ef03cdc48fdaf", size = 883057, upload-time = "2025-11-05T20:42:42.741Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/8f/f8daacd177db4bf7c2223bab41e630c52711f8af9ed279be2058d2fe4982/rignore-0.7.6-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:90f0a00ce0c866c275bf888271f1dc0d2140f29b82fcf33cdbda1e1a6af01010", size = 820150, upload-time = "2025-11-05T20:42:26.545Z" },
+    { url = "https://files.pythonhosted.org/packages/36/31/b65b837e39c3f7064c426754714ac633b66b8c2290978af9d7f513e14aa9/rignore-0.7.6-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c1ad295537041dc2ed4b540fb1a3906bd9ede6ccdad3fe79770cd89e04e3c73c", size = 897406, upload-time = "2025-11-05T20:40:53.854Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/58/1970ce006c427e202ac7c081435719a076c478f07b3a23f469227788dc23/rignore-0.7.6-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f782dbd3a65a5ac85adfff69e5c6b101285ef3f845c3a3cae56a54bebf9fe116", size = 874050, upload-time = "2025-11-05T20:41:08.922Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/00/eb45db9f90137329072a732273be0d383cb7d7f50ddc8e0bceea34c1dfdf/rignore-0.7.6-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:65cece3b36e5b0826d946494734c0e6aaf5a0337e18ff55b071438efe13d559e", size = 1167835, upload-time = "2025-11-05T20:41:24.997Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/f1/6f1d72ddca41a64eed569680587a1236633587cc9f78136477ae69e2c88a/rignore-0.7.6-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d7e4bb66c13cd7602dc8931822c02dfbbd5252015c750ac5d6152b186f0a8be0", size = 941945, upload-time = "2025-11-05T20:41:40.628Z" },
+    { url = "https://files.pythonhosted.org/packages/48/6f/2f178af1c1a276a065f563ec1e11e7a9e23d4996fd0465516afce4b5c636/rignore-0.7.6-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:297e500c15766e196f68aaaa70e8b6db85fa23fdc075b880d8231fdfba738cd7", size = 959067, upload-time = "2025-11-05T20:42:11.09Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/db/423a81c4c1e173877c7f9b5767dcaf1ab50484a94f60a0b2ed78be3fa765/rignore-0.7.6-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:a07084211a8d35e1a5b1d32b9661a5ed20669970b369df0cf77da3adea3405de", size = 984438, upload-time = "2025-11-05T20:41:55.443Z" },
+    { url = "https://files.pythonhosted.org/packages/31/eb/c4f92cc3f2825d501d3c46a244a671eb737fc1bcf7b05a3ecd34abb3e0d7/rignore-0.7.6-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:181eb2a975a22256a1441a9d2f15eb1292839ea3f05606620bd9e1938302cf79", size = 1078365, upload-time = "2025-11-05T21:40:15.148Z" },
+    { url = "https://files.pythonhosted.org/packages/26/09/99442f02794bd7441bfc8ed1c7319e890449b816a7493b2db0e30af39095/rignore-0.7.6-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:7bbcdc52b5bf9f054b34ce4af5269df5d863d9c2456243338bc193c28022bd7b", size = 1139066, upload-time = "2025-11-05T21:40:32.771Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/88/bcfc21e520bba975410e9419450f4b90a2ac8236b9a80fd8130e87d098af/rignore-0.7.6-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:f2e027a6da21a7c8c0d87553c24ca5cc4364def18d146057862c23a96546238e", size = 1118036, upload-time = "2025-11-05T21:40:49.646Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/25/d37215e4562cda5c13312636393aea0bafe38d54d4e0517520a4cc0753ec/rignore-0.7.6-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:ee4a18b82cbbc648e4aac1510066682fe62beb5dc88e2c67c53a83954e541360", size = 1127550, upload-time = "2025-11-05T21:41:07.648Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/76/a264ab38bfa1620ec12a8ff1c07778da89e16d8c0f3450b0333020d3d6dc/rignore-0.7.6-cp313-cp313-win32.whl", hash = "sha256:a7d7148b6e5e95035d4390396895adc384d37ff4e06781a36fe573bba7c283e5", size = 646097, upload-time = "2025-11-05T21:41:53.201Z" },
+    { url = "https://files.pythonhosted.org/packages/62/44/3c31b8983c29ea8832b6082ddb1d07b90379c2d993bd20fce4487b71b4f4/rignore-0.7.6-cp313-cp313-win_amd64.whl", hash = "sha256:b037c4b15a64dced08fc12310ee844ec2284c4c5c1ca77bc37d0a04f7bff386e", size = 726170, upload-time = "2025-11-05T21:41:38.131Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/41/e26a075cab83debe41a42661262f606166157df84e0e02e2d904d134c0d8/rignore-0.7.6-cp313-cp313-win_arm64.whl", hash = "sha256:e47443de9b12fe569889bdbe020abe0e0b667516ee2ab435443f6d0869bd2804", size = 656184, upload-time = "2025-11-05T21:41:27.396Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/b9/1f5bd82b87e5550cd843ceb3768b4a8ef274eb63f29333cf2f29644b3d75/rignore-0.7.6-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:8e41be9fa8f2f47239ded8920cc283699a052ac4c371f77f5ac017ebeed75732", size = 882632, upload-time = "2025-11-05T20:42:44.063Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/6b/07714a3efe4a8048864e8a5b7db311ba51b921e15268b17defaebf56d3db/rignore-0.7.6-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:6dc1e171e52cefa6c20e60c05394a71165663b48bca6c7666dee4f778f2a7d90", size = 820760, upload-time = "2025-11-05T20:42:27.885Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/0f/348c829ea2d8d596e856371b14b9092f8a5dfbb62674ec9b3f67e4939a9d/rignore-0.7.6-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0ce2268837c3600f82ab8db58f5834009dc638ee17103582960da668963bebc5", size = 899044, upload-time = "2025-11-05T20:40:55.336Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/30/2e1841a19b4dd23878d73edd5d82e998a83d5ed9570a89675f140ca8b2ad/rignore-0.7.6-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:690a3e1b54bfe77e89c4bacb13f046e642f8baadafc61d68f5a726f324a76ab6", size = 874144, upload-time = "2025-11-05T20:41:10.195Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/bf/0ce9beb2e5f64c30e3580bef09f5829236889f01511a125f98b83169b993/rignore-0.7.6-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:09d12ac7a0b6210c07bcd145007117ebd8abe99c8eeb383e9e4673910c2754b2", size = 1168062, upload-time = "2025-11-05T20:41:26.511Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/8b/571c178414eb4014969865317da8a02ce4cf5241a41676ef91a59aab24de/rignore-0.7.6-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2a2b2b74a8c60203b08452479b90e5ce3dbe96a916214bc9eb2e5af0b6a9beb0", size = 942542, upload-time = "2025-11-05T20:41:41.838Z" },
+    { url = "https://files.pythonhosted.org/packages/19/62/7a3cf601d5a45137a7e2b89d10c05b5b86499190c4b7ca5c3c47d79ee519/rignore-0.7.6-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8fc5a531ef02131e44359419a366bfac57f773ea58f5278c2cdd915f7d10ea94", size = 958739, upload-time = "2025-11-05T20:42:12.463Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/1f/4261f6a0d7caf2058a5cde2f5045f565ab91aa7badc972b57d19ce58b14e/rignore-0.7.6-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:b7a1f77d9c4cd7e76229e252614d963442686bfe12c787a49f4fe481df49e7a9", size = 984138, upload-time = "2025-11-05T20:41:56.775Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/bf/628dfe19c75e8ce1f45f7c248f5148b17dfa89a817f8e3552ab74c3ae812/rignore-0.7.6-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:ead81f728682ba72b5b1c3d5846b011d3e0174da978de87c61645f2ed36659a7", size = 1079299, upload-time = "2025-11-05T21:40:16.639Z" },
+    { url = "https://files.pythonhosted.org/packages/af/a5/be29c50f5c0c25c637ed32db8758fdf5b901a99e08b608971cda8afb293b/rignore-0.7.6-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:12ffd50f520c22ffdabed8cd8bfb567d9ac165b2b854d3e679f4bcaef11a9441", size = 1139618, upload-time = "2025-11-05T21:40:34.507Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/40/3c46cd7ce4fa05c20b525fd60f599165e820af66e66f2c371cd50644558f/rignore-0.7.6-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:e5a16890fbe3c894f8ca34b0fcacc2c200398d4d46ae654e03bc9b3dbf2a0a72", size = 1117626, upload-time = "2025-11-05T21:40:51.494Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/b9/aea926f263b8a29a23c75c2e0d8447965eb1879d3feb53cfcf84db67ed58/rignore-0.7.6-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:3abab3bf99e8a77488ef6c7c9a799fac22224c28fe9f25cc21aa7cc2b72bfc0b", size = 1128144, upload-time = "2025-11-05T21:41:09.169Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/f6/0d6242f8d0df7f2ecbe91679fefc1f75e7cd2072cb4f497abaab3f0f8523/rignore-0.7.6-cp314-cp314-win32.whl", hash = "sha256:eeef421c1782953c4375aa32f06ecae470c1285c6381eee2a30d2e02a5633001", size = 646385, upload-time = "2025-11-05T21:41:55.105Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/38/c0dcd7b10064f084343d6af26fe9414e46e9619c5f3224b5272e8e5d9956/rignore-0.7.6-cp314-cp314-win_amd64.whl", hash = "sha256:6aeed503b3b3d5af939b21d72a82521701a4bd3b89cd761da1e7dc78621af304", size = 725738, upload-time = "2025-11-05T21:41:39.736Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/7a/290f868296c1ece914d565757ab363b04730a728b544beb567ceb3b2d96f/rignore-0.7.6-cp314-cp314-win_arm64.whl", hash = "sha256:104f215b60b3c984c386c3e747d6ab4376d5656478694e22c7bd2f788ddd8304", size = 656008, upload-time = "2025-11-05T21:41:29.028Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/d2/3c74e3cd81fe8ea08a8dcd2d755c09ac2e8ad8fe409508904557b58383d3/rignore-0.7.6-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:bb24a5b947656dd94cb9e41c4bc8b23cec0c435b58be0d74a874f63c259549e8", size = 882835, upload-time = "2025-11-05T20:42:45.443Z" },
+    { url = "https://files.pythonhosted.org/packages/77/61/a772a34b6b63154877433ac2d048364815b24c2dd308f76b212c408101a2/rignore-0.7.6-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:5b1e33c9501cefe24b70a1eafd9821acfd0ebf0b35c3a379430a14df089993e3", size = 820301, upload-time = "2025-11-05T20:42:29.226Z" },
+    { url = "https://files.pythonhosted.org/packages/71/30/054880b09c0b1b61d17eeb15279d8bf729c0ba52b36c3ada52fb827cbb3c/rignore-0.7.6-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bec3994665a44454df86deb762061e05cd4b61e3772f5b07d1882a8a0d2748d5", size = 897611, upload-time = "2025-11-05T20:40:56.475Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/40/b2d1c169f833d69931bf232600eaa3c7998ba4f9a402e43a822dad2ea9f2/rignore-0.7.6-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:26cba2edfe3cff1dfa72bddf65d316ddebf182f011f2f61538705d6dbaf54986", size = 873875, upload-time = "2025-11-05T20:41:11.561Z" },
+    { url = "https://files.pythonhosted.org/packages/55/59/ca5ae93d83a1a60e44b21d87deb48b177a8db1b85e82fc8a9abb24a8986d/rignore-0.7.6-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ffa86694fec604c613696cb91e43892aa22e1fec5f9870e48f111c603e5ec4e9", size = 1167245, upload-time = "2025-11-05T20:41:28.29Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/52/cf3dce392ba2af806cba265aad6bcd9c48bb2a6cb5eee448d3319f6e505b/rignore-0.7.6-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:48efe2ed95aa8104145004afb15cdfa02bea5cdde8b0344afeb0434f0d989aa2", size = 941750, upload-time = "2025-11-05T20:41:43.111Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/be/3f344c6218d779395e785091d05396dfd8b625f6aafbe502746fcd880af2/rignore-0.7.6-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8dcae43eb44b7f2457fef7cc87f103f9a0013017a6f4e62182c565e924948f21", size = 958896, upload-time = "2025-11-05T20:42:13.784Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/34/d3fa71938aed7d00dcad87f0f9bcb02ad66c85d6ffc83ba31078ce53646a/rignore-0.7.6-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2cd649a7091c0dad2f11ef65630d30c698d505cbe8660dd395268e7c099cc99f", size = 983992, upload-time = "2025-11-05T20:41:58.022Z" },
+    { url = "https://files.pythonhosted.org/packages/24/a4/52a697158e9920705bdbd0748d59fa63e0f3233fb92e9df9a71afbead6ca/rignore-0.7.6-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:42de84b0289d478d30ceb7ae59023f7b0527786a9a5b490830e080f0e4ea5aeb", size = 1078181, upload-time = "2025-11-05T21:40:18.151Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/65/aa76dbcdabf3787a6f0fd61b5cc8ed1e88580590556d6c0207960d2384bb/rignore-0.7.6-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:875a617e57b53b4acbc5a91de418233849711c02e29cc1f4f9febb2f928af013", size = 1139232, upload-time = "2025-11-05T21:40:35.966Z" },
+    { url = "https://files.pythonhosted.org/packages/08/44/31b31a49b3233c6842acc1c0731aa1e7fb322a7170612acf30327f700b44/rignore-0.7.6-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:8703998902771e96e49968105207719f22926e4431b108450f3f430b4e268b7c", size = 1117349, upload-time = "2025-11-05T21:40:53.013Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/ae/1b199a2302c19c658cf74e5ee1427605234e8c91787cfba0015f2ace145b/rignore-0.7.6-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:602ef33f3e1b04c1e9a10a3c03f8bc3cef2d2383dcc250d309be42b49923cabc", size = 1127702, upload-time = "2025-11-05T21:41:10.881Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/d3/18210222b37e87e36357f7b300b7d98c6dd62b133771e71ae27acba83a4f/rignore-0.7.6-cp314-cp314t-win32.whl", hash = "sha256:c1d8f117f7da0a4a96a8daef3da75bc090e3792d30b8b12cfadc240c631353f9", size = 647033, upload-time = "2025-11-05T21:42:00.095Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/87/033eebfbee3ec7d92b3bb1717d8f68c88e6fc7de54537040f3b3a405726f/rignore-0.7.6-cp314-cp314t-win_amd64.whl", hash = "sha256:ca36e59408bec81de75d307c568c2d0d410fb880b1769be43611472c61e85c96", size = 725647, upload-time = "2025-11-05T21:41:44.449Z" },
+    { url = "https://files.pythonhosted.org/packages/79/62/b88e5879512c55b8ee979c666ee6902adc4ed05007226de266410ae27965/rignore-0.7.6-cp314-cp314t-win_arm64.whl", hash = "sha256:b83adabeb3e8cf662cabe1931b83e165b88c526fa6af6b3aa90429686e474896", size = 656035, upload-time = "2025-11-05T21:41:31.13Z" },
+]
+
 [[package]]
 name = "rpds-py"
 version = "0.30.0"
@@ -5016,13 +6361,132 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/1c/78/504fdd027da3b84ff1aecd9f6957e65f35134534ccc6da8628eb71e76d3f/send2trash-2.1.0-py3-none-any.whl", hash = "sha256:0da2f112e6d6bb22de6aa6daa7e144831a4febf2a87261451c4ad849fe9a873c", size = 17610, upload-time = "2026-01-14T06:27:35.218Z" },
 ]
 
+[[package]]
+name = "sentencepiece"
+version = "0.2.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/15/15/2e7a025fc62d764b151ae6d0f2a92f8081755ebe8d4a64099accc6f77ba6/sentencepiece-0.2.1.tar.gz", hash = "sha256:8138cec27c2f2282f4a34d9a016e3374cd40e5c6e9cb335063db66a0a3b71fad", size = 3228515, upload-time = "2025-08-12T07:00:51.718Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/4a/be/32ce495aa1d0e0c323dcb1ba87096037358edee539cac5baf8755a6bd396/sentencepiece-0.2.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:57cae326c8727de58c85977b175af132a7138d84c764635d7e71bbee7e774133", size = 1943152, upload-time = "2025-08-12T06:59:40.048Z" },
+    { url = "https://files.pythonhosted.org/packages/88/7e/ff23008899a58678e98c6ff592bf4d368eee5a71af96d0df6b38a039dd4f/sentencepiece-0.2.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:56dd39a3c4d6493db3cdca7e8cc68c6b633f0d4195495cbadfcf5af8a22d05a6", size = 1325651, upload-time = "2025-08-12T06:59:41.536Z" },
+    { url = "https://files.pythonhosted.org/packages/19/84/42eb3ce4796777a1b5d3699dfd4dca85113e68b637f194a6c8d786f16a04/sentencepiece-0.2.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:d9381351182ff9888cc80e41c632e7e274b106f450de33d67a9e8f6043da6f76", size = 1253645, upload-time = "2025-08-12T06:59:42.903Z" },
+    { url = "https://files.pythonhosted.org/packages/89/fa/d3d5ebcba3cb9e6d3775a096251860c41a6bc53a1b9461151df83fe93255/sentencepiece-0.2.1-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:99f955df238021bf11f0fc37cdb54fd5e5b5f7fd30ecc3d93fb48b6815437167", size = 1316273, upload-time = "2025-08-12T06:59:44.476Z" },
+    { url = "https://files.pythonhosted.org/packages/04/88/14f2f4a2b922d8b39be45bf63d79e6cd3a9b2f248b2fcb98a69b12af12f5/sentencepiece-0.2.1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0cdfecef430d985f1c2bcbfff3defd1d95dae876fbd0173376012d2d7d24044b", size = 1387881, upload-time = "2025-08-12T06:59:46.09Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/b8/903e5ccb77b4ef140605d5d71b4f9e0ad95d456d6184688073ed11712809/sentencepiece-0.2.1-cp312-cp312-win32.whl", hash = "sha256:a483fd29a34c3e34c39ac5556b0a90942bec253d260235729e50976f5dba1068", size = 999540, upload-time = "2025-08-12T06:59:48.023Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/81/92df5673c067148c2545b1bfe49adfd775bcc3a169a047f5a0e6575ddaca/sentencepiece-0.2.1-cp312-cp312-win_amd64.whl", hash = "sha256:4cdc7c36234fda305e85c32949c5211faaf8dd886096c7cea289ddc12a2d02de", size = 1054671, upload-time = "2025-08-12T06:59:49.895Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/02/c5e3bc518655d714622bec87d83db9cdba1cd0619a4a04e2109751c4f47f/sentencepiece-0.2.1-cp312-cp312-win_arm64.whl", hash = "sha256:daeb5e9e9fcad012324807856113708614d534f596d5008638eb9b40112cd9e4", size = 1033923, upload-time = "2025-08-12T06:59:51.952Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/4a/85fbe1706d4d04a7e826b53f327c4b80f849cf1c7b7c5e31a20a97d8f28b/sentencepiece-0.2.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:dcd8161eee7b41aae57ded06272905dbd680a0a04b91edd0f64790c796b2f706", size = 1943150, upload-time = "2025-08-12T06:59:53.588Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/83/4cfb393e287509fc2155480b9d184706ef8d9fa8cbf5505d02a5792bf220/sentencepiece-0.2.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:c6c8f42949f419ff8c7e9960dbadcfbc982d7b5efc2f6748210d3dd53a7de062", size = 1325651, upload-time = "2025-08-12T06:59:55.073Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/de/5a007fb53b1ab0aafc69d11a5a3dd72a289d5a3e78dcf2c3a3d9b14ffe93/sentencepiece-0.2.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:097f3394e99456e9e4efba1737c3749d7e23563dd1588ce71a3d007f25475fff", size = 1253641, upload-time = "2025-08-12T06:59:56.562Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/d2/f552be5928105588f4f4d66ee37dd4c61460d8097e62d0e2e0eec41bc61d/sentencepiece-0.2.1-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d7b670879c370d350557edabadbad1f6561a9e6968126e6debca4029e5547820", size = 1316271, upload-time = "2025-08-12T06:59:58.109Z" },
+    { url = "https://files.pythonhosted.org/packages/96/df/0cfe748ace5485be740fed9476dee7877f109da32ed0d280312c94ec259f/sentencepiece-0.2.1-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c7f0fd2f2693309e6628aeeb2e2faf6edd221134dfccac3308ca0de01f8dab47", size = 1387882, upload-time = "2025-08-12T07:00:00.701Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/dd/f7774d42a881ced8e1739f393ab1e82ece39fc9abd4779e28050c2e975b5/sentencepiece-0.2.1-cp313-cp313-win32.whl", hash = "sha256:92b3816aa2339355fda2c8c4e021a5de92180b00aaccaf5e2808972e77a4b22f", size = 999541, upload-time = "2025-08-12T07:00:02.709Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/e9/932b9eae6fd7019548321eee1ab8d5e3b3d1294df9d9a0c9ac517c7b636d/sentencepiece-0.2.1-cp313-cp313-win_amd64.whl", hash = "sha256:10ed3dab2044c47f7a2e7b4969b0c430420cdd45735d78c8f853191fa0e3148b", size = 1054669, upload-time = "2025-08-12T07:00:04.915Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/3a/76488a00ea7d6931689cda28726a1447d66bf1a4837943489314593d5596/sentencepiece-0.2.1-cp313-cp313-win_arm64.whl", hash = "sha256:ac650534e2251083c5f75dde4ff28896ce7c8904133dc8fef42780f4d5588fcd", size = 1033922, upload-time = "2025-08-12T07:00:06.496Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/b6/08fe2ce819e02ccb0296f4843e3f195764ce9829cbda61b7513f29b95718/sentencepiece-0.2.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:8dd4b477a7b069648d19363aad0cab9bad2f4e83b2d179be668efa672500dc94", size = 1946052, upload-time = "2025-08-12T07:00:08.136Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/d9/1ea0e740591ff4c6fc2b6eb1d7510d02f3fb885093f19b2f3abd1363b402/sentencepiece-0.2.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:0c0f672da370cc490e4c59d89e12289778310a0e71d176c541e4834759e1ae07", size = 1327408, upload-time = "2025-08-12T07:00:09.572Z" },
+    { url = "https://files.pythonhosted.org/packages/99/7e/1fb26e8a21613f6200e1ab88824d5d203714162cf2883248b517deb500b7/sentencepiece-0.2.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:ad8493bea8432dae8d6830365352350f3b4144415a1d09c4c8cb8d30cf3b6c3c", size = 1254857, upload-time = "2025-08-12T07:00:11.021Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/85/c72fd1f3c7a6010544d6ae07f8ddb38b5e2a7e33bd4318f87266c0bbafbf/sentencepiece-0.2.1-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b81a24733726e3678d2db63619acc5a8dccd074f7aa7a54ecd5ca33ca6d2d596", size = 1315722, upload-time = "2025-08-12T07:00:12.989Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/e8/661e5bd82a8aa641fd6c1020bd0e890ef73230a2b7215ddf9c8cd8e941c2/sentencepiece-0.2.1-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0a81799d0a68d618e89063fb423c3001a034c893069135ffe51fee439ae474d6", size = 1387452, upload-time = "2025-08-12T07:00:15.088Z" },
+    { url = "https://files.pythonhosted.org/packages/99/5e/ae66c361023a470afcbc1fbb8da722c72ea678a2fcd9a18f1a12598c7501/sentencepiece-0.2.1-cp313-cp313t-win32.whl", hash = "sha256:89a3ea015517c42c0341d0d962f3e6aaf2cf10d71b1932d475c44ba48d00aa2b", size = 1002501, upload-time = "2025-08-12T07:00:16.966Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/03/d332828c4ff764e16c1b56c2c8f9a33488bbe796b53fb6b9c4205ddbf167/sentencepiece-0.2.1-cp313-cp313t-win_amd64.whl", hash = "sha256:33f068c9382dc2e7c228eedfd8163b52baa86bb92f50d0488bf2b7da7032e484", size = 1057555, upload-time = "2025-08-12T07:00:18.573Z" },
+    { url = "https://files.pythonhosted.org/packages/88/14/5aee0bf0864df9bd82bd59e7711362908e4935e3f9cdc1f57246b5d5c9b9/sentencepiece-0.2.1-cp313-cp313t-win_arm64.whl", hash = "sha256:b3616ad246f360e52c85781e47682d31abfb6554c779e42b65333d4b5f44ecc0", size = 1036042, upload-time = "2025-08-12T07:00:20.209Z" },
+    { url = "https://files.pythonhosted.org/packages/24/9c/89eb8b2052f720a612478baf11c8227dcf1dc28cd4ea4c0c19506b5af2a2/sentencepiece-0.2.1-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:5d0350b686c320068702116276cfb26c066dc7e65cfef173980b11bb4d606719", size = 1943147, upload-time = "2025-08-12T07:00:21.809Z" },
+    { url = "https://files.pythonhosted.org/packages/82/0b/a1432bc87f97c2ace36386ca23e8bd3b91fb40581b5e6148d24b24186419/sentencepiece-0.2.1-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:c7f54a31cde6fa5cb030370566f68152a742f433f8d2be458463d06c208aef33", size = 1325624, upload-time = "2025-08-12T07:00:23.289Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/99/bbe054ebb5a5039457c590e0a4156ed073fb0fe9ce4f7523404dd5b37463/sentencepiece-0.2.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c83b85ab2d6576607f31df77ff86f28182be4a8de6d175d2c33ca609925f5da1", size = 1253670, upload-time = "2025-08-12T07:00:24.69Z" },
+    { url = "https://files.pythonhosted.org/packages/19/ad/d5c7075f701bd97971d7c2ac2904f227566f51ef0838dfbdfdccb58cd212/sentencepiece-0.2.1-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1855f57db07b51fb51ed6c9c452f570624d2b169b36f0f79ef71a6e6c618cd8b", size = 1316247, upload-time = "2025-08-12T07:00:26.435Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/03/35fbe5f3d9a7435eebd0b473e09584bd3cc354ce118b960445b060d33781/sentencepiece-0.2.1-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:01e6912125cb45d3792f530a4d38f8e21bf884d6b4d4ade1b2de5cf7a8d2a52b", size = 1387894, upload-time = "2025-08-12T07:00:28.339Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/aa/956ef729aafb6c8f9c443104c9636489093bb5c61d6b90fc27aa1a865574/sentencepiece-0.2.1-cp314-cp314-win32.whl", hash = "sha256:c415c9de1447e0a74ae3fdb2e52f967cb544113a3a5ce3a194df185cbc1f962f", size = 1096698, upload-time = "2025-08-12T07:00:29.764Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/cb/fe400d8836952cc535c81a0ce47dc6875160e5fedb71d2d9ff0e9894c2a6/sentencepiece-0.2.1-cp314-cp314-win_amd64.whl", hash = "sha256:881b2e44b14fc19feade3cbed314be37de639fc415375cefaa5bc81a4be137fd", size = 1155115, upload-time = "2025-08-12T07:00:32.865Z" },
+    { url = "https://files.pythonhosted.org/packages/32/89/047921cf70f36c7b6b6390876b2399b3633ab73b8d0cb857e5a964238941/sentencepiece-0.2.1-cp314-cp314-win_arm64.whl", hash = "sha256:2005242a16d2dc3ac5fe18aa7667549134d37854823df4c4db244752453b78a8", size = 1133890, upload-time = "2025-08-12T07:00:34.763Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/11/5b414b9fae6255b5fb1e22e2ed3dc3a72d3a694e5703910e640ac78346bb/sentencepiece-0.2.1-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:a19adcec27c524cb7069a1c741060add95f942d1cbf7ad0d104dffa0a7d28a2b", size = 1946081, upload-time = "2025-08-12T07:00:36.97Z" },
+    { url = "https://files.pythonhosted.org/packages/77/eb/7a5682bb25824db8545f8e5662e7f3e32d72a508fdce086029d89695106b/sentencepiece-0.2.1-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:e37e4b4c4a11662b5db521def4e44d4d30ae69a1743241412a93ae40fdcab4bb", size = 1327406, upload-time = "2025-08-12T07:00:38.669Z" },
+    { url = "https://files.pythonhosted.org/packages/03/b0/811dae8fb9f2784e138785d481469788f2e0d0c109c5737372454415f55f/sentencepiece-0.2.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:477c81505db072b3ab627e7eab972ea1025331bd3a92bacbf798df2b75ea86ec", size = 1254846, upload-time = "2025-08-12T07:00:40.611Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/23/195b2e7ec85ebb6a547969f60b723c7aca5a75800ece6cc3f41da872d14e/sentencepiece-0.2.1-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:010f025a544ef770bb395091d57cb94deb9652d8972e0d09f71d85d5a0816c8c", size = 1315721, upload-time = "2025-08-12T07:00:42.914Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/aa/553dbe4178b5f23eb28e59393dddd64186178b56b81d9b8d5c3ff1c28395/sentencepiece-0.2.1-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:733e59ff1794d26db706cd41fc2d7ca5f6c64a820709cb801dc0ea31780d64ab", size = 1387458, upload-time = "2025-08-12T07:00:44.56Z" },
+    { url = "https://files.pythonhosted.org/packages/66/7c/08ff0012507297a4dd74a5420fdc0eb9e3e80f4e88cab1538d7f28db303d/sentencepiece-0.2.1-cp314-cp314t-win32.whl", hash = "sha256:d3233770f78e637dc8b1fda2cd7c3b99ec77e7505041934188a4e7fe751de3b0", size = 1099765, upload-time = "2025-08-12T07:00:46.058Z" },
+    { url = "https://files.pythonhosted.org/packages/91/d5/2a69e1ce15881beb9ddfc7e3f998322f5cedcd5e4d244cb74dade9441663/sentencepiece-0.2.1-cp314-cp314t-win_amd64.whl", hash = "sha256:5e4366c97b68218fd30ea72d70c525e6e78a6c0a88650f57ac4c43c63b234a9d", size = 1157807, upload-time = "2025-08-12T07:00:47.673Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/16/54f611fcfc2d1c46cbe3ec4169780b2cfa7cf63708ef2b71611136db7513/sentencepiece-0.2.1-cp314-cp314t-win_arm64.whl", hash = "sha256:105e36e75cbac1292642045458e8da677b2342dcd33df503e640f0b457cb6751", size = 1136264, upload-time = "2025-08-12T07:00:49.485Z" },
+]
+
+[[package]]
+name = "sentry-sdk"
+version = "2.60.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "certifi" },
+    { name = "urllib3" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/54/a2/2e6c090db384cc515069f4f85542bd5baf6786852073020ea73d4a76d3ea/sentry_sdk-2.60.0.tar.gz", hash = "sha256:0bd25e54e78ca02d0be512529fa644bbbf9e8470d7b26371294012d4ca93c978", size = 452946, upload-time = "2026-05-13T13:34:52.516Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/29/41/f2b800b7f12a05dd48c2a6280d4dd812d1425fc66ed3fe3fd99420c41d1a/sentry_sdk-2.60.0-py3-none-any.whl", hash = "sha256:28a536c03291c8bcb363cf35c611b32738ec118ff64d8d6383b096448ac4c803", size = 475616, upload-time = "2026-05-13T13:34:50.259Z" },
+]
+
+[[package]]
+name = "setproctitle"
+version = "1.3.7"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/8d/48/49393a96a2eef1ab418b17475fb92b8fcfad83d099e678751b05472e69de/setproctitle-1.3.7.tar.gz", hash = "sha256:bc2bc917691c1537d5b9bca1468437176809c7e11e5694ca79a9ca12345dcb9e", size = 27002, upload-time = "2025-09-05T12:51:25.278Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/fb/f0/2dc88e842077719d7384d86cc47403e5102810492b33680e7dadcee64cd8/setproctitle-1.3.7-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:2dc99aec591ab6126e636b11035a70991bc1ab7a261da428491a40b84376654e", size = 18049, upload-time = "2025-09-05T12:49:36.241Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/b4/50940504466689cda65680c9e9a1e518e5750c10490639fa687489ac7013/setproctitle-1.3.7-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:cdd8aa571b7aa39840fdbea620e308a19691ff595c3a10231e9ee830339dd798", size = 13079, upload-time = "2025-09-05T12:49:38.088Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/99/71630546b9395b095f4082be41165d1078204d1696c2d9baade3de3202d0/setproctitle-1.3.7-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:2906b6c7959cdb75f46159bf0acd8cc9906cf1361c9e1ded0d065fe8f9039629", size = 32932, upload-time = "2025-09-05T12:49:39.271Z" },
+    { url = "https://files.pythonhosted.org/packages/50/22/cee06af4ffcfb0e8aba047bd44f5262e644199ae7527ae2c1f672b86495c/setproctitle-1.3.7-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6915964a6dda07920a1159321dcd6d94fc7fc526f815ca08a8063aeca3c204f1", size = 33736, upload-time = "2025-09-05T12:49:40.565Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/00/a5949a8bb06ef5e7df214fc393bb2fb6aedf0479b17214e57750dfdd0f24/setproctitle-1.3.7-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:cff72899861c765bd4021d1ff1c68d60edc129711a2fdba77f9cb69ef726a8b6", size = 35605, upload-time = "2025-09-05T12:49:42.362Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/3a/50caca532a9343828e3bf5778c7a84d6c737a249b1796d50dd680290594d/setproctitle-1.3.7-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:b7cb05bd446687ff816a3aaaf831047fc4c364feff7ada94a66024f1367b448c", size = 33143, upload-time = "2025-09-05T12:49:43.515Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/14/b843a251296ce55e2e17c017d6b9f11ce0d3d070e9265de4ecad948b913d/setproctitle-1.3.7-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:3a57b9a00de8cae7e2a1f7b9f0c2ac7b69372159e16a7708aa2f38f9e5cc987a", size = 34434, upload-time = "2025-09-05T12:49:45.31Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/b7/06145c238c0a6d2c4bc881f8be230bb9f36d2bf51aff7bddcb796d5eed67/setproctitle-1.3.7-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:d8828b356114f6b308b04afe398ed93803d7fca4a955dd3abe84430e28d33739", size = 32795, upload-time = "2025-09-05T12:49:46.419Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/dc/ef76a81fac9bf27b84ed23df19c1f67391a753eed6e3c2254ebcb5133f56/setproctitle-1.3.7-cp312-cp312-win32.whl", hash = "sha256:b0304f905efc845829ac2bc791ddebb976db2885f6171f4a3de678d7ee3f7c9f", size = 12552, upload-time = "2025-09-05T12:49:47.635Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/5b/a9fe517912cd6e28cf43a212b80cb679ff179a91b623138a99796d7d18a0/setproctitle-1.3.7-cp312-cp312-win_amd64.whl", hash = "sha256:9888ceb4faea3116cf02a920ff00bfbc8cc899743e4b4ac914b03625bdc3c300", size = 13247, upload-time = "2025-09-05T12:49:49.16Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/2f/fcedcade3b307a391b6e17c774c6261a7166aed641aee00ed2aad96c63ce/setproctitle-1.3.7-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:c3736b2a423146b5e62230502e47e08e68282ff3b69bcfe08a322bee73407922", size = 18047, upload-time = "2025-09-05T12:49:50.271Z" },
+    { url = "https://files.pythonhosted.org/packages/23/ae/afc141ca9631350d0a80b8f287aac79a76f26b6af28fd8bf92dae70dc2c5/setproctitle-1.3.7-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:3384e682b158d569e85a51cfbde2afd1ab57ecf93ea6651fe198d0ba451196ee", size = 13073, upload-time = "2025-09-05T12:49:51.46Z" },
+    { url = "https://files.pythonhosted.org/packages/87/ed/0a4f00315bc02510395b95eec3d4aa77c07192ee79f0baae77ea7b9603d8/setproctitle-1.3.7-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:0564a936ea687cd24dffcea35903e2a20962aa6ac20e61dd3a207652401492dd", size = 33284, upload-time = "2025-09-05T12:49:52.741Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/e4/adf3c4c0a2173cb7920dc9df710bcc67e9bcdbf377e243b7a962dc31a51a/setproctitle-1.3.7-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a5d1cb3f81531f0eb40e13246b679a1bdb58762b170303463cb06ecc296f26d0", size = 34104, upload-time = "2025-09-05T12:49:54.416Z" },
+    { url = "https://files.pythonhosted.org/packages/52/4f/6daf66394152756664257180439d37047aa9a1cfaa5e4f5ed35e93d1dc06/setproctitle-1.3.7-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a7d159e7345f343b44330cbba9194169b8590cb13dae940da47aa36a72aa9929", size = 35982, upload-time = "2025-09-05T12:49:56.295Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/62/f2c0595403cf915db031f346b0e3b2c0096050e90e0be658a64f44f4278a/setproctitle-1.3.7-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:0b5074649797fd07c72ca1f6bff0406f4a42e1194faac03ecaab765ce605866f", size = 33150, upload-time = "2025-09-05T12:49:58.025Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/29/10dd41cde849fb2f9b626c846b7ea30c99c81a18a5037a45cc4ba33c19a7/setproctitle-1.3.7-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:61e96febced3f61b766115381d97a21a6265a0f29188a791f6df7ed777aef698", size = 34463, upload-time = "2025-09-05T12:49:59.424Z" },
+    { url = "https://files.pythonhosted.org/packages/71/3c/cedd8eccfaf15fb73a2c20525b68c9477518917c9437737fa0fda91e378f/setproctitle-1.3.7-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:047138279f9463f06b858e579cc79580fbf7a04554d24e6bddf8fe5dddbe3d4c", size = 32848, upload-time = "2025-09-05T12:50:01.107Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/3e/0a0e27d1c9926fecccfd1f91796c244416c70bf6bca448d988638faea81d/setproctitle-1.3.7-cp313-cp313-win32.whl", hash = "sha256:7f47accafac7fe6535ba8ba9efd59df9d84a6214565108d0ebb1199119c9cbbd", size = 12544, upload-time = "2025-09-05T12:50:15.81Z" },
+    { url = "https://files.pythonhosted.org/packages/36/1b/6bf4cb7acbbd5c846ede1c3f4d6b4ee52744d402e43546826da065ff2ab7/setproctitle-1.3.7-cp313-cp313-win_amd64.whl", hash = "sha256:fe5ca35aeec6dc50cabab9bf2d12fbc9067eede7ff4fe92b8f5b99d92e21263f", size = 13235, upload-time = "2025-09-05T12:50:16.89Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/a4/d588d3497d4714750e3eaf269e9e8985449203d82b16b933c39bd3fc52a1/setproctitle-1.3.7-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:10e92915c4b3086b1586933a36faf4f92f903c5554f3c34102d18c7d3f5378e9", size = 18058, upload-time = "2025-09-05T12:50:02.501Z" },
+    { url = "https://files.pythonhosted.org/packages/05/77/7637f7682322a7244e07c373881c7e982567e2cb1dd2f31bd31481e45500/setproctitle-1.3.7-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:de879e9c2eab637f34b1a14c4da1e030c12658cdc69ee1b3e5be81b380163ce5", size = 13072, upload-time = "2025-09-05T12:50:03.601Z" },
+    { url = "https://files.pythonhosted.org/packages/52/09/f366eca0973cfbac1470068d1313fa3fe3de4a594683385204ec7f1c4101/setproctitle-1.3.7-cp313-cp313t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:c18246d88e227a5b16248687514f95642505000442165f4b7db354d39d0e4c29", size = 34490, upload-time = "2025-09-05T12:50:04.948Z" },
+    { url = "https://files.pythonhosted.org/packages/71/36/611fc2ed149fdea17c3677e1d0df30d8186eef9562acc248682b91312706/setproctitle-1.3.7-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7081f193dab22df2c36f9fc6d113f3793f83c27891af8fe30c64d89d9a37e152", size = 35267, upload-time = "2025-09-05T12:50:06.015Z" },
+    { url = "https://files.pythonhosted.org/packages/88/a4/64e77d0671446bd5a5554387b69e1efd915274686844bea733714c828813/setproctitle-1.3.7-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:9cc9b901ce129350637426a89cfd650066a4adc6899e47822e2478a74023ff7c", size = 37376, upload-time = "2025-09-05T12:50:07.484Z" },
+    { url = "https://files.pythonhosted.org/packages/89/bc/ad9c664fe524fb4a4b2d3663661a5c63453ce851736171e454fa2cdec35c/setproctitle-1.3.7-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:80e177eff2d1ec172188d0d7fd9694f8e43d3aab76a6f5f929bee7bf7894e98b", size = 33963, upload-time = "2025-09-05T12:50:09.056Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/01/a36de7caf2d90c4c28678da1466b47495cbbad43badb4e982d8db8167ed4/setproctitle-1.3.7-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:23e520776c445478a67ee71b2a3c1ffdafbe1f9f677239e03d7e2cc635954e18", size = 35550, upload-time = "2025-09-05T12:50:10.791Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/68/17e8aea0ed5ebc17fbf03ed2562bfab277c280e3625850c38d92a7b5fcd9/setproctitle-1.3.7-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:5fa1953126a3b9bd47049d58c51b9dac72e78ed120459bd3aceb1bacee72357c", size = 33727, upload-time = "2025-09-05T12:50:12.032Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/33/90a3bf43fe3a2242b4618aa799c672270250b5780667898f30663fd94993/setproctitle-1.3.7-cp313-cp313t-win32.whl", hash = "sha256:4a5e212bf438a4dbeece763f4962ad472c6008ff6702e230b4f16a037e2f6f29", size = 12549, upload-time = "2025-09-05T12:50:13.074Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/0e/50d1f07f3032e1f23d814ad6462bc0a138f369967c72494286b8a5228e40/setproctitle-1.3.7-cp313-cp313t-win_amd64.whl", hash = "sha256:cf2727b733e90b4f874bac53e3092aa0413fe1ea6d4f153f01207e6ce65034d9", size = 13243, upload-time = "2025-09-05T12:50:14.146Z" },
+    { url = "https://files.pythonhosted.org/packages/89/c7/43ac3a98414f91d1b86a276bc2f799ad0b4b010e08497a95750d5bc42803/setproctitle-1.3.7-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:80c36c6a87ff72eabf621d0c79b66f3bdd0ecc79e873c1e9f0651ee8bf215c63", size = 18052, upload-time = "2025-09-05T12:50:17.928Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/2c/dc258600a25e1a1f04948073826bebc55e18dbd99dc65a576277a82146fa/setproctitle-1.3.7-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:b53602371a52b91c80aaf578b5ada29d311d12b8a69c0c17fbc35b76a1fd4f2e", size = 13071, upload-time = "2025-09-05T12:50:19.061Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/26/8e3bb082992f19823d831f3d62a89409deb6092e72fc6940962983ffc94f/setproctitle-1.3.7-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:fcb966a6c57cf07cc9448321a08f3be6b11b7635be502669bc1d8745115d7e7f", size = 33180, upload-time = "2025-09-05T12:50:20.395Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/af/ae692a20276d1159dd0cf77b0bcf92cbb954b965655eb4a69672099bb214/setproctitle-1.3.7-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:46178672599b940368d769474fe13ecef1b587d58bb438ea72b9987f74c56ea5", size = 34043, upload-time = "2025-09-05T12:50:22.454Z" },
+    { url = "https://files.pythonhosted.org/packages/34/b2/6a092076324dd4dac1a6d38482bedebbff5cf34ef29f58585ec76e47bc9d/setproctitle-1.3.7-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:7f9e9e3ff135cbcc3edd2f4cf29b139f4aca040d931573102742db70ff428c17", size = 35892, upload-time = "2025-09-05T12:50:23.937Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/1a/8836b9f28cee32859ac36c3df85aa03e1ff4598d23ea17ca2e96b5845a8f/setproctitle-1.3.7-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:14c7eba8d90c93b0e79c01f0bd92a37b61983c27d6d7d5a3b5defd599113d60e", size = 32898, upload-time = "2025-09-05T12:50:25.617Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/22/8fabdc24baf42defb599714799d8445fe3ae987ec425a26ec8e80ea38f8e/setproctitle-1.3.7-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:9e64e98077fb30b6cf98073d6c439cd91deb8ebbf8fc62d9dbf52bd38b0c6ac0", size = 34308, upload-time = "2025-09-05T12:50:26.827Z" },
+    { url = "https://files.pythonhosted.org/packages/15/1b/b9bee9de6c8cdcb3b3a6cb0b3e773afdb86bbbc1665a3bfa424a4294fda2/setproctitle-1.3.7-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:b91387cc0f02a00ac95dcd93f066242d3cca10ff9e6153de7ee07069c6f0f7c8", size = 32536, upload-time = "2025-09-05T12:50:28.5Z" },
+    { url = "https://files.pythonhosted.org/packages/37/0c/75e5f2685a5e3eda0b39a8b158d6d8895d6daf3ba86dec9e3ba021510272/setproctitle-1.3.7-cp314-cp314-win32.whl", hash = "sha256:52b054a61c99d1b72fba58b7f5486e04b20fefc6961cd76722b424c187f362ed", size = 12731, upload-time = "2025-09-05T12:50:43.955Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/ae/acddbce90d1361e1786e1fb421bc25baeb0c22ef244ee5d0176511769ec8/setproctitle-1.3.7-cp314-cp314-win_amd64.whl", hash = "sha256:5818e4080ac04da1851b3ec71e8a0f64e3748bf9849045180566d8b736702416", size = 13464, upload-time = "2025-09-05T12:50:45.057Z" },
+    { url = "https://files.pythonhosted.org/packages/01/6d/20886c8ff2e6d85e3cabadab6aab9bb90acaf1a5cfcb04d633f8d61b2626/setproctitle-1.3.7-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:6fc87caf9e323ac426910306c3e5d3205cd9f8dcac06d233fcafe9337f0928a3", size = 18062, upload-time = "2025-09-05T12:50:29.78Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/60/26dfc5f198715f1343b95c2f7a1c16ae9ffa45bd89ffd45a60ed258d24ea/setproctitle-1.3.7-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:6134c63853d87a4897ba7d5cc0e16abfa687f6c66fc09f262bb70d67718f2309", size = 13075, upload-time = "2025-09-05T12:50:31.604Z" },
+    { url = "https://files.pythonhosted.org/packages/21/9c/980b01f50d51345dd513047e3ba9e96468134b9181319093e61db1c47188/setproctitle-1.3.7-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:1403d2abfd32790b6369916e2313dffbe87d6b11dca5bbd898981bcde48e7a2b", size = 34744, upload-time = "2025-09-05T12:50:32.777Z" },
+    { url = "https://files.pythonhosted.org/packages/86/b4/82cd0c86e6d1c4538e1a7eb908c7517721513b801dff4ba3f98ef816a240/setproctitle-1.3.7-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e7c5bfe4228ea22373e3025965d1a4116097e555ee3436044f5c954a5e63ac45", size = 35589, upload-time = "2025-09-05T12:50:34.13Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/4f/9f6b2a7417fd45673037554021c888b31247f7594ff4bd2239918c5cd6d0/setproctitle-1.3.7-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:585edf25e54e21a94ccb0fe81ad32b9196b69ebc4fc25f81da81fb8a50cca9e4", size = 37698, upload-time = "2025-09-05T12:50:35.524Z" },
+    { url = "https://files.pythonhosted.org/packages/20/92/927b7d4744aac214d149c892cb5fa6dc6f49cfa040cb2b0a844acd63dcaf/setproctitle-1.3.7-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:96c38cdeef9036eb2724c2210e8d0b93224e709af68c435d46a4733a3675fee1", size = 34201, upload-time = "2025-09-05T12:50:36.697Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/0c/fd4901db5ba4b9d9013e62f61d9c18d52290497f956745cd3e91b0d80f90/setproctitle-1.3.7-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:45e3ef48350abb49cf937d0a8ba15e42cee1e5ae13ca41a77c66d1abc27a5070", size = 35801, upload-time = "2025-09-05T12:50:38.314Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/e3/54b496ac724e60e61cc3447f02690105901ca6d90da0377dffe49ff99fc7/setproctitle-1.3.7-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:1fae595d032b30dab4d659bece20debd202229fce12b55abab978b7f30783d73", size = 33958, upload-time = "2025-09-05T12:50:39.841Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/a8/c84bb045ebf8c6fdc7f7532319e86f8380d14bbd3084e6348df56bdfe6fd/setproctitle-1.3.7-cp314-cp314t-win32.whl", hash = "sha256:02432f26f5d1329ab22279ff863c83589894977063f59e6c4b4845804a08f8c2", size = 12745, upload-time = "2025-09-05T12:50:41.377Z" },
+    { url = "https://files.pythonhosted.org/packages/08/b6/3a5a4f9952972791a9114ac01dfc123f0df79903577a3e0a7a404a695586/setproctitle-1.3.7-cp314-cp314t-win_amd64.whl", hash = "sha256:cbc388e3d86da1f766d8fc2e12682e446064c01cea9f88a88647cfe7c011de6a", size = 13469, upload-time = "2025-09-05T12:50:42.67Z" },
+]
+
 [[package]]
 name = "setuptools"
-version = "82.0.1"
+version = "80.10.2"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/4f/db/cfac1baf10650ab4d1c111714410d2fbb77ac5a616db26775db562c8fab2/setuptools-82.0.1.tar.gz", hash = "sha256:7d872682c5d01cfde07da7bccc7b65469d3dca203318515ada1de5eda35efbf9", size = 1152316, upload-time = "2026-03-09T12:47:17.221Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/76/95/faf61eb8363f26aa7e1d762267a8d602a1b26d4f3a1e758e92cb3cb8b054/setuptools-80.10.2.tar.gz", hash = "sha256:8b0e9d10c784bf7d262c4e5ec5d4ec94127ce206e8738f29a437945fbc219b70", size = 1200343, upload-time = "2026-01-25T22:38:17.252Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/9d/76/f789f7a86709c6b087c5a2f52f911838cad707cc613162401badc665acfe/setuptools-82.0.1-py3-none-any.whl", hash = "sha256:a59e362652f08dcd477c78bb6e7bd9d80a7995bc73ce773050228a348ce2e5bb", size = 1006223, upload-time = "2026-03-09T12:47:15.026Z" },
+    { url = "https://files.pythonhosted.org/packages/94/b8/f1f62a5e3c0ad2ff1d189590bfa4c46b4f3b6e49cef6f26c6ee4e575394d/setuptools-80.10.2-py3-none-any.whl", hash = "sha256:95b30ddfb717250edb492926c92b5221f7ef3fbcc2b07579bcd4a27da21d0173", size = 1064234, upload-time = "2026-01-25T22:38:15.216Z" },
 ]
 
 [[package]]
@@ -5108,15 +6572,15 @@ wheels = [
 
 [[package]]
 name = "starlette"
-version = "1.0.0"
+version = "0.52.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "anyio" },
     { name = "typing-extensions", marker = "python_full_version < '3.13'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/81/69/17425771797c36cded50b7fe44e850315d039f28b15901ab44839e70b593/starlette-1.0.0.tar.gz", hash = "sha256:6a4beaf1f81bb472fd19ea9b918b50dc3a77a6f2e190a12954b25e6ed5eea149", size = 2655289, upload-time = "2026-03-22T18:29:46.779Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/c4/68/79977123bb7be889ad680d79a40f339082c1978b5cfcf62c2d8d196873ac/starlette-0.52.1.tar.gz", hash = "sha256:834edd1b0a23167694292e94f597773bc3f89f362be6effee198165a35d62933", size = 2653702, upload-time = "2026-01-18T13:34:11.062Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/0b/c9/584bc9651441b4ba60cc4d557d8a547b5aff901af35bda3a4ee30c819b82/starlette-1.0.0-py3-none-any.whl", hash = "sha256:d3ec55e0bb321692d275455ddfd3df75fff145d009685eb40dc91fc66b03d38b", size = 72651, upload-time = "2026-03-22T18:29:45.111Z" },
+    { url = "https://files.pythonhosted.org/packages/81/0d/13d1d239a25cbfb19e740db83143e95c772a1fe10202dda4b76792b114dd/starlette-0.52.1-py3-none-any.whl", hash = "sha256:0029d43eb3d273bc4f83a08720b4912ea4b071087a3b48db01b7c839f7954d74", size = 74272, upload-time = "2026-01-18T13:34:09.188Z" },
 ]
 
 [[package]]
@@ -5148,6 +6612,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/dc/e6/412c1e1f200ca8c32ecf10201839183e261ad61ced3ede34a66f6d4be3cf/streamlit-1.55.0-py3-none-any.whl", hash = "sha256:1e4a16449c6131696180f4ddb40ea8c51834e89c2a43e1b0362bc9b1cfd9b415", size = 9075714, upload-time = "2026-03-03T22:25:59.126Z" },
 ]
 
+[[package]]
+name = "supervisor"
+version = "4.3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/a9/b5/37e7a3706de436a8a2d75334711dad1afb4ddffab09f25e31d89e467542f/supervisor-4.3.0.tar.gz", hash = "sha256:4a2bf149adf42997e1bb44b70c43b613275ec9852c3edacca86a9166b27e945e", size = 468912, upload-time = "2025-08-23T18:25:02.418Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0e/65/5e726c372da8a5e35022a94388b12252710aad0c2351699c3d76ae8dba78/supervisor-4.3.0-py2.py3-none-any.whl", hash = "sha256:0bcb763fddafba410f35cbde226aa7f8514b9fb82eb05a0c85f6588d1c13f8db", size = 320736, upload-time = "2025-08-23T18:25:00.767Z" },
+]
+
 [[package]]
 name = "sympy"
 version = "1.14.0"
@@ -5160,6 +6633,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/a2/09/77d55d46fd61b4a135c444fc97158ef34a095e5681d0a6c10b75bf356191/sympy-1.14.0-py3-none-any.whl", hash = "sha256:e091cc3e99d2141a0ba2847328f5479b05d94a6635cb96148ccb3f34671bd8f5", size = 6299353, upload-time = "2025-04-27T18:04:59.103Z" },
 ]
 
+[[package]]
+name = "tabulate"
+version = "0.10.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/46/58/8c37dea7bbf769b20d58e7ace7e5edfe65b849442b00ffcdd56be88697c6/tabulate-0.10.0.tar.gz", hash = "sha256:e2cfde8f79420f6deeffdeda9aaec3b6bc5abce947655d17ac662b126e48a60d", size = 91754, upload-time = "2026-03-04T18:55:34.402Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/99/55/db07de81b5c630da5cbf5c7df646580ca26dfaefa593667fc6f2fe016d2e/tabulate-0.10.0-py3-none-any.whl", hash = "sha256:f0b0622e567335c8fabaaa659f1b33bcb6ddfe2e496071b743aa113f8774f2d3", size = 39814, upload-time = "2026-03-04T18:55:31.284Z" },
+]
+
 [[package]]
 name = "tenacity"
 version = "9.1.4"
@@ -5192,6 +6674,53 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/32/d5/f9a850d79b0851d1d4ef6456097579a9005b31fea68726a4ae5f2d82ddd9/threadpoolctl-3.6.0-py3-none-any.whl", hash = "sha256:43a0b8fd5a2928500110039e43a5eed8480b918967083ea48dc3ab9f13c4a7fb", size = 18638, upload-time = "2025-03-13T13:49:21.846Z" },
 ]
 
+[[package]]
+name = "tiktoken"
+version = "0.12.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "regex" },
+    { name = "requests" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/7d/ab/4d017d0f76ec3171d469d80fc03dfbb4e48a4bcaddaa831b31d526f05edc/tiktoken-0.12.0.tar.gz", hash = "sha256:b18ba7ee2b093863978fcb14f74b3707cdc8d4d4d3836853ce7ec60772139931", size = 37806, upload-time = "2025-10-06T20:22:45.419Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a4/85/be65d39d6b647c79800fd9d29241d081d4eeb06271f383bb87200d74cf76/tiktoken-0.12.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:b97f74aca0d78a1ff21b8cd9e9925714c15a9236d6ceacf5c7327c117e6e21e8", size = 1050728, upload-time = "2025-10-06T20:21:52.756Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/42/6573e9129bc55c9bf7300b3a35bef2c6b9117018acca0dc760ac2d93dffe/tiktoken-0.12.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:2b90f5ad190a4bb7c3eb30c5fa32e1e182ca1ca79f05e49b448438c3e225a49b", size = 994049, upload-time = "2025-10-06T20:21:53.782Z" },
+    { url = "https://files.pythonhosted.org/packages/66/c5/ed88504d2f4a5fd6856990b230b56d85a777feab84e6129af0822f5d0f70/tiktoken-0.12.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:65b26c7a780e2139e73acc193e5c63ac754021f160df919add909c1492c0fb37", size = 1129008, upload-time = "2025-10-06T20:21:54.832Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/90/3dae6cc5436137ebd38944d396b5849e167896fc2073da643a49f372dc4f/tiktoken-0.12.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:edde1ec917dfd21c1f2f8046b86348b0f54a2c0547f68149d8600859598769ad", size = 1152665, upload-time = "2025-10-06T20:21:56.129Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/fe/26df24ce53ffde419a42f5f53d755b995c9318908288c17ec3f3448313a3/tiktoken-0.12.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:35a2f8ddd3824608b3d650a000c1ef71f730d0c56486845705a8248da00f9fe5", size = 1194230, upload-time = "2025-10-06T20:21:57.546Z" },
+    { url = "https://files.pythonhosted.org/packages/20/cc/b064cae1a0e9fac84b0d2c46b89f4e57051a5f41324e385d10225a984c24/tiktoken-0.12.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:83d16643edb7fa2c99eff2ab7733508aae1eebb03d5dfc46f5565862810f24e3", size = 1254688, upload-time = "2025-10-06T20:21:58.619Z" },
+    { url = "https://files.pythonhosted.org/packages/81/10/b8523105c590c5b8349f2587e2fdfe51a69544bd5a76295fc20f2374f470/tiktoken-0.12.0-cp312-cp312-win_amd64.whl", hash = "sha256:ffc5288f34a8bc02e1ea7047b8d041104791d2ddbf42d1e5fa07822cbffe16bd", size = 878694, upload-time = "2025-10-06T20:21:59.876Z" },
+    { url = "https://files.pythonhosted.org/packages/00/61/441588ee21e6b5cdf59d6870f86beb9789e532ee9718c251b391b70c68d6/tiktoken-0.12.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:775c2c55de2310cc1bc9a3ad8826761cbdc87770e586fd7b6da7d4589e13dab3", size = 1050802, upload-time = "2025-10-06T20:22:00.96Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/05/dcf94486d5c5c8d34496abe271ac76c5b785507c8eae71b3708f1ad9b45a/tiktoken-0.12.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:a01b12f69052fbe4b080a2cfb867c4de12c704b56178edf1d1d7b273561db160", size = 993995, upload-time = "2025-10-06T20:22:02.788Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/70/5163fe5359b943f8db9946b62f19be2305de8c3d78a16f629d4165e2f40e/tiktoken-0.12.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:01d99484dc93b129cd0964f9d34eee953f2737301f18b3c7257bf368d7615baa", size = 1128948, upload-time = "2025-10-06T20:22:03.814Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/da/c028aa0babf77315e1cef357d4d768800c5f8a6de04d0eac0f377cb619fa/tiktoken-0.12.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:4a1a4fcd021f022bfc81904a911d3df0f6543b9e7627b51411da75ff2fe7a1be", size = 1151986, upload-time = "2025-10-06T20:22:05.173Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/5a/886b108b766aa53e295f7216b509be95eb7d60b166049ce2c58416b25f2a/tiktoken-0.12.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:981a81e39812d57031efdc9ec59fa32b2a5a5524d20d4776574c4b4bd2e9014a", size = 1194222, upload-time = "2025-10-06T20:22:06.265Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/f8/4db272048397636ac7a078d22773dd2795b1becee7bc4922fe6207288d57/tiktoken-0.12.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9baf52f84a3f42eef3ff4e754a0db79a13a27921b457ca9832cf944c6be4f8f3", size = 1255097, upload-time = "2025-10-06T20:22:07.403Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/32/45d02e2e0ea2be3a9ed22afc47d93741247e75018aac967b713b2941f8ea/tiktoken-0.12.0-cp313-cp313-win_amd64.whl", hash = "sha256:b8a0cd0c789a61f31bf44851defbd609e8dd1e2c8589c614cc1060940ef1f697", size = 879117, upload-time = "2025-10-06T20:22:08.418Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/76/994fc868f88e016e6d05b0da5ac24582a14c47893f4474c3e9744283f1d5/tiktoken-0.12.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:d5f89ea5680066b68bcb797ae85219c72916c922ef0fcdd3480c7d2315ffff16", size = 1050309, upload-time = "2025-10-06T20:22:10.939Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/b8/57ef1456504c43a849821920d582a738a461b76a047f352f18c0b26c6516/tiktoken-0.12.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:b4e7ed1c6a7a8a60a3230965bdedba8cc58f68926b835e519341413370e0399a", size = 993712, upload-time = "2025-10-06T20:22:12.115Z" },
+    { url = "https://files.pythonhosted.org/packages/72/90/13da56f664286ffbae9dbcfadcc625439142675845baa62715e49b87b68b/tiktoken-0.12.0-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:fc530a28591a2d74bce821d10b418b26a094bf33839e69042a6e86ddb7a7fb27", size = 1128725, upload-time = "2025-10-06T20:22:13.541Z" },
+    { url = "https://files.pythonhosted.org/packages/05/df/4f80030d44682235bdaecd7346c90f67ae87ec8f3df4a3442cb53834f7e4/tiktoken-0.12.0-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:06a9f4f49884139013b138920a4c393aa6556b2f8f536345f11819389c703ebb", size = 1151875, upload-time = "2025-10-06T20:22:14.559Z" },
+    { url = "https://files.pythonhosted.org/packages/22/1f/ae535223a8c4ef4c0c1192e3f9b82da660be9eb66b9279e95c99288e9dab/tiktoken-0.12.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:04f0e6a985d95913cabc96a741c5ffec525a2c72e9df086ff17ebe35985c800e", size = 1194451, upload-time = "2025-10-06T20:22:15.545Z" },
+    { url = "https://files.pythonhosted.org/packages/78/a7/f8ead382fce0243cb625c4f266e66c27f65ae65ee9e77f59ea1653b6d730/tiktoken-0.12.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:0ee8f9ae00c41770b5f9b0bb1235474768884ae157de3beb5439ca0fd70f3e25", size = 1253794, upload-time = "2025-10-06T20:22:16.624Z" },
+    { url = "https://files.pythonhosted.org/packages/93/e0/6cc82a562bc6365785a3ff0af27a2a092d57c47d7a81d9e2295d8c36f011/tiktoken-0.12.0-cp313-cp313t-win_amd64.whl", hash = "sha256:dc2dd125a62cb2b3d858484d6c614d136b5b848976794edfb63688d539b8b93f", size = 878777, upload-time = "2025-10-06T20:22:18.036Z" },
+    { url = "https://files.pythonhosted.org/packages/72/05/3abc1db5d2c9aadc4d2c76fa5640134e475e58d9fbb82b5c535dc0de9b01/tiktoken-0.12.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:a90388128df3b3abeb2bfd1895b0681412a8d7dc644142519e6f0a97c2111646", size = 1050188, upload-time = "2025-10-06T20:22:19.563Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/7b/50c2f060412202d6c95f32b20755c7a6273543b125c0985d6fa9465105af/tiktoken-0.12.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:da900aa0ad52247d8794e307d6446bd3cdea8e192769b56276695d34d2c9aa88", size = 993978, upload-time = "2025-10-06T20:22:20.702Z" },
+    { url = "https://files.pythonhosted.org/packages/14/27/bf795595a2b897e271771cd31cb847d479073497344c637966bdf2853da1/tiktoken-0.12.0-cp314-cp314-manylinux_2_28_aarch64.whl", hash = "sha256:285ba9d73ea0d6171e7f9407039a290ca77efcdb026be7769dccc01d2c8d7fff", size = 1129271, upload-time = "2025-10-06T20:22:22.06Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/de/9341a6d7a8f1b448573bbf3425fa57669ac58258a667eb48a25dfe916d70/tiktoken-0.12.0-cp314-cp314-manylinux_2_28_x86_64.whl", hash = "sha256:d186a5c60c6a0213f04a7a802264083dea1bbde92a2d4c7069e1a56630aef830", size = 1151216, upload-time = "2025-10-06T20:22:23.085Z" },
+    { url = "https://files.pythonhosted.org/packages/75/0d/881866647b8d1be4d67cb24e50d0c26f9f807f994aa1510cb9ba2fe5f612/tiktoken-0.12.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:604831189bd05480f2b885ecd2d1986dc7686f609de48208ebbbddeea071fc0b", size = 1194860, upload-time = "2025-10-06T20:22:24.602Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/1e/b651ec3059474dab649b8d5b69f5c65cd8fcd8918568c1935bd4136c9392/tiktoken-0.12.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:8f317e8530bb3a222547b85a58583238c8f74fd7a7408305f9f63246d1a0958b", size = 1254567, upload-time = "2025-10-06T20:22:25.671Z" },
+    { url = "https://files.pythonhosted.org/packages/80/57/ce64fd16ac390fafde001268c364d559447ba09b509181b2808622420eec/tiktoken-0.12.0-cp314-cp314-win_amd64.whl", hash = "sha256:399c3dd672a6406719d84442299a490420b458c44d3ae65516302a99675888f3", size = 921067, upload-time = "2025-10-06T20:22:26.753Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/a4/72eed53e8976a099539cdd5eb36f241987212c29629d0a52c305173e0a68/tiktoken-0.12.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:c2c714c72bc00a38ca969dae79e8266ddec999c7ceccd603cc4f0d04ccd76365", size = 1050473, upload-time = "2025-10-06T20:22:27.775Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/d7/0110b8f54c008466b19672c615f2168896b83706a6611ba6e47313dbc6e9/tiktoken-0.12.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:cbb9a3ba275165a2cb0f9a83f5d7025afe6b9d0ab01a22b50f0e74fee2ad253e", size = 993855, upload-time = "2025-10-06T20:22:28.799Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/77/4f268c41a3957c418b084dd576ea2fad2e95da0d8e1ab705372892c2ca22/tiktoken-0.12.0-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:dfdfaa5ffff8993a3af94d1125870b1d27aed7cb97aa7eb8c1cefdbc87dbee63", size = 1129022, upload-time = "2025-10-06T20:22:29.981Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/2b/fc46c90fe5028bd094cd6ee25a7db321cb91d45dc87531e2bdbb26b4867a/tiktoken-0.12.0-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:584c3ad3d0c74f5269906eb8a659c8bfc6144a52895d9261cdaf90a0ae5f4de0", size = 1150736, upload-time = "2025-10-06T20:22:30.996Z" },
+    { url = "https://files.pythonhosted.org/packages/28/c0/3c7a39ff68022ddfd7d93f3337ad90389a342f761c4d71de99a3ccc57857/tiktoken-0.12.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:54c891b416a0e36b8e2045b12b33dd66fb34a4fe7965565f1b482da50da3e86a", size = 1194908, upload-time = "2025-10-06T20:22:32.073Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/0d/c1ad6f4016a3968c048545f5d9b8ffebf577774b2ede3e2e352553b685fe/tiktoken-0.12.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:5edb8743b88d5be814b1a8a8854494719080c28faaa1ccbef02e87354fe71ef0", size = 1253706, upload-time = "2025-10-06T20:22:33.385Z" },
+    { url = "https://files.pythonhosted.org/packages/af/df/c7891ef9d2712ad774777271d39fdef63941ffba0a9d59b7ad1fd2765e57/tiktoken-0.12.0-cp314-cp314t-win_amd64.whl", hash = "sha256:f61c0aea5565ac82e2ec50a05e02a6c44734e91b51c10510b084ea1b8e633a71", size = 920667, upload-time = "2025-10-06T20:22:34.444Z" },
+]
+
 [[package]]
 name = "tinycss2"
 version = "1.4.0"
@@ -5298,6 +6827,120 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/c7/18/c86eb8e0202e32dd3df50d43d7ff9854f8e0603945ff398974c1d91ac1ef/tomli_w-1.2.0-py3-none-any.whl", hash = "sha256:188306098d013b691fcadc011abd66727d3c414c571bb01b1a174ba8c983cf90", size = 6675, upload-time = "2025-01-15T12:07:22.074Z" },
 ]
 
+[[package]]
+name = "torch"
+version = "2.9.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "filelock" },
+    { name = "fsspec" },
+    { name = "jinja2" },
+    { name = "networkx" },
+    { name = "nvidia-cublas-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
+    { name = "nvidia-cuda-cupti-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
+    { name = "nvidia-cuda-nvrtc-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
+    { name = "nvidia-cuda-runtime-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
+    { name = "nvidia-cudnn-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
+    { name = "nvidia-cufft-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
+    { name = "nvidia-cufile-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
+    { name = "nvidia-curand-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
+    { name = "nvidia-cusolver-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
+    { name = "nvidia-cusparse-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
+    { name = "nvidia-cusparselt-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
+    { name = "nvidia-nccl-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
+    { name = "nvidia-nvjitlink-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
+    { name = "nvidia-nvshmem-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
+    { name = "nvidia-nvtx-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
+    { name = "setuptools" },
+    { name = "sympy" },
+    { name = "triton", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
+    { name = "typing-extensions" },
+]
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0f/27/07c645c7673e73e53ded71705045d6cb5bae94c4b021b03aa8d03eee90ab/torch-2.9.1-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:da5f6f4d7f4940a173e5572791af238cb0b9e21b1aab592bd8b26da4c99f1cd6", size = 104126592, upload-time = "2025-11-12T15:20:41.62Z" },
+    { url = "https://files.pythonhosted.org/packages/19/17/e377a460603132b00760511299fceba4102bd95db1a0ee788da21298ccff/torch-2.9.1-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:27331cd902fb4322252657f3902adf1c4f6acad9dcad81d8df3ae14c7c4f07c4", size = 899742281, upload-time = "2025-11-12T15:22:17.602Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/1a/64f5769025db846a82567fa5b7d21dba4558a7234ee631712ee4771c436c/torch-2.9.1-cp312-cp312-win_amd64.whl", hash = "sha256:81a285002d7b8cfd3fdf1b98aa8df138d41f1a8334fd9ea37511517cedf43083", size = 110940568, upload-time = "2025-11-12T15:21:18.689Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/ab/07739fd776618e5882661d04c43f5b5586323e2f6a2d7d84aac20d8f20bd/torch-2.9.1-cp312-none-macosx_11_0_arm64.whl", hash = "sha256:c0d25d1d8e531b8343bea0ed811d5d528958f1dcbd37e7245bc686273177ad7e", size = 74479191, upload-time = "2025-11-12T15:21:25.816Z" },
+    { url = "https://files.pythonhosted.org/packages/20/60/8fc5e828d050bddfab469b3fe78e5ab9a7e53dda9c3bdc6a43d17ce99e63/torch-2.9.1-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:c29455d2b910b98738131990394da3e50eea8291dfeb4b12de71ecf1fdeb21cb", size = 104135743, upload-time = "2025-11-12T15:21:34.936Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/b7/6d3f80e6918213babddb2a37b46dbb14c15b14c5f473e347869a51f40e1f/torch-2.9.1-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:524de44cd13931208ba2c4bde9ec7741fd4ae6bfd06409a604fc32f6520c2bc9", size = 899749493, upload-time = "2025-11-12T15:24:36.356Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/47/c7843d69d6de8938c1cbb1eba426b1d48ddf375f101473d3e31a5fc52b74/torch-2.9.1-cp313-cp313-win_amd64.whl", hash = "sha256:545844cc16b3f91e08ce3b40e9c2d77012dd33a48d505aed34b7740ed627a1b2", size = 110944162, upload-time = "2025-11-12T15:21:53.151Z" },
+    { url = "https://files.pythonhosted.org/packages/28/0e/2a37247957e72c12151b33a01e4df651d9d155dd74d8cfcbfad15a79b44a/torch-2.9.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:5be4bf7496f1e3ffb1dd44b672adb1ac3f081f204c5ca81eba6442f5f634df8e", size = 74830751, upload-time = "2025-11-12T15:21:43.792Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/f7/7a18745edcd7b9ca2381aa03353647bca8aace91683c4975f19ac233809d/torch-2.9.1-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:30a3e170a84894f3652434b56d59a64a2c11366b0ed5776fab33c2439396bf9a", size = 104142929, upload-time = "2025-11-12T15:21:48.319Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/dd/f1c0d879f2863ef209e18823a988dc7a1bf40470750e3ebe927efdb9407f/torch-2.9.1-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:8301a7b431e51764629208d0edaa4f9e4c33e6df0f2f90b90e261d623df6a4e2", size = 899748978, upload-time = "2025-11-12T15:23:04.568Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/9f/6986b83a53b4d043e36f3f898b798ab51f7f20fdf1a9b01a2720f445043d/torch-2.9.1-cp313-cp313t-win_amd64.whl", hash = "sha256:2e1c42c0ae92bf803a4b2409fdfed85e30f9027a66887f5e7dcdbc014c7531db", size = 111176995, upload-time = "2025-11-12T15:22:01.618Z" },
+    { url = "https://files.pythonhosted.org/packages/40/60/71c698b466dd01e65d0e9514b5405faae200c52a76901baf6906856f17e4/torch-2.9.1-cp313-none-macosx_11_0_arm64.whl", hash = "sha256:2c14b3da5df416cf9cb5efab83aa3056f5b8cd8620b8fde81b4987ecab730587", size = 74480347, upload-time = "2025-11-12T15:21:57.648Z" },
+    { url = "https://files.pythonhosted.org/packages/48/50/c4b5112546d0d13cc9eaa1c732b823d676a9f49ae8b6f97772f795874a03/torch-2.9.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1edee27a7c9897f4e0b7c14cfc2f3008c571921134522d5b9b5ec4ebbc69041a", size = 74433245, upload-time = "2025-11-12T15:22:39.027Z" },
+    { url = "https://files.pythonhosted.org/packages/81/c9/2628f408f0518b3bae49c95f5af3728b6ab498c8624ab1e03a43dd53d650/torch-2.9.1-cp314-cp314-manylinux_2_28_aarch64.whl", hash = "sha256:19d144d6b3e29921f1fc70503e9f2fc572cde6a5115c0c0de2f7ca8b1483e8b6", size = 104134804, upload-time = "2025-11-12T15:22:35.222Z" },
+    { url = "https://files.pythonhosted.org/packages/28/fc/5bc91d6d831ae41bf6e9e6da6468f25330522e92347c9156eb3f1cb95956/torch-2.9.1-cp314-cp314-manylinux_2_28_x86_64.whl", hash = "sha256:c432d04376f6d9767a9852ea0def7b47a7bbc8e7af3b16ac9cf9ce02b12851c9", size = 899747132, upload-time = "2025-11-12T15:23:36.068Z" },
+    { url = "https://files.pythonhosted.org/packages/63/5d/e8d4e009e52b6b2cf1684bde2a6be157b96fb873732542fb2a9a99e85a83/torch-2.9.1-cp314-cp314-win_amd64.whl", hash = "sha256:d187566a2cdc726fc80138c3cdb260970fab1c27e99f85452721f7759bbd554d", size = 110934845, upload-time = "2025-11-12T15:22:48.367Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/b2/2d15a52516b2ea3f414643b8de68fa4cb220d3877ac8b1028c83dc8ca1c4/torch-2.9.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:cb10896a1f7fedaddbccc2017ce6ca9ecaaf990f0973bdfcf405439750118d2c", size = 74823558, upload-time = "2025-11-12T15:22:43.392Z" },
+    { url = "https://files.pythonhosted.org/packages/86/5c/5b2e5d84f5b9850cd1e71af07524d8cbb74cba19379800f1f9f7c997fc70/torch-2.9.1-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:0a2bd769944991c74acf0c4ef23603b9c777fdf7637f115605a4b2d8023110c7", size = 104145788, upload-time = "2025-11-12T15:23:52.109Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/8c/3da60787bcf70add986c4ad485993026ac0ca74f2fc21410bc4eb1bb7695/torch-2.9.1-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:07c8a9660bc9414c39cac530ac83b1fb1b679d7155824144a40a54f4a47bfa73", size = 899735500, upload-time = "2025-11-12T15:24:08.788Z" },
+    { url = "https://files.pythonhosted.org/packages/db/2b/f7818f6ec88758dfd21da46b6cd46af9d1b3433e53ddbb19ad1e0da17f9b/torch-2.9.1-cp314-cp314t-win_amd64.whl", hash = "sha256:c88d3299ddeb2b35dcc31753305612db485ab6f1823e37fb29451c8b2732b87e", size = 111163659, upload-time = "2025-11-12T15:23:20.009Z" },
+]
+
+[[package]]
+name = "torchaudio"
+version = "2.9.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "torch" },
+]
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f1/83/71cbadd7b66753818b5775f2088bad4f721d581de276996df4968000a626/torchaudio-2.9.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:7581ef170794c599aed55918e00d0acd9e5c9a0f19400c9a9a840955180365c5", size = 808098, upload-time = "2025-11-12T15:26:01.408Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/2d/32e8bec360459107f9b451cc1a5b6fdd5f1d3e653e65a111502084f21e3a/torchaudio-2.9.1-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:742f9d24db5f1f46d8c7e29c599fe55b866d92c4a8181fcb95eab12da225ceb0", size = 474604, upload-time = "2025-11-12T15:25:49.122Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/0d/b5af1d55ede1ca07769a2cf71256073d8958e2a5521fc734fc19f5343283/torchaudio-2.9.1-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:4533fdafba73d7bcfcb5f1225b2cc8974a290ed0fe54c44638d6f440e91b8999", size = 2059899, upload-time = "2025-11-12T15:26:19.363Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/7c/df90eb0b337cbad59296ed91778e32be069330f5186256d4ce9ea603d324/torchaudio-2.9.1-cp312-cp312-win_amd64.whl", hash = "sha256:923dccc67be4a6cbb45c3dcc2d69ee182bda75b09b69bc88cd3bcdfc739883a2", size = 665337, upload-time = "2025-11-12T15:26:07.407Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/1b/3321ad6379ac2d968064704e8d015c31ccae5d1ece070f87fb44b17d90e6/torchaudio-2.9.1-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:bb69557484c92513a980027ec4cb314b0f43cf4442bbfd97440e66528dbad22d", size = 808136, upload-time = "2025-11-12T15:26:00.276Z" },
+    { url = "https://files.pythonhosted.org/packages/76/e2/fe55b3882157fd57aa131f5bcad90f0329be90827e1c0e0c482662ddef38/torchaudio-2.9.1-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:ba2799ceec5e4373a0aa26df30d608f1eaaefd8ac4a7ae0c3446f63106f5b5a5", size = 474349, upload-time = "2025-11-12T15:26:02.78Z" },
+    { url = "https://files.pythonhosted.org/packages/74/d3/0b090c03cac5a20691507e0945589a696fb10402ccd2457eea47dbf8a71b/torchaudio-2.9.1-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:bc3c8e9a240bfad8bc61f769324a4f3ce5d60eec161369d457c595c35dbb10c7", size = 2060343, upload-time = "2025-11-12T15:26:03.88Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/db/2555cfd428f4bf09a4df1c6f9204d0acc217c46edb35776c16e7a2a9a1c9/torchaudio-2.9.1-cp313-cp313-win_amd64.whl", hash = "sha256:13ee96ea9bbbc85e198cb671273af06f010e6981d7b912d001eef6bc74e23f4f", size = 665301, upload-time = "2025-11-12T15:26:04.952Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/58/e82d8b5f447abdddc950965f1395f36baef3602643dd069100c6369ba73e/torchaudio-2.9.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:9290f6a6409deb1f9113d5aef97ec646eeee6410b6bcc57ab8b57066b54da7c1", size = 813456, upload-time = "2025-11-12T15:26:13.963Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/45/dd9ad6af9bb595095cd98028d270f933760968b92a3497282e31289ef3b4/torchaudio-2.9.1-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:eeae7ca60b64c4bfb78fbd104a089d072b151423d5d2f90da1da00787f03b800", size = 476577, upload-time = "2025-11-12T15:26:09.54Z" },
+    { url = "https://files.pythonhosted.org/packages/79/97/c49aeb01d8a9ced2b8215a38b69b8eafd1afe295a487a73b7030c6ff3396/torchaudio-2.9.1-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:5f445e896215e6f7bba497dc68aab1e6cb077ae0ab3a90095067f16df6a9bb98", size = 2062158, upload-time = "2025-11-12T15:26:10.487Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/70/30b2a0ecca2a0a5e6a8cee8952fdea3872854ea5bcd86fe3df369fdc2543/torchaudio-2.9.1-cp313-cp313t-win_amd64.whl", hash = "sha256:c558ba70d548f7491245ed7a35310f6310d83fc7591f073ab5fed9fd38cef987", size = 669253, upload-time = "2025-11-12T15:26:06.285Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/38/0dabf362f946ab5773d3db3322718d652d70ad12a82f500d54c6c8b9cc88/torchaudio-2.9.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:69a582650279ee16ff9087f99b4234fe5d766e1bf7f0be352db5f46991854c1e", size = 810496, upload-time = "2025-11-12T15:26:11.515Z" },
+    { url = "https://files.pythonhosted.org/packages/05/1c/e05a32ee6868dc05463242db672f23dba5d042423fefcf294db4dac343a8/torchaudio-2.9.1-cp314-cp314-manylinux_2_28_aarch64.whl", hash = "sha256:9c0d004f784c49078017f8217fdc901df0eb9724e50fb269b3a6c99b1d4eae75", size = 474566, upload-time = "2025-11-12T15:26:08.628Z" },
+    { url = "https://files.pythonhosted.org/packages/15/52/8cec1fe90f05b888f9060467e1eb8c27f9295b8729a83d443e3bd7c471d3/torchaudio-2.9.1-cp314-cp314-manylinux_2_28_x86_64.whl", hash = "sha256:d2743b28ff5538d5fdf2ff6657d392852ccdfe640ede46f566b2907ca32d8dca", size = 2060358, upload-time = "2025-11-12T15:26:12.885Z" },
+    { url = "https://files.pythonhosted.org/packages/04/73/6ba396813d714f895f86c82be61b590fbe14255ebe6866f5ea5916c075a3/torchaudio-2.9.1-cp314-cp314-win_amd64.whl", hash = "sha256:234c7a9d4d0a6ed735cd37965baa9a89ca36bdbebece8a6a5ff7727acbb43026", size = 665039, upload-time = "2025-11-12T15:26:18.308Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/f6/237e00a04dea497a40a8567d024dfb39193abec3ca3695ad51919ad633d1/torchaudio-2.9.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:e13cb38971ac259fc4e102282a3e48f6df5f0ab00eb785ca5155e3392d1e86f1", size = 813463, upload-time = "2025-11-12T15:26:16.261Z" },
+    { url = "https://files.pythonhosted.org/packages/57/99/5fcd46a80086030899badeb5a934fab337c88325b3f68c60faa0b672d4d2/torchaudio-2.9.1-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:35c96ed1011b50eaf17948da173b09450cdc5bb7f908687571adb4a4c072c05e", size = 476577, upload-time = "2025-11-12T15:26:17.355Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/4c/bc428f71d5ef728fba2ecb151a3a6d187e6f0b9446b76e4f87e46d2206a3/torchaudio-2.9.1-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:c220c4acf9914cce2dc81c3624d7c84008ef436dc31bcbb89e8f4416d3615a34", size = 2062170, upload-time = "2025-11-12T15:26:20.837Z" },
+    { url = "https://files.pythonhosted.org/packages/07/0e/be41f412e1225bdbd9b7fd7f41a20f070c707f5274b82542eeccf6dc2b79/torchaudio-2.9.1-cp314-cp314t-win_amd64.whl", hash = "sha256:cfd12934c7b54b41d4c79dfd26fbfe88fafa9cc5cc77c074e953bb7018d9322c", size = 669265, upload-time = "2025-11-12T15:26:14.976Z" },
+]
+
+[[package]]
+name = "torchvision"
+version = "0.24.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "numpy" },
+    { name = "pillow" },
+    { name = "torch" },
+]
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f0/af/18e2c6b9538a045f60718a0c5a058908ccb24f88fde8e6f0fc12d5ff7bd3/torchvision-0.24.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:e48bf6a8ec95872eb45763f06499f87bd2fb246b9b96cb00aae260fda2f96193", size = 1891433, upload-time = "2025-11-12T15:25:03.232Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/43/600e5cfb0643d10d633124f5982d7abc2170dfd7ce985584ff16edab3e76/torchvision-0.24.1-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:7fb7590c737ebe3e1c077ad60c0e5e2e56bb26e7bccc3b9d04dbfc34fd09f050", size = 2386737, upload-time = "2025-11-12T15:25:08.288Z" },
+    { url = "https://files.pythonhosted.org/packages/93/b1/db2941526ecddd84884132e2742a55c9311296a6a38627f9e2627f5ac889/torchvision-0.24.1-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:66a98471fc18cad9064123106d810a75f57f0838eee20edc56233fd8484b0cc7", size = 8049868, upload-time = "2025-11-12T15:25:13.058Z" },
+    { url = "https://files.pythonhosted.org/packages/69/98/16e583f59f86cd59949f59d52bfa8fc286f86341a229a9d15cbe7a694f0c/torchvision-0.24.1-cp312-cp312-win_amd64.whl", hash = "sha256:4aa6cb806eb8541e92c9b313e96192c6b826e9eb0042720e2fa250d021079952", size = 4302006, upload-time = "2025-11-12T15:25:16.184Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/97/ab40550f482577f2788304c27220e8ba02c63313bd74cf2f8920526aac20/torchvision-0.24.1-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:8a6696db7fb71eadb2c6a48602106e136c785642e598eb1533e0b27744f2cce6", size = 1891435, upload-time = "2025-11-12T15:25:28.642Z" },
+    { url = "https://files.pythonhosted.org/packages/30/65/ac0a3f9be6abdbe4e1d82c915d7e20de97e7fd0e9a277970508b015309f3/torchvision-0.24.1-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:db2125c46f9cb25dc740be831ce3ce99303cfe60439249a41b04fd9f373be671", size = 2338718, upload-time = "2025-11-12T15:25:26.19Z" },
+    { url = "https://files.pythonhosted.org/packages/10/b5/5bba24ff9d325181508501ed7f0c3de8ed3dd2edca0784d48b144b6c5252/torchvision-0.24.1-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:f035f0cacd1f44a8ff6cb7ca3627d84c54d685055961d73a1a9fb9827a5414c8", size = 8049661, upload-time = "2025-11-12T15:25:22.558Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/ec/54a96ae9ab6a0dd66d4bba27771f892e36478a9c3489fa56e51c70abcc4d/torchvision-0.24.1-cp313-cp313-win_amd64.whl", hash = "sha256:16274823b93048e0a29d83415166a2e9e0bf4e1b432668357b657612a4802864", size = 4319808, upload-time = "2025-11-12T15:25:17.318Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/f3/a90a389a7e547f3eb8821b13f96ea7c0563cdefbbbb60a10e08dda9720ff/torchvision-0.24.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:e3f96208b4bef54cd60e415545f5200346a65024e04f29a26cd0006dbf9e8e66", size = 2005342, upload-time = "2025-11-12T15:25:11.871Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/fe/ff27d2ed1b524078164bea1062f23d2618a5fc3208e247d6153c18c91a76/torchvision-0.24.1-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:f231f6a4f2aa6522713326d0d2563538fa72d613741ae364f9913027fa52ea35", size = 2341708, upload-time = "2025-11-12T15:25:25.08Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/b9/d6c903495cbdfd2533b3ef6f7b5643ff589ea062f8feb5c206ee79b9d9e5/torchvision-0.24.1-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:1540a9e7f8cf55fe17554482f5a125a7e426347b71de07327d5de6bfd8d17caa", size = 8177239, upload-time = "2025-11-12T15:25:18.554Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/2b/ba02e4261369c3798310483028495cf507e6cb3f394f42e4796981ecf3a7/torchvision-0.24.1-cp313-cp313t-win_amd64.whl", hash = "sha256:d83e16d70ea85d2f196d678bfb702c36be7a655b003abed84e465988b6128938", size = 4251604, upload-time = "2025-11-12T15:25:34.069Z" },
+    { url = "https://files.pythonhosted.org/packages/42/84/577b2cef8f32094add5f52887867da4c2a3e6b4261538447e9b48eb25812/torchvision-0.24.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:cccf4b4fec7fdfcd3431b9ea75d1588c0a8596d0333245dafebee0462abe3388", size = 2005319, upload-time = "2025-11-12T15:25:23.827Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/34/ecb786bffe0159a3b49941a61caaae089853132f3cd1e8f555e3621f7e6f/torchvision-0.24.1-cp314-cp314-manylinux_2_28_aarch64.whl", hash = "sha256:1b495edd3a8f9911292424117544f0b4ab780452e998649425d1f4b2bed6695f", size = 2338844, upload-time = "2025-11-12T15:25:32.625Z" },
+    { url = "https://files.pythonhosted.org/packages/51/99/a84623786a6969504c87f2dc3892200f586ee13503f519d282faab0bb4f0/torchvision-0.24.1-cp314-cp314-manylinux_2_28_x86_64.whl", hash = "sha256:ab211e1807dc3e53acf8f6638df9a7444c80c0ad050466e8d652b3e83776987b", size = 8175144, upload-time = "2025-11-12T15:25:31.355Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/ba/8fae3525b233e109317ce6a9c1de922ab2881737b029a7e88021f81e068f/torchvision-0.24.1-cp314-cp314-win_amd64.whl", hash = "sha256:18f9cb60e64b37b551cd605a3d62c15730c086362b40682d23e24b616a697d41", size = 4234459, upload-time = "2025-11-12T15:25:19.859Z" },
+    { url = "https://files.pythonhosted.org/packages/50/33/481602c1c72d0485d4b3a6b48c9534b71c2957c9d83bf860eb837bf5a620/torchvision-0.24.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:ec9d7379c519428395e4ffda4dbb99ec56be64b0a75b95989e00f9ec7ae0b2d7", size = 2005336, upload-time = "2025-11-12T15:25:27.225Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/7f/372de60bf3dd8f5593bd0d03f4aecf0d1fd58f5bc6943618d9d913f5e6d5/torchvision-0.24.1-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:af9201184c2712d808bd4eb656899011afdfce1e83721c7cb08000034df353fe", size = 2341704, upload-time = "2025-11-12T15:25:29.857Z" },
+    { url = "https://files.pythonhosted.org/packages/36/9b/0f3b9ff3d0225ee2324ec663de0e7fb3eb855615ca958ac1875f22f1f8e5/torchvision-0.24.1-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:9ef95d819fd6df81bc7cc97b8f21a15d2c0d3ac5dbfaab5cbc2d2ce57114b19e", size = 8177422, upload-time = "2025-11-12T15:25:37.357Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/ab/e2bcc7c2f13d882a58f8b30ff86f794210b075736587ea50f8c545834f8a/torchvision-0.24.1-cp314-cp314t-win_amd64.whl", hash = "sha256:480b271d6edff83ac2e8d69bbb4cf2073f93366516a50d48f140ccfceedb002e", size = 4335190, upload-time = "2025-11-12T15:25:35.745Z" },
+]
+
 [[package]]
 name = "tornado"
 version = "6.5.5"
@@ -5338,22 +6981,35 @@ wheels = [
 
 [[package]]
 name = "transformers"
-version = "5.3.0"
+version = "4.57.6"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
+    { name = "filelock" },
     { name = "huggingface-hub" },
     { name = "numpy" },
     { name = "packaging" },
     { name = "pyyaml" },
     { name = "regex" },
+    { name = "requests" },
     { name = "safetensors" },
     { name = "tokenizers" },
     { name = "tqdm" },
-    { name = "typer" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/fc/1a/70e830d53ecc96ce69cfa8de38f163712d2b43ac52fbd743f39f56025c31/transformers-5.3.0.tar.gz", hash = "sha256:009555b364029da9e2946d41f1c5de9f15e6b1df46b189b7293f33a161b9c557", size = 8830831, upload-time = "2026-03-04T17:41:46.119Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/c4/35/67252acc1b929dc88b6602e8c4a982e64f31e733b804c14bc24b47da35e6/transformers-4.57.6.tar.gz", hash = "sha256:55e44126ece9dc0a291521b7e5492b572e6ef2766338a610b9ab5afbb70689d3", size = 10134912, upload-time = "2026-01-16T10:38:39.284Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/03/b8/e484ef633af3887baeeb4b6ad12743363af7cce68ae51e938e00aaa0529d/transformers-4.57.6-py3-none-any.whl", hash = "sha256:4c9e9de11333ddfe5114bc872c9f370509198acf0b87a832a0ab9458e2bd0550", size = 11993498, upload-time = "2026-01-16T10:38:31.289Z" },
+]
+
+[[package]]
+name = "triton"
+version = "3.5.1"
+source = { registry = "https://pypi.org/simple" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b8/88/ae8320064e32679a5429a2c9ebbc05c2bf32cefb6e076f9b07f6d685a9b4/transformers-5.3.0-py3-none-any.whl", hash = "sha256:50ac8c89c3c7033444fb3f9f53138096b997ebb70d4b5e50a2e810bf12d3d29a", size = 10661827, upload-time = "2026-03-04T17:41:42.722Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/50/9a8358d3ef58162c0a415d173cfb45b67de60176e1024f71fbc4d24c0b6d/triton-3.5.1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d2c6b915a03888ab931a9fd3e55ba36785e1fe70cbea0b40c6ef93b20fc85232", size = 170470207, upload-time = "2025-11-11T17:41:00.253Z" },
+    { url = "https://files.pythonhosted.org/packages/27/46/8c3bbb5b0a19313f50edcaa363b599e5a1a5ac9683ead82b9b80fe497c8d/triton-3.5.1-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f3f4346b6ebbd4fad18773f5ba839114f4826037c9f2f34e0148894cd5dd3dba", size = 170470410, upload-time = "2025-11-11T17:41:06.319Z" },
+    { url = "https://files.pythonhosted.org/packages/37/92/e97fcc6b2c27cdb87ce5ee063d77f8f26f19f06916aa680464c8104ef0f6/triton-3.5.1-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0b4d2c70127fca6a23e247f9348b8adde979d2e7a20391bfbabaac6aebc7e6a8", size = 170579924, upload-time = "2025-11-11T17:41:12.455Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/e6/c595c35e5c50c4bc56a7bac96493dad321e9e29b953b526bbbe20f9911d0/triton-3.5.1-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d0637b1efb1db599a8e9dc960d53ab6e4637db7d4ab6630a0974705d77b14b60", size = 170480488, upload-time = "2025-11-11T17:41:18.222Z" },
+    { url = "https://files.pythonhosted.org/packages/16/b5/b0d3d8b901b6a04ca38df5e24c27e53afb15b93624d7fd7d658c7cd9352a/triton-3.5.1-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bac7f7d959ad0f48c0e97d6643a1cc0fd5786fe61cb1f83b537c6b2d54776478", size = 170582192, upload-time = "2025-11-11T17:41:23.963Z" },
 ]
 
 [[package]]
@@ -5515,6 +7171,78 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/6a/2a/dc2228b2888f51192c7dc766106cd475f1b768c10caaf9727659726f7391/virtualenv-20.36.1-py3-none-any.whl", hash = "sha256:575a8d6b124ef88f6f51d56d656132389f961062a9177016a50e4f507bbcc19f", size = 6008258, upload-time = "2026-01-09T18:20:59.425Z" },
 ]
 
+[[package]]
+name = "vllm"
+version = "0.14.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "aiohttp" },
+    { name = "anthropic" },
+    { name = "blake3" },
+    { name = "cachetools" },
+    { name = "cbor2" },
+    { name = "cloudpickle" },
+    { name = "compressed-tensors" },
+    { name = "depyf" },
+    { name = "diskcache" },
+    { name = "einops" },
+    { name = "fastapi", extra = ["standard"] },
+    { name = "filelock" },
+    { name = "flashinfer-python" },
+    { name = "gguf" },
+    { name = "grpcio" },
+    { name = "grpcio-reflection" },
+    { name = "ijson" },
+    { name = "lark" },
+    { name = "llguidance", marker = "platform_machine == 'aarch64' or platform_machine == 'arm64' or platform_machine == 'ppc64le' or platform_machine == 's390x' or platform_machine == 'x86_64'" },
+    { name = "lm-format-enforcer" },
+    { name = "mcp" },
+    { name = "mistral-common", extra = ["image"] },
+    { name = "model-hosting-container-standards" },
+    { name = "msgspec" },
+    { name = "ninja" },
+    { name = "numba" },
+    { name = "numpy" },
+    { name = "openai" },
+    { name = "openai-harmony" },
+    { name = "opencv-python-headless" },
+    { name = "outlines-core" },
+    { name = "partial-json-parser" },
+    { name = "pillow" },
+    { name = "prometheus-client" },
+    { name = "prometheus-fastapi-instrumentator" },
+    { name = "protobuf" },
+    { name = "psutil" },
+    { name = "py-cpuinfo" },
+    { name = "pybase64" },
+    { name = "pydantic" },
+    { name = "python-json-logger" },
+    { name = "pyyaml" },
+    { name = "pyzmq" },
+    { name = "ray", extra = ["cgraph"] },
+    { name = "regex" },
+    { name = "requests" },
+    { name = "sentencepiece" },
+    { name = "setproctitle" },
+    { name = "setuptools" },
+    { name = "six" },
+    { name = "tiktoken" },
+    { name = "tokenizers" },
+    { name = "torch" },
+    { name = "torchaudio" },
+    { name = "torchvision" },
+    { name = "tqdm" },
+    { name = "transformers" },
+    { name = "typing-extensions" },
+    { name = "watchfiles" },
+    { name = "xgrammar", marker = "platform_machine == 'aarch64' or platform_machine == 'arm64' or platform_machine == 'ppc64le' or platform_machine == 's390x' or platform_machine == 'x86_64'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/01/fd/abb7391e8cb5cb729ae770946b4f61b9e9b56bac8805e7baeaed651378d5/vllm-0.14.0.tar.gz", hash = "sha256:ed86c6a9d22fbfd059648794493cad88444c71688f3ff6efcb26c5ca353f0e5d", size = 19690728, upload-time = "2026-01-20T10:55:03.658Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e6/8a/bfaac90c55be0f3144bc870c39e36c5c2571f68788e7bbf8a83c6cc70bbf/vllm-0.14.0-cp38-abi3-manylinux_2_31_aarch64.whl", hash = "sha256:f4684881e3677b69d731494c68ad0525588b02cad556c5d5aef4f7eba9368c86", size = 448040411, upload-time = "2026-01-20T10:50:00.177Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/06/36d927bf262d5a180739218e69a4122325dc63c9baf33297e5f0322df9fc/vllm-0.14.0-cp38-abi3-manylinux_2_31_x86_64.whl", hash = "sha256:9362cadde2cd1329a0c4a0ea9eace233d79576b3d6f5648b854922b2a2554a01", size = 495377847, upload-time = "2026-01-20T10:50:29.898Z" },
+]
+
 [[package]]
 name = "watchdog"
 version = "6.0.0"
@@ -5699,6 +7427,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/3f/0e/fa3b193432cfc60c93b42f3be03365f5f909d2b3ea410295cf36df739e31/widgetsnbextension-4.0.15-py3-none-any.whl", hash = "sha256:8156704e4346a571d9ce73b84bee86a29906c9abfd7223b7228a28899ccf3366", size = 2196503, upload-time = "2025-11-01T21:15:53.565Z" },
 ]
 
+[[package]]
+name = "win32-setctime"
+version = "1.2.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/b3/8f/705086c9d734d3b663af0e9bb3d4de6578d08f46b1b101c2442fd9aecaa2/win32_setctime-1.2.0.tar.gz", hash = "sha256:ae1fdf948f5640aae05c511ade119313fb6a30d7eabe25fef9764dca5873c4c0", size = 4867, upload-time = "2024-12-07T15:28:28.314Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e1/07/c6fe3ad3e685340704d314d765b7912993bcb8dc198f0e7a89382d37974b/win32_setctime-1.2.0-py3-none-any.whl", hash = "sha256:95d644c4e708aba81dc3704a116d8cbc974d70b3bdb8be1d150e36be6e9d1390", size = 4083, upload-time = "2024-12-07T15:28:26.465Z" },
+]
+
 [[package]]
 name = "wrapt"
 version = "1.17.3"
@@ -5748,6 +7485,31 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/1f/f6/a933bd70f98e9cf3e08167fc5cd7aaaca49147e48411c0bd5ae701bb2194/wrapt-1.17.3-py3-none-any.whl", hash = "sha256:7171ae35d2c33d326ac19dd8facb1e82e5fd04ef8c6c0e394d7af55a55051c22", size = 23591, upload-time = "2025-08-12T05:53:20.674Z" },
 ]
 
+[[package]]
+name = "xgrammar"
+version = "0.1.29"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "mlx-lm", marker = "platform_machine == 'arm64' and sys_platform == 'darwin'" },
+    { name = "numpy" },
+    { name = "pydantic" },
+    { name = "torch" },
+    { name = "transformers" },
+    { name = "triton", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/02/a3/70dbe3ffd331a1e7e1ad5a95690a4086e6c7cdb8089f5c7eda712219ccec/xgrammar-0.1.29.tar.gz", hash = "sha256:cf195afa81b489eebf35d4c6f37f27136d05420739ab4a6f7f065c938d7e4baa", size = 2321317, upload-time = "2025-12-19T08:23:54.53Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c1/d8/fb282fc78be6e9bbefb5cb389f66b22e4efd6ae14f06234f599651620da5/xgrammar-0.1.29-cp312-cp312-macosx_10_14_x86_64.whl", hash = "sha256:d992a3cee7594bbdaa64ae59f90da5ce21c5fe654719df3816014289ada6f04d", size = 16007376, upload-time = "2025-12-19T08:23:23.634Z" },
+    { url = "https://files.pythonhosted.org/packages/82/a7/2c9767620ee50f2f40f1eb95e55a3a29e1a0670f087ee6dc1bc1c887b906/xgrammar-0.1.29-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:1bbdf02e45cfa8614218ba01ca7952d375f8bc1c13884e3d04daa4b54180cbc2", size = 17913535, upload-time = "2025-12-19T08:23:26.02Z" },
+    { url = "https://files.pythonhosted.org/packages/57/94/18793c64bf0368075a34c06e196bf002f1e6ab0aee332268f44e8d356d5a/xgrammar-0.1.29-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6eb370a16b27a683e5f2b9e429ab41440c69977d4a504849ed61831b94cc704c", size = 34705239, upload-time = "2025-12-19T08:23:28.369Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/da/4c14e3e00be698009b52700f15326a23272b4b00475939b6acc86b151188/xgrammar-0.1.29-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:79e6e4f5cd33be77418cf91efc482f2b3d773d309891224383bc8a4948ad7b07", size = 34906135, upload-time = "2025-12-19T08:23:30.838Z" },
+    { url = "https://files.pythonhosted.org/packages/22/d8/34423997f48627cef3b74cc894d9dfcaacae02941c06237ac5f3196406a7/xgrammar-0.1.29-cp312-cp312-win_amd64.whl", hash = "sha256:39bdfadedbce34599835486164fa80ba00248c6c75ad91f3843db90ef37e037f", size = 5928381, upload-time = "2025-12-19T08:23:33.428Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/ef/8a4b4cb10fc996c0a25c9bf5613aaf5a86114291a9a4003e43605cab42bf/xgrammar-0.1.29-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:fedf21e447ef646f23a6e2d11877c0812d55965dcf8c0aa9b0f32590c9b6e22a", size = 17913609, upload-time = "2025-12-19T08:23:36.06Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/c5/e4965c9921e7bb6061f246ae7f8c7b9b1dfc21262248100c2f9b398b361e/xgrammar-0.1.29-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eb22aea775971f7d8c4d0e193257ebeb71b68acd9d36af3331ca5fd4d9a46991", size = 34904126, upload-time = "2025-12-19T08:23:38.335Z" },
+    { url = "https://files.pythonhosted.org/packages/09/26/641d7ee1a59e526aa94be980c485f899088d09dd1af517a2e1d0e85853bc/xgrammar-0.1.29-cp313-cp313-win_amd64.whl", hash = "sha256:12e6d63e892e9da8d088569dd629af58a5eafd909dc58788d499c4fd74bcd2a1", size = 5928450, upload-time = "2025-12-19T08:23:40.667Z" },
+]
+
 [[package]]
 name = "xxhash"
 version = "3.6.0"

From 9c5ceb377f22de2df1466cb5a51746fc3402b306 Mon Sep 17 00:00:00 2001
From: Aravind N <aravindn1308@outlook.com>
Date: Thu, 11 Jun 2026 15:56:28 -0400
Subject: [PATCH 10/15] chore: untrack paper artefacts, notebooks, and
 experiment scripts

Remove from git tracking (files retained locally):
- results.md, updates.md, markdown/camera_ready_metrics.md
- notebooks/analysis.ipynb, notebooks/run_pipeline.ipynb
- baselines/fix_zeroshot_scores.py, baselines/submit_zeroshot.sh
- scripts/repair_meps_v6.py, scripts/repair_meps_v7.py
- scripts/run_finmme_fixes_v{8,9,10}.sh, run_finmme_legend_grounding.sh
- scripts/submit_eval.sh, scripts/submit_pipeline.sh

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 baselines/fix_zeroshot_scores.py       | 143 ----
 baselines/submit_zeroshot.sh           |  68 --
 markdown/camera_ready_metrics.md       | 122 ----
 notebooks/analysis.ipynb               | 442 -------------
 notebooks/run_pipeline.ipynb           | 881 -------------------------
 results.md                             | 390 -----------
 scripts/repair_meps_v6.py              |  98 ---
 scripts/repair_meps_v7.py              | 101 ---
 scripts/run_finmme_fixes_v10.sh        |  31 -
 scripts/run_finmme_fixes_v8_g3flash.sh |  29 -
 scripts/run_finmme_fixes_v9.sh         |  30 -
 scripts/run_finmme_legend_grounding.sh |  22 -
 scripts/submit_eval.sh                 |  98 ---
 scripts/submit_pipeline.sh             | 147 -----
 updates.md                             | 126 ----
 15 files changed, 2728 deletions(-)
 delete mode 100644 baselines/fix_zeroshot_scores.py
 delete mode 100755 baselines/submit_zeroshot.sh
 delete mode 100644 markdown/camera_ready_metrics.md
 delete mode 100644 notebooks/analysis.ipynb
 delete mode 100644 notebooks/run_pipeline.ipynb
 delete mode 100644 results.md
 delete mode 100644 scripts/repair_meps_v6.py
 delete mode 100644 scripts/repair_meps_v7.py
 delete mode 100755 scripts/run_finmme_fixes_v10.sh
 delete mode 100755 scripts/run_finmme_fixes_v8_g3flash.sh
 delete mode 100755 scripts/run_finmme_fixes_v9.sh
 delete mode 100755 scripts/run_finmme_legend_grounding.sh
 delete mode 100755 scripts/submit_eval.sh
 delete mode 100755 scripts/submit_pipeline.sh
 delete mode 100644 updates.md

diff --git a/baselines/fix_zeroshot_scores.py b/baselines/fix_zeroshot_scores.py
deleted file mode 100644
index 5ac9301..0000000
--- a/baselines/fix_zeroshot_scores.py
+++ /dev/null
@@ -1,143 +0,0 @@
-"""Fix zero-shot metrics JSONL in-place without re-running API calls.
-
-Repairs two issues:
-  1. MCQ scoring: "c) 42%" was scored 0 against expected "C" — extract leading letter.
-  2. Truncated JSON: tries to recover answer from cut-off raw_response by closing the
-     JSON.
-
-Usage:
-    .venv/bin/python baselines/fix_zeroshot_scores.py \
-        output/baselines/metrics_chartqapro_test_zeroshot_gemini_gemini_2_5_flash.jsonl
-"""
-
-from __future__ import annotations
-
-import argparse
-import contextlib
-import json
-import re
-import shutil
-import sys
-from pathlib import Path
-
-
-_REPO_ROOT = Path(__file__).resolve().parent.parent
-if str(_REPO_ROOT / "src") not in sys.path:
-    sys.path.insert(0, str(_REPO_ROOT / "src"))
-
-from agentfinvqa.eval.eval_outputs import score_answer_accuracy  # noqa: E402
-
-
-# ---------------------------------------------------------------------------
-# Helpers
-# ---------------------------------------------------------------------------
-
-
-def _try_parse_raw(raw: str) -> str | None:
-    """Try to extract an answer from a (possibly truncated) raw JSON string."""
-    raw = raw.strip()
-    raw = re.sub(r"^\s*```(?:json)?\s*", "", raw, flags=re.IGNORECASE)
-    raw = re.sub(r"\s*```\s*$", "", raw).strip()
-
-    # Happy path
-    with contextlib.suppress(Exception):
-        return json.loads(raw).get("answer", "")
-
-    # Truncated mid-value: close the string and object
-    for suffix in ['"}', '"}}', '"}}}']:
-        with contextlib.suppress(Exception):
-            return json.loads(raw + suffix).get("answer", "")
-
-    # Extract answer field with regex as last resort
-    m = re.search(r'"answer"\s*:\s*"((?:\\.|[^"\\])*)"', raw, flags=re.DOTALL)
-    if m:
-        with contextlib.suppress(Exception):
-            return json.loads(f'"{m.group(1)}"')
-        return m.group(1)
-
-    return None
-
-
-def _normalize_mcq(predicted: str, expected: str) -> str:
-    """If expected is a single MCQ letter, strip trailing text from predicted."""
-    if not re.fullmatch(r"[A-Da-d]", expected.strip()):
-        return predicted
-    m = re.match(r"^\s*([A-Da-d])\s*[).:]?\s*", predicted.strip())
-    return m.group(1) if m else predicted
-
-
-# ---------------------------------------------------------------------------
-# Main
-# ---------------------------------------------------------------------------
-
-
-def fix_file(path: Path) -> None:
-    """Fix scoring errors in a metrics JSONL file in-place."""
-    rows = [json.loads(line) for line in path.open() if line.strip()]
-
-    reparsed = fixed_score = 0
-    out_rows = []
-
-    for row in rows:
-        raw = row.get("raw_response", "")
-        expected = row.get("expected", "")
-        old_predicted = row.get("predicted", "")
-        old_accuracy = row.get("answer_accuracy", 0.0)
-        old_parse_ok = row.get("parse_ok", False)
-        qt = row.get("question_type", "standard")
-
-        # Step 1: re-parse if truncated
-        new_predicted = old_predicted
-        new_parse_ok = old_parse_ok
-        if not old_parse_ok and raw:
-            recovered = _try_parse_raw(raw)
-            if recovered is not None:
-                new_predicted = recovered
-                new_parse_ok = True
-                reparsed += 1
-
-        # Step 2: normalize MCQ letter
-        scored_predicted = _normalize_mcq(new_predicted, expected)
-
-        # Step 3: re-score (cast to str in case of numeric values in the data)
-        new_accuracy = score_answer_accuracy(str(expected), str(scored_predicted), qt)
-
-        if new_accuracy != old_accuracy or new_predicted != old_predicted:
-            fixed_score += 1
-
-        row["predicted"] = new_predicted
-        row["parse_ok"] = new_parse_ok
-        row["answer_accuracy"] = new_accuracy
-        out_rows.append(row)
-
-    # Backup original
-    backup = path.with_suffix(".jsonl.bak")
-    shutil.copy(path, backup)
-    print(f"Backup  → {backup}")
-
-    # Write fixed file
-    with open(path, "w") as f:
-        for row in out_rows:
-            f.write(json.dumps(row) + "\n")
-
-    total = len(out_rows)
-    acc = sum(r["answer_accuracy"] for r in out_rows) / total if total else 0
-    print(f"Rows    : {total}")
-    print(f"Reparsed truncated : {reparsed}")
-    print(f"Score changed      : {fixed_score}")
-    print(f"New accuracy       : {acc:.4f}")
-    print(f"Fixed  → {path}")
-
-
-def main() -> None:
-    """CLI entry point: fix scoring errors in one or more metrics JSONL files."""
-    parser = argparse.ArgumentParser()
-    parser.add_argument("files", nargs="+", help="JSONL file(s) to fix")
-    args = parser.parse_args()
-    for f in args.files:
-        print(f"\n=== {f} ===")
-        fix_file(Path(f))
-
-
-if __name__ == "__main__":
-    main()
diff --git a/baselines/submit_zeroshot.sh b/baselines/submit_zeroshot.sh
deleted file mode 100755
index 695f624..0000000
--- a/baselines/submit_zeroshot.sh
+++ /dev/null
@@ -1,68 +0,0 @@
-#!/usr/bin/env bash
-# Submit a zero-shot baseline SLURM job.
-#
-# Usage:
-#   baselines/submit_zeroshot.sh --dataset chartqapro --backend gemini --model gemini-2.5-flash
-#   baselines/submit_zeroshot.sh --dataset finmme --backend openai --model gpt-4o --after 12345
-#
-# Options:
-#   --dataset   DATASET   chartqapro | finmme  (default: chartqapro)
-#   --split     SPLIT     test | train | ...   (default: test)
-#   --n         N         samples, 0=all       (default: 0)
-#   --backend   BACKEND   gemini | openai      (default: gemini)
-#   --model     MODEL     model name           (default: gemini-2.5-flash)
-#   --workers   N         parallel workers     (default: 8)
-#   --resume              skip done samples
-#   --out       DIR       output dir           (default: output/baselines/)
-#   --prompt_style STYLE  structured (default) | minimal — minimal = bare Q/A, no JSON rules
-#   --after     JOB_ID    hold until job completes
-set -euo pipefail
-
-REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
-
-DATASET="chartqapro"
-SPLIT="test"
-N=0
-BACKEND="gemini"
-MODEL="gemini-2.5-flash"
-WORKERS=8
-RESUME=0
-OUT="output/baselines/"
-AFTER_JOB=""
-PROMPT_STYLE="structured"
-
-while [[ $# -gt 0 ]]; do
-    case "$1" in
-        --dataset)  DATASET="$2";  shift 2 ;;
-        --split)    SPLIT="$2";    shift 2 ;;
-        --n)        N="$2";        shift 2 ;;
-        --backend)  BACKEND="$2";  shift 2 ;;
-        --model)    MODEL="$2";    shift 2 ;;
-        --workers)  WORKERS="$2";  shift 2 ;;
-        --resume)        RESUME=1;              shift ;;
-        --out)           OUT="$2";             shift 2 ;;
-        --after)         AFTER_JOB="$2";       shift 2 ;;
-        --prompt_style)  PROMPT_STYLE="$2";    shift 2 ;;
-        *) echo "Unknown option: $1"; exit 1 ;;
-    esac
-done
-
-export DATASET SPLIT N BACKEND MODEL WORKERS RESUME OUT PROMPT_STYLE
-
-echo "=== Submitting zero-shot baseline ==="
-echo "  Dataset  : $DATASET / $SPLIT  (n=$N)"
-echo "  Model    : $BACKEND / $MODEL"
-echo "  Workers  : $WORKERS"
-echo "  Prompt   : $PROMPT_STYLE"
-echo "  Output   : $OUT"
-[[ -n "$AFTER_JOB" ]] && echo "  After    : $AFTER_JOB"
-echo ""
-
-DEP=""
-[[ -n "$AFTER_JOB" ]] && DEP="--dependency=afterok:${AFTER_JOB}"
-
-JOB=$(sbatch --parsable --export=ALL \
-    --job-name="zeroshot_${BACKEND}_${DATASET}" \
-    $DEP \
-    "$REPO_ROOT/baselines/slurm_zeroshot.slrm")
-echo "Submitted job: $JOB"
diff --git a/markdown/camera_ready_metrics.md b/markdown/camera_ready_metrics.md
deleted file mode 100644
index 88bc034..0000000
--- a/markdown/camera_ready_metrics.md
+++ /dev/null
@@ -1,122 +0,0 @@
-# Camera-Ready Metrics (FinMME)
-
-This file captures the paper-safe numbers to cite from the current workspace state.
-
-Primary artifacts:
-
-- **Agent v8 (scale-up):** `output/final/finmme_fixes_v8_g3flash_color_area/metrics_finmme_train_fixes_v8_g3flash_color_area.jsonl` (**n = 1,250** train `sample_id`s)
-- **Agent v9 (verifier related sentences + caption cross-check):** `output/final/finmme_fixes_v9_g3flash_related_sents/metrics_finmme_train_fixes_v9_g3flash_related_sents.jsonl` (**n = 1,250** — same IDs as v8)
-- **Agent v10 (verifier choice-conflict meta-signal):** `output/final/finmme_fixes_v10_g3flash_choice_conflict/metrics_finmme_train_fixes_v10_g3flash_choice_conflict.jsonl` (**n = 1,250** — same IDs as v8)
-- **Agent v7 (ablation ladder):** `output/final/finmme_fixes_v7_g3flash_conf_gate/*` (**n = 250**)
-- **Zero-shot Gemini-3 Flash Preview (structured):** `output/baselines/metrics_finmme_train_zeroshot_structured_gemini_gemini_3_flash_preview.jsonl` (**n = 11,099** FinMME train rows — full train split coverage after the April 2026 re-run)
-- Earlier ladder runs (v4, v5): `output/final/finmme_fixes_v4_g3flash/*`, `output/final/finmme_v5_multiselect/*`
-
-Unless stated otherwise, **accuracy** means mean **`answer_accuracy`** (rule-based scorer with numeric tolerance + MCQ partial credit). **Exact** means the fraction of rows with **`answer_accuracy ≥ 0.999`**.
-
-## 1) Headline — fair same-model gain (matched IDs, **n = 1,250**)
-
-All **1,250** agent IDs (v8, v9, v10) appear in the full Gemini-3 zero-shot train file — join on `sample_id`.
-
-| System | Mean `answer_accuracy` | Exact (≥ 0.999) |
-|--------|----------------------:|----------------:|
-| Zero-shot `gemini-3-flash-preview` (structured) | **63.56%** | **56.40%** |
-| Agent `fixes_v8_g3flash_color_area` | **71.24%** | **65.12%** |
-| Agent `fixes_v9_g3flash_related_sents` | **71.28%** | **64.56%** |
-| Agent `fixes_v10_g3flash_choice_conflict` | **71.08%** | **64.24%** |
-| **Δ (v8 − zero-shot)** | **+7.68 pp** | **+8.72 pp** |
-| **Δ (v9 − zero-shot)** | **+7.72 pp** | **+8.16 pp** |
-| **Δ (v10 − zero-shot)** | **+7.52 pp** | **+7.84 pp** |
-
-Paired **McNemar** test (binary “strict correct” = `answer_accuracy == 1` vs `< 1`, scipy `chi2.cdf`):
-
-- **v8 vs zero-shot**: **χ² = 68.21**, **p ≈ 1.1 × 10⁻¹⁶**
-- **v9 vs zero-shot**: **χ² = 61.45**, **p ≈ 4.5 × 10⁻¹⁵**
-- **v10 vs zero-shot**: **χ² = 57.37**, **p ≈ 3.6 × 10⁻¹⁴**
-- **Pairwise between agents (all not significant)**: v9 vs v8 χ² = 0.34, p = 0.56; v10 vs v8 χ² = 0.90, p = 0.34; v9 vs v10 χ² = 0.10, p = 0.75.
-
-**By `question_type` on the same overlap (v8 / v9 / v10 vs zero-shot):**
-- mcq (n = 1,150): **+8.09 / +8.13 / +7.83 pp** mean
-- standard (n = 100): **+3.00 / +3.00 / +4.00 pp** — treat the standard delta as **exploratory** (wide CI).
-
-## 2) Ablations on the **250-ID** ladder (historical / controlled slice)
-
-| Comparison | Mean `answer_accuracy` | Exact |
-|---|---:|---:|
-| Zero-shot G3 (structured) on a **250-ID** snapshot after parser repair | *(see `*.bak` / notebook §14)* | **52.8%** |
-| Agent `fixes_v7_g3flash_conf_gate` (same 250 IDs) | **69.6%** | **62.8%** |
-| Δ (v7 agent − zero-shot) on that snapshot | — | **+10.0 pp** exact |
-
-Use **§1** for the main paper claim; keep **§2** only if you need to cite the original ablation-era strict-exact snapshot.
-
-## 3) Verifier effectiveness
-
-**v7 (n = 250)** — accuracy by `verifier_verdict` (exact):
-
-| Verdict | Count | Exact |
-|---|---:|---:|
-| `confirmed` | 180 | **68.33%** |
-| `revised` | 66 | **50.00%** |
-| `error` | 4 | **25.00%** |
-
-**v8 (n = 1,250)** — exact on subset:
-
-| Verdict | Count | Exact |
-|---|---:|---:|
-| `confirmed` | 986 | **68.15%** |
-| `revised` | 234 | **55.56%** |
-| `error` | 30 | *(rare slice — cite with care)* |
-
-**v9 (n = 1,250)** — exact on subset:
-
-| Verdict | Count | Exact |
-|---|---:|---:|
-| `confirmed` | 999 | **67.97%** |
-| `revised` | 215 | **52.09%** |
-| `error` | 36 | *(rare slice — cite with care)* |
-
-**v10 (n = 1,250)** — exact on subset:
-
-| Verdict | Count | Exact |
-|---|---:|---:|
-| `confirmed` | 982 | **69.04%** |
-| `revised` | 247 | **47.77%** |
-| `error` | 21 | *(rare slice — cite with care)* |
-
-## 4) Most defensible novelty lift (multi-select)
-
-From v4 to v5 on FinMME `multiple_choice` (`n=86`):
-
-- `fixes_v4_g3flash`: **30.23%**
-- `fixes_v5_multiselect`: **53.49%**
-- **Gain: `+23.26 pp`**
-
-## 5) Failure taxonomy snapshot (v7, n = 250)
-
-Top failure categories from `taxonomy_finmme_train_fixes_v7_g3flash_conf_gate.jsonl`:
-
-| Failure Type | Count | Share of Failures (n=93) |
-|---|---:|---:|
-| `question_misunderstanding` | 25 | **26.9%** |
-| `legend_confusion` | 18 | **19.4%** |
-| `extraction_error` | 17 | **18.3%** |
-
-## 6) Runtime context
-
-**v7** (from trace metrics on 250 IDs): mean **~32 s**, median **~18.7 s**, p95 **~147 s**.
-
-**v8 @ 1,250** (from metrics JSONL): mean **43.9 s**, median **30.1 s**, p95 **209.4 s** — agent wall-clock remains **several×** a single zero-shot call (see results memo for a head-to-head latency table).
-
-**v9 @ 1,250** (from metrics JSONL): mean **43.7 s**, median **31.0 s**, **p95 87.5 s** — **~2.4× tighter tail than v8/v10**; adding `related_sentences` + caption-as-cross-check gives the verifier enough textual grounding to converge without long retry chains. This is v9's clearest unambiguous gain at full scale even though headline accuracy is tied with v8.
-
-**v10 @ 1,250** (from metrics JSONL): mean **44.2 s**, median **29.6 s**, p95 **222.9 s** — same order of magnitude as v8.
-
-## 7) Important caveats (must keep in paper text)
-
-1. **Two different FinMME train sample counts** — the iterative ladder (v1–v7) is documented on **250** IDs; **`fixes_v8`**, **`fixes_v9`**, and **`fixes_v10`** are all evaluated on the same **1,250** train IDs. Compare systems only after **`sample_id` join**.
-2. **Zero-shot train file is full-split (11,099 rows)** — the headline fair comparison uses the **1,250-ID overlap** with v8/v9/v10, not the zero-shot mean over all 11k (that full mean is **~61.5%**, dominated by much harder **standard** questions than in the 1,250-ID slice).
-3. **Gemini-3 zero-shot file was parser-repaired** (141 rows recovered on an early snapshot) before the headline **52.8%** exact-on-250 number stabilized; the authoritative baseline file is the 11k-row JSONL above.
-4. **Mean vs exact** — do not mix them in the same delta sentence without labeling columns.
-
-## 8) Suggested one-line claim
-
-On **1,250** FinMME train questions where both systems have predictions, our Gemini-3-based agent (**`fixes_v8_g3flash_color_area`**) achieves **71.24%** mean `answer_accuracy` vs **63.56%** for a **fair same-model** Gemini-3 Flash Preview zero-shot baseline (**+7.68 pp**; McNemar **p ≪ 0.001**), with the clearest lift on **MCQ** (**+8.09 pp** on 1,150). Adding analyst `related_sentences` + caption-as-cross-check (**v9**, **71.28%**, **+7.72 pp**) or a choice-conflict meta-signal (**v10**, **71.08%**, **+7.52 pp**) leaves headline accuracy statistically tied with v8 (pairwise McNemar p ≥ 0.34), but **v9 cuts p95 latency by ~2.4×** (87.5 s vs v8's 209.4 s) — a real operational gain. The strongest **isolated** pipeline ablation remains multi-select MCQ support (**+23.3 pp** on `multiple_choice` from v4 → v5).
diff --git a/notebooks/analysis.ipynb b/notebooks/analysis.ipynb
deleted file mode 100644
index 2ea8e45..0000000
--- a/notebooks/analysis.ipynb
+++ /dev/null
@@ -1,442 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "7fb27b941602401d91542211134fc71a",
-   "metadata": {},
-   "source": "# ChartQAPro Evaluation — Analysis Walkthrough\n\nThis notebook walks through the full evaluation artifact stack produced by the\nagentic ChartQAPro framework. By the end you will be able to:\n\n- Load and inspect **MEPs** (Model Evaluation Packets) directly\n- Plot **accuracy by question type** from `metrics.jsonl`\n- Visualise the **verifier revision rate** and its effect on accuracy\n- Chart the **failure taxonomy** breakdown from `taxonomy.jsonl`\n- Browse individual samples — question, plan, vision answer, verifier verdict, chart image\n\n**Prerequisites:** Run these commands first (from any directory in the repo):\n```bash\nuv run --env-file \"$(git rev-parse --show-toplevel)/.env\" --directory \"$(git rev-parse --show-toplevel)/implementations/agentic_vqa_eval\" -m agentfinvqa.runner.run_generate_meps --n 25 --config gemini_gemini\nuv run --env-file \"$(git rev-parse --show-toplevel)/.env\" --directory \"$(git rev-parse --show-toplevel)/implementations/agentic_vqa_eval\" -m agentfinvqa.eval.eval_outputs  --mep_dir meps/gemini_gemini/chartqapro/test --out output/metrics.jsonl\nuv run --env-file \"$(git rev-parse --show-toplevel)/.env\" --directory \"$(git rev-parse --show-toplevel)/implementations/agentic_vqa_eval\" -m agentfinvqa.eval.error_taxonomy --mep_dir meps/gemini_gemini/chartqapro/test --metrics_file output/metrics.jsonl --out output/taxonomy.jsonl\n```"
-  },
-  {
-   "cell_type": "markdown",
-   "id": "acae54e37e7d407bbb7b55eff062a284",
-   "metadata": {},
-   "source": [
-    "## 1. Setup"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "9a63283cbaf04dbcab1f6479b197f3a8",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import json\n",
-    "from pathlib import Path\n",
-    "\n",
-    "import matplotlib.pyplot as plt\n",
-    "import pandas as pd\n",
-    "\n",
-    "\n",
-    "# Point these at your actual output files\n",
-    "MEP_DIR = Path(\"./meps/gemini_gemini/chartqapro/test\")\n",
-    "METRICS_FILE = Path(\"./output/metrics.jsonl\")\n",
-    "TAXONOMY_FILE = Path(\"./output/taxonomy.jsonl\")\n",
-    "\n",
-    "plt.style.use(\"seaborn-v0_8-whitegrid\")\n",
-    "plt.rcParams.update({\"figure.dpi\": 120, \"font.size\": 11})\n",
-    "\n",
-    "print(\"Setup complete\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "8dd0d8092fe74a7c96281538738b07e2",
-   "metadata": {},
-   "source": [
-    "## 2. Load MEPs\n",
-    "\n",
-    "Each MEP is a self-contained JSON file capturing the full agent trace for one sample.\n",
-    "We read them all into a list of dicts for analysis."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "72eea5119410473aa328ad9291626812",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "meps = []\n",
-    "for path in sorted(MEP_DIR.glob(\"*.json\")):\n",
-    "    meps.append(json.loads(path.read_text()))\n",
-    "\n",
-    "print(f\"Loaded {len(meps)} MEPs from {MEP_DIR}\")\n",
-    "\n",
-    "# Peek at one MEP's top-level keys\n",
-    "if meps:\n",
-    "    print(\"\\nTop-level MEP keys:\", list(meps[0].keys()))\n",
-    "    print(\"Plan steps for first MEP:\")\n",
-    "    for i, step in enumerate(meps[0].get(\"plan\", {}).get(\"parsed\", {}).get(\"steps\", []), 1):\n",
-    "        print(f\"  {i}. {step}\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "8edb47106e1a46a883d545849b8ab81b",
-   "metadata": {},
-   "source": [
-    "## 3. Load metrics.jsonl\n",
-    "\n",
-    "`metrics.jsonl` is produced by `eval_outputs.py` and contains one row per sample\n",
-    "with accuracy, latency, verifier verdict, and (optionally) judge scores."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "10185d26023b46108eb7d9f57d49d2b3",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "metrics = [json.loads(line) for line in METRICS_FILE.read_text().splitlines() if line.strip()]\n",
-    "df = pd.DataFrame(metrics)\n",
-    "\n",
-    "print(f\"Columns: {list(df.columns)}\")\n",
-    "print(f\"\\nSamples: {len(df)}\")\n",
-    "print(f\"Overall accuracy: {df['answer_accuracy'].mean():.1%}\")\n",
-    "df[[\"answer_accuracy\", \"latency_sec\"]].describe().round(3)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "8763a12b2bbd4a93a75aff182afb95dc",
-   "metadata": {},
-   "source": [
-    "## 4. Accuracy by Question Type\n",
-    "\n",
-    "ChartQAPro has five question types: `standard`, `mcq`, `conversational`,\n",
-    "`hypothetical`, `unanswerable`. Performance varies significantly across types —\n",
-    "this plot shows where the model struggles."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "7623eae2785240b9bd12b16a66d81610",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "by_type = df.groupby(\"question_type\")[\"answer_accuracy\"].agg([\"mean\", \"count\"]).reset_index()\n",
-    "by_type = by_type.sort_values(\"mean\", ascending=True)\n",
-    "\n",
-    "colors = [\"#d63031\" if v < 0.4 else \"#fdcb6e\" if v < 0.75 else \"#00b894\" for v in by_type[\"mean\"]]\n",
-    "\n",
-    "fig, ax = plt.subplots(figsize=(8, 4))\n",
-    "bars = ax.barh(by_type[\"question_type\"], by_type[\"mean\"], color=colors, edgecolor=\"white\")\n",
-    "\n",
-    "for bar, (_, row) in zip(bars, by_type.iterrows()):\n",
-    "    ax.text(\n",
-    "        bar.get_width() + 0.01,\n",
-    "        bar.get_y() + bar.get_height() / 2,\n",
-    "        f\"{row['mean']:.1%}  (n={int(row['count'])})\",\n",
-    "        va=\"center\",\n",
-    "        fontsize=10,\n",
-    "    )\n",
-    "\n",
-    "ax.set_xlim(0, 1.15)\n",
-    "ax.set_xlabel(\"Answer Accuracy\")\n",
-    "ax.set_title(\"Accuracy by Question Type\", fontweight=\"bold\")\n",
-    "ax.axvline(df[\"answer_accuracy\"].mean(), color=\"#6c5ce7\", linestyle=\"--\", linewidth=1.2, label=\"Overall mean\")\n",
-    "ax.legend()\n",
-    "plt.tight_layout()\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "7cdc8c89c7104fffa095e18ddfef8986",
-   "metadata": {},
-   "source": [
-    "## 5. Verifier (Pass 2.5) Analysis\n",
-    "\n",
-    "The VerifierAgent independently re-examines each chart image and either **confirms**\n",
-    "or **revises** the VisionAgent's draft answer. This cell shows:\n",
-    "- How often the verifier intervened\n",
-    "- Whether revisions improved accuracy"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "b118ea5561624da68c537baed56e602f",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "if \"verifier_verdict\" not in df.columns or df[\"verifier_verdict\"].eq(\"skipped\").all():\n",
-    "    print(\"Verifier was not used (--no_verifier flag was set). Re-run without it to see this analysis.\")\n",
-    "else:\n",
-    "    verdict_counts = df[\"verifier_verdict\"].value_counts()\n",
-    "\n",
-    "    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(11, 4))\n",
-    "\n",
-    "    # Pie chart: verdict distribution\n",
-    "    verdict_colors = {\"confirmed\": \"#00b894\", \"revised\": \"#fdcb6e\", \"skipped\": \"#b2bec3\"}\n",
-    "    vc = verdict_counts.reindex([\"confirmed\", \"revised\", \"skipped\"]).dropna()\n",
-    "    ax1.pie(vc.values, labels=vc.index, colors=[verdict_colors[k] for k in vc.index], autopct=\"%1.1f%%\", startangle=90)\n",
-    "    ax1.set_title(\"Verifier Verdict Distribution\", fontweight=\"bold\")\n",
-    "\n",
-    "    # Bar chart: accuracy by verdict\n",
-    "    acc_by_verdict = df.groupby(\"verifier_verdict\")[\"answer_accuracy\"].mean()\n",
-    "    bars = ax2.bar(\n",
-    "        acc_by_verdict.index,\n",
-    "        acc_by_verdict.values,\n",
-    "        color=[verdict_colors.get(k, \"#6c5ce7\") for k in acc_by_verdict.index],\n",
-    "        edgecolor=\"white\",\n",
-    "        width=0.5,\n",
-    "    )\n",
-    "    for bar in bars:\n",
-    "        ax2.text(\n",
-    "            bar.get_x() + bar.get_width() / 2,\n",
-    "            bar.get_height() + 0.01,\n",
-    "            f\"{bar.get_height():.1%}\",\n",
-    "            ha=\"center\",\n",
-    "            fontsize=10,\n",
-    "        )\n",
-    "    ax2.set_ylim(0, 1.1)\n",
-    "    ax2.set_ylabel(\"Avg Answer Accuracy\")\n",
-    "    ax2.set_title(\"Accuracy by Verifier Verdict\", fontweight=\"bold\")\n",
-    "\n",
-    "    plt.tight_layout()\n",
-    "    plt.show()\n",
-    "\n",
-    "    # Also show before/after for revised samples\n",
-    "    revised_rows = df[df[\"verifier_verdict\"] == \"revised\"]\n",
-    "    if len(revised_rows) > 0 and \"vision_answer\" in df.columns:\n",
-    "        from agentfinvqa.eval.eval_outputs import score_answer_accuracy\n",
-    "\n",
-    "        before = revised_rows.apply(\n",
-    "            lambda r: score_answer_accuracy(r[\"expected\"], r[\"vision_answer\"], r[\"question_type\"]), axis=1\n",
-    "        ).mean()\n",
-    "        after = revised_rows[\"answer_accuracy\"].mean()\n",
-    "        print(f\"\\nFor the {len(revised_rows)} revised samples:\")\n",
-    "        print(f\"  Accuracy BEFORE verifier: {before:.1%}\")\n",
-    "        print(f\"  Accuracy AFTER  verifier: {after:.1%}\")\n",
-    "        print(f\"  Delta: {after - before:+.1%}\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "938c804e27f84196a10c8828c723f798",
-   "metadata": {},
-   "source": [
-    "## 6. Failure Taxonomy (Pass 4)\n",
-    "\n",
-    "The `error_taxonomy.py` pass asks a VLM to diagnose *why* the agent failed — using\n",
-    "the chart image, the wrong answer, the correct answer, and the agent's explanation.\n",
-    "This gives a grounded diagnosis rather than a guess."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "504fb2a444614c0babb325280ed9130a",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "if not TAXONOMY_FILE.exists():\n",
-    "    print(f\"{TAXONOMY_FILE} not found. Run error_taxonomy.py first.\")\n",
-    "else:\n",
-    "    tax = [json.loads(line) for line in TAXONOMY_FILE.read_text().splitlines() if line.strip()]\n",
-    "    tax_df = pd.DataFrame(tax)\n",
-    "\n",
-    "    counts = tax_df[\"failure_type\"].value_counts()\n",
-    "\n",
-    "    palette = {\n",
-    "        \"correct\": \"#00b894\",\n",
-    "        \"extraction_error\": \"#e84393\",\n",
-    "        \"axis_misread\": \"#e17055\",\n",
-    "        \"arithmetic_mistake\": \"#fdcb6e\",\n",
-    "        \"legend_confusion\": \"#fd79a8\",\n",
-    "        \"hallucinated_element\": \"#d63031\",\n",
-    "        \"unanswerable_failure\": \"#0984e3\",\n",
-    "        \"question_misunderstanding\": \"#6c5ce7\",\n",
-    "        \"other\": \"#b2bec3\",\n",
-    "    }\n",
-    "    bar_colors = [palette.get(k, \"#6c5ce7\") for k in counts.index]\n",
-    "\n",
-    "    fig, ax = plt.subplots(figsize=(9, 5))\n",
-    "    bars = ax.barh(counts.index[::-1], counts.values[::-1], color=bar_colors[::-1], edgecolor=\"white\")\n",
-    "    for bar in bars:\n",
-    "        ax.text(\n",
-    "            bar.get_width() + 0.1,\n",
-    "            bar.get_y() + bar.get_height() / 2,\n",
-    "            str(int(bar.get_width())),\n",
-    "            va=\"center\",\n",
-    "            fontsize=10,\n",
-    "        )\n",
-    "    ax.set_xlabel(\"Number of samples\")\n",
-    "    ax.set_title(\"Failure Taxonomy Breakdown (Pass 4)\", fontweight=\"bold\")\n",
-    "    plt.tight_layout()\n",
-    "    plt.show()\n",
-    "\n",
-    "    wrong = tax_df[tax_df[\"failure_type\"] != \"correct\"]\n",
-    "    print(f\"\\nTotal wrong: {len(wrong)} / {len(tax_df)}\")\n",
-    "    failure_counts = counts[counts.index != \"correct\"]\n",
-    "    if failure_counts.empty:\n",
-    "        print(\"Most common failure: none (all samples correct)\")\n",
-    "    else:\n",
-    "        print(f\"Most common failure: {failure_counts.idxmax()}\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "59bbdb311c014d738909a11f9e486628",
-   "metadata": {},
-   "source": [
-    "## 7. Judge Scores (if available)\n",
-    "\n",
-    "When `eval_outputs.py` is run without `--no_judge`, five rubric scores are computed\n",
-    "per sample by an LLM judge. This cell plots their distributions."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "b43b363d81ae4b689946ece5c682cd59",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "judge_cols = [c for c in df.columns if c.startswith(\"judge_\") and c != \"judge_parse_error\"]\n",
-    "\n",
-    "if not judge_cols:\n",
-    "    print(\"No judge scores found. Re-run eval_outputs.py without --no_judge.\")\n",
-    "else:\n",
-    "    fig, axes = plt.subplots(1, len(judge_cols), figsize=(3.5 * len(judge_cols), 3.5), sharey=False)\n",
-    "    if len(judge_cols) == 1:\n",
-    "        axes = [axes]\n",
-    "\n",
-    "    for ax, col in zip(axes, judge_cols):\n",
-    "        vals = pd.to_numeric(df[col], errors=\"coerce\").dropna()\n",
-    "\n",
-    "        ax.hist(vals, bins=10, range=(0, 1), color=\"#6c5ce7\", edgecolor=\"white\", alpha=0.85)\n",
-    "\n",
-    "        if len(vals) > 0:\n",
-    "            mean_val = vals.mean()\n",
-    "            ax.axvline(mean_val, color=\"#d63031\", linestyle=\"--\", linewidth=1.5)\n",
-    "            ax.text(0.05, ax.get_ylim()[1] * 0.9, f\"μ={mean_val:.2f}\", fontsize=9, color=\"#d63031\")\n",
-    "\n",
-    "        ax.set_title(col.replace(\"judge_\", \"\").replace(\"_\", \"\\n\"), fontsize=9, fontweight=\"bold\")\n",
-    "        ax.set_xlabel(\"Score (0–1)\")\n",
-    "\n",
-    "    plt.suptitle(\"LLM Judge Rubric Distributions\", fontweight=\"bold\", y=1.02)\n",
-    "    plt.tight_layout()\n",
-    "    plt.show()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "8a65eabff63a45729fe45fb5ade58bdc",
-   "metadata": {},
-   "source": [
-    "## 8. Browse a Single MEP\n",
-    "\n",
-    "Change `SAMPLE_ID` below to any sample ID in your MEP directory.\n",
-    "This cell prints the full agent trace and displays the chart image."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "c3933fab20d04ec698c2621248eb3be0",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from IPython.display import Image\n",
-    "from IPython.display import display as ip_display\n",
-    "\n",
-    "\n",
-    "# ← change to any sample_id in your MEP directory\n",
-    "SAMPLE_ID = meps[0][\"sample\"][\"sample_id\"] if meps else None\n",
-    "\n",
-    "mep = next((m for m in meps if m[\"sample\"][\"sample_id\"] == SAMPLE_ID), None)\n",
-    "if mep is None:\n",
-    "    print(f\"Sample {SAMPLE_ID!r} not found in {MEP_DIR}\")\n",
-    "else:\n",
-    "    sample = mep[\"sample\"]\n",
-    "    plan = mep.get(\"plan\", {}).get(\"parsed\", {})\n",
-    "    vision = mep.get(\"vision\", {}).get(\"parsed\", {})\n",
-    "    verifier = mep.get(\"verifier\") or {}\n",
-    "    v_parsed = verifier.get(\"parsed\", {})\n",
-    "\n",
-    "    print(\"=\" * 60)\n",
-    "    print(f\"Sample : {sample['sample_id']}\")\n",
-    "    print(f\"Type   : {sample['question_type']}\")\n",
-    "    print(f\"Q      : {sample['question']}\")\n",
-    "    print(f\"Expected: {sample['expected_output']}\")\n",
-    "    print()\n",
-    "    print(\"--- Planner steps ---\")\n",
-    "    for i, s in enumerate(plan.get(\"steps\", []), 1):\n",
-    "        print(f\"  {i}. {s}\")\n",
-    "    print()\n",
-    "    print(\"--- VisionAgent ---\")\n",
-    "    print(f\"  Draft answer : {vision.get('answer', '—')}\")\n",
-    "    print(f\"  Explanation  : {vision.get('explanation', '—')[:200]}\")\n",
-    "    print()\n",
-    "    if v_parsed:\n",
-    "        print(\"--- VerifierAgent ---\")\n",
-    "        print(f\"  Verdict  : {v_parsed.get('verdict', '—')}\")\n",
-    "        print(f\"  Answer   : {v_parsed.get('answer', '—')}\")\n",
-    "        print(f\"  Reasoning: {v_parsed.get('reasoning', '—')}\")\n",
-    "    print(\"=\" * 60)\n",
-    "\n",
-    "    img_path = sample.get(\"image_ref\", {}).get(\"path\", \"\")\n",
-    "    if img_path and Path(img_path).exists():\n",
-    "        ip_display(Image(filename=img_path, width=600))\n",
-    "    else:\n",
-    "        print(f\"Image not found at: {img_path}\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "4dd4641cc4064e0191573fe9c69df29b",
-   "metadata": {},
-   "source": [
-    "## 9. Failure Cases Deep Dive\n",
-    "\n",
-    "Find all samples where the verifier revised the answer but it was still wrong —\n",
-    "these are the hardest cases where neither agent got it right."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "8309879909854d7188b41380fd92a7c3",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "if \"verifier_verdict\" in df.columns:\n",
-    "    revised_wrong = df[(df[\"verifier_verdict\"] == \"revised\") & (df[\"answer_accuracy\"] < 1.0)][\n",
-    "        [\"sample_id\", \"question_type\", \"expected\", \"vision_answer\", \"predicted\", \"answer_accuracy\"]\n",
-    "    ]\n",
-    "\n",
-    "    print(f\"Samples where verifier revised but was still wrong: {len(revised_wrong)}\")\n",
-    "    if len(revised_wrong) > 0:\n",
-    "        ip_display(revised_wrong.head(10))\n",
-    "else:\n",
-    "    print(\"verifier_verdict column not present — run with verifier enabled\")"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": ".venv",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.13.7"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}
diff --git a/notebooks/run_pipeline.ipynb b/notebooks/run_pipeline.ipynb
deleted file mode 100644
index 7b163e1..0000000
--- a/notebooks/run_pipeline.ipynb
+++ /dev/null
@@ -1,881 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "cell-title",
-   "metadata": {},
-   "source": [
-    "# ChartQAPro — End-to-End Pipeline Execution\n",
-    "\n",
-    "Run the **complete agentic loop** from dataset loading through MEP generation,\n",
-    "evaluation, failure taxonomy, and summary — all from one notebook.\n",
-    "\n",
-    "**How to use:** Edit the parameters in **Cell 1 (Configuration)**, then *Run All*.\n",
-    "\n",
-    "| Section | What it does |\n",
-    "|---|---|\n",
-    "| 1 — Configuration | All tunable parameters in one place |\n",
-    "| 2 — Environment | Check API keys, install path, imports |\n",
-    "| 2.5 — Langfuse health check | Verify Langfuse credentials are configured before running |\n",
-    "| 3 — Load dataset | Pull samples from HuggingFace |\n",
-    "| 4 — Instantiate agents | Build Planner, OCR, Vision, Verifier |\n",
-    "| 5 — Run pipeline | Generate MEPs (Plan → OCR → Vision → Verify) |\n",
-    "| 6 — Inspect MEP | Browse the first result |\n",
-    "| 7 — OCR insight | See what OCR extracted and injected |\n",
-    "| 8 — Ablation: no OCR | Re-run without OCR to compare |\n",
-    "| 9 — Pass 1: eval outputs | Rule-based accuracy + optional LLM judge |\n",
-    "| 10 — Pass 2: eval traces | Latency, tool calls, replayability |\n",
-    "| 11 — Pass 4: failure taxonomy | VLM-based diagnosis of wrong answers |\n",
-    "| 12 — Summarize | Aggregate to summary.csv |\n",
-    "\n",
-    "> **Companion notebook:** `analysis.ipynb` visualises existing results with charts and dashboards.\n",
-    "> This notebook *generates* the results."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "cell-config",
-   "metadata": {},
-   "source": [
-    "## 1 — Configuration\n",
-    "\n",
-    "Change these values. Everything else runs automatically."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "cell-config-code",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import sys\n",
-    "import uuid\n",
-    "from pathlib import Path\n",
-    "\n",
-    "\n",
-    "# ── Tune these before running ────────────────────────────────────────────────\n",
-    "N_SAMPLES = 1  # samples to process (keep ≤10 for a first run)\n",
-    "CONFIG = \"gemini_gemini\"  # gemini_gemini | openai_openai | openai_gemini | gemini_openai\n",
-    "SPLIT = \"test\"\n",
-    "USE_OCR = True  # False = skip OcrReaderTool  (--no_ocr equivalent)\n",
-    "USE_VERIFIER = True  # False = skip VerifierAgent  (--no_verifier equivalent)\n",
-    "OCR_MODEL = None  # None = same model as vision; 'gemini-2.5-flash-lite' = cheaper OCR\n",
-    "USE_JUDGE = False  # True = LLM rubric judge (extra API calls per sample)\n",
-    "RUN_ABLATION = True  # True = also run without OCR after the main run\n",
-    "# ────────────────────────────────────────────────────────────────────\n",
-    "\n",
-    "REPO_ROOT = Path(\".\").resolve()\n",
-    "RUN_ID = str(uuid.uuid4())\n",
-    "OUT_DIR = str(REPO_ROOT / \"meps\" / CONFIG / \"chartqapro\" / SPLIT)\n",
-    "IMAGE_DIR = str(REPO_ROOT / \"data\" / \"chartqapro_images\")\n",
-    "OUT_LABEL = f\"{CONFIG}_n{N_SAMPLES}\"\n",
-    "\n",
-    "ocr_status = \"enabled\" if USE_OCR else \"disabled\"\n",
-    "ver_status = \"enabled\" if USE_VERIFIER else \"disabled\"\n",
-    "print(f\"Config     : {CONFIG}\")\n",
-    "print(f\"Samples    : {N_SAMPLES}  split={SPLIT}\")\n",
-    "print(f\"OCR        : {ocr_status}\")\n",
-    "print(f\"Verifier   : {ver_status}\")\n",
-    "print(f\"LLM judge  : {'enabled' if USE_JUDGE else 'disabled (--no_judge)'}\")\n",
-    "print(f\"Run ID     : {RUN_ID}\")\n",
-    "print(f\"Output dir : {OUT_DIR}\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "cell-env-hdr",
-   "metadata": {},
-   "source": [
-    "## 2 — Environment\n",
-    "\n",
-    "Verify API keys and import all modules. Fix any errors here before proceeding."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "cell-env",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import json\n",
-    "import os\n",
-    "\n",
-    "\n",
-    "# Make sure src/ is on the path\n",
-    "src_path = str(REPO_ROOT / \"src\")\n",
-    "if src_path not in sys.path:\n",
-    "    sys.path.insert(0, src_path)\n",
-    "\n",
-    "from dotenv import load_dotenv  # noqa: E402\n",
-    "\n",
-    "\n",
-    "load_dotenv(REPO_ROOT / \".env\")\n",
-    "\n",
-    "# API key check\n",
-    "missing = []\n",
-    "for var, needed_for in [(\"OPENAI_API_KEY\", \"openai\"), (\"GEMINI_API_KEY\", \"gemini\")]:\n",
-    "    val = os.environ.get(var, \"\")\n",
-    "    needed = needed_for in CONFIG\n",
-    "    if val and not val.startswith(\"your_\"):\n",
-    "        print(f\"  ok  {var}  ({val[:3]}...)\")\n",
-    "    elif needed:\n",
-    "        print(f\"  MISSING  {var}  <- required for {CONFIG}\")\n",
-    "        missing.append(var)\n",
-    "    else:\n",
-    "        print(f\"  skip  {var}  (not needed for {CONFIG})\")\n",
-    "\n",
-    "if missing:\n",
-    "    raise EnvironmentError(f\"Set {missing} in .env and re-run this cell.\")\n",
-    "\n",
-    "# Imports\n",
-    "import pandas as pd  # noqa: E402\n",
-    "from IPython.display import Image, display  # noqa: E402, A004\n",
-    "\n",
-    "from agentfinvqa.agents.planner_agent import PlannerAgent  # noqa: E402\n",
-    "from agentfinvqa.agents.verifier_agent import VerifierAgent  # noqa: E402\n",
-    "from agentfinvqa.agents.vision_agent import VisionAgent  # noqa: E402\n",
-    "from agentfinvqa.datasets.chartqapro_loader import (  # noqa: E402\n",
-    "    load_chartqapro,\n",
-    ")\n",
-    "from agentfinvqa.eval.error_taxonomy import classify_failure  # noqa: E402\n",
-    "from agentfinvqa.eval.eval_outputs import evaluate_mep  # noqa: E402\n",
-    "from agentfinvqa.eval.eval_traces import evaluate_trace  # noqa: E402\n",
-    "from agentfinvqa.eval.summarize import summarize, write_csv  # noqa: E402\n",
-    "from agentfinvqa.langfuse_integration.client import get_client  # noqa: E402\n",
-    "from agentfinvqa.mep.writer import iter_meps  # noqa: E402\n",
-    "from agentfinvqa.runner.run_generate_meps import (  # noqa: E402\n",
-    "    BACKEND_CONFIGS,\n",
-    "    process_sample,\n",
-    ")\n",
-    "from agentfinvqa.tools.ocr_reader_tool import OcrReaderTool  # noqa: E402\n",
-    "\n",
-    "\n",
-    "print(\"\\nAll imports OK\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "cell-opik-hdr",
-   "metadata": {},
-   "source": [
-    "## 2.5 — Langfuse Health Check\n",
-    "\n",
-    "Verifies that Langfuse credentials are configured before the pipeline runs.\n",
-    "\n",
-    "| Check | What it tests |\n",
-    "|---|---|\n",
-    "| Env vars present | `LANGFUSE_PUBLIC_KEY` and `LANGFUSE_SECRET_KEY` are set in `.env` |\n",
-    "| Client init | `Langfuse()` initialises without error |\n",
-    "\n",
-    "If the keys are absent the cell prints a skip notice and continues — Langfuse is optional.\n",
-    "The pipeline produces identical MEPs with or without it; tracing is purely additive."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "cell-opik-check",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from agentfinvqa.langfuse_integration.client import reset_client\n",
-    "\n",
-    "\n",
-    "# Force re-initialisation so re-running this cell picks up any .env changes\n",
-    "reset_client()\n",
-    "\n",
-    "lf_public = os.environ.get(\"LANGFUSE_PUBLIC_KEY\", \"\")\n",
-    "lf_secret = os.environ.get(\"LANGFUSE_SECRET_KEY\", \"\")\n",
-    "\n",
-    "if not lf_public or not lf_secret:\n",
-    "    print(\"[skip] LANGFUSE_PUBLIC_KEY / LANGFUSE_SECRET_KEY are not set.\")\n",
-    "    print(\"       Langfuse tracing is disabled. Pipeline will run fine without it.\")\n",
-    "    print()\n",
-    "    print(\"To enable Langfuse tracing, add to .env:\")\n",
-    "    print(\"  LANGFUSE_PUBLIC_KEY=pk-lf-...\")\n",
-    "    print(\"  LANGFUSE_SECRET_KEY=sk-lf-...\")\n",
-    "    print(\"  # LANGFUSE_HOST=https://cloud.langfuse.com  (default; change for self-hosted)\")\n",
-    "else:\n",
-    "    results = {}\n",
-    "\n",
-    "    # -- Check 1: Env vars present --\n",
-    "    results[\"env\"] = (\"ok\", f\"pk={lf_public[:3]}...\")\n",
-    "\n",
-    "    # -- Check 2: Client initialises --\n",
-    "    try:\n",
-    "        _lf_hc = get_client()\n",
-    "        if _lf_hc is not None:\n",
-    "            results[\"client\"] = (\"ok\", \"Langfuse() ready\")\n",
-    "        else:\n",
-    "            results[\"client\"] = (\"fail\", \"get_client() returned None\")\n",
-    "    except Exception as e:\n",
-    "        results[\"client\"] = (\"fail\", str(e))\n",
-    "\n",
-    "    # -- Report --\n",
-    "    labels = [\n",
-    "        (\"env\", \"Env vars present\"),\n",
-    "        (\"client\", \"Client init     \"),\n",
-    "    ]\n",
-    "    all_ok = True\n",
-    "    for key, label in labels:\n",
-    "        status, detail = results.get(key, (\"skip\", \"\"))\n",
-    "        marker = \"✓ OK  \" if status == \"ok\" else (\"⊘ skip\" if status == \"skip\" else \"✗ FAIL\")\n",
-    "        if status not in (\"ok\", \"skip\"):\n",
-    "            all_ok = False\n",
-    "        print(f\"  {marker}  {label}  {detail}\")\n",
-    "\n",
-    "    print()\n",
-    "    if all_ok:\n",
-    "        lf_host = os.environ.get(\"LANGFUSE_HOST\") or os.environ.get(\"LANGFUSE_BASE_URL\") or \"https://cloud.langfuse.com\"\n",
-    "        print(\"✓ Langfuse is configured.\")\n",
-    "        print(f\"Host      : {lf_host}\")\n",
-    "        print(\"Traces and scores will be recorded automatically during the pipeline run.\")\n",
-    "    else:\n",
-    "        print(\"⚠ WARNING: Langfuse client failed to initialise.\")\n",
-    "        print(\"The pipeline will still run; tracing will be skipped.\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "cell-data-hdr",
-   "metadata": {},
-   "source": [
-    "## 3 — Load Dataset\n",
-    "\n",
-    "Downloads ChartQAPro from HuggingFace (cached after first run) and saves chart images locally."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "cell-data",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from collections import Counter\n",
-    "\n",
-    "\n",
-    "Path(IMAGE_DIR).mkdir(parents=True, exist_ok=True)\n",
-    "\n",
-    "samples = load_chartqapro(split=SPLIT, n=N_SAMPLES, image_dir=IMAGE_DIR)\n",
-    "print(f\"Loaded {len(samples)} samples from ChartQAPro ({SPLIT} split)\\n\")\n",
-    "\n",
-    "qt_counts = Counter(s.question_type.value for s in samples)\n",
-    "print(\"Question type breakdown:\")\n",
-    "for qt, n in sorted(qt_counts.items()):\n",
-    "    print(f\"  {qt:<22} {n}\")\n",
-    "\n",
-    "# Peek at first sample\n",
-    "s0 = samples[0]\n",
-    "print(f\"\\nFirst sample: {s0.sample_id}\")\n",
-    "print(f\"  Q: {s0.question}\")\n",
-    "print(f\"  A: {s0.expected_output}\")\n",
-    "print(f\"  Type: {s0.question_type.value}\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "cell-agents-hdr",
-   "metadata": {},
-   "source": [
-    "## 4 — Instantiate Agents\n",
-    "\n",
-    "Build the four components of the pipeline. Agents are created once and reused across all samples.\n",
-    "CrewAI creates a fresh `Crew` per `run()` call, so this is thread-safe for parallel workers."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "cell-agents",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "config = dict(BACKEND_CONFIGS[CONFIG])\n",
-    "Path(OUT_DIR).mkdir(parents=True, exist_ok=True)\n",
-    "\n",
-    "# PlannerAgent: text-only LLM, no image access\n",
-    "planner = PlannerAgent(\n",
-    "    backend=config[\"planner_backend\"],\n",
-    "    model=config[\"planner_model\"],\n",
-    ")\n",
-    "print(f\"PlannerAgent   : {config['planner_backend']} / {config['planner_model']}\")\n",
-    "\n",
-    "# VisionAgent: multimodal LLM + VisionQATool\n",
-    "vision_agent = VisionAgent(\n",
-    "    agent_backend=config[\"planner_backend\"],\n",
-    "    agent_model=config[\"planner_model\"],\n",
-    "    vision_backend=config[\"vision_backend\"],\n",
-    "    vision_model=config[\"vision_model\"],\n",
-    ")\n",
-    "print(f\"VisionAgent    : {config['vision_backend']} / {config['vision_model']}\")\n",
-    "\n",
-    "# VerifierAgent: optional Pass 2.5 critic\n",
-    "verifier = None\n",
-    "if USE_VERIFIER:\n",
-    "    verifier = VerifierAgent(backend=config[\"vision_backend\"], model=config[\"vision_model\"])\n",
-    "    print(f\"VerifierAgent  : {config['vision_backend']} / {config['vision_model']}\")\n",
-    "else:\n",
-    "    print(\"VerifierAgent  : disabled (USE_VERIFIER=False)\")\n",
-    "\n",
-    "# OcrReaderTool: optional perception pre-pass\n",
-    "ocr = None\n",
-    "if USE_OCR:\n",
-    "    ocr_model = OCR_MODEL or config[\"vision_model\"]\n",
-    "    ocr = OcrReaderTool(backend=config[\"vision_backend\"], model=ocr_model)\n",
-    "    print(f\"OcrReaderTool  : {config['vision_backend']} / {ocr_model}\")\n",
-    "else:\n",
-    "    print(\"OcrReaderTool  : disabled (USE_OCR=False)\")\n",
-    "\n",
-    "# Langfuse observability (no-op if keys not set)\n",
-    "lf_client = get_client()\n",
-    "lf_status = \"enabled\" if lf_client else \"not configured\"\n",
-    "print(f\"Langfuse       : {lf_status}\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "cell-run-hdr",
-   "metadata": {},
-   "source": [
-    "## 5 — Run the Pipeline\n",
-    "\n",
-    "For each sample: **Plan → [OCR] → Vision → [Verify] → write MEP**.\n",
-    "\n",
-    "Each call to `process_sample()` is fully self-contained: it creates a fresh CrewAI `Crew`,\n",
-    "runs the agent chain, and serialises the result to `OUT_DIR/<sample_id>.json`.\n",
-    "\n",
-    "To parallelise, increase `N_WORKERS` below and run again."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "cell-run",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from concurrent.futures import ThreadPoolExecutor, as_completed\n",
-    "\n",
-    "\n",
-    "N_WORKERS = 1  # set >1 to parallelise (increase N_SAMPLES too)\n",
-    "\n",
-    "mep_paths = []\n",
-    "print(f\"Running {len(samples)} samples  workers={N_WORKERS}  -> {OUT_DIR}\\n\")\n",
-    "\n",
-    "\n",
-    "def _run_one(sample):\n",
-    "    return process_sample(\n",
-    "        sample,\n",
-    "        planner,\n",
-    "        vision_agent,\n",
-    "        config,\n",
-    "        RUN_ID,\n",
-    "        OUT_DIR,\n",
-    "        lf_client=lf_client,\n",
-    "        verifier_agent=verifier,\n",
-    "        ocr_tool=ocr,\n",
-    "    )\n",
-    "\n",
-    "\n",
-    "if N_WORKERS <= 1:\n",
-    "    for i, sample in enumerate(samples, 1):\n",
-    "        print(f\"[{i}/{len(samples)}] {sample.sample_id} ...\", end=\" \", flush=True)\n",
-    "        try:\n",
-    "            path = _run_one(sample)\n",
-    "            mep_paths.append(path)\n",
-    "            print(\"OK\")\n",
-    "        except Exception as exc:\n",
-    "            print(f\"ERROR: {exc}\")\n",
-    "else:\n",
-    "    with ThreadPoolExecutor(max_workers=N_WORKERS) as pool:\n",
-    "        futures = {pool.submit(_run_one, s): s for s in samples}\n",
-    "        for done, fut in enumerate(as_completed(futures), 1):\n",
-    "            s = futures[fut]\n",
-    "            try:\n",
-    "                path = fut.result()\n",
-    "                mep_paths.append(path)\n",
-    "                print(f\"[{done}/{len(samples)}] {s.sample_id} -> OK\")\n",
-    "            except Exception as exc:\n",
-    "                print(f\"[{done}/{len(samples)}] {s.sample_id} ERROR: {exc}\")\n",
-    "\n",
-    "print(f\"\\nDone -- {len(mep_paths)}/{len(samples)} MEPs written to {OUT_DIR}\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "cell-inspect-hdr",
-   "metadata": {},
-   "source": [
-    "## 6 — Inspect First MEP\n",
-    "\n",
-    "MEPs are self-contained JSON files. Every field you see here is what the agent actually\n",
-    "produced — no post-processing. The `lf_trace_id` links this MEP back to the live trace\n",
-    "in the Langfuse dashboard if Langfuse is configured."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "cell-inspect",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "if not mep_paths:\n",
-    "    print(\"No MEPs written -- check errors above.\")\n",
-    "else:\n",
-    "    mep = json.loads(Path(mep_paths[0]).read_text())\n",
-    "    s = mep[\"sample\"]\n",
-    "    pl = mep.get(\"plan\", {}).get(\"parsed\", {})\n",
-    "    vi = mep.get(\"vision\", {}).get(\"parsed\", {})\n",
-    "    vr = (mep.get(\"verifier\") or {}).get(\"parsed\", {})\n",
-    "    ts = mep.get(\"timestamps\", {})\n",
-    "\n",
-    "    print(\"=\" * 64)\n",
-    "    print(f\"Sample   : {s['sample_id']}\")\n",
-    "    print(f\"Type     : {s['question_type']}\")\n",
-    "    print(f\"Question : {s['question']}\")\n",
-    "    print(f\"Expected : {s['expected_output']}\")\n",
-    "    print()\n",
-    "    print(\"Planner steps:\")\n",
-    "    for j, step in enumerate(pl.get(\"steps\", []), 1):\n",
-    "        print(f\"  {j}. {step}\")\n",
-    "    print()\n",
-    "    print(f\"Vision answer : {vi.get('answer', '--')}\")\n",
-    "    print(f\"Explanation   : {vi.get('explanation', '--')[:280]}\")\n",
-    "    if vr:\n",
-    "        print()\n",
-    "        print(f\"Verifier verdict  : {vr.get('verdict', '--')}\")\n",
-    "        print(f\"Verifier answer   : {vr.get('answer', '--')}\")\n",
-    "        print(f\"Verifier reasoning: {vr.get('reasoning', '--')}\")\n",
-    "    print()\n",
-    "    print(\"Timestamps (ms):\")\n",
-    "    for k in [\"planner_ms\", \"ocr_ms\", \"vision_ms\", \"verifier_ms\"]:\n",
-    "        print(f\"  {k:<16} {ts.get(k, 0):.0f}\")\n",
-    "    if mep.get(\"lf_trace_id\"):\n",
-    "        print(f\"Langfuse trace ID: {mep['lf_trace_id']}\")\n",
-    "    print(\"=\" * 64)\n",
-    "\n",
-    "    img_path = s.get(\"image_ref\", {}).get(\"path\", \"\")\n",
-    "    if img_path and Path(img_path).exists():\n",
-    "        display(Image(filename=img_path, width=640))\n",
-    "    else:\n",
-    "        print(f\"(image not found at: {img_path})\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "cell-ocr-hdr",
-   "metadata": {},
-   "source": [
-    "## 7 — OCR Insight: What Was Injected into the Vision Prompt?\n",
-    "\n",
-    "The OcrReaderTool makes a single VLM call focused purely on text transcription.\n",
-    "Its structured JSON output is injected into the VisionAgent's prompt as `{ocr_block}`.\n",
-    "\n",
-    "This cell shows exactly what was transcribed and injected. When `USE_OCR=False`,\n",
-    "`{ocr_block}` renders as an empty string and the prompt is otherwise unchanged —\n",
-    "a clean example of conditional context injection without prompt branching."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "cell-ocr",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "if not mep_paths:\n",
-    "    print(\"No MEPs to inspect.\")\n",
-    "else:\n",
-    "    mep = json.loads(Path(mep_paths[0]).read_text())\n",
-    "    ocr_data = mep.get(\"ocr\")\n",
-    "\n",
-    "    if ocr_data is None:\n",
-    "        print(\"OCR was disabled (ocr: null in MEP).\")\n",
-    "        print(\"The {ocr_block} placeholder in vision.txt rendered as an empty string.\")\n",
-    "        print(\"Re-run with USE_OCR=True to see OCR output.\")\n",
-    "    else:\n",
-    "        parsed = ocr_data.get(\"parsed\", {})\n",
-    "        ts = mep.get(\"timestamps\", {})\n",
-    "        print(f\"OCR elapsed     : {ts.get('ocr_ms', 0):.0f} ms\")\n",
-    "        print(f\"Parse error     : {ocr_data.get('parse_error', False)}\")\n",
-    "        print()\n",
-    "        print(\"Structured OCR output (injected as {ocr_block} into vision.txt):\")\n",
-    "        print(f\"  chart_type  : {parsed.get('chart_type', '--')}\")\n",
-    "        print(f\"  title       : {parsed.get('title', '--')}\")\n",
-    "        x = parsed.get(\"x_axis\", {})\n",
-    "        print(f\"  x_axis      : label={x.get('label', '--')}  ticks={x.get('ticks', [])}\")\n",
-    "        y = parsed.get(\"y_axis\", {})\n",
-    "        print(f\"  y_axis      : label={y.get('label', '--')}  ticks={y.get('ticks', [])}\")\n",
-    "        print(f\"  legend      : {parsed.get('legend', [])}\")\n",
-    "        print(f\"  data_labels : {parsed.get('data_labels', [])}\")\n",
-    "        print(f\"  annotations : {parsed.get('annotations', [])}\")\n",
-    "        print()\n",
-    "        # Show raw OCR text\n",
-    "        raw = ocr_data.get(\"raw_text\", \"\")\n",
-    "        print(\"Raw OCR response (first 400 chars):\")\n",
-    "        print(raw[:400])"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "cell-ablation-hdr",
-   "metadata": {},
-   "source": [
-    "## 8 — Ablation: Run Without OCR\n",
-    "\n",
-    "Runs the same samples with `ocr_tool=None` and writes to a separate directory.\n",
-    "This lets you compare the two runs side-by-side in Pass 1 evaluation.\n",
-    "\n",
-    "Set `RUN_ABLATION=False` in the config cell to skip this section."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "cell-ablation",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "no_ocr_paths = []\n",
-    "OUT_DIR_NO_OCR = str(REPO_ROOT / \"meps\" / (CONFIG + \"_no_ocr\") / \"chartqapro\" / SPLIT)\n",
-    "RUN_ID_NO_OCR = str(uuid.uuid4())\n",
-    "\n",
-    "if not RUN_ABLATION:\n",
-    "    print(\"Skipped (RUN_ABLATION=False).\")\n",
-    "elif not USE_OCR:\n",
-    "    print(\"USE_OCR is already False -- the main run above IS the no-OCR baseline.\")\n",
-    "    print(\"Set USE_OCR=True and re-run to get the with-OCR version for comparison.\")\n",
-    "else:\n",
-    "    Path(OUT_DIR_NO_OCR).mkdir(parents=True, exist_ok=True)\n",
-    "    print(f\"Running {len(samples)} samples WITHOUT OCR -> {OUT_DIR_NO_OCR}\\n\")\n",
-    "    for i, sample in enumerate(samples, 1):\n",
-    "        print(f\"[{i}/{len(samples)}] {sample.sample_id} ...\", end=\" \", flush=True)\n",
-    "        try:\n",
-    "            path = process_sample(\n",
-    "                sample,\n",
-    "                planner,\n",
-    "                vision_agent,\n",
-    "                config,\n",
-    "                RUN_ID_NO_OCR,\n",
-    "                OUT_DIR_NO_OCR,\n",
-    "                lf_client=lf_client,\n",
-    "                verifier_agent=verifier,\n",
-    "                ocr_tool=None,  # <-- OCR disabled\n",
-    "            )\n",
-    "            no_ocr_paths.append(path)\n",
-    "            print(\"OK\")\n",
-    "        except Exception as exc:\n",
-    "            print(f\"ERROR: {exc}\")\n",
-    "    print(f\"\\nDone -- {len(no_ocr_paths)} no-OCR MEPs written\")\n",
-    "    print(\"\\nOCR vs no-OCR: check ocr_ms in timestamps for the time cost:\")\n",
-    "    if mep_paths:\n",
-    "        mep_with = json.loads(Path(mep_paths[0]).read_text())\n",
-    "        mep_without = json.loads(Path(no_ocr_paths[0]).read_text())\n",
-    "        print(\n",
-    "            f\"  With OCR    ocr_ms={mep_with.get('timestamps', {}).get('ocr_ms', 0):.0f}  vision_ms={mep_with.get('timestamps', {}).get('vision_ms', 0):.0f}\"\n",
-    "        )\n",
-    "        print(\n",
-    "            f\"  Without OCR ocr_ms={mep_without.get('timestamps', {}).get('ocr_ms', 0):.0f}  vision_ms={mep_without.get('timestamps', {}).get('vision_ms', 0):.0f}\"\n",
-    "        )"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "cell-eval1-hdr",
-   "metadata": {},
-   "source": [
-    "## 9 — Pass 1: Evaluate Outputs\n",
-    "\n",
-    "Rule-based accuracy scoring + optional LLM judge (5 rubric dimensions).\n",
-    "\n",
-    "- `answer_accuracy`: exact-match with numeric tolerance; MCQ partial credit\n",
-    "- `verifier_verdict`: `confirmed` / `revised` / `skipped`\n",
-    "- `judge_*`: scored 0–1 by a text LLM (only when `USE_JUDGE=True`)\n",
-    "\n",
-    "Results are written to `metrics_<label>.jsonl` in the repo root."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "cell-eval1",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "metrics_path = str(REPO_ROOT / \"output\" / f\"metrics_{OUT_LABEL}.jsonl\")\n",
-    "Path(REPO_ROOT / \"output\").mkdir(parents=True, exist_ok=True)\n",
-    "metrics_list = []\n",
-    "\n",
-    "print(f\"Evaluating MEPs in {OUT_DIR} ...\")\n",
-    "with open(metrics_path, \"w\") as f_out:\n",
-    "    for mep_dict in iter_meps(OUT_DIR):\n",
-    "        try:\n",
-    "            m = evaluate_mep(\n",
-    "                mep_dict,\n",
-    "                use_judge=USE_JUDGE,\n",
-    "                judge_backend=config.get(\"judge_backend\", \"gemini\"),\n",
-    "                judge_model=config.get(\"vision_model\", \"gemini-2.5-flash-lite\"),\n",
-    "            )\n",
-    "            f_out.write(json.dumps(m) + \"\\n\")\n",
-    "            metrics_list.append(m)\n",
-    "        except Exception as exc:\n",
-    "            print(f\"  eval error: {exc}\")\n",
-    "\n",
-    "print(f\"Pass 1 complete -- {len(metrics_list)} rows -> {metrics_path}\\n\")\n",
-    "\n",
-    "df = pd.DataFrame(metrics_list)\n",
-    "print(f\"Overall accuracy : {df['answer_accuracy'].mean():.1%}  (n={len(df)})\")\n",
-    "if \"verifier_verdict\" in df.columns and not df[\"verifier_verdict\"].eq(\"skipped\").all():\n",
-    "    revised = (df[\"verifier_verdict\"] == \"revised\").sum()\n",
-    "    print(f\"Verifier revised : {revised}/{len(df)} ({revised / len(df):.1%})\")\n",
-    "\n",
-    "# Accuracy by question type\n",
-    "print()\n",
-    "print(\"Accuracy by question type:\")\n",
-    "for qt, grp in df.groupby(\"question_type\"):\n",
-    "    print(f\"  {qt:<22} {grp['answer_accuracy'].mean():.1%}  (n={len(grp)})\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "cell-eval1-noocr",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Compare OCR vs no-OCR accuracy (only runs if ablation was done)\n",
-    "if no_ocr_paths:\n",
-    "    no_ocr_metrics = []\n",
-    "    for mep_dict in iter_meps(OUT_DIR_NO_OCR):\n",
-    "        import contextlib\n",
-    "\n",
-    "        with contextlib.suppress(Exception):\n",
-    "            no_ocr_metrics.append(evaluate_mep(mep_dict, use_judge=False))\n",
-    "    df_no_ocr = pd.DataFrame(no_ocr_metrics)\n",
-    "    print(\"Accuracy comparison:\")\n",
-    "    print(f\"  WITH OCR    : {df['answer_accuracy'].mean():.1%}  (n={len(df)})\")\n",
-    "    print(f\"  WITHOUT OCR : {df_no_ocr['answer_accuracy'].mean():.1%}  (n={len(df_no_ocr)})\")\n",
-    "    delta = df[\"answer_accuracy\"].mean() - df_no_ocr[\"answer_accuracy\"].mean()\n",
-    "    print(f\"  Delta       : {delta:+.1%}  (positive = OCR helped)\")\n",
-    "else:\n",
-    "    print(\"Ablation not run -- set RUN_ABLATION=True and re-run to compare OCR vs no-OCR.\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "cell-eval2-hdr",
-   "metadata": {},
-   "source": [
-    "## 10 — Pass 2: Evaluate Traces\n",
-    "\n",
-    "Trace-level metrics: latency per agent, tool call counts, and replayability score\n",
-    "(fraction of required MEP fields that are present and non-empty)."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "cell-eval2",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "trace_path = str(REPO_ROOT / \"output\" / f\"trace_metrics_{OUT_LABEL}.jsonl\")\n",
-    "Path(REPO_ROOT / \"output\").mkdir(parents=True, exist_ok=True)\n",
-    "trace_rows = []\n",
-    "\n",
-    "with open(trace_path, \"w\") as f_out:\n",
-    "    for mep_dict in iter_meps(OUT_DIR):\n",
-    "        row = evaluate_trace(mep_dict)\n",
-    "        f_out.write(json.dumps(row) + \"\\n\")\n",
-    "        trace_rows.append(row)\n",
-    "\n",
-    "trace_df = pd.DataFrame(trace_rows)\n",
-    "print(f\"Pass 2 complete -- {len(trace_df)} rows -> {trace_path}\\n\")\n",
-    "\n",
-    "cols = [\n",
-    "    \"latency_sec\",\n",
-    "    \"planner_latency_sec\",\n",
-    "    \"vision_latency_sec\",\n",
-    "    \"tool_call_count\",\n",
-    "    \"replayability\",\n",
-    "    \"error_count\",\n",
-    "]\n",
-    "cols = [c for c in cols if c in trace_df.columns]\n",
-    "print(trace_df[cols].describe().round(3).to_string())"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "cell-tax-hdr",
-   "metadata": {},
-   "source": [
-    "## 11 — Pass 4: Failure Taxonomy\n",
-    "\n",
-    "For each **wrong** answer, a VLM is shown the chart image, the wrong answer,\n",
-    "the correct answer, and the agent's explanation — and classifies the primary failure mode.\n",
-    "\n",
-    "Unlike a text-only judge, this pass can verify whether axis labels were actually ambiguous,\n",
-    "whether the cited data point appears in the image, etc.\n",
-    "\n",
-    "Correct answers (`answer_accuracy == 1.0`) are skipped without making any API call."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "cell-tax",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "taxonomy_path = str(REPO_ROOT / \"output\" / f\"taxonomy_{OUT_LABEL}.jsonl\")\n",
-    "Path(REPO_ROOT / \"output\").mkdir(parents=True, exist_ok=True)\n",
-    "taxonomy_rows = []\n",
-    "\n",
-    "# Build accuracy lookup from Pass 1\n",
-    "acc_map = {r[\"sample_id\"]: r[\"answer_accuracy\"] for r in metrics_list}\n",
-    "\n",
-    "vlm_backend = config[\"vision_backend\"]\n",
-    "vlm_model = config[\"vision_model\"]\n",
-    "\n",
-    "print(f\"Classifying failures using {vlm_backend} / {vlm_model} ...\")\n",
-    "with open(taxonomy_path, \"w\") as f_out:\n",
-    "    for mep_dict in iter_meps(OUT_DIR):\n",
-    "        sid = mep_dict.get(\"sample\", {}).get(\"sample_id\", \"\")\n",
-    "        acc = acc_map.get(sid, 0.0)\n",
-    "        try:\n",
-    "            result = classify_failure(\n",
-    "                mep_dict,\n",
-    "                answer_accuracy=acc,\n",
-    "                backend=vlm_backend,\n",
-    "                model=vlm_model,\n",
-    "            )\n",
-    "            row = {\"sample_id\": sid, \"answer_accuracy\": acc, **result}\n",
-    "            f_out.write(json.dumps(row) + \"\\n\")\n",
-    "            taxonomy_rows.append(row)\n",
-    "            marker = \"(skipped -- correct)\" if acc == 1.0 else result.get(\"failure_type\", \"\")\n",
-    "            print(f\"  {sid}: {marker}\")\n",
-    "        except Exception as exc:\n",
-    "            print(f\"  {sid}: ERROR {exc}\")\n",
-    "\n",
-    "tax_df = pd.DataFrame(taxonomy_rows)\n",
-    "print(f\"\\nPass 4 complete -- {len(tax_df)} rows -> {taxonomy_path}\\n\")\n",
-    "print(\"Failure type breakdown:\")\n",
-    "print(tax_df[\"failure_type\"].value_counts().to_string())"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "cell-sum-hdr",
-   "metadata": {},
-   "source": [
-    "## 12 — Summarize\n",
-    "\n",
-    "Aggregate all metrics into `summary_<label>.csv`, grouped by `config_name` and `question_type`.\n",
-    "To compare multiple configs, run cells 5–12 again with a different `CONFIG` value\n",
-    "then concatenate the `metrics_*.jsonl` files before summarising."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "cell-sum",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "summary_path = str(REPO_ROOT / \"output\" / f\"summary_{OUT_LABEL}.csv\")\n",
-    "Path(REPO_ROOT / \"output\").mkdir(parents=True, exist_ok=True)\n",
-    "\n",
-    "rows = summarize(metrics_list)\n",
-    "write_csv(rows, summary_path)\n",
-    "print(f\"Summary written -> {summary_path}  ({len(rows)} rows)\\n\")\n",
-    "\n",
-    "summary_df = pd.DataFrame(rows)\n",
-    "rename = {\n",
-    "    \"answer_accuracy_mean\": \"accuracy\",\n",
-    "    \"latency_sec_mean\": \"latency_s\",\n",
-    "    \"tool_call_count_mean\": \"tool_calls\",\n",
-    "}\n",
-    "show_cols = [\n",
-    "    \"config_name\",\n",
-    "    \"question_type\",\n",
-    "    \"count\",\n",
-    "    \"accuracy\",\n",
-    "    \"latency_s\",\n",
-    "    \"tool_calls\",\n",
-    "]\n",
-    "show_cols = [c for c in show_cols if c in [rename.get(k, k) for k in summary_df.columns] + list(summary_df.columns)]\n",
-    "\n",
-    "display(\n",
-    "    summary_df.rename(columns=rename)[\n",
-    "        [\n",
-    "            c\n",
-    "            for c in [\n",
-    "                \"config_name\",\n",
-    "                \"question_type\",\n",
-    "                \"count\",\n",
-    "                \"accuracy\",\n",
-    "                \"latency_s\",\n",
-    "                \"tool_calls\",\n",
-    "            ]\n",
-    "            if c in summary_df.rename(columns=rename).columns\n",
-    "        ]\n",
-    "    ]\n",
-    "    .fillna(\"\")\n",
-    "    .style.format({\"accuracy\": \"{:.1%}\", \"latency_s\": \"{:.1f}\", \"tool_calls\": \"{:.1f}\"})\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "cell-next-hdr",
-   "metadata": {},
-   "source": [
-    "## What to Explore Next\n",
-    "\n",
-    "- **`analysis.ipynb`** — visualise the results you just generated: accuracy charts, verifier\n",
-    "  revision analysis, failure taxonomy bar chart, judge score distributions, per-sample browser\n",
-    "\n",
-    "- **Compare configs** — change `CONFIG` in Cell 1 to `gemini_gemini` or `openai_gemini`,\n",
-    "  re-run cells 5–12, then concatenate the two `metrics_*.jsonl` files and summarise together\n",
-    "\n",
-    "- **Model overrides** — set `OCR_MODEL = 'gpt-4o-mini'` to run a cheaper model for OCR\n",
-    "  while keeping `gpt-4o` for the VisionAgent\n",
-    "\n",
-    "- **Streamlit dashboard** — `streamlit run src/agentfinvqa/eval/dashboard.py`\n",
-    "\n",
-    "- **HTML report** — `uv run --env-file .env -m agentfinvqa.eval.report --metrics metrics_<label>.jsonl --taxonomy taxonomy_<label>.jsonl --out report.html`"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "99286c3a",
-   "metadata": {},
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": ".venv",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.13.7"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}
diff --git a/results.md b/results.md
deleted file mode 100644
index 37412f3..0000000
--- a/results.md
+++ /dev/null
@@ -1,390 +0,0 @@
-# AgentFinVQA — Initial results summary
-
-This note condenses numbers from `notebooks/results_analysis.ipynb` (saved cell outputs), `output/final/**/summary*.csv`, and `output/baselines/*.jsonl` as of the current workspace. Use it as a starting point for an internal or initial report; re-run the notebook to refresh figures and tables.
-
----
-
-## Scope
-
-| Source | Rows (approx.) | Notes |
-|--------|----------------|--------|
-| ChartQAPro (test) | 8,107 metric rows across configs in the notebook load | Per-config *n* varies slightly (e.g. OpenAI 2,709 vs Gemini 2,708). |
-| FinMME (train) | 11,082 | Full Gemini agent run on the train split. |
-
-Primary models referenced: **Gemini 2.5 Flash** (agent and zero-shot) and **OpenAI GPT-4o** (ChartQAPro agent).
-
----
-
-## 1. ChartQAPro — overall accuracy (full available test metrics)
-
-| System | Accuracy | n |
-|--------|----------|---|
-| Gemini (2.5-Flash) — full agent | **0.5343** | 2,708 |
-| Gemini — no verifier | **0.5264** | 2,690 |
-| OpenAI (GPT-4o) | **0.4186** | 2,709 |
-
-**By question type (ChartQAPro, Gemini vs OpenAI):** hypothetical is strongest for both; OpenAI is relatively weaker on **standard** questions (0.39 vs ~0.57 for Gemini).
-
----
-
-## 2. ChartQAPro — zero-shot vs full agent (baseline file)
-
-From `output/baselines/metrics_chartqapro_test_zeroshot_gemini_gemini_2_5_flash.jsonl` (as loaded in the notebook):
-
-- **~2,689** rows  
-- Mean answer accuracy **~0.597**
-
-The full Gemini agent on the aggregated test metrics is **~0.534** (section 1), so on this aggregate, zero-shot is higher than the full pipeline on the same broad ChartQAPro evaluation — the notebook explores *where* the agent gains or loses (sample-level and by type).
-
----
-
-## 3. ChartQAPro — 250-sample aligned slice (No-OCR ablation)
-
-Restricted to **250** samples where **no-OCR, no-verifier, full Gemini, planner v2, OpenAI**, and **zero-shot** all have results (see notebook §13).
-
-| System | Accuracy (n = 250) |
-|--------|---------------------|
-| Zero-shot | **0.6520** |
-| Agent (full Gemini) | **0.6360** |
-| Agent (planner v2) | **0.6320** |
-| Agent (no OCR) | **0.6280** |
-| Agent (no verifier) | **0.6120** |
-| OpenAI (full) | **0.5040** |
-
-On this slice, zero-shot is slightly above the full Gemini agent; planner v2 is close to full agent. Removing OCR or verifier hurts accuracy relative to full.
-
----
-
-## 4. FinMME — full train split (Gemini agent)
-
-| System | Accuracy | n |
-|--------|----------|---|
-| Gemini (2.5-Flash) full agent | **0.5653** | 11,082 |
-
-**By question type:** MCQ **~0.63**, open **standard** **~0.23** (FinMME is much harder on non-MCQ items in this run).
-
----
-
-## 5. FinMME — zero-shot vs agent vs planner v2 (matched IDs)
-
-Baseline: `output/baselines/metrics_finmme_train_zeroshot_structured_gemini_gemini_2_5_flash.jsonl` (**233** rows).  
-Planner v2 metrics: `output/final/finmme_planner_v2/` (**250** rows in the planner file).
-
-Evaluation uses the **intersection of IDs** present in both zero-shot and planner v2 → **n = 233** (not 250).
-
-| System | Accuracy (n = 233) |
-|--------|---------------------|
-| Zero-shot (structured) | **~0.547** |
-| Agent (Gemini full) | **~0.592** |
-| Agent (Planner v2) | **~0.526** |
-
-On this matched set, the **full Gemini agent beats zero-shot**; **planner v2 is below both** (numbers recomputed from JSONL; notebook shows bootstrap CIs on the same slice).
-
-**Planner v2 — official summary on all 250 FinMME train samples** (`output/final/finmme_planner_v2/summary_finmme_train_planner_v2.csv`):
-
-- **ALL:** accuracy **0.544** (250 samples), mean latency **~18.9 s**
-
----
-
-## 6. ChartQAPro — planner v2 summary (250 samples)
-
-From `output/final/chartqapro_planner_v2/summary_chartqapro_test_planner_v2.csv`:
-
-- **ALL:** accuracy **0.632** (250 samples), mean latency **~16.2 s**
-
----
-
-## 7. Latency vs accuracy (notebook)
-
-Illustrative means from the latency table in the notebook (ChartQAPro aggregates):
-
-| System | Mean latency (s) | Accuracy |
-|--------|-------------------|----------|
-| Zero-shot (Gemini) | ~3.20 | ~0.597 |
-| Agent (Gemini) | ~11.96 | ~0.534 |
-| Agent (Gemini — no verifier) | ~12.69 | ~0.526 |
-| Agent (OpenAI) | ~7.73 | ~0.419 |
-
-(Exact latency rows depend on which trace files were merged; see notebook output.)
-
----
-
-## 8. Figures and artifacts (paths)
-
-Generated or referenced under `output/final/` (examples):
-
-- `fig_zeroshot_vs_agent.pdf`
-- `fig_latency_vs_accuracy_zs_with_no_verifier.pdf`
-- `fig_finmme_zeroshot_vs_agent_250.pdf`
-
----
-
-## 8b. FinMME — iterative fixes experiments (train slice)
-
-Progressive runs on a shared FinMME **train** slice: **v1–v7** on **250** labeled train IDs; **`fixes_v8_g3flash_color_area`**, **`fixes_v9_g3flash_related_sents`**, and **`fixes_v10_g3flash_choice_conflict`** target the same **1,250** train IDs (superset of the original 250 — same pipeline and config).  
-Runs v1–v6 use **Gemini 2.5 Flash Lite** for all stages; v4, v7, v8, v9, and v10 use **Gemini 3 Flash Preview** for planner/vision/verifier.
-
-**Post-eval coverage:** v8, v9, and v10 all have full **`metrics_*.jsonl`** rows (**n = 1,250**) on the same FinMME train ID slice — direct paired comparison is supported across all three.
-
-### What changed in each run
-
-| Run | Changes vs previous |
-|-----|---------------------|
-| `no_legend_grounding` | Baseline — no legend grounding, no caption injection, default token limits |
-| `fixes_v1` | + token limits raised to 2 048 · + analyst-caption hint injected into vision prompt · + verifier UNANSWERABLE pushback · + legend grounding enabled |
-| `fixes_v2` | + Gemini `thinking_budget=0` (eliminates thinking tokens) · + `choice_analysis` trimmed · + MCQ choices passed explicitly to verifier |
-| `fixes_v3` | + `thinking_budget=512` (moderate reasoning without exhausting output budget) |
-| `fixes_v4_g3flash` | + Gemini 3 Flash Preview model · + forced-choice retry when vision returns UNANSWERABLE on MCQ · + caption injected into verifier task · + MCQ-aware planner (eliminate-wrong-options guidance) · + pie/donut legend grounding |
-| `fixes_v5_multiselect` | + full multi-select MCQ support (planner / vision / verifier each have separate prompts for select-all-that-apply questions) |
-| `fixes_v6_conf_gate` | + verifier self-confidence field · + reluctance hint when vision is high-confidence · + confidence gate (revisions with confidence < 0.75 downgraded) — *(MEPs repaired in-place after parse-key bug caused 244/250 parse failures on first run)* |
-| `fixes_v7_g3flash_conf_gate` | + confidence default fixed to 0.75 (neutral) so gate only fires on explicit low confidence · fresh re-run with Gemini 3 Flash Preview + gate correctly active |
-| `fixes_v8_g3flash_color_area` | + OpenCV pixel-counting `color_area_tool` inserted between legend grounding and vision · per-label pixel breakdown + dominant-label hint injected into vision prompt for bar/pie/donut charts · `MEPColorArea` field added to MEP schema · gated by chart type, legend availability, and ambiguity flags (`color_ambiguity`, `low_confidence`) |
-| `fixes_v9_g3flash_related_sents` | + verifier sees `related_sentences` from sample metadata · caption reframed from “background” to “cross-check the draft answer” (same g3flash stack as v8) |
-| `fixes_v10_g3flash_choice_conflict` | + everything in v9 · when vision `choice_analysis` marks **≥2** single-select options at confidence **≥0.95**, verifier prompt gets a **VISION AMBIGUITY FLAG** (conflicting choice labels only — not the full `choice_analysis` dict) |
-
-### Accuracy (mean `answer_accuracy` with MCQ partial credit; strict exact in “No-judge” column)
-
-| Run | n | Mean acc. | Exact (≥ 0.999) | Δ vs baseline |
-|-----|---:|----------:|----------------:|---------------|
-| `no_legend_grounding` | 250 | — | **0.480** | — |
-| `fixes_v1` | 250 | — | **0.504** | +2.4 pp |
-| `fixes_v2` | 250 | — | **0.516** | +3.6 pp |
-| `fixes_v3` | 250 | — | **0.516** | +3.6 pp |
-| `fixes_v4_g3flash` | 250 | — | **0.560** | +8.0 pp |
-| `fixes_v5_multiselect` | 250 | **0.694** | **0.624** | +14.4 pp |
-| `fixes_v6_conf_gate` | 250 | **0.610** | **0.624** | +14.4 pp *(repaired)* |
-| `fixes_v7_g3flash_conf_gate` | 250 | **0.696** | **0.628** | **+14.8 pp** |
-| `fixes_v8_g3flash_color_area` | **1,250** | **0.712** | **0.651** | **+17.1 pp** |
-| `fixes_v9_g3flash_related_sents` | **1,250** | **0.713** | **0.646** | **+16.6 pp** |
-| `fixes_v10_g3flash_choice_conflict` | **1,250** | **0.711** | **0.642** | **+16.2 pp** |
-
-Per-type **mean** `answer_accuracy` (**n = 1,250** each):
-- v8: **mcq 0.725** (1,150), **standard 0.570** (100)
-- v9: **mcq 0.725** (1,150), **standard 0.570** (100)
-- v10: **mcq 0.722** (1,150), **standard 0.580** (100)
-
-At full scale v8, v9, and v10 are within **±0.2 pp mean acc.** of each other; per-type breakdowns are essentially indistinguishable. Earlier v9-vs-v8 deltas reported on a 784-sample partial eval were selection bias from fast-finishing samples and disappear once the full **1,250** rows are scored.
-
-The earlier **standard 0.70 on n = 20** (250-ID slice) was a small-sample artifact; v7 vs v8 on the **paired 250 overlap** differ by **−0.2 pp** mean acc. (essentially tied).
-
-**Paired strict correctness (`answer_accuracy == 1`) on the full 1,250-ID overlap (continuity-corrected McNemar with scipy `chi2.cdf`):**
-- v10 vs v8 — **χ² = 0.90**, **p = 0.34** (no significant change)
-- **v9 vs v8** — **χ² = 0.34**, **p = 0.56** (no significant change; v9-only wins = 50, v8-only wins = 57)
-- **v9 vs v10** — **χ² = 0.10**, **p = 0.75** (no significant change)
-
-All three runs (v8, v9, v10) sit inside the same paired-significance band — additional verifier context (`related_sentences`, choice-conflict flag) doesn't move strict accuracy at this n. Their *behavior* differs (verifier verdict mix, latency tail — see below), but headline mean / exact accuracy does not.
-
-*Mean `answer_accuracy` is rule-based (numeric tolerance + MCQ partial credit). The “Exact” column is the share of rows with `answer_accuracy ≥ 0.999`. Auxiliary rubric dimensions from `gemini-2.5-flash-lite` are stored as `judge_*` fields (explanation quality, hallucination rate, etc.) — separate from `answer_accuracy`. v6 mean score is lower than v5 due to minor differences in the repaired MEP set; exact scores match v5.*
-
-**FinMME paper baseline (full 11k eval):** Gemini Flash 2.0 = 51.85% avg. Our v7 on 250 samples = **69.6%** mean acc. (+17.8 pp vs paper headline, different metric family).
-
-### MAX_TOKENS truncation
-
-| Run | Samples truncated | % of run |
-|-----|------------------:|---------:|
-| `no_legend_grounding` | 167 | 66.8 % *(n = 250)* |
-| `fixes_v1` | 129 | 51.6 % |
-| `fixes_v2` | 6 | 2.4 % |
-| `fixes_v3` | 3 | 1.2 % |
-| `fixes_v4_g3flash` | 9 | 3.6 % |
-| `fixes_v5_multiselect` | 16 | 6.4 % |
-| `fixes_v6_conf_gate` | 21 | 8.4 % |
-| `fixes_v7_g3flash_conf_gate` | 20 | 8.0 % |
-| `fixes_v8_g3flash_color_area` | **184** | **14.7 %** *(n = 1,250)* |
-| `fixes_v9_g3flash_related_sents` | **199** | **15.9 %** *(n = 1,250 MEPs; vision/verifier `tool_trace` `finish_reason`)* |
-| `fixes_v10_g3flash_choice_conflict` | **183** | **14.6 %** *(n = 1,250)* |
-
-Raising token limits in `fixes_v1` reduced truncation modestly. Disabling thinking tokens in `fixes_v2` cut it to near-zero; `fixes_v3` halves it further. Later runs are slightly higher due to richer prompts (multi-select blocks, caption injection, verifier tools). On the **1,250-ID** v8 eval, **14.7%** of MEPs hit MAX_TOKENS in at least one traced stage (vs **8.0%** on the 250-ID v7 row) — expect slice and prompt-stack differences; the long-tail risk remains real. v9 shows a slightly higher hit rate (**15.9%**); v10 is back in line with v8 (**14.6%**).
-
-### UNANSWERABLE over-refusal
-
-| Run | UA predicted | Notes |
-|-----|-------------|-------|
-| `no_legend_grounding` | 46 | High over-refusal |
-| `fixes_v1` | 34 | Verifier pushback helps |
-| `fixes_v2` | 37 | — |
-| `fixes_v3` | 38 | — |
-| `fixes_v4_g3flash` | 5 | Forced-choice retry eliminates most MCQ UNANSWERABLE |
-| `fixes_v5_multiselect` | 4 | — |
-| `fixes_v6_conf_gate` | 0 | — |
-| `fixes_v7_g3flash_conf_gate` | 2 | — |
-| `fixes_v8_g3flash_color_area` | **14** *(n = 1,250)* / 2 *(n = 250)* | At 1,250 IDs, a small rise in UNANSWERABLE predictions vs the 250-ID snapshot; still low vs early runs |
-| `fixes_v9_g3flash_related_sents` | **7** *(n = 1,250)* | Matches v10; both halve v8's UA rate, consistent with the new caption / source-sentence framing giving the verifier more text to ground on |
-| `fixes_v10_g3flash_choice_conflict` | **7** *(n = 1,250)* | Slightly lower than v8's 14 on the same ID slice |
-
-### Verifier verdicts
-
-| Run | Confirmed | Revised | Error | Gated |
-|-----|-----------|---------|-------|-------|
-| `no_legend_grounding` | 175 | 73 | 2 | — |
-| `fixes_v1` | 196 | 54 | 0 | — |
-| `fixes_v2` | 205 | 41 | 4 | — |
-| `fixes_v3` | 207 | 43 | 0 | — |
-| `fixes_v4_g3flash` | 193 | 50 | 7 | — |
-| `fixes_v5_multiselect` | 179 | 70 | 1 | — |
-| `fixes_v6_conf_gate` | 193 | 52 | 5 | 0 *(bug: 0.0 default gated all revisions; repaired)* |
-| `fixes_v7_g3flash_conf_gate` | 180 | 66 | 4 | 1 |
-| `fixes_v8_g3flash_color_area` | **986** | **234** | **30** | 0 *(n = 1,250)* |
-| `fixes_v9_g3flash_related_sents` | **999** | **215** | **36** | 0 *(n = 1,250)* |
-| `fixes_v10_g3flash_choice_conflict` | **982** | **247** | **21** | 0 *(n = 1,250)* |
-
-**Verifier effectiveness (v7, n = 250):**
-
-- Revised samples: **66**
-- Exact accuracy on revised subset: **50.0%** (33/66)
-- Exact accuracy on non-revised subset: **67.4%** (124/184)
-
-**Verifier effectiveness (v8, n = 1,250):**
-
-- Revised samples: **234**; exact on revised subset **55.6%**
-- Confirmed samples: **986**; exact on confirmed subset **68.2%**
-- At scale, revisions track harder items but are no longer a “coin flip” the way the tiny v7 revised slice suggested.
-
-**Verifier effectiveness (v9, n = 1,250):**
-
-- Revised samples: **215**; exact on revised subset **52.1%** (mean **62.6%**)
-- Confirmed samples: **999**; exact on confirmed subset **68.0%** (mean **73.8%**)
-- Adding `related_sentences` shifts the verifier toward **slightly more confirmations** (999 vs v8's 986) and **fewer revisions** (215 vs 234) — the new textual signal seems to resolve some uncertainty in place rather than triggering a revision. Revised-subset exact dips ~3.5 pp vs v8 but mean is essentially flat (62.6% vs 62.6%), suggesting the marginal revisions are partial-credit cases rather than fresh wins.
-
-**Verifier effectiveness (v10, n = 1,250):**
-
-- Revised samples: **247**; exact (≥ 0.999) on revised subset **47.8%**
-- Confirmed samples: **982**; exact on confirmed subset **69.0%**
-- Mean `answer_accuracy` is almost unchanged vs v8 (**71.08%** vs **71.24%**), but the revised tail is **weaker** under exact-match accounting — worth monitoring if v10’s ambiguity flag invites extra revisions.
-
-### Latency (250 samples for v1–v7; v8 / v9 / v10 at 1,250)
-
-| Run | p50 (s) | p95 (s) | mean (s) |
-|-----|---------|---------|----------|
-| `no_legend_grounding` | 18.9 | 27.4 | 21.6 |
-| `fixes_v1` | 21.2 | 38.9 | 24.4 |
-| `fixes_v2` | 15.4 | 27.1 | 21.6 |
-| `fixes_v3` | 18.7 | 30.7 | 20.1 |
-| `fixes_v4_g3flash` | 30.4 | 232.8 | 46.5 |
-| `fixes_v5_multiselect` | 32.0 | 247.7 | 49.0 |
-| `fixes_v6_conf_gate` | 33.6 | 256.7 | 52.4 |
-| `fixes_v7_g3flash_conf_gate` | 32.3 | 246.1 | 41.5 |
-| `fixes_v8_g3flash_color_area` | **30.1** | **209.4** | **43.9** *(n = 1,250)* |
-| `fixes_v9_g3flash_related_sents` | **31.0** | **87.5** | **43.7** *(n = 1,250)* |
-| `fixes_v10_g3flash_choice_conflict` | **29.6** | **222.9** | **44.2** *(n = 1,250)* |
-
-`fixes_v1` is slower than baseline (legend grounding adds a stage). `fixes_v2` is fastest (thinking tokens off). v4–v7 improve accuracy substantially but increase latency and tail risk due to richer prompts and additional verification logic. On the **250-ID** v8 snapshot, median latency dipped vs v7 while mean rose slightly. On **n = 1,250**, v8 shows **mean 43.9 s**, **p50 30.1 s**, **p95 209.4 s** — same long-tail story, slightly lower mean than the 250-ID v8 snapshot (46.9 s) partly because more cached judge scores shortened some eval paths. **v10** is similar (**mean 44.2 s**, **p50 29.6 s**, **p95 222.9 s**).
-
-**v9 is the clear latency winner**: **mean 43.7 s**, **p50 31.0 s**, but **p95 only 87.5 s** — a **~2.4× tighter tail** than v8/v10 (209–223 s). Adding `related_sentences` and reframing the caption as a cross-check seems to give the verifier enough textual grounding that it converges without long retry chains; the long tail of v8 where the verifier kept thrashing on ambiguous charts collapses. This is the strongest unambiguous v9 win even though headline accuracy is tied with v8.
-
-### Failure taxonomy by question type (v7)
-
-From `taxonomy_finmme_train_fixes_v7_g3flash_conf_gate.jsonl` joined with metrics:
-
-- Total failures: **93** (`mcq`: 87, `standard`: 6)
-- Top overall failure types:
-  - `question_misunderstanding`: **25** (26.9%)
-  - `legend_confusion`: **18** (19.4%)
-  - `extraction_error`: **17** (18.3%)
-
-**MCQ failure composition (n=87):**
-
-| Failure type | Count | Share |
-|-------------|-------|-------|
-| question_misunderstanding | 23 | 26.4% |
-| extraction_error | 17 | 19.5% |
-| legend_confusion | 16 | 18.4% |
-| hallucinated_element | 12 | 13.8% |
-| other | 9 | 10.3% |
-| axis_misread | 6 | 6.9% |
-| unanswerable_failure | 4 | 4.6% |
-
-Most residual errors in v7 are therefore comprehension/grounding issues in MCQ, not UNANSWERABLE over-refusal.
-
-### Fair baseline check: Gemini-3 zero-shot vs agent
-
-`output/baselines/metrics_finmme_train_zeroshot_structured_gemini_gemini_3_flash_preview.jsonl` now holds **11,099** FinMME train rows (Gemini-3 Flash Preview structured zero-shot, parser-repaired). The file was initially under-parsed (`parse_ok=false` for 142 rows on an early 250-row snapshot); after repair, a **historical** strict-exact snapshot on **250** IDs was **52.8%** zero-shot vs **62.8%** agent v7 (**+10.0 pp** exact) — useful as an ablation-era record; backups live next to the baseline file.
-
-**Matched overlap (recommended for the paper):** the **1,250** `sample_id`s in **`fixes_v8_g3flash_color_area`** / **`fixes_v9_g3flash_related_sents`** / **`fixes_v10_g3flash_choice_conflict`** metrics all exist in the full zero-shot file. On that overlap (same rule-based `answer_accuracy`, same judge stack for the agent traces):
-
-| System | Mean `answer_accuracy` | Exact (≥ 0.999) |
-|--------|----------------------:|----------------:|
-| Agent `fixes_v8_g3flash_color_area` | **71.24%** | **65.12%** |
-| Agent `fixes_v9_g3flash_related_sents` | **71.28%** | **64.56%** |
-| Agent `fixes_v10_g3flash_choice_conflict` | **71.08%** | **64.24%** |
-| Zero-shot Gemini-3 preview (structured) | **63.56%** | **56.40%** |
-| **Δ (v8 agent − zero-shot)** | **+7.68 pp** | **+8.72 pp** |
-| **Δ (v9 agent − zero-shot)** | **+7.72 pp** | **+8.16 pp** |
-| **Δ (v10 agent − zero-shot)** | **+7.52 pp** | **+7.84 pp** |
-
-Paired **McNemar** test on strict correctness (binary strict correct = `answer_accuracy == 1` vs `< 1`, scipy `chi2.cdf`):
-- **v8** vs zero-shot — **χ² = 68.21**, **p ≈ 1.1 × 10⁻¹⁶**
-- **v9** vs zero-shot — **χ² = 61.45**, **p ≈ 4.5 × 10⁻¹⁵**
-- **v10** vs zero-shot — **χ² = 57.37**, **p ≈ 3.6 × 10⁻¹⁴**
-
-All three are overwhelmingly significant against zero-shot. Pairwise between the agents, all comparisons are **not significant** (v9 vs v8 p = 0.56, v10 vs v8 p = 0.34, v9 vs v10 p = 0.75) — at this n, accuracy is statistically tied across v8 / v9 / v10.
-
-**By `question_type` on the same 1,250-ID overlap (v8 / v9 / v10 vs zero-shot):**
-- mcq (n = 1,150): **+8.09 pp / +8.13 pp / +7.83 pp** mean acc.
-- standard (n = 100): **+3.00 pp / +3.00 pp / +4.00 pp** — treat the standard slice as **directional only** (wide uncertainty).
-
-(v9 full-scale numbers are now in the table above; the historical "v9 partial @ n = 784" snapshot was a fast-finishing-sample selection bias and is no longer the operating estimate.)
-
-**Full-file zero-shot context (not matched to v8 / v10):** on all **11,099** train rows, mean zero-shot acc. is **~61.5%**, with **standard** questions much harder (**~24%** mean) than in the first-1,250-ID slice — so scaling the agent to the full train split may see a lower standard-type floor than this overlap suggests.
-
-### Version legend
-
-| Tag | Model (planner/vision/verifier) | OCR / judge |
-|-----|---------------------------------|-------------|
-| `no_legend_grounding` | gemini-2.5-flash-lite | gemini-2.5-flash-lite |
-| `fixes_v1` | gemini-2.5-flash-lite | gemini-2.5-flash-lite |
-| `fixes_v2` | gemini-2.5-flash-lite | gemini-2.5-flash-lite |
-| `fixes_v3` | gemini-2.5-flash-lite | gemini-2.5-flash-lite |
-| `fixes_v4_g3flash` | **gemini-3-flash-preview** | gemini-2.5-flash-lite |
-| `fixes_v5_multiselect` | gemini-2.5-flash-lite | gemini-2.5-flash-lite |
-| `fixes_v6_conf_gate` | gemini-2.5-flash-lite | gemini-2.5-flash-lite |
-| `fixes_v7_g3flash_conf_gate` | **gemini-3-flash-preview** | gemini-2.5-flash-lite |
-| `fixes_v8_g3flash_color_area` | **gemini-3-flash-preview** | gemini-2.5-flash-lite |
-| `fixes_v9_g3flash_related_sents` | **gemini-3-flash-preview** | gemini-2.5-flash-lite |
-| `fixes_v10_g3flash_choice_conflict` | **gemini-3-flash-preview** | gemini-2.5-flash-lite |
-
-v1–v7: **250** FinMME train samples; v8 / v9 / v10 all evaluated on the same **1,250** train samples (`gemini_gemini` config, FinMME train split).
-
-### Color-area stage activation (v8)
-
-`color_area_tool` is gated by chart type, legend availability, and ambiguity flags, so it does not fire on every sample.
-
-| Metric | v8 @ 250 IDs (snapshot) | v8 @ 1,250 IDs |
-|---|---:|---:|
-| Color-area stage triggered | 12 (4.8%) | **62 (5.0%)** |
-| ↳ flagged `color_ambiguity` (hint suppressed) | 10 | **52** |
-| ↳ flagged `low_confidence` (hint suppressed) | 2 | **3** |
-| Legend compliance retries fired | 5 | **165** *(13.2% of 1,250 MEPs)* |
-
-The stage is conservatively gated — many charts (lines, multi-axis, etc.) never qualify — but at **n = 1,250** it fires on **~5%** of samples, not “effectively never.” **Paired v7 vs v8 on the same 250 IDs** is still **≈0 pp** mean acc. (see `metrics_*.n250` backups). The headline **0.712** at **n = 1,250** is mainly a **more stable MCQ estimate** (**72.5%** on 1,150 mcq) than the small 250-ID window suggested; it is **not** a large paired gain over v7 on identical IDs.
-
-### Key takeaways
-
-- **+14.8 pp accuracy** over baseline achieved by `fixes_v7` (48.0% → 62.8% no-judge; **69.6% judge-based**). `fixes_v8` matches v7 within noise (69.4% judge / 62.8% no-judge); the color-area hint is correct in direction but only activates on ~5% of the slice, so it doesn't move the headline number.
-- **Multi-select MCQ**: largest single-run gain was v5 (+8.8 pp on multiple_choice type, 30.2% → 53.5%).
-- **UNANSWERABLE over-refusal**: 46 → 2 on the 250-ID ladder (forced-choice retry in v4); **14 / 1,250** on v8; **7 / 1,250** on both v9 and v10 (still low vs early runs; the v9/v10 verifier prompts cut UA-confirmations in half by giving the model more text to ground on).
-- **MAX_TOKENS**: near-eliminated by v2–v3 on the ladder; later prompts add some tail risk again (**184** hits at v8, **199** v9, **183** v10 — all at **n = 1,250** MEPs by `tool_trace` `finish_reason`).
-- **Fair same-model baseline (primary):** on the **1,250-ID** overlap with full Gemini-3 zero-shot train eval, all three g3flash agents beat zero-shot by ~7.5–7.7 pp mean acc. (v8 **+7.68 / +8.72 pp**; v9 **+7.72 / +8.16 pp**; v10 **+7.52 / +7.84 pp** — mean / exact). All three p ≤ 4.5 × 10⁻¹⁵ vs zero-shot. **Pairwise between agents, no comparison is significant** (v9 vs v8 p = 0.56, v10 vs v8 p = 0.34, v9 vs v10 p = 0.75). Legacy **250-ID** strict-exact headline was **+10.0 pp** (v7 vs repaired zero-shot snapshot) — cite as historical ablation only.
-- **v9 / v10 verifier prompts:** v9 adds analyst `related_sentences` + caption-as–cross-check framing; v10 adds a **choice-conflict** meta-signal when two high-confidence single-select options collide. At full n = 1,250 both are statistically tied with v8 on mean / exact accuracy (paired McNemar p ≥ 0.34); v9's distinctive win is a **2.4× tighter latency tail** (p95 87.5 s vs v8's 209.4 s).
-- **Confidence gate**: designed to block low-confidence verifier revisions; only fires when model explicitly returns `confidence < 0.75` (1 gate in v7). Bug in v6 where `confidence` was required in parse keys caused all revisions to fail; repaired in-place.
-- **Model upgrade (g3flash)**: v4, v7, v8, v9, and v10 use Gemini 3 Flash Preview — contributes meaningful gains over 2.5 Flash Lite.
-- **Verifier**: at v8 **n = 1,250**, revised rows remain harder but revised-subset exact rises to **~55.6%** (vs **50%** on 66 v7 revised IDs). **v10** increases revisions (**247** vs **234**) but **exact** on revised rows drops to **~47.8%** while headline mean acc. stays within **~0.2 pp** of v8 — monitor if the ambiguity flag trades calibration for exactness.
-- **OpenCV color-area (v8)**: opt-in stage between legend grounding and vision; **~5%** trigger rate at 1,250 IDs; `MEPColorArea` trace for audits.
-- **vs. paper baseline**: v7 **0.696** mean acc. on 250 IDs vs Gemini Flash 2.0 from FinMME paper (51.85%) = **+17.8 pp** (different metric family than the paper table).
-
-Full per-sample analysis, flip tables, taxonomy breakdowns, and charts are in `notebooks/results_analysis.ipynb` § 14–16.
-For paper-ready headline numbers, see `markdown/camera_ready_metrics.md`.
-
----
-
-## 9. Caveats for the report
-
-1. **Different n across configs** — ChartQAPro row counts differ slightly by config; comparisons should note which subset is used.  
-2. **FinMME 233 vs 250** — Zero-shot baseline does not cover all 250 planner-v2 IDs; the fair three-way comparison uses **233** overlapping samples.  
-3. **FinMME v8 / v9 / v10 vs ladder (n)** — v1–v7 rows in §8b are **250** train IDs; **`fixes_v8`**, **`fixes_v9`**, and **`fixes_v10`** each ship **1,250** `metrics_*.jsonl` rows on the same ID slice — do not mix headline tables with the smaller ladder rows without a `sample_id` join.  
-4. **Slices vs full test** — The **250-sample** ChartQAPro block is a *controlled subset*; headline full-test numbers are in §1–2.  
-5. **Refresh** — Re-execute `results_analysis.ipynb` after new runs to update tables and PDFs.
-
----
-
-*Generated to support an initial results memo; align wording with your paper’s definitions of accuracy and splits.*
diff --git a/scripts/repair_meps_v6.py b/scripts/repair_meps_v6.py
deleted file mode 100644
index 6413da9..0000000
--- a/scripts/repair_meps_v6.py
+++ /dev/null
@@ -1,98 +0,0 @@
-"""
-Repair fixes_v6_conf_gate MEPs: re-parse verifier.raw_text using the corrected
-required-keys list (confidence is optional, not required).
-
-Run:
-    python scripts/repair_meps_v6.py
-"""
-
-import json
-import sys
-from pathlib import Path
-
-
-sys.path.insert(0, str(Path(__file__).parent.parent / "src"))
-from agentfinvqa.utils.json_strict import parse_strict
-
-
-VERIFIER_REQUIRED_KEYS = ["verdict", "answer", "reasoning"]  # confidence is optional
-VALID_VERDICTS = {"confirmed", "revised"}
-
-MEP_DIR = Path("meps/gemini_gemini/finmme/fixes_v6_conf_gate/train")
-
-
-def repair_mep(path: Path) -> str:
-    """Return one of: 'fixed', 'already_ok', 'no_raw', 'unparsable'."""
-    data = json.loads(path.read_text())
-    verifier = data.get("verifier") or {}
-    verdict = verifier.get("verdict", "skipped")
-
-    if verdict in VALID_VERDICTS and verifier.get("parse_error") is False:
-        return "already_ok"
-
-    raw_text = (verifier.get("raw_text") or "").strip()
-    if not raw_text:
-        return "no_raw"
-
-    parsed, parse_ok = parse_strict(raw_text, required_keys=VERIFIER_REQUIRED_KEYS)
-    if not parsed:
-        return "unparsable"
-
-    # Normalise verdict
-    raw_verdict = str(parsed.get("verdict", "")).lower()
-    if raw_verdict not in VALID_VERDICTS:
-        raw_verdict = "confirmed"
-    parsed["verdict"] = raw_verdict
-
-    # Clamp optional confidence
-    try:
-        conf = float(parsed.get("confidence", 1.0))
-        parsed["confidence"] = max(0.0, min(1.0, conf))
-    except (TypeError, ValueError):
-        parsed["confidence"] = 1.0 if raw_verdict == "confirmed" else 0.5
-
-    # Apply confidence gate: downgrade low-confidence revisions
-    gated = False
-    if raw_verdict == "revised":
-        if parsed["confidence"] < 0.75:
-            old_reasoning = parsed.get("reasoning", "")[:80]
-            parsed["verdict"] = "confirmed"
-            parsed["answer"] = (data.get("vision") or {}).get("parsed", {}).get("answer", "")
-            parsed["reasoning"] = (
-                f"[Confidence gate: revision confidence {parsed['confidence']:.2f} < 0.75 — "
-                f"keeping vision answer. Original reasoning: {old_reasoning}]"
-            )
-            gated = True
-
-    # Update verifier block
-    verifier["parsed"] = parsed
-    verifier["verdict"] = parsed["verdict"]
-    verifier["parse_error"] = not parse_ok
-
-    # Clean up errors list: remove verifier_invalid_output entries
-    errors = [e for e in (data.get("errors") or []) if "verifier_invalid_output" not in str(e)]
-    if gated:
-        errors.append(f"verifier_revision_gated: confidence={parsed['confidence']:.2f}")
-    data["errors"] = errors
-
-    path.write_text(json.dumps(data, indent=2))
-    return "gated" if gated else "fixed"
-
-
-def main():
-    results = {"fixed": 0, "gated": 0, "already_ok": 0, "no_raw": 0, "unparsable": 0}
-    paths = sorted(MEP_DIR.glob("*.json"))
-    print(f"Repairing {len(paths)} MEPs in {MEP_DIR} ...")
-    for i, p in enumerate(paths, 1):
-        outcome = repair_mep(p)
-        results[outcome] += 1
-        if i % 50 == 0:
-            print(f"  {i}/{len(paths)} processed ...")
-
-    print("\nDone.")
-    for k, v in results.items():
-        print(f"  {k:<14}: {v}")
-
-
-if __name__ == "__main__":
-    main()
diff --git a/scripts/repair_meps_v7.py b/scripts/repair_meps_v7.py
deleted file mode 100644
index a5f3305..0000000
--- a/scripts/repair_meps_v7.py
+++ /dev/null
@@ -1,101 +0,0 @@
-"""
-Repair fixes_v7_g3flash_conf_gate MEPs: the confidence gate incorrectly fired
-for all verifier revisions because the model never returned a 'confidence' field,
-causing the default of 0.0 to trigger the < 0.75 gate threshold.
-
-Fix: un-gate revisions where 'confidence' is NOT present in raw_text.
-Only keep gated if the model explicitly returned confidence < 0.75.
-
-Run:
-    python scripts/repair_meps_v7.py
-"""
-
-import json
-import sys
-from pathlib import Path
-
-
-sys.path.insert(0, str(Path(__file__).parent.parent / "src"))
-from agentfinvqa.utils.json_strict import parse_strict
-
-
-VERIFIER_REQUIRED_KEYS = ["verdict", "answer", "reasoning"]
-VALID_VERDICTS = {"confirmed", "revised"}
-CONFIDENCE_GATE_THRESHOLD = 0.75
-
-MEP_DIR = Path("meps/gemini_gemini/finmme/fixes_v7_g3flash_conf_gate/train")
-
-
-def repair_mep(path: Path) -> str:
-    """Return one of: 'ungated', 'gate_kept', 'already_ok', 'no_raw', 'unparsable'."""
-    data = json.loads(path.read_text())
-    errors = data.get("errors") or []
-    verifier = data.get("verifier") or {}
-
-    was_gated = any("verifier_revision_gated" in str(e) for e in errors)
-    if not was_gated:
-        return "already_ok"
-
-    raw_text = (verifier.get("raw_text") or "").strip()
-    if not raw_text:
-        return "no_raw"
-
-    parsed, parse_ok = parse_strict(raw_text, required_keys=VERIFIER_REQUIRED_KEYS)
-    if not parsed:
-        return "unparsable"
-
-    raw_verdict = str(parsed.get("verdict", "")).lower()
-    if raw_verdict not in VALID_VERDICTS:
-        raw_verdict = "confirmed"
-
-    # Check if the model explicitly returned a confidence value
-    confidence_in_raw = "confidence" in parsed
-    if confidence_in_raw:
-        try:
-            explicit_conf = float(parsed["confidence"])
-            explicit_conf = max(0.0, min(1.0, explicit_conf))
-        except (TypeError, ValueError):
-            explicit_conf = CONFIDENCE_GATE_THRESHOLD  # neutral if unparsable
-    else:
-        explicit_conf = CONFIDENCE_GATE_THRESHOLD  # model didn't return it → neutral, don't gate
-
-    # Only keep gated if confidence was explicit AND below threshold
-    should_gate = (raw_verdict == "revised") and confidence_in_raw and (explicit_conf < CONFIDENCE_GATE_THRESHOLD)
-
-    if should_gate:
-        # Gate is legitimately correct — leave as-is
-        return "gate_kept"
-
-    # Un-gate: restore the verifier's actual verdict/answer
-    parsed["verdict"] = raw_verdict
-    parsed["confidence"] = explicit_conf
-
-    verifier["parsed"] = parsed
-    verifier["verdict"] = raw_verdict
-    verifier["parse_error"] = not parse_ok
-
-    # Remove the incorrect gate error
-    errors = [e for e in errors if "verifier_revision_gated" not in str(e)]
-    data["errors"] = errors
-
-    path.write_text(json.dumps(data, indent=2))
-    return "ungated"
-
-
-def main():
-    results = {"ungated": 0, "gate_kept": 0, "already_ok": 0, "no_raw": 0, "unparsable": 0}
-    paths = sorted(MEP_DIR.glob("*.json"))
-    print(f"Repairing {len(paths)} MEPs in {MEP_DIR} ...")
-    for i, p in enumerate(paths, 1):
-        outcome = repair_mep(p)
-        results[outcome] += 1
-        if i % 50 == 0:
-            print(f"  {i}/{len(paths)} processed ...")
-
-    print("\nDone.")
-    for k, v in results.items():
-        print(f"  {k:<14}: {v}")
-
-
-if __name__ == "__main__":
-    main()
diff --git a/scripts/run_finmme_fixes_v10.sh b/scripts/run_finmme_fixes_v10.sh
deleted file mode 100755
index 3dea2e7..0000000
--- a/scripts/run_finmme_fixes_v10.sh
+++ /dev/null
@@ -1,31 +0,0 @@
-#!/usr/bin/env bash
-# FinMME train (1,250 samples): Gemini 3 Flash Preview (planner / vision / verifier) + Flash-Lite judge.
-# v10 — everything in v9, plus verifier **choice-conflict meta-signal**:
-#   - related_sentences + caption cross-check (same as v9)
-#   - When vision's ``choice_analysis`` rates ≥2 single-select options at confidence ≥0.95,
-#     the verifier prompt gets a VISION AMBIGUITY FLAG (labels only — not the full dict).
-# Same 1,250-ID slice as v8/v9 for paired comparison.
-#
-# Output dir (run_tag): meps/gemini_gemini/finmme/fixes_v10_g3flash_choice_conflict/train/
-# Metrics dir         : output/final/finmme_fixes_v10_g3flash_choice_conflict/
-#
-# Usage: ./scripts/run_finmme_fixes_v10.sh
-# Remove --resume below for a full re-run from scratch.
-set -euo pipefail
-
-REPO_ROOT="$(cd -- "$(dirname "${BASH_SOURCE[0]}")"/.. && pwd)"
-cd "$REPO_ROOT"
-
-scripts/submit_pipeline.sh \
-    --dataset finmme \
-    --split train \
-    --n 1250 \
-    --config gemini_gemini \
-    --vision_model gemini-3-flash-preview \
-    --planner_model gemini-3-flash-preview \
-    --verifier_model gemini-3-flash-preview \
-    --judge_model gemini-2.5-flash-lite \
-    --run_tag fixes_v10_g3flash_choice_conflict \
-    --out_label finmme_train_fixes_v10_g3flash_choice_conflict \
-    --langfuse \
-    --resume
diff --git a/scripts/run_finmme_fixes_v8_g3flash.sh b/scripts/run_finmme_fixes_v8_g3flash.sh
deleted file mode 100755
index 3a23131..0000000
--- a/scripts/run_finmme_fixes_v8_g3flash.sh
+++ /dev/null
@@ -1,29 +0,0 @@
-#!/usr/bin/env bash
-# FinMME train (1250 samples = original 250 + 1000 new, indices 250..1249):
-# Gemini 3 Flash preview (planner / vision / verifier) + Flash-Lite judge.
-# v8 — includes color-area (OpenCV) stage; distinct run_tag / out_label vs v7 conf_gate runs.
-#
-# --n 1250 + --resume: the first 250 samples already have MEPs in
-#   meps/gemini_gemini/finmme/fixes_v8_g3flash_color_area/train/ and are skipped;
-#   the runner only processes the new samples finmme_000250..finmme_001249.
-# After the chained judge batch eval, the metrics file rebuilds with 1250 rows.
-# Usage: ./scripts/run_finmme_fixes_v8_g3flash.sh
-# Remove --resume below for a full re-run from scratch.
-set -euo pipefail
-
-REPO_ROOT="$(cd -- "$(dirname "${BASH_SOURCE[0]}")"/.. && pwd)"
-cd "$REPO_ROOT"
-
-scripts/submit_pipeline.sh \
-    --dataset finmme \
-    --split train \
-    --n 1250 \
-    --config gemini_gemini \
-    --vision_model gemini-3-flash-preview \
-    --planner_model gemini-3-flash-preview \
-    --verifier_model gemini-3-flash-preview \
-    --judge_model gemini-2.5-flash-lite \
-    --run_tag fixes_v8_g3flash_color_area \
-    --out_label finmme_train_fixes_v8_g3flash_color_area \
-    --langfuse \
-    --resume
diff --git a/scripts/run_finmme_fixes_v9.sh b/scripts/run_finmme_fixes_v9.sh
deleted file mode 100755
index 23a673f..0000000
--- a/scripts/run_finmme_fixes_v9.sh
+++ /dev/null
@@ -1,30 +0,0 @@
-#!/usr/bin/env bash
-# FinMME train (1,250 samples): Gemini 3 Flash Preview (planner / vision / verifier) + Flash-Lite judge.
-# v9 — verifier now sees:
-#   - related_sentences (analyst source text from sample metadata) — new in v9
-#   - caption reframed from "background" to "cross-check the draft answer" — new in v9
-# Same 1,250-ID slice as v8 for a paired comparison.
-#
-# Output dir (run_tag): meps/gemini_gemini/finmme/fixes_v9_g3flash_related_sents/train/
-# Metrics dir         : output/final/finmme_fixes_v9_g3flash_related_sents/
-#
-# Usage: ./scripts/run_finmme_fixes_v9.sh
-# Remove --resume below for a full re-run from scratch.
-set -euo pipefail
-
-REPO_ROOT="$(cd -- "$(dirname "${BASH_SOURCE[0]}")"/.. && pwd)"
-cd "$REPO_ROOT"
-
-scripts/submit_pipeline.sh \
-    --dataset finmme \
-    --split train \
-    --n 1250 \
-    --config gemini_gemini \
-    --vision_model gemini-3-flash-preview \
-    --planner_model gemini-3-flash-preview \
-    --verifier_model gemini-3-flash-preview \
-    --judge_model gemini-2.5-flash-lite \
-    --run_tag fixes_v9_g3flash_related_sents \
-    --out_label finmme_train_fixes_v9_g3flash_related_sents \
-    --langfuse \
-    --resume
diff --git a/scripts/run_finmme_legend_grounding.sh b/scripts/run_finmme_legend_grounding.sh
deleted file mode 100755
index ef880a6..0000000
--- a/scripts/run_finmme_legend_grounding.sh
+++ /dev/null
@@ -1,22 +0,0 @@
-#!/usr/bin/env bash
-# Run the first 250 FinMME samples with legend grounding enabled.
-set -euo pipefail
-
-REPO_ROOT="$(cd -- "$(dirname "${BASH_SOURCE[0]}")"/.. && pwd)"
-cd "$REPO_ROOT"
-
-scripts/submit_pipeline.sh \
-    --dataset        finmme \
-    --split          train \
-    --n              250 \
-    --config         gemini_gemini \
-    --planner_model  gemini-2.5-flash \
-    --vision_model   gemini-2.5-flash \
-    --ocr_model      gemini-2.5-flash-lite \
-    --verifier_model gemini-2.5-flash \
-    --judge_model    gemini-2.5-flash-lite \
-    --workers        8 \
-    --langfuse \
-    --run_tag        legend_grounding \
-    --job_name       finmme_legend_grounding \
-    --out_label      finmme_train_legend_grounding
diff --git a/scripts/submit_eval.sh b/scripts/submit_eval.sh
deleted file mode 100755
index 5cd3373..0000000
--- a/scripts/submit_eval.sh
+++ /dev/null
@@ -1,98 +0,0 @@
-#!/usr/bin/env bash
-# Submit a post-evaluation-only SLURM job on existing MEPs.
-#
-# Usage:
-#   scripts/submit_eval.sh [options]
-#
-# Options:
-#   --dataset DATASET      Dataset (default: finmme)
-#   --split SPLIT          Split slice used during generation (default: train)
-#   --config CONFIG        Backend config preset (default: gemini_gemini)
-#   --workers N            Parallel eval workers (default: 8)
-#   --judge_model M        Judge model (default: gemini-2.5-flash-lite)
-#   --use_judge            Run inline LLM judge per sample
-#   --langfuse             Push eval scores to Langfuse traces
-#   --eval_dir DIR         Output directory for artifacts (default: output)
-#   --out_label LABEL      Label for output files (default: DATASET_SPLIT)
-#   --no_verifier          MEPs live under <dataset>/no_verifier/<split> (match generation)
-#   --no_ocr               MEPs live under <dataset>/no_ocr/<split> (match generation)
-#   --eval_resume          Merge with existing metrics_*.jsonl: skip sample_ids already scored
-#   --after JOB_ID         Hold until JOB_ID completes successfully (optional)
-
-set -euo pipefail
-
-REPO_ROOT="$(cd -- "$(dirname "${BASH_SOURCE[0]}")"/.. && pwd)"
-cd "$REPO_ROOT"
-
-mkdir -p logs
-
-module --force purge
-module load slurm/bonecho/25.05.2
-
-# Defaults
-DATASET="finmme"
-SPLIT="train"
-CONFIG="gemini_gemini"
-WORKERS=8
-JUDGE_MODEL="gemini-2.5-flash-lite"
-MEP_START=0
-USE_JUDGE=0
-LANGFUSE=0
-EVAL_RESUME=0
-EVAL_DIR="output"
-OUT_LABEL=""
-AFTER_JOB=""
-NO_VERIFIER=0
-NO_OCR=0
-RUN_TAG=""
-
-while [[ $# -gt 0 ]]; do
-    case "$1" in
-        --dataset)   DATASET="$2";   shift 2 ;;
-        --split)     SPLIT="$2";     shift 2 ;;
-        --config)    CONFIG="$2";    shift 2 ;;
-        --workers)     WORKERS="$2";     shift 2 ;;
-        --judge_model) JUDGE_MODEL="$2"; shift 2 ;;
-        --mep_start)   MEP_START="$2";   shift 2 ;;
-        --use_judge)   USE_JUDGE=1;      shift ;;
-        --eval_resume) EVAL_RESUME=1;    shift ;;
-        --langfuse)  LANGFUSE=1;     shift ;;
-        --no_verifier) NO_VERIFIER=1;  shift ;;
-        --no_ocr)      NO_OCR=1;       shift ;;
-        --run_tag)     RUN_TAG="$2";   shift 2 ;;
-        --eval_dir)  EVAL_DIR="$2";  shift 2 ;;
-        --out_label) OUT_LABEL="$2"; shift 2 ;;
-        --after)     AFTER_JOB="$2"; shift 2 ;;
-        *) echo "Unknown option: $1"; exit 1 ;;
-    esac
-done
-
-OUT_LABEL="${OUT_LABEL:-${DATASET}_${SPLIT}}"
-
-export DATASET SPLIT CONFIG WORKERS JUDGE_MODEL MEP_START USE_JUDGE LANGFUSE EVAL_RESUME EVAL_DIR OUT_LABEL NO_VERIFIER NO_OCR RUN_TAG
-
-echo "=== Submitting eval-only job ==="
-echo "  Dataset      : $DATASET"
-echo "  Split        : $SPLIT"
-echo "  Config       : $CONFIG"
-echo "  Workers      : $WORKERS"
-echo "  Judge model  : $JUDGE_MODEL"
-echo "  Use judge    : $USE_JUDGE"
-echo "  Eval resume  : $EVAL_RESUME"
-echo "  Langfuse     : $LANGFUSE"
-echo "  Eval dir     : $EVAL_DIR"
-echo "  Output label : $OUT_LABEL"
-echo "  No verifier  : $NO_VERIFIER"
-echo "  No OCR       : $NO_OCR"
-[[ -n "$AFTER_JOB" ]] && echo "  After job    : $AFTER_JOB"
-echo ""
-
-JOB_DEP=""
-[[ -n "$AFTER_JOB" ]] && JOB_DEP="--dependency=afterok:${AFTER_JOB}"
-
-JOB=$(sbatch --parsable --export=ALL $JOB_DEP scripts/slurm_eval_only.slrm)
-echo "Eval job submitted: $JOB"
-echo ""
-echo "Monitor with:"
-echo "  squeue -j $JOB"
-echo "  tail -f logs/slurm_eval_${JOB}.out"
diff --git a/scripts/submit_pipeline.sh b/scripts/submit_pipeline.sh
deleted file mode 100755
index 0ddb8e0..0000000
--- a/scripts/submit_pipeline.sh
+++ /dev/null
@@ -1,147 +0,0 @@
-#!/usr/bin/env bash
-# Submit MEP generation + batch judge submission as a chained SLURM pipeline.
-# Job 2 only runs if Job 1 succeeds (afterok dependency).
-#
-# Usage:
-#   scripts/submit_pipeline.sh [options]
-#
-# Options:
-#   --dataset DATASET      Dataset to run (default: finmme)
-#   --split SPLIT          Dataset split slice (default: train[3000:5000])
-#   --n N                  Max samples (default: 2000). Use 0 for the full split (after --split slice).
-#   --workers N            Parallel workers (default: 8)
-#   --planner_model M      Planner model (default: gemini-2.5-flash)
-#   --vision_model M       Vision model (default: gemini-2.5-flash)
-#   --ocr_model M          OCR model (default: gemini-2.5-flash-lite)
-#   --verifier_model M     Verifier model (default: gemini-2.5-flash)
-#   --judge_model M        Judge model for batch eval (default: gemini-2.5-flash-lite)
-#   --langfuse             Enable Langfuse tracing
-#   --resume               Resume from existing MEPs
-#   --no_verifier          Skip Pass 2.5 verifier (ablation: planner/vision answer kept)
-#   --no_legend_grounding  Skip legend grounding stage (ablation)
-#   --out_label LABEL      Batch metrics basename (default: {dataset}_{split}[_no_verifier], split chars sanitized)
-#   --config CONFIG        Backend config preset (default: gemini_gemini)
-#   --job_name NAME        SLURM job name (default: agentfinvqa_batch)
-#   --after JOB_ID         Hold job 1 until JOB_ID completes successfully (optional)
-
-set -euo pipefail
-
-REPO_ROOT="$(cd -- "$(dirname "${BASH_SOURCE[0]}")"/.. && pwd)"
-cd "$REPO_ROOT"
-
-mkdir -p logs
-
-# Load SLURM module so sbatch is available
-module --force purge
-module load slurm/bonecho/25.05.2
-
-# Defaults
-DATASET="finmme"
-SPLIT="train[3000:5000]"
-N=2000
-WORKERS=8
-PLANNER_MODEL="gemini-2.5-flash"
-VISION_MODEL="gemini-2.5-flash"
-OCR_MODEL="gemini-2.5-flash-lite"
-VERIFIER_MODEL="gemini-2.5-flash"
-JUDGE_MODEL="gemini-2.5-flash-lite"
-CONFIG="gemini_gemini"
-LANGFUSE=0
-RESUME=0
-NO_VERIFIER=0
-NO_OCR=0
-NO_LEGEND_GROUNDING=0
-RUN_TAG=""
-OUT_LABEL=""
-AFTER_JOB=""
-JOB_NAME="agentfinvqa_batch"
-
-while [[ $# -gt 0 ]]; do
-    case "$1" in
-        --dataset)       DATASET="$2";        shift 2 ;;
-        --split)         SPLIT="$2";          shift 2 ;;
-        --n)             N="$2";              shift 2 ;;
-        --workers)       WORKERS="$2";        shift 2 ;;
-        --planner_model) PLANNER_MODEL="$2";  shift 2 ;;
-        --vision_model)  VISION_MODEL="$2";   shift 2 ;;
-        --ocr_model)     OCR_MODEL="$2";      shift 2 ;;
-        --verifier_model) VERIFIER_MODEL="$2"; shift 2 ;;
-        --judge_model)   JUDGE_MODEL="$2";    shift 2 ;;
-        --config)        CONFIG="$2";         shift 2 ;;
-        --langfuse)      LANGFUSE=1;          shift ;;
-        --resume)        RESUME=1;            shift ;;
-        --no_verifier)   NO_VERIFIER=1;       shift ;;
-        --no_ocr)              NO_OCR=1;              shift ;;
-        --no_legend_grounding) NO_LEGEND_GROUNDING=1; shift ;;
-        --run_tag)             RUN_TAG="$2";          shift 2 ;;
-        --out_label)     OUT_LABEL="$2";      shift 2 ;;
-        --after)         AFTER_JOB="$2";      shift 2 ;;
-        --job_name)      JOB_NAME="$2";       shift 2 ;;
-        *) echo "Unknown option: $1"; exit 1 ;;
-    esac
-done
-
-# Default batch-judge output label: avoids collisions (e.g. metrics_test.jsonl for every dataset).
-# MEP dir: meps/${CONFIG}/${DATASET}/${SPLIT} or .../${DATASET}/no_verifier/${SPLIT} if NO_VERIFIER=1.
-if [[ -z "${OUT_LABEL}" ]]; then
-    SAFE_SPLIT=$(printf '%s' "$SPLIT" | sed 's/[^A-Za-z0-9._-]/_/g' | tr -s '_' | sed 's/^_//' | sed 's/_$//')
-    OUT_LABEL="${DATASET}_${SAFE_SPLIT}"
-    [[ "$NO_VERIFIER" == "1" ]] && OUT_LABEL="${OUT_LABEL}_no_verifier"
-fi
-
-if [[ "$NO_VERIFIER" == "1" ]]; then
-    MEP_DIR_PREVIEW="meps/${CONFIG}/${DATASET}/no_verifier/${SPLIT}"
-else
-    MEP_DIR_PREVIEW="meps/${CONFIG}/${DATASET}/${SPLIT}"
-fi
-
-# Export vars so sbatch inherits them (avoids --export string parsing issues
-# with special characters like brackets in split names e.g. train[0:1])
-export DATASET SPLIT N WORKERS PLANNER_MODEL VISION_MODEL OCR_MODEL VERIFIER_MODEL LANGFUSE RESUME NO_VERIFIER NO_OCR NO_LEGEND_GROUNDING RUN_TAG
-export JUDGE_MODEL CONFIG OUT_LABEL JOB_NAME
-
-echo "=== Submitting ${DATASET} pipeline ==="
-echo "  Dataset        : $DATASET"
-echo "  Split          : $SPLIT"
-echo "  N              : $N"
-echo "  Workers        : $WORKERS"
-echo "  Planner model  : $PLANNER_MODEL"
-echo "  Vision model   : $VISION_MODEL"
-echo "  OCR model      : $OCR_MODEL"
-echo "  Verifier model : $VERIFIER_MODEL"
-echo "  Judge model    : $JUDGE_MODEL"
-echo "  Langfuse       : $LANGFUSE"
-echo "  Config         : $CONFIG"
-echo "  Resume         : $RESUME"
-echo "  No verifier    : $NO_VERIFIER"
-echo "  No OCR         : $NO_OCR"
-echo "  No legend grnd : $NO_LEGEND_GROUNDING"
-echo "  Run tag        : ${RUN_TAG:-none}"
-echo "  MEP directory  : $MEP_DIR_PREVIEW"
-echo "  Batch metrics  : output/metrics_${OUT_LABEL}.jsonl"
-echo "  Output label   : $OUT_LABEL"
-echo "  Job name       : $JOB_NAME"
-[[ -n "$AFTER_JOB" ]] && echo "  After job      : $AFTER_JOB"
-echo ""
-
-# Job 1: MEP generation (optionally held until AFTER_JOB completes)
-JOB1_DEP=""
-[[ -n "$AFTER_JOB" ]] && JOB1_DEP="--dependency=afterok:${AFTER_JOB}"
-JOB1=$(sbatch --parsable --export=ALL --job-name="${JOB_NAME}" --cpus-per-task="${WORKERS}" $JOB1_DEP scripts/slurm_run_batch.slrm)
-echo "Job 1 (generate) submitted: $JOB1"
-
-# Load SLURM module so sbatch is available
-module --force purge
-module load slurm/bonecho/25.05.2
-
-# Job 2: submit Gemini Batch judge job (runs only if job 1 succeeds)
-JOB2=$(sbatch --parsable --export=ALL \
-    --job-name="${JOB_NAME}_judge" \
-    --dependency=afterok:${JOB1} \
-    scripts/slurm_submit_judge_batch.slrm)
-echo "Job 2 (judge submit) submitted: $JOB2 (depends on $JOB1)"
-
-echo ""
-echo "Monitor with:"
-echo "  squeue -j ${JOB1},${JOB2}"
-echo "  tail -f logs/slurm_batch_${JOB1}.out"
diff --git a/updates.md b/updates.md
deleted file mode 100644
index d4caef7..0000000
--- a/updates.md
+++ /dev/null
@@ -1,126 +0,0 @@
-# Recent Codebase Updates
-
-For project-management tracking, see `markdown/clickup_worklog_v1_to_v7.md`.
-
-## FinMME Iterative Fixes — v4 through v10 (2026-04 / 2026-05)
-
-### Multi-select MCQ support (`fixes_v5_multiselect`)
-- Added `_is_multi_select(sample)` helper in `vision_agent.py` — checks `metadata.question_type_raw == "multiple_choice"` or keywords ("select all", "all that apply", etc.)
-- **Planner prompt** (`agents/prompts/planner.txt`): added distinct multi-select MCQ guidance — "Evaluate EACH choice independently", "Compile ALL choices supported", do not stop at first match
-- **Vision prompt** (`agents/prompts/vision.txt`): added `{multi_select_block}` placeholder; MCQ rules split into single-select vs multi-select paths; UNANSWERABLE override applies only when no choices are present
-- **Vision agent** (`agents/vision_agent.py`): `_format_multi_select_block()` generates a bold warning block; Task `expected_output` updated conditionally for multi-select
-- **Vision tool** (`tools/vision_qa_tool.py`): `VisionQAInput` has `multi_select: bool`; `_build_prompt()` has three branches for multi-select / single MCQ / open
-- **Verifier agent** (`agents/verifier_agent.py`): passes `multi_select_note` into task description; verifier tool called with `multi_select=True/False`
-- **Verifier tool** (`tools/verifier_tool.py`): two separate prompt templates `_VERIFIER_PROMPT_SINGLE` and `_VERIFIER_PROMPT_MULTI`; multi prompt enforces per-choice step-by-step verification and never collapsing to single letter
-- Result: multiple_choice accuracy 30.2% → 53.5% (+23.3 pp)
-
-### Verifier confidence gate (`fixes_v6_conf_gate` / `fixes_v7_g3flash_conf_gate`)
-- **Selective verifier**: `vision_min_conf` computed from `choice_analysis` confidence scores; if ≥ 0.95 a strong reluctance hint is added to verifier task; if ≥ 0.85 a soft hint
-- **Confidence gate** in `runner/run_generate_meps.py`: if verifier returns `verdict=revised` with `confidence < 0.75`, revision is downgraded to confirmed and vision answer retained; logged as `verifier_revision_gated`
-- **Bug (v6)**: `"confidence"` added to `VERIFIER_REQUIRED_KEYS` caused `parse_strict` to return `{}` for 244/250 samples (model rarely returns this field) → regression −8.8 pp
-- **Repair script** (`scripts/repair_meps_v6.py`): re-parsed `verifier.raw_text` for all 250 v6 MEPs using corrected required_keys `["verdict", "answer", "reasoning"]`; fixed 239 MEPs in-place
-- **Fix (v7)**: confidence default changed from `0.0` → `0.75` (neutral, passes gate) in both `verifier_agent.py` and `run_generate_meps.py`; gate now only fires on explicit model output `< 0.75`
-- **Repair script** (`scripts/repair_meps_v7.py`): un-gates revisions in v7 MEPs generated before the fix where `confidence` was absent from raw output
-- Result: v7 gate fired 1 time (correctly), 66 revisions passed through; judge accuracy 69.6% (+0.2 pp vs v5)
-
-### Pipeline additions (`fixes_v4_g3flash`)
-- **Forced-choice retry**: if VisionAgent returns UNANSWERABLE and MCQ choices exist, vision is re-called with "FORCED CHOICE" prepend; reduced UNANSWERABLE rate from 38 → 5
-- **Caption → verifier**: `verified_caption` from sample metadata injected into verifier task description
-- **MCQ-aware planner**: added eliminate-wrong-options guidance and verify-best-match step
-- **Pie/donut legend grounding**: `_LEGEND_GROUNDING_CHART_TYPES` extended to include `"pie"` and `"donut"`
-- **Model preset**: `gemini_gemini_flash` (gemini-2.5-flash) and `gemini_gemini_flash_preview` (gemini-2.5-flash-preview-04-17) added to runner config
-
-### FinMME verifier context upgrades — v9 / v10 (2026-05)
-
-- **`fixes_v9_g3flash_related_sents`** (`scripts/run_finmme_fixes_v9.sh`): verifier prompt now includes **`related_sentences`** from sample metadata (analyst source text) and reframes **`verified_caption`** from “background” to **cross-check the draft answer**; planner/vision/verifier remain **Gemini 3 Flash Preview** with **`gemini-2.5-flash-lite`** judge (`--run_tag fixes_v9_g3flash_related_sents`, `--out_label finmme_train_fixes_v9_g3flash_related_sents`).
-  - **Full post-eval (n = 1,250):** mean `answer_accuracy` **71.28%**, exact **64.56%**; mcq **72.52%** (1,150), standard **57.00%** (100). vs Gemini-3 zero-shot on the same overlap: **+7.72 pp** mean (**+8.16 pp** exact); McNemar vs zero-shot **χ² ≈ 61.45**, **p ≈ 4.5×10⁻¹⁵**; paired **v9 vs v8** strict correctness **χ² ≈ 0.34, p ≈ 0.56** (not significant). MAX_TOKENS: **199 / 1,250** (**15.9%**); UNANSWERABLE predictions **7 / 1,250**; verifier verdicts **999 / 215 / 36** (confirmed / revised / error — slightly more confirmations / fewer revisions than v8). Latency (metrics JSONL): mean **43.7 s**, p50 **31.0 s**, **p95 87.5 s** — the **~2.4× tighter tail vs v8 (p95 209 s)** is v9's clearest unambiguous gain.
-  - Earlier partial-eval read (n = 784) reported v9 at **70.60% mean** and **−1.47 pp vs v8** on that subset; that was selection bias from the fastest-finishing samples and disappears once the full 1,250 rows are scored.
-- **`fixes_v10_g3flash_choice_conflict`** (`scripts/run_finmme_fixes_v10.sh`): everything in v9 plus a **choice-conflict meta-signal** — when vision `choice_analysis` marks **≥2** single-select options at confidence **≥0.95**, the verifier sees **conflicting choice labels only** (not the full `choice_analysis` dict), via `format_ambiguity_block` / `choice_analysis_ambiguity_labels` in `src/agentfinvqa/tools/verifier_tool.py` and wiring in `src/agentfinvqa/agents/verifier_agent.py`.
-  - **Full post-eval (n = 1,250):** mean `answer_accuracy` **71.08%**, exact **64.24%**; mcq **72.22%** (1,150), standard **58.00%** (100). vs Gemini-3 zero-shot on the same overlap: **+7.52 pp** mean; McNemar vs zero-shot **χ² ≈ 57.4**, **p ≈ 3.6×10⁻¹⁴**; paired **v10 vs v8** strict correctness **p ≈ 0.34** (not significant). MAX_TOKENS: **183 / 1,250** (**14.6%**); UNANSWERABLE predictions **7 / 1,250**; verifier verdicts **982 / 247 / 21** (confirmed / revised / error). Latency (metrics JSONL): mean **44.2 s**, p50 **29.6 s**, p95 **222.9 s**.
-- **Eval-only resume:** `scripts/submit_eval.sh` supports **`--eval_resume`** for merging existing `metrics_*.jsonl` / trace / taxonomy by `sample_id` (see `scripts/run_batch.py`).
-
-### Color-area pre-hint (`fixes_v8_g3flash_color_area`)
-- **New tool** `src/agentfinvqa/tools/color_area_tool.py`: OpenCV/HSV pixel counter that masks each labeled series color in a chart region and returns a per-label pixel breakdown plus the dominant label.
-- **Gating** (`should_trigger_color_area`): the stage fires only when (a) `chart_type` is one of the supported color-area types (bar, pie, donut variants), (b) a legend map exists with ≥2 series, and (c) the question is plausibly a color-area / dominance question. All other charts skip the stage.
-- **Vision-prompt injection** (`format_color_area_block_for_vision`): when the OpenCV result is clean, the per-label pixel ranking and dominant-label hint are formatted as a context block and injected into the vision prompt; when `color_ambiguity` or `low_confidence` is set, the hint is suppressed so the vision agent isn't misled by a weak mask.
-- **MEP schema** (`mep/schema.py`): new `MEPColorArea` dataclass capturing `triggered`, `breakdown`, `largest`, `total_pixels_matched`, `low_confidence`, `color_ambiguity`, `parse_error`, and `tool_trace`; wired into the `MEP` dataclass as `color_area: Optional[MEPColorArea] = None`.
-- **Runner integration** (`runner/run_generate_meps.py`): color-area stage runs after legend grounding and before vision; the result is threaded into `build_vision_task_description` via the `color_area=` kwarg.
-- **Vision agent** (`agents/vision_agent.py`): `build_vision_task_description` now accepts `color_area: Optional[MEPColorArea]` and emits the formatted block (or nothing when suppressed).
-- **Tests** (`tests/agentfinvqa/test_color_area_tool.py`): unit suite covering the HSV-color helper, OpenCV-imread mocking, dominant-label selection, ambiguity flagging, and the `format_color_area_block_for_vision` formatter.
-- **Runner script** (`scripts/run_finmme_fixes_v8_g3flash.sh`): one-shot wrapper that calls `submit_pipeline.sh` with `--config gemini_gemini`, Gemini 3 Flash Preview models, `--resume`, and writes outputs under `output/final/finmme_fixes_v8_g3flash_color_area/`.
-- **Results — 250-ID snapshot (early eval, still valid for paired v7 comparison)**:
-  - Mean `answer_accuracy` **0.694** (v7: **0.696**, Δ **−0.2 pp** on the same 250 IDs — within noise)
-  - Exact (≥ 0.999) **0.628** (same as v7 on that slice)
-  - Verifier verdicts: confirmed **187** / revised **59** / error **4** / gated **0** — revision rate drops vs v7 on the same IDs
-  - Color-area triggered **12/250** (4.8%); **10** `color_ambiguity` / **2** `low_confidence` suppressions — only ~2 samples received a usable hint, so the 250-ID headline stayed flat
-  - MAX_TOKENS **16/250**; UNANSWERABLE **2/250**; legend compliance retries **5/250**
-  - Latency p50 **29.8 s** (v7: 32.3 s), mean **46.9 s** (v7: 41.5 s)
-- **Results — 1,250-ID scale-up (May 2026 post-eval)** — `metrics_finmme_train_fixes_v8_g3flash_color_area.jsonl`:
-  - Mean `answer_accuracy` **0.7124** (exact **65.12%**); by type: **mcq 0.7248** (n = 1,150), **standard 0.5700** (n = 100)
-  - `vision_parse_ok` **~0.930**, `has_errors` **~3.9%** (reliability improved vs the first 250-ID tail)
-  - Verifier verdicts: confirmed **986** / revised **234** / error **30**
-  - Color-area triggered **62/1,250** (**5.0%**); **52** ambiguity / **3** low-confidence suppressions (MEP-derived counts)
-  - MAX_TOKENS hits **184/1,250** (**14.7%**); UNANSWERABLE predictions **14/1,250** (**1.1%**); legend compliance retries **165/1,250** (**13.2%**)
-  - Latency mean **43.9 s**, p50 **30.1 s**, p95 **209.4 s**
-- **Fair same-model baseline (Gemini-3 zero-shot)** — `output/baselines/metrics_finmme_train_zeroshot_structured_gemini_gemini_3_flash_preview.jsonl` is the **full FinMME train** run (**11,099** rows). On the **1,250-ID overlap**, all three g3flash agents beat zero-shot by ~7.5–7.7 pp mean acc.: v8 **+7.68 pp** (McNemar χ² ≈ 68.2, p ≈ 1.1×10⁻¹⁶), v9 **+7.72 pp** (χ² ≈ 61.5, p ≈ 4.5×10⁻¹⁵), v10 **+7.52 pp** (χ² ≈ 57.4, p ≈ 3.6×10⁻¹⁴). Pairwise between agents nothing is significant (v9 vs v8 p = 0.56, v10 vs v8 p = 0.34, v9 vs v10 p = 0.75). The legacy **+10.0 pp on 250 IDs** (strict exact v7 vs repaired zero-shot snapshot) is superseded for the main paper claim — see `results.md` §8b and `markdown/camera_ready_metrics.md`.
-- **Artifact hygiene:** `scripts/run_batch.py` now **sorts** `metrics_*.jsonl`, `trace_metrics_*.jsonl`, and `taxonomy_*.jsonl` by `sample_id` before flush so reruns are diff-stable (results buffered in memory until workers finish — interrupted `--eval_only` runs may write nothing).
-
-### Notebook (`notebooks/results_analysis.ipynb`)
-- Section 14 expanded to 9-run comparison covering all runs through v8
-- Per-type breakdown (single_choice / multiple_choice / numerical), revision gated tracking, confidence field availability
-- Section 15 paper comparison table (Table 3 style from FinMME ACL 2025 paper) vs Gemini Flash 2.0, Qwen2.5-VL 72B, GPT-4o, Claude 3.5 Sonnet, GPT-4o Mini
-- Added fair 250-ID comparison cell for `fixes_v7_g3flash_conf_gate` vs zero-shot baselines (`gemini-2.5-flash` and `gemini-3-flash-preview`) with coverage-aware matched IDs
-- Added Section 16: failure taxonomy by question type (v5→v7), including v7 heatmap and trend plots for top failure categories
-- Section 14 / 15 / 16 cells extended to also load and report `fixes_v8_g3flash_color_area`, including per-type accuracy, MAX_TOKENS / UNANSWERABLE / verifier-verdict / latency rows, and a `color_area_triggered` activation breakdown
-
-### Zero-shot parser repair (Gemini 3 Flash Preview)
-- Root cause: `baselines/run_zeroshot.py` structured parser only accepted strict JSON, so fenced/truncated-but-recoverable responses were marked `parse_ok=false` with empty `predicted`.
-- Implemented robust extraction in `run_zeroshot.py`:
-  - code-fence stripping (` ```json ... ``` `)
-  - truncated JSON suffix recovery
-  - regex fallback for `"answer": "..."` extraction
-  - last-resort `Answer: ...` fallback
-- Mirrored same extraction improvements in `baselines/fix_zeroshot_scores.py`.
-- Repaired existing file in place:
-  - `output/baselines/metrics_finmme_train_zeroshot_structured_gemini_gemini_3_flash_preview.jsonl`
-  - Reparsed rows: **141**
-  - Exact accuracy moved from artificially low (~29.2%) to **52.8%** on 250 rows
-  - Backup written as `.jsonl.bak`
-
-### v7 verifier effectiveness snapshot
-- v7 verifier verdict counts: `confirmed=180`, `revised=66`, `error=4`
-- Exact accuracy by verdict:
-  - `confirmed`: **68.33%**
-  - `revised`: **50.00%**
-  - `error`: **25.00%**
-- Revised subset (`n=66`) remains harder than non-revised subset (`n=184`, 67.39% exact), so revision quality is still a key improvement target.
-
----
-
-## Langfuse Integration
-- Added `_Instrumentor` protocol plus `_build_instrumentor` helper so Google/OpenAI telemetry hooks are instantiated only when their packages are installed; prevents assigning `None` to imported classes and keeps imports at module top for Ruff E402.
-- `get_client` now runs from a cached `_client` and `_initialised` flag exactly as before, but the instrumentation guards wrap `instrument()` calls in `contextlib.suppress` so failures never crash the service.
-- Switched `register_dataset` to accept `Sequence[PerceivedSample]`, iterate with an explicit `for` loop, and print success counts; the CLI now uses a typed `DatasetLoaderConfig` (loader/display/default image dir) so both dataset CLI and runner share one configuration source.
-- Introduced `DatasetConfig` TypedDict and `DatasetLoader` aliases inside the MEP runner, then reused them for CLI argument validation and to compute dataset slugs.
-- Extracted `_run_verifier_stage` from `process_sample` to encapsulate parsing, defaulting, and error tracking for Pass 2.5 output; reduces branching and keeps error messages consistent with the previous inlined logic.
-- Centralized dataset registration and Langfuse prompt pushes at runner start, so a single `get_client()` call now drives dataset creation, prompt versioning, and on-the-fly score logging without duplicated env handling between CLI utilities.
-- Added clearer log lines (dataset name, skip counts, Langfuse enablement) around runner startup so long-running pipeline executions expose their configuration at a glance.
-
-## Vision Agent Prompting
-- Split `build_vision_task_description` into `_format_choice_blocks`, `_format_context_block`, `_format_plan_steps`, and `_format_ocr_block` so each conditional block can be unit-tested independently and Ruff no longer reports PLR0912.
-- Each formatter mirrors the existing prompt structure (e.g., choice labels lines, context prefix, OCR axis formatting), so the generated prompt text is identical while the main builder simply fills the template.
-- The refactor keeps `VISION_PROMPT_PATH` templating untouched, guaranteeing that only formatting helpers change behavior; this makes prompt diffs easy to audit alongside prompt text stored in `agents/prompts/vision.txt`.
-
-## Evaluation & Taxonomy Pipeline
-- `_parse_choice_labels` now stores lookups in `maybe_label` before appending, eliminating assignments of `str | None` into a list of `str`; this appeases mypy and clarifies the branch logic.
-- Gemini helper functions in `error_taxonomy.py` and `eval_topk.py` now construct `genai.types.Part.from_bytes(...)` directly and only cast the `client.models` attribute to `Any`, removing redundant casts that mypy flagged while keeping compatibility with the google-genai stubs.
-- The Streamlit dashboard’s `sidebar_path_picker` docstring now starts with an imperative verb (“Select…”) matching Ruff D401 requirements.
-- The taxonomy classifier now shares the same prompt string but routes missing-image cases through explicit OpenAI/Gemini fallbacks, improving error messaging and making it simple to reason about when a multimodal call will actually occur.
-- Top-K evaluation continues to record Langfuse scores when available, but safer casting ensures those writes degrade gracefully if Langfuse credentials are absent.
-
-## Static Analysis & Tooling Hygiene
-- Added module docstring to `langfuse_integration/client.py`, docstrings to `DatasetLoaderConfig`/`DatasetConfig`, and removed blank lines per Ruff D1xx/D2xx suggestions.
-- Updated typing imports (e.g., using `collections.abc.Callable`, `TypedDict`, `Protocol`) to make mypy happy under `from __future__ import annotations`.
-- Verified all changes with `UV_CACHE_DIR=/tmp/uv-cache uv run ruff check ...` and `... uv run mypy`, ensuring the pre-commit hooks that originally failed now succeed locally.
-- Leveraged Ruff’s PLR checks as a forcing function to split logic-heavy helpers; the resulting structure also simplifies future unit test authoring because each helper has a single responsibility.
-- Documented the new behavior in `updates.md` so future reviewers can see at a glance why typing and linting changes were necessary (e.g., compatibility with google-genai release cadence).

From 8faf702c14dcf5dcea2bacc1076cc3c387a4c587 Mon Sep 17 00:00:00 2001
From: Aravind N <aravindn1308@outlook.com>
Date: Thu, 11 Jun 2026 16:09:43 -0400
Subject: [PATCH 11/15] chore: update dependencies for security and
 compatibility

- Upgraded jupyterlab to version 4.5.7 for improved security.
- Added security lower bounds for transitive dependencies: aiohttp, cryptography, gitpython, idna, jupyter-server, and mistune.
- Updated the version of aiohttp to 3.14.1 in the lock file.
- Added new CVE exclusions in the code checks workflow.
---
 .github/workflows/code_checks.yml |   2 +
 pyproject.toml                    |   9 +-
 uv.lock                           | 291 ++++++++++++++++--------------
 3 files changed, 169 insertions(+), 133 deletions(-)

diff --git a/.github/workflows/code_checks.yml b/.github/workflows/code_checks.yml
index 4759817..4153008 100644
--- a/.github/workflows/code_checks.yml
+++ b/.github/workflows/code_checks.yml
@@ -58,3 +58,5 @@ jobs:
           ignore-vulns: |
             GHSA-4xh5-x5gv-qwph
             CVE-2026-4539
+            CVE-2026-45829
+            CVE-2025-69872
diff --git a/pyproject.toml b/pyproject.toml
index 172280b..e952dae 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -13,7 +13,7 @@ dependencies = [
     "ipython>=9.4.0",
     "ipywidgets>=8.1.7",
     "jupyter>=1.1.1",
-    "jupyterlab>=4.4.8",
+    "jupyterlab>=4.5.7",  # PYSEC-2026-164, CVE-2026-42557
     "matplotlib>=3.10.5",
     "numpy>=1.26,<2.0",
     "opencv-python-headless>=4.8.0",
@@ -30,6 +30,13 @@ dependencies = [
     "vllm>=0.14.0",
     "qwen-vl-utils==0.0.14",
     "litellm>=1.84.0",
+    # Security lower bounds for transitive dependencies
+    "aiohttp>=3.14.0",       # CVE-2026-34993, CVE-2026-47265
+    "cryptography>=46.0.7",  # PYSEC-2026-35, PYSEC-2026-36
+    "gitpython>=3.1.50",     # CVE-2026-42215, CVE-2026-42284, CVE-2026-44244, GHSA-mv93-w799-cj2w
+    "idna>=3.15",            # CVE-2026-45409
+    "jupyter-server>=2.18.0",  # PYSEC-2026-67/68/69, CVE-2026-40110
+    "mistune>=3.2.1",        # PYSEC-2026-168, CVE-2026-33079
 ]
 
 [build-system]
diff --git a/uv.lock b/uv.lock
index 66b6e22..4edace0 100644
--- a/uv.lock
+++ b/uv.lock
@@ -24,16 +24,22 @@ name = "agentfinvqa"
 version = "0.1.0"
 source = { editable = "." }
 dependencies = [
+    { name = "aiohttp" },
+    { name = "cryptography" },
     { name = "datasets" },
+    { name = "gitpython" },
     { name = "google-genai" },
+    { name = "idna" },
     { name = "ipykernel" },
     { name = "ipython" },
     { name = "ipywidgets" },
     { name = "jupyter" },
+    { name = "jupyter-server" },
     { name = "jupyterlab" },
     { name = "langfuse" },
     { name = "litellm" },
     { name = "matplotlib" },
+    { name = "mistune" },
     { name = "mypy" },
     { name = "numpy" },
     { name = "openai" },
@@ -81,16 +87,22 @@ docs = [
 
 [package.metadata]
 requires-dist = [
+    { name = "aiohttp", specifier = ">=3.14.0" },
+    { name = "cryptography", specifier = ">=46.0.7" },
     { name = "datasets", specifier = ">=4.0.0" },
+    { name = "gitpython", specifier = ">=3.1.50" },
     { name = "google-genai", specifier = ">=1.34.0" },
+    { name = "idna", specifier = ">=3.15" },
     { name = "ipykernel", specifier = ">=6.29.5" },
     { name = "ipython", specifier = ">=9.4.0" },
     { name = "ipywidgets", specifier = ">=8.1.7" },
     { name = "jupyter", specifier = ">=1.1.1" },
-    { name = "jupyterlab", specifier = ">=4.4.8" },
+    { name = "jupyter-server", specifier = ">=2.18.0" },
+    { name = "jupyterlab", specifier = ">=4.5.7" },
     { name = "langfuse", specifier = ">=4" },
     { name = "litellm", specifier = ">=1.84.0" },
     { name = "matplotlib", specifier = ">=3.10.5" },
+    { name = "mistune", specifier = ">=3.2.1" },
     { name = "mypy", specifier = ">=1.19.1" },
     { name = "numpy", specifier = ">=1.26,<2.0" },
     { name = "openai", specifier = ">=2.8.0" },
@@ -147,7 +159,7 @@ wheels = [
 
 [[package]]
 name = "aiohttp"
-version = "3.13.3"
+version = "3.14.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "aiohappyeyeballs" },
@@ -156,78 +168,93 @@ dependencies = [
     { name = "frozenlist" },
     { name = "multidict" },
     { name = "propcache" },
+    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
     { name = "yarl" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/50/42/32cf8e7704ceb4481406eb87161349abb46a57fee3f008ba9cb610968646/aiohttp-3.13.3.tar.gz", hash = "sha256:a949eee43d3782f2daae4f4a2819b2cb9b0c5d3b7f7a927067cc84dafdbb9f88", size = 7844556, upload-time = "2026-01-03T17:33:05.204Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/a0/be/4fc11f202955a69e0db803a12a062b8379c970c7c84f4882b6da17337cc1/aiohttp-3.13.3-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:b903a4dfee7d347e2d87697d0713be59e0b87925be030c9178c5faa58ea58d5c", size = 739732, upload-time = "2026-01-03T17:30:14.23Z" },
-    { url = "https://files.pythonhosted.org/packages/97/2c/621d5b851f94fa0bb7430d6089b3aa970a9d9b75196bc93bb624b0db237a/aiohttp-3.13.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:a45530014d7a1e09f4a55f4f43097ba0fd155089372e105e4bff4ca76cb1b168", size = 494293, upload-time = "2026-01-03T17:30:15.96Z" },
-    { url = "https://files.pythonhosted.org/packages/5d/43/4be01406b78e1be8320bb8316dc9c42dbab553d281c40364e0f862d5661c/aiohttp-3.13.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:27234ef6d85c914f9efeb77ff616dbf4ad2380be0cda40b4db086ffc7ddd1b7d", size = 493533, upload-time = "2026-01-03T17:30:17.431Z" },
-    { url = "https://files.pythonhosted.org/packages/8d/a8/5a35dc56a06a2c90d4742cbf35294396907027f80eea696637945a106f25/aiohttp-3.13.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d32764c6c9aafb7fb55366a224756387cd50bfa720f32b88e0e6fa45b27dcf29", size = 1737839, upload-time = "2026-01-03T17:30:19.422Z" },
-    { url = "https://files.pythonhosted.org/packages/bf/62/4b9eeb331da56530bf2e198a297e5303e1c1ebdceeb00fe9b568a65c5a0c/aiohttp-3.13.3-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:b1a6102b4d3ebc07dad44fbf07b45bb600300f15b552ddf1851b5390202ea2e3", size = 1703932, upload-time = "2026-01-03T17:30:21.756Z" },
-    { url = "https://files.pythonhosted.org/packages/7c/f6/af16887b5d419e6a367095994c0b1332d154f647e7dc2bd50e61876e8e3d/aiohttp-3.13.3-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c014c7ea7fb775dd015b2d3137378b7be0249a448a1612268b5a90c2d81de04d", size = 1771906, upload-time = "2026-01-03T17:30:23.932Z" },
-    { url = "https://files.pythonhosted.org/packages/ce/83/397c634b1bcc24292fa1e0c7822800f9f6569e32934bdeef09dae7992dfb/aiohttp-3.13.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2b8d8ddba8f95ba17582226f80e2de99c7a7948e66490ef8d947e272a93e9463", size = 1871020, upload-time = "2026-01-03T17:30:26Z" },
-    { url = "https://files.pythonhosted.org/packages/86/f6/a62cbbf13f0ac80a70f71b1672feba90fdb21fd7abd8dbf25c0105fb6fa3/aiohttp-3.13.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9ae8dd55c8e6c4257eae3a20fd2c8f41edaea5992ed67156642493b8daf3cecc", size = 1755181, upload-time = "2026-01-03T17:30:27.554Z" },
-    { url = "https://files.pythonhosted.org/packages/0a/87/20a35ad487efdd3fba93d5843efdfaa62d2f1479eaafa7453398a44faf13/aiohttp-3.13.3-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:01ad2529d4b5035578f5081606a465f3b814c542882804e2e8cda61adf5c71bf", size = 1561794, upload-time = "2026-01-03T17:30:29.254Z" },
-    { url = "https://files.pythonhosted.org/packages/de/95/8fd69a66682012f6716e1bc09ef8a1a2a91922c5725cb904689f112309c4/aiohttp-3.13.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:bb4f7475e359992b580559e008c598091c45b5088f28614e855e42d39c2f1033", size = 1697900, upload-time = "2026-01-03T17:30:31.033Z" },
-    { url = "https://files.pythonhosted.org/packages/e5/66/7b94b3b5ba70e955ff597672dad1691333080e37f50280178967aff68657/aiohttp-3.13.3-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:c19b90316ad3b24c69cd78d5c9b4f3aa4497643685901185b65166293d36a00f", size = 1728239, upload-time = "2026-01-03T17:30:32.703Z" },
-    { url = "https://files.pythonhosted.org/packages/47/71/6f72f77f9f7d74719692ab65a2a0252584bf8d5f301e2ecb4c0da734530a/aiohttp-3.13.3-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:96d604498a7c782cb15a51c406acaea70d8c027ee6b90c569baa6e7b93073679", size = 1740527, upload-time = "2026-01-03T17:30:34.695Z" },
-    { url = "https://files.pythonhosted.org/packages/fa/b4/75ec16cbbd5c01bdaf4a05b19e103e78d7ce1ef7c80867eb0ace42ff4488/aiohttp-3.13.3-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:084911a532763e9d3dd95adf78a78f4096cd5f58cdc18e6fdbc1b58417a45423", size = 1554489, upload-time = "2026-01-03T17:30:36.864Z" },
-    { url = "https://files.pythonhosted.org/packages/52/8f/bc518c0eea29f8406dcf7ed1f96c9b48e3bc3995a96159b3fc11f9e08321/aiohttp-3.13.3-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:7a4a94eb787e606d0a09404b9c38c113d3b099d508021faa615d70a0131907ce", size = 1767852, upload-time = "2026-01-03T17:30:39.433Z" },
-    { url = "https://files.pythonhosted.org/packages/9d/f2/a07a75173124f31f11ea6f863dc44e6f09afe2bca45dd4e64979490deab1/aiohttp-3.13.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:87797e645d9d8e222e04160ee32aa06bc5c163e8499f24db719e7852ec23093a", size = 1722379, upload-time = "2026-01-03T17:30:41.081Z" },
-    { url = "https://files.pythonhosted.org/packages/3c/4a/1a3fee7c21350cac78e5c5cef711bac1b94feca07399f3d406972e2d8fcd/aiohttp-3.13.3-cp312-cp312-win32.whl", hash = "sha256:b04be762396457bef43f3597c991e192ee7da460a4953d7e647ee4b1c28e7046", size = 428253, upload-time = "2026-01-03T17:30:42.644Z" },
-    { url = "https://files.pythonhosted.org/packages/d9/b7/76175c7cb4eb73d91ad63c34e29fc4f77c9386bba4a65b53ba8e05ee3c39/aiohttp-3.13.3-cp312-cp312-win_amd64.whl", hash = "sha256:e3531d63d3bdfa7e3ac5e9b27b2dd7ec9df3206a98e0b3445fa906f233264c57", size = 455407, upload-time = "2026-01-03T17:30:44.195Z" },
-    { url = "https://files.pythonhosted.org/packages/97/8a/12ca489246ca1faaf5432844adbfce7ff2cc4997733e0af120869345643a/aiohttp-3.13.3-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:5dff64413671b0d3e7d5918ea490bdccb97a4ad29b3f311ed423200b2203e01c", size = 734190, upload-time = "2026-01-03T17:30:45.832Z" },
-    { url = "https://files.pythonhosted.org/packages/32/08/de43984c74ed1fca5c014808963cc83cb00d7bb06af228f132d33862ca76/aiohttp-3.13.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:87b9aab6d6ed88235aa2970294f496ff1a1f9adcd724d800e9b952395a80ffd9", size = 491783, upload-time = "2026-01-03T17:30:47.466Z" },
-    { url = "https://files.pythonhosted.org/packages/17/f8/8dd2cf6112a5a76f81f81a5130c57ca829d101ad583ce57f889179accdda/aiohttp-3.13.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:425c126c0dc43861e22cb1c14ba4c8e45d09516d0a3ae0a3f7494b79f5f233a3", size = 490704, upload-time = "2026-01-03T17:30:49.373Z" },
-    { url = "https://files.pythonhosted.org/packages/6d/40/a46b03ca03936f832bc7eaa47cfbb1ad012ba1be4790122ee4f4f8cba074/aiohttp-3.13.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7f9120f7093c2a32d9647abcaf21e6ad275b4fbec5b55969f978b1a97c7c86bf", size = 1720652, upload-time = "2026-01-03T17:30:50.974Z" },
-    { url = "https://files.pythonhosted.org/packages/f7/7e/917fe18e3607af92657e4285498f500dca797ff8c918bd7d90b05abf6c2a/aiohttp-3.13.3-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:697753042d57f4bf7122cab985bf15d0cef23c770864580f5af4f52023a56bd6", size = 1692014, upload-time = "2026-01-03T17:30:52.729Z" },
-    { url = "https://files.pythonhosted.org/packages/71/b6/cefa4cbc00d315d68973b671cf105b21a609c12b82d52e5d0c9ae61d2a09/aiohttp-3.13.3-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6de499a1a44e7de70735d0b39f67c8f25eb3d91eb3103be99ca0fa882cdd987d", size = 1759777, upload-time = "2026-01-03T17:30:54.537Z" },
-    { url = "https://files.pythonhosted.org/packages/fb/e3/e06ee07b45e59e6d81498b591fc589629be1553abb2a82ce33efe2a7b068/aiohttp-3.13.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:37239e9f9a7ea9ac5bf6b92b0260b01f8a22281996da609206a84df860bc1261", size = 1861276, upload-time = "2026-01-03T17:30:56.512Z" },
-    { url = "https://files.pythonhosted.org/packages/7c/24/75d274228acf35ceeb2850b8ce04de9dd7355ff7a0b49d607ee60c29c518/aiohttp-3.13.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f76c1e3fe7d7c8afad7ed193f89a292e1999608170dcc9751a7462a87dfd5bc0", size = 1743131, upload-time = "2026-01-03T17:30:58.256Z" },
-    { url = "https://files.pythonhosted.org/packages/04/98/3d21dde21889b17ca2eea54fdcff21b27b93f45b7bb94ca029c31ab59dc3/aiohttp-3.13.3-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:fc290605db2a917f6e81b0e1e0796469871f5af381ce15c604a3c5c7e51cb730", size = 1556863, upload-time = "2026-01-03T17:31:00.445Z" },
-    { url = "https://files.pythonhosted.org/packages/9e/84/da0c3ab1192eaf64782b03971ab4055b475d0db07b17eff925e8c93b3aa5/aiohttp-3.13.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:4021b51936308aeea0367b8f006dc999ca02bc118a0cc78c303f50a2ff6afb91", size = 1682793, upload-time = "2026-01-03T17:31:03.024Z" },
-    { url = "https://files.pythonhosted.org/packages/ff/0f/5802ada182f575afa02cbd0ec5180d7e13a402afb7c2c03a9aa5e5d49060/aiohttp-3.13.3-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:49a03727c1bba9a97d3e93c9f93ca03a57300f484b6e935463099841261195d3", size = 1716676, upload-time = "2026-01-03T17:31:04.842Z" },
-    { url = "https://files.pythonhosted.org/packages/3f/8c/714d53bd8b5a4560667f7bbbb06b20c2382f9c7847d198370ec6526af39c/aiohttp-3.13.3-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:3d9908a48eb7416dc1f4524e69f1d32e5d90e3981e4e37eb0aa1cd18f9cfa2a4", size = 1733217, upload-time = "2026-01-03T17:31:06.868Z" },
-    { url = "https://files.pythonhosted.org/packages/7d/79/e2176f46d2e963facea939f5be2d26368ce543622be6f00a12844d3c991f/aiohttp-3.13.3-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:2712039939ec963c237286113c68dbad80a82a4281543f3abf766d9d73228998", size = 1552303, upload-time = "2026-01-03T17:31:08.958Z" },
-    { url = "https://files.pythonhosted.org/packages/ab/6a/28ed4dea1759916090587d1fe57087b03e6c784a642b85ef48217b0277ae/aiohttp-3.13.3-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:7bfdc049127717581866fa4708791220970ce291c23e28ccf3922c700740fdc0", size = 1763673, upload-time = "2026-01-03T17:31:10.676Z" },
-    { url = "https://files.pythonhosted.org/packages/e8/35/4a3daeb8b9fab49240d21c04d50732313295e4bd813a465d840236dd0ce1/aiohttp-3.13.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:8057c98e0c8472d8846b9c79f56766bcc57e3e8ac7bfd510482332366c56c591", size = 1721120, upload-time = "2026-01-03T17:31:12.575Z" },
-    { url = "https://files.pythonhosted.org/packages/bc/9f/d643bb3c5fb99547323e635e251c609fbbc660d983144cfebec529e09264/aiohttp-3.13.3-cp313-cp313-win32.whl", hash = "sha256:1449ceddcdbcf2e0446957863af03ebaaa03f94c090f945411b61269e2cb5daf", size = 427383, upload-time = "2026-01-03T17:31:14.382Z" },
-    { url = "https://files.pythonhosted.org/packages/4e/f1/ab0395f8a79933577cdd996dd2f9aa6014af9535f65dddcf88204682fe62/aiohttp-3.13.3-cp313-cp313-win_amd64.whl", hash = "sha256:693781c45a4033d31d4187d2436f5ac701e7bbfe5df40d917736108c1cc7436e", size = 453899, upload-time = "2026-01-03T17:31:15.958Z" },
-    { url = "https://files.pythonhosted.org/packages/99/36/5b6514a9f5d66f4e2597e40dea2e3db271e023eb7a5d22defe96ba560996/aiohttp-3.13.3-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:ea37047c6b367fd4bd632bff8077449b8fa034b69e812a18e0132a00fae6e808", size = 737238, upload-time = "2026-01-03T17:31:17.909Z" },
-    { url = "https://files.pythonhosted.org/packages/f7/49/459327f0d5bcd8c6c9ca69e60fdeebc3622861e696490d8674a6d0cb90a6/aiohttp-3.13.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:6fc0e2337d1a4c3e6acafda6a78a39d4c14caea625124817420abceed36e2415", size = 492292, upload-time = "2026-01-03T17:31:19.919Z" },
-    { url = "https://files.pythonhosted.org/packages/e8/0b/b97660c5fd05d3495b4eb27f2d0ef18dc1dc4eff7511a9bf371397ff0264/aiohttp-3.13.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c685f2d80bb67ca8c3837823ad76196b3694b0159d232206d1e461d3d434666f", size = 493021, upload-time = "2026-01-03T17:31:21.636Z" },
-    { url = "https://files.pythonhosted.org/packages/54/d4/438efabdf74e30aeceb890c3290bbaa449780583b1270b00661126b8aae4/aiohttp-3.13.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:48e377758516d262bde50c2584fc6c578af272559c409eecbdd2bae1601184d6", size = 1717263, upload-time = "2026-01-03T17:31:23.296Z" },
-    { url = "https://files.pythonhosted.org/packages/71/f2/7bddc7fd612367d1459c5bcf598a9e8f7092d6580d98de0e057eb42697ad/aiohttp-3.13.3-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:34749271508078b261c4abb1767d42b8d0c0cc9449c73a4df494777dc55f0687", size = 1669107, upload-time = "2026-01-03T17:31:25.334Z" },
-    { url = "https://files.pythonhosted.org/packages/00/5a/1aeaecca40e22560f97610a329e0e5efef5e0b5afdf9f857f0d93839ab2e/aiohttp-3.13.3-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:82611aeec80eb144416956ec85b6ca45a64d76429c1ed46ae1b5f86c6e0c9a26", size = 1760196, upload-time = "2026-01-03T17:31:27.394Z" },
-    { url = "https://files.pythonhosted.org/packages/f8/f8/0ff6992bea7bd560fc510ea1c815f87eedd745fe035589c71ce05612a19a/aiohttp-3.13.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2fff83cfc93f18f215896e3a190e8e5cb413ce01553901aca925176e7568963a", size = 1843591, upload-time = "2026-01-03T17:31:29.238Z" },
-    { url = "https://files.pythonhosted.org/packages/e3/d1/e30e537a15f53485b61f5be525f2157da719819e8377298502aebac45536/aiohttp-3.13.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bbe7d4cecacb439e2e2a8a1a7b935c25b812af7a5fd26503a66dadf428e79ec1", size = 1720277, upload-time = "2026-01-03T17:31:31.053Z" },
-    { url = "https://files.pythonhosted.org/packages/84/45/23f4c451d8192f553d38d838831ebbc156907ea6e05557f39563101b7717/aiohttp-3.13.3-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:b928f30fe49574253644b1ca44b1b8adbd903aa0da4b9054a6c20fc7f4092a25", size = 1548575, upload-time = "2026-01-03T17:31:32.87Z" },
-    { url = "https://files.pythonhosted.org/packages/6a/ed/0a42b127a43712eda7807e7892c083eadfaf8429ca8fb619662a530a3aab/aiohttp-3.13.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7b5e8fe4de30df199155baaf64f2fcd604f4c678ed20910db8e2c66dc4b11603", size = 1679455, upload-time = "2026-01-03T17:31:34.76Z" },
-    { url = "https://files.pythonhosted.org/packages/2e/b5/c05f0c2b4b4fe2c9d55e73b6d3ed4fd6c9dc2684b1d81cbdf77e7fad9adb/aiohttp-3.13.3-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:8542f41a62bcc58fc7f11cf7c90e0ec324ce44950003feb70640fc2a9092c32a", size = 1687417, upload-time = "2026-01-03T17:31:36.699Z" },
-    { url = "https://files.pythonhosted.org/packages/c9/6b/915bc5dad66aef602b9e459b5a973529304d4e89ca86999d9d75d80cbd0b/aiohttp-3.13.3-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:5e1d8c8b8f1d91cd08d8f4a3c2b067bfca6ec043d3ff36de0f3a715feeedf926", size = 1729968, upload-time = "2026-01-03T17:31:38.622Z" },
-    { url = "https://files.pythonhosted.org/packages/11/3b/e84581290a9520024a08640b63d07673057aec5ca548177a82026187ba73/aiohttp-3.13.3-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:90455115e5da1c3c51ab619ac57f877da8fd6d73c05aacd125c5ae9819582aba", size = 1545690, upload-time = "2026-01-03T17:31:40.57Z" },
-    { url = "https://files.pythonhosted.org/packages/f5/04/0c3655a566c43fd647c81b895dfe361b9f9ad6d58c19309d45cff52d6c3b/aiohttp-3.13.3-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:042e9e0bcb5fba81886c8b4fbb9a09d6b8a00245fd8d88e4d989c1f96c74164c", size = 1746390, upload-time = "2026-01-03T17:31:42.857Z" },
-    { url = "https://files.pythonhosted.org/packages/1f/53/71165b26978f719c3419381514c9690bd5980e764a09440a10bb816ea4ab/aiohttp-3.13.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:2eb752b102b12a76ca02dff751a801f028b4ffbbc478840b473597fc91a9ed43", size = 1702188, upload-time = "2026-01-03T17:31:44.984Z" },
-    { url = "https://files.pythonhosted.org/packages/29/a7/cbe6c9e8e136314fa1980da388a59d2f35f35395948a08b6747baebb6aa6/aiohttp-3.13.3-cp314-cp314-win32.whl", hash = "sha256:b556c85915d8efaed322bf1bdae9486aa0f3f764195a0fb6ee962e5c71ef5ce1", size = 433126, upload-time = "2026-01-03T17:31:47.463Z" },
-    { url = "https://files.pythonhosted.org/packages/de/56/982704adea7d3b16614fc5936014e9af85c0e34b58f9046655817f04306e/aiohttp-3.13.3-cp314-cp314-win_amd64.whl", hash = "sha256:9bf9f7a65e7aa20dd764151fb3d616c81088f91f8df39c3893a536e279b4b984", size = 459128, upload-time = "2026-01-03T17:31:49.2Z" },
-    { url = "https://files.pythonhosted.org/packages/6c/2a/3c79b638a9c3d4658d345339d22070241ea341ed4e07b5ac60fb0f418003/aiohttp-3.13.3-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:05861afbbec40650d8a07ea324367cb93e9e8cc7762e04dd4405df99fa65159c", size = 769512, upload-time = "2026-01-03T17:31:51.134Z" },
-    { url = "https://files.pythonhosted.org/packages/29/b9/3e5014d46c0ab0db8707e0ac2711ed28c4da0218c358a4e7c17bae0d8722/aiohttp-3.13.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:2fc82186fadc4a8316768d61f3722c230e2c1dcab4200d52d2ebdf2482e47592", size = 506444, upload-time = "2026-01-03T17:31:52.85Z" },
-    { url = "https://files.pythonhosted.org/packages/90/03/c1d4ef9a054e151cd7839cdc497f2638f00b93cbe8043983986630d7a80c/aiohttp-3.13.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:0add0900ff220d1d5c5ebbf99ed88b0c1bbf87aa7e4262300ed1376a6b13414f", size = 510798, upload-time = "2026-01-03T17:31:54.91Z" },
-    { url = "https://files.pythonhosted.org/packages/ea/76/8c1e5abbfe8e127c893fe7ead569148a4d5a799f7cf958d8c09f3eedf097/aiohttp-3.13.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:568f416a4072fbfae453dcf9a99194bbb8bdeab718e08ee13dfa2ba0e4bebf29", size = 1868835, upload-time = "2026-01-03T17:31:56.733Z" },
-    { url = "https://files.pythonhosted.org/packages/8e/ac/984c5a6f74c363b01ff97adc96a3976d9c98940b8969a1881575b279ac5d/aiohttp-3.13.3-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:add1da70de90a2569c5e15249ff76a631ccacfe198375eead4aadf3b8dc849dc", size = 1720486, upload-time = "2026-01-03T17:31:58.65Z" },
-    { url = "https://files.pythonhosted.org/packages/b2/9a/b7039c5f099c4eb632138728828b33428585031a1e658d693d41d07d89d1/aiohttp-3.13.3-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:10b47b7ba335d2e9b1239fa571131a87e2d8ec96b333e68b2a305e7a98b0bae2", size = 1847951, upload-time = "2026-01-03T17:32:00.989Z" },
-    { url = "https://files.pythonhosted.org/packages/3c/02/3bec2b9a1ba3c19ff89a43a19324202b8eb187ca1e928d8bdac9bbdddebd/aiohttp-3.13.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:3dd4dce1c718e38081c8f35f323209d4c1df7d4db4bab1b5c88a6b4d12b74587", size = 1941001, upload-time = "2026-01-03T17:32:03.122Z" },
-    { url = "https://files.pythonhosted.org/packages/37/df/d879401cedeef27ac4717f6426c8c36c3091c6e9f08a9178cc87549c537f/aiohttp-3.13.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:34bac00a67a812570d4a460447e1e9e06fae622946955f939051e7cc895cfab8", size = 1797246, upload-time = "2026-01-03T17:32:05.255Z" },
-    { url = "https://files.pythonhosted.org/packages/8d/15/be122de1f67e6953add23335c8ece6d314ab67c8bebb3f181063010795a7/aiohttp-3.13.3-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:a19884d2ee70b06d9204b2727a7b9f983d0c684c650254679e716b0b77920632", size = 1627131, upload-time = "2026-01-03T17:32:07.607Z" },
-    { url = "https://files.pythonhosted.org/packages/12/12/70eedcac9134cfa3219ab7af31ea56bc877395b1ac30d65b1bc4b27d0438/aiohttp-3.13.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:5f8ca7f2bb6ba8348a3614c7918cc4bb73268c5ac2a207576b7afea19d3d9f64", size = 1795196, upload-time = "2026-01-03T17:32:09.59Z" },
-    { url = "https://files.pythonhosted.org/packages/32/11/b30e1b1cd1f3054af86ebe60df96989c6a414dd87e27ad16950eee420bea/aiohttp-3.13.3-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:b0d95340658b9d2f11d9697f59b3814a9d3bb4b7a7c20b131df4bcef464037c0", size = 1782841, upload-time = "2026-01-03T17:32:11.445Z" },
-    { url = "https://files.pythonhosted.org/packages/88/0d/d98a9367b38912384a17e287850f5695c528cff0f14f791ce8ee2e4f7796/aiohttp-3.13.3-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:a1e53262fd202e4b40b70c3aff944a8155059beedc8a89bba9dc1f9ef06a1b56", size = 1795193, upload-time = "2026-01-03T17:32:13.705Z" },
-    { url = "https://files.pythonhosted.org/packages/43/a5/a2dfd1f5ff5581632c7f6a30e1744deda03808974f94f6534241ef60c751/aiohttp-3.13.3-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:d60ac9663f44168038586cab2157e122e46bdef09e9368b37f2d82d354c23f72", size = 1621979, upload-time = "2026-01-03T17:32:15.965Z" },
-    { url = "https://files.pythonhosted.org/packages/fa/f0/12973c382ae7c1cccbc4417e129c5bf54c374dfb85af70893646e1f0e749/aiohttp-3.13.3-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:90751b8eed69435bac9ff4e3d2f6b3af1f57e37ecb0fbeee59c0174c9e2d41df", size = 1822193, upload-time = "2026-01-03T17:32:18.219Z" },
-    { url = "https://files.pythonhosted.org/packages/3c/5f/24155e30ba7f8c96918af1350eb0663e2430aad9e001c0489d89cd708ab1/aiohttp-3.13.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:fc353029f176fd2b3ec6cfc71be166aba1936fe5d73dd1992ce289ca6647a9aa", size = 1769801, upload-time = "2026-01-03T17:32:20.25Z" },
-    { url = "https://files.pythonhosted.org/packages/eb/f8/7314031ff5c10e6ece114da79b338ec17eeff3a079e53151f7e9f43c4723/aiohttp-3.13.3-cp314-cp314t-win32.whl", hash = "sha256:2e41b18a58da1e474a057b3d35248d8320029f61d70a37629535b16a0c8f3767", size = 466523, upload-time = "2026-01-03T17:32:22.215Z" },
-    { url = "https://files.pythonhosted.org/packages/b4/63/278a98c715ae467624eafe375542d8ba9b4383a016df8fdefe0ae28382a7/aiohttp-3.13.3-cp314-cp314t-win_amd64.whl", hash = "sha256:44531a36aa2264a1860089ffd4dce7baf875ee5a6079d5fb42e261c704ef7344", size = 499694, upload-time = "2026-01-03T17:32:24.546Z" },
+sdist = { url = "https://files.pythonhosted.org/packages/82/78/8ea7308cac6934de8c74a14f3d5f65d1c89287426688be79538d0e5c013d/aiohttp-3.14.1.tar.gz", hash = "sha256:307f2cff90a764d329e77040603fa032db89c5c24fdad50c4c15334cba744035", size = 7955794, upload-time = "2026-06-07T21:09:35.529Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1d/21/151624b51cd92553d95424daf4bf19f19ce9be9002d19253e7e7ce67197b/aiohttp-3.14.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:d35143e27778b4bb0fb189562d7f275bff79c62ab8e98459717c0ea617ff2480", size = 757402, upload-time = "2026-06-07T21:06:40.311Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/82/280619e0bd7bf2454987e19282616e84762255dd9c8468f62382e8c191f1/aiohttp-3.14.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:bcfb80a2cc36fba2534e5e5b5264dc7ae6fcd9bf15256da3e53d2f499e6fa29d", size = 512310, upload-time = "2026-06-07T21:06:42.207Z" },
+    { url = "https://files.pythonhosted.org/packages/55/b2/2aac325583aaa1353045f96dffa586d8a34e8322e14a7ba49cffeb103ab4/aiohttp-3.14.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:27fd7c91e51729b4f7e1577865fa6d34c9adccbc39aabe9000285b48af9f0ec2", size = 512448, upload-time = "2026-06-07T21:06:43.813Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/72/a60607cb849faa8af8a356c9329ea2eb6f395d49e82cc82ccba1fd8deb8f/aiohttp-3.14.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:64c567bf9eaf664280116a8688f63016e6b32db2505908e2bdaca1b6438142f2", size = 1766854, upload-time = "2026-06-07T21:06:45.391Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/d3/d9fe1c9ec7557ab4d0d82bebaa728c6418f0b93295ec2f4ab015f7710cc7/aiohttp-3.14.1-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:f5e6ff2bdbb8f4cd3fbe41f99e25bbcd58e3bf9f13d3dd31a11e7917251cc77a", size = 1740884, upload-time = "2026-06-07T21:06:47.413Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/dc/f2cecfaf9337ba3e63f181500814ff502aa3d00d9c7ec93a9d23d10a27b2/aiohttp-3.14.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:2f73e01dc37122325caf079982621262f96d74823c179038a82fddfc50359264", size = 1810034, upload-time = "2026-06-07T21:06:50.165Z" },
+    { url = "https://files.pythonhosted.org/packages/66/d7/2ff65c5e65c0d7476daf7e15c032e0805e36811185b9623e3238ad6c763e/aiohttp-3.14.1-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:bb2c0c80d431c0d03f2c7dbf125150fedd4f0de17366a7ca33f7ccb822391842", size = 1904054, upload-time = "2026-06-07T21:06:52.035Z" },
+    { url = "https://files.pythonhosted.org/packages/20/9c/d445818389df371f56d141d881153ba23183c4735a03f7356ffb43f7757d/aiohttp-3.14.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3e6fc1a85fa7194a1a7d19f44e8609180f4a8eb5fa4c7ed8b4355f080fad235c", size = 1790278, upload-time = "2026-06-07T21:06:54.049Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/aa/bf04cb4d865fc6101c2229a294ad744973b72e513fdc5a6b791e6983d72a/aiohttp-3.14.1-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:686b6c0d3911ec387b444ddf5dc62fb7f7c0a7d5186a7861626496a5ab4aff95", size = 1591795, upload-time = "2026-06-07T21:06:55.911Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/b4/4dac0038960427ba832f6609dfb4ea5437d7fd80c72001b9e48f834f428b/aiohttp-3.14.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:c6fa4dc7ad6f8109c70bb1499e589f76b0b792baf39f9b017eb92c8a81d0a199", size = 1728397, upload-time = "2026-06-07T21:06:57.777Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/f9/7cd4e8ad7aa3b75f17d56bb5498dd604a93d4e6eece822ba0568c413fff0/aiohttp-3.14.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:87a5eea1b2a5e21e1ebdbb33ad4165359189327e63fc4e4894693e7f821ac817", size = 1766504, upload-time = "2026-06-07T21:07:00.009Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/df/fc01d9fcad0f73fed3f3d361f1f94f975947b50dff82919f6dc2bf4316cc/aiohttp-3.14.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:1c1421eb01d4fd608d88cc8290211d177a58532b55ad94076fb349c5bf467f0a", size = 1777806, upload-time = "2026-06-07T21:07:02.064Z" },
+    { url = "https://files.pythonhosted.org/packages/41/09/47e2d090bddcc8fb4ccb4c314aadc32d7c5d9bb55f50f6ad1c92fc15d501/aiohttp-3.14.1-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:34b257ec41345c1e8f2df68fa908a7952f5de932723871eb633ecbbff396c9a4", size = 1580707, upload-time = "2026-06-07T21:07:03.942Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/36/f1a4ce904ae0b6930cfe9afc96d0896f7ec1a620c400405d63783bb95a9c/aiohttp-3.14.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:de538791a80e5d862addbc183f70f0158ac9b9bb872bb147f1fd2a683691e087", size = 1798121, upload-time = "2026-06-07T21:07:05.987Z" },
+    { url = "https://files.pythonhosted.org/packages/70/0a/e0075ce9ca0279ee1d4f0c0b85f54fea02ebc83c3007651a72bece658fec/aiohttp-3.14.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:6f71173be42d3241d428f760122febb748de0623f44308a6f120d0dd9ec572e3", size = 1767580, upload-time = "2026-06-07T21:07:07.873Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/61/a0c0a8f327a9c52095cdd8e312391b00d3ed64ab6c72bb5c33d8ec251cf7/aiohttp-3.14.1-cp312-cp312-win32.whl", hash = "sha256:ec8dc383ee57ea3e883477dcca3f11b65d58199f1080acaf4cd6ad9a99698be4", size = 452771, upload-time = "2026-06-07T21:07:09.669Z" },
+    { url = "https://files.pythonhosted.org/packages/df/d9/ea367c75f16ac9c6cdc8febb25e8318fa21a2b1bc8d6514d4b2d890bface/aiohttp-3.14.1-cp312-cp312-win_amd64.whl", hash = "sha256:2aa92c87868cd13674989f9ee83e5f9f7ea4237589b728048e1f0c8f6caa3271", size = 479873, upload-time = "2026-06-07T21:07:11.538Z" },
+    { url = "https://files.pythonhosted.org/packages/03/64/8d96784a7851156db8a4c6c3f6f91042fdf39fb15a4cc38c8b3c14833c45/aiohttp-3.14.1-cp312-cp312-win_arm64.whl", hash = "sha256:2c840c90759922cb5e6dda94596e079a30fb5a5ba548e7e0dc00574703940847", size = 448073, upload-time = "2026-06-07T21:07:13.637Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/97/bd137012dd97e1649162b099135a80e1fd59aaa807b2430fc448d1029aff/aiohttp-3.14.1-cp313-cp313-android_21_arm64_v8a.whl", hash = "sha256:b3a03285a7f9c7b016324574a6d92a1c895da6b978cb8f1deee3ac72bc6da178", size = 506882, upload-time = "2026-06-07T21:07:15.501Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/79/e5cc690e9d922a66887ceeaca53a8ffd5a7b0be3816142b7abc433742d89/aiohttp-3.14.1-cp313-cp313-android_21_x86_64.whl", hash = "sha256:2a73f487ab8ef5abbb24b7aa9b73e98eaba9e9e031804ff2416f02eca315ccaf", size = 515270, upload-time = "2026-06-07T21:07:17.53Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/22/a73ccbf9dbd6e26dda0b24d5fd5db7da92ee3383a79f47677ffb834c5c5b/aiohttp-3.14.1-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:915fbb7b41b115192259f8c9ae58f3ddc444d2b5579917270211858e606a4afd", size = 485841, upload-time = "2026-06-07T21:07:19.555Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/b9/57ed8eaf596321c2ad747bd480fb1700dbd7177c60dfc9e4c187f629662e/aiohttp-3.14.1-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:7fb4bdf95b0561a79f259f9d28fbc109728c5ee7f27aff6391f0ca703a329abe", size = 492088, upload-time = "2026-06-07T21:07:21.581Z" },
+    { url = "https://files.pythonhosted.org/packages/78/c0/5ebe5270a7c140d7c6f79dcb018640225f14d406c149e4eec04a7d82fe71/aiohttp-3.14.1-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:1b9748363260121d2927704f5d4fc498150669ca3ae93625986ee89c8f80dcd4", size = 501564, upload-time = "2026-06-07T21:07:23.388Z" },
+    { url = "https://files.pythonhosted.org/packages/75/7f/8cdaa24fc7983865e0915153b96a9ac5bcdd3548d64c5a27d17cecccad2d/aiohttp-3.14.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:86a6dab78b0e43e2897a3bbe15745aa60dc5423ca437b7b0b164c069bf91b876", size = 751998, upload-time = "2026-06-07T21:07:25.046Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/f4/c4227aacfacc5cb0cc2d119b65301d177912a6842cd64e120c47af76064f/aiohttp-3.14.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:4dfd6e47d3c44c2279907607f73a4240b88c69eb8b90da7e2441a8045dfd21da", size = 510918, upload-time = "2026-06-07T21:07:27.28Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/01/a2d5f96cd4e74424864d30bc0a7e44d0a12dacdcfa91b5b2d1bd3dca6bf3/aiohttp-3.14.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:317acd9f8602858dc7d59679812c376c7f0b97bcbbf16e0d6237f54141d8a8a6", size = 508657, upload-time = "2026-06-07T21:07:29.252Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/ed/3c0fb5c500fdd8e7ebc10d1889c04384fffa1a9163eac1356088ca9da1b1/aiohttp-3.14.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:bd869c427324e5cb15195793de951295710db28be7d818247f3097b4ab5d4b96", size = 1757907, upload-time = "2026-06-07T21:07:31.03Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/ab/d4c924d9bd5be3050c226612413ce68cb54c70d2c31b661bfc8d9a5b6a70/aiohttp-3.14.1-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:93b032b5ec3255473c143627d21a69ac74ae12f7f33974cb587c564d11b1066f", size = 1737565, upload-time = "2026-06-07T21:07:33.031Z" },
+    { url = "https://files.pythonhosted.org/packages/19/2a/37326821ff779084020cdc33224d20b19f42f4183a500ff92022a739eda7/aiohttp-3.14.1-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f234b4deb12f3ad59127e037bc57c40c21e45b45282df7d3a55a0f409f595296", size = 1799018, upload-time = "2026-06-07T21:07:35.003Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/4f/6e947ba73e4ce09070761c05ed3a8ceb7c21f5e46798671d8b2aac0e4626/aiohttp-3.14.1-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:9af6779bfb46abf124068327abcdf9ce95c9ef8287a3e8da76ccf2d0f16c28fa", size = 1894416, upload-time = "2026-06-07T21:07:36.956Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/6e/dbf1d0625dc711fb2851f4f3c3055c39ed58bae92082d8c627dbe6013736/aiohttp-3.14.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:faccab372e66bc76d5731525e7f1143c922271725b9d38c9f97edcc66266b451", size = 1783881, upload-time = "2026-06-07T21:07:39.063Z" },
+    { url = "https://files.pythonhosted.org/packages/44/c2/5e25098a67268ed369483ae7d1a58bd0a13d03aab860d2a0e4a6eb25b046/aiohttp-3.14.1-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f380468b09d2a81633ee863b0ec5648d364bd17bb8ecfb8c2f387f7ac1faf42c", size = 1587572, upload-time = "2026-06-07T21:07:41.058Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/bd/cf9cee17e140f942a3de73e658a543aa8fbf35a5fc67a9d2538d52d77f0b/aiohttp-3.14.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:97e704dcd26271f5bda3fa07c3ce0fb76d6d3f8659f4baa1a24442cc9ba177ca", size = 1722137, upload-time = "2026-06-07T21:07:43.014Z" },
+    { url = "https://files.pythonhosted.org/packages/89/6d/5684f8c59045c96f81a18cefbc1fbbd79d25b88f1c622f2a5c5c08fcb632/aiohttp-3.14.1-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:269b76ac5394092b95bc4a098f4fc6c191c083c3bd12775d1e30e663132f6a09", size = 1755953, upload-time = "2026-06-07T21:07:45.933Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/40/35caf3170f8359760740a7d9aa0fff2e344bef98e1d1186f5a0f6dec17e6/aiohttp-3.14.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:5c0b3e614340c889d575451696374c9d17affd54cd607ca0babed8f8c37b9397", size = 1766479, upload-time = "2026-06-07T21:07:48.047Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/a1/b0c61e7a137f0d81de49a82023a6df73c3c16d6fefb0f8e4a93d21639002/aiohttp-3.14.1-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:5663ee9257cfa1add7253a7da3035a02f31b6600ec48261585e1800a81533080", size = 1580077, upload-time = "2026-06-07T21:07:50.069Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/41/194ea4623693009fcefebef7aef63c141754f153e9cd0d39d3b9e36c175c/aiohttp-3.14.1-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:603a2c834142172ffddc054067f5ec0ca65d57a0aa98a71bc81952573208e345", size = 1791688, upload-time = "2026-06-07T21:07:52.106Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/45/4de841f005cfe1fd63e2a2fe011262c515e2a62aa6994b15947e7d717ac9/aiohttp-3.14.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:cb21957bb8aca671c1765e32f58164cf0c50e6bf41c0bbbd16da20732ecaf588", size = 1761094, upload-time = "2026-06-07T21:07:54.113Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/ae/dbce10533d3896d544d5053939ed75b7dc31a1b0973d959b1b5ae21028d6/aiohttp-3.14.1-cp313-cp313-win32.whl", hash = "sha256:e509a55f681e6158c20f70f102f9cf61fb20fbc382272bc6d94b7343f2582780", size = 452662, upload-time = "2026-06-07T21:07:56.06Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/d9/0bf1a19362c32f06229da5e7ddfcec91f93474d6307f7a2d3135e9c674dc/aiohttp-3.14.1-cp313-cp313-win_amd64.whl", hash = "sha256:1ac8531b638959718e18c2207fbfe297819875da46a740b29dfa29beba64355a", size = 479748, upload-time = "2026-06-07T21:07:58.319Z" },
+    { url = "https://files.pythonhosted.org/packages/22/0a/62e7232dc9484fbec112ceb32efb6a624cc7994ec6e2b019286f17c4e8f2/aiohttp-3.14.1-cp313-cp313-win_arm64.whl", hash = "sha256:250d14af67f6b6a1a4a811049b1afa69d61d617fca6bf33149b3ab1a6dbcf7b8", size = 447723, upload-time = "2026-06-07T21:08:00.154Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/a1/5fafa04e1ca91ddb47608699d60649c1c6db3cf41c99e78fc4056f9513db/aiohttp-3.14.1-cp314-cp314-android_24_arm64_v8a.whl", hash = "sha256:7c106c26852ca1c2047c6b80384f17100b4e439af276f21ef3d4e2f450ae7e15", size = 508531, upload-time = "2026-06-07T21:08:02.093Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/2e/bfa02f699d87ffc86d5959270b28f1cb410add3ccaced8ed2e0b8a5238fc/aiohttp-3.14.1-cp314-cp314-android_24_x86_64.whl", hash = "sha256:20205f7f5ade7aaec9f4b500549bbc071b046453aed72f9c06dcab87896a83e8", size = 514718, upload-time = "2026-06-07T21:08:04.476Z" },
+    { url = "https://files.pythonhosted.org/packages/85/a5/9594ad6289eebbc97d167c44213d557807f90e59115caad24de21ad2c3b1/aiohttp-3.14.1-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:62a759436b29e677181a9e76bab8b8f689a29cb9c535f45f7c48c9c830d3f8c3", size = 487918, upload-time = "2026-06-07T21:08:06.377Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/61/16a32c36c3c49edec122a3dc811f2057df2f94d3b14aa107c8017d981618/aiohttp-3.14.1-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:2964cbf553df4d7a57348da44d961d871895fc1ee4e8c322b2a95612c7b17fba", size = 494014, upload-time = "2026-06-07T21:08:08.263Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/89/3ebcf96ed99c05bec9c434aaac6963fd3cbab4a786ae739908a144d9ce44/aiohttp-3.14.1-cp314-cp314-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:237651caadc3a59badd39319c54642b5299e9cc98a3a194310e55d5bb9f5e397", size = 502398, upload-time = "2026-06-07T21:08:10.244Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/3d/b74870a0c2d40c355928cd5b96c7a11fa821b8a40fc41365e64479b151fb/aiohttp-3.14.1-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:896e12dfdbbab9d8f7e16d2b28c6769a60126fa92095d1ebf9473d02593a2448", size = 758018, upload-time = "2026-06-07T21:08:12.447Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/66/f42f5c984d99e49c6cff5f26f590750f2e2f7ef1fcfb99966ab5be1b632e/aiohttp-3.14.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:d03f281ed22579314ba00821ce20115a7c0ac430660b4cc05704a3f818b3e004", size = 512462, upload-time = "2026-06-07T21:08:14.624Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/a7/248e1aebe0c7810b0271e021a0f2a5eb6e78a051885b3c9df49f42a5802d/aiohttp-3.14.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:07eabb979d236335fed927e137a928c9adfb7df3b9ec7aa31726f133a62be983", size = 512824, upload-time = "2026-06-07T21:08:16.572Z" },
+    { url = "https://files.pythonhosted.org/packages/26/97/2aa0e5ba0727dc3bd5aaebb7ccbc510f7dfb7fb961ec87497cd496635ab1/aiohttp-3.14.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4fe1f1087cbadb280b5e1bb054a4f00d1423c74d6626c5e48400d871d34ecefe", size = 1749898, upload-time = "2026-06-07T21:08:18.635Z" },
+    { url = "https://files.pythonhosted.org/packages/00/8d/e97f6c96c891d457c8479d92a514ba194d0412f981d72c70341ee18488ed/aiohttp-3.14.1-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:367a9314fdc79dab0fac96e216cb41dd73c85bdca85306ce8999118ba7e0f333", size = 1710114, upload-time = "2026-06-07T21:08:20.892Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/e6/aa8d7e863048c8fceb5cd6ce74017311cec3ead07847387e12265fb4444e/aiohttp-3.14.1-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a24f677ebe83749039e7bdf862ff0bbb16818ae4193d4ef96505e269375bcce0", size = 1802541, upload-time = "2026-06-07T21:08:23.044Z" },
+    { url = "https://files.pythonhosted.org/packages/83/a8/72193137de57fda4ebfae4563182d082c8856e3b6e9871d0b46f028fb369/aiohttp-3.14.1-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:c83afe0ba876be7e943d2e0ba645809ad441575d2840c895c21ee5de93b9377a", size = 1875776, upload-time = "2026-06-07T21:08:25.288Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/18/938441025db6769a3464596b2410af3afde0b21eb2f204c6f766f68af4bd/aiohttp-3.14.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:634e385930fb6d2d479cf3aa66515955863b77a5e3c2b5894ca259a25b308602", size = 1760329, upload-time = "2026-06-07T21:08:27.363Z" },
+    { url = "https://files.pythonhosted.org/packages/60/29/bf2496b4065e76e09fe48015aaffe5ce161d8f089b06ac6982070f653076/aiohttp-3.14.1-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:eeea07c4397bbc57719c4eed8f9c284874d4f175f9b6d57f7a1546b976d455ca", size = 1587293, upload-time = "2026-06-07T21:08:29.805Z" },
+    { url = "https://files.pythonhosted.org/packages/49/a2/2136674d52123b1354bd05dd5753c318db47dc0c927cc70b27bab3755456/aiohttp-3.14.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:335c0cc3e3545ce98dcb9cfcb836f40c3411f43fa03dab757597d80c89af8a35", size = 1714756, upload-time = "2026-06-07T21:08:32.094Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/b9/e5fd2e6f915503081c0f9b1e8540947037929c70c191da2e4d54b31a21a1/aiohttp-3.14.1-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:ae6be797afdef264e8a84864a85b196ca06045586481b3df8a967322fd2fa844", size = 1721052, upload-time = "2026-06-07T21:08:34.167Z" },
+    { url = "https://files.pythonhosted.org/packages/63/5a/2833e324a2263e104e31e2e91bc5bbee81bc499afd32203faee048a883f0/aiohttp-3.14.1-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:8560b4d712474335d08907db7973f71912d3a9a8f1dee992ec06b5d2fe359496", size = 1766888, upload-time = "2026-06-07T21:08:36.95Z" },
+    { url = "https://files.pythonhosted.org/packages/57/fa/dea6511870913162f3b2e8c42a7614eb203a4540b8c2da43e0bfb0548f3c/aiohttp-3.14.1-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:2b7edd08e0a5deb1e8564a2fcd8f4561014a3f05252334671bbf55ddd47db0e5", size = 1581679, upload-time = "2026-06-07T21:08:39.292Z" },
+    { url = "https://files.pythonhosted.org/packages/14/bd/3cf0d55e71784b33534e9710a67d382d900598b4787fbce6cc7317f8c42a/aiohttp-3.14.1-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:b6ff7fcee63287ae57b5df3e4f5957ce032122802509246dec1a5bcc55904c95", size = 1782021, upload-time = "2026-06-07T21:08:41.407Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/af/14bb5843eccbe234f4dfb78ab73e549d99727247e62ae5d62cbd22eaf5b0/aiohttp-3.14.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:6ffbb2f4ec1ceaff7e07d43922954da26b223d188bf30658e561b98e23089444", size = 1742574, upload-time = "2026-06-07T21:08:43.795Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/1e/fbeb7af9210a67ac0f9c9bec0f8f4568497924e33137a3d5b48e1cf85f3f/aiohttp-3.14.1-cp314-cp314-win32.whl", hash = "sha256:a9875b46d910cff3ea2f5962f9d266b465459fe634e22556ab9bd6fc1192eea0", size = 457773, upload-time = "2026-06-07T21:08:46.168Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/2b/13e8d741a9ec5db7d900c060554cf8352ab85e44e2a4469ebb9d377bda17/aiohttp-3.14.1-cp314-cp314-win_amd64.whl", hash = "sha256:af8b4b81a960eeaf1234971ac3cd0ba5901f3cd42eae42a46b4d089a8b492719", size = 485001, upload-time = "2026-06-07T21:08:48.401Z" },
+    { url = "https://files.pythonhosted.org/packages/df/30/491acfa2c4d6c3ff59c49a14fc1b50be3241e25bbb0c84c09e2da4d11395/aiohttp-3.14.1-cp314-cp314-win_arm64.whl", hash = "sha256:cf4491381b1b57425c315a56a439251b1bdac07b2275f19a8c44bc57744532ec", size = 453809, upload-time = "2026-06-07T21:08:50.7Z" },
+    { url = "https://files.pythonhosted.org/packages/34/e3/19dbe1a1f4cc6230eb9e314de7fe68053b0992f9302b27d12141a0b5db53/aiohttp-3.14.1-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:819c054312f1af92947e6a55883d1b66feefab11531a7fc45e0fb9b63880b5c2", size = 793320, upload-time = "2026-06-07T21:08:52.775Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/20/1b7182219ba1b108430d6e4dc53d25ae02dcfcf5a045b33af4e8c5167527/aiohttp-3.14.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:10ee9c1753a8f706345b22496c79fbddb5be0599e0823f3738b1534058e25340", size = 529077, upload-time = "2026-06-07T21:08:55Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/c8/14ce60ec31a2e5f5274bb17d383a6f7a3aabca31ac04eee05585bbadab16/aiohttp-3.14.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:1601cc37baf5750ccacae618ec2daf020769581695550e3b654a911f859c563d", size = 532476, upload-time = "2026-06-07T21:08:57.176Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/02/9ac85e081e53da2e061b02fa7758fe0a12d17b8ce2d1f5e6c7cb76730328/aiohttp-3.14.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4d6e0ac9da31c9c04c84e1c0182ad8d6df35965a85cae29cd71d089621b3ae94", size = 1922347, upload-time = "2026-06-07T21:08:59.563Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/3e/d3ba07a0ab38b5389e10bec4362d21e10a4f667cba2d79ba30837b3a5059/aiohttp-3.14.1-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:9e8f2d660c350b3d0e259c7a7e3d9b7fc8b41210cbcc3d4a7076ff0a5e5c2fdc", size = 1786465, upload-time = "2026-06-07T21:09:01.909Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/cb/e2ee978a00cfb2df829704a69528b18154eba5939f45bc1efa8f33aee4c5/aiohttp-3.14.1-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:4691802dda97be727f79d86818acaad7eb8e9252626a1d6b519fedbb92d5e251", size = 1909423, upload-time = "2026-06-07T21:09:04.357Z" },
+    { url = "https://files.pythonhosted.org/packages/73/5d/1430334858b1022b58ae50399a918f0bd6fe8fa7fa183598d657ff61e040/aiohttp-3.14.1-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:c389c482a7e9b9dc3ee2701ac46c4125297a3818875b9c305ddb603c04828fd1", size = 2001906, upload-time = "2026-06-07T21:09:06.722Z" },
+    { url = "https://files.pythonhosted.org/packages/66/4e/560c7472d3d198a23aa5c8b19a5115bf6a9b77b7d3e4bb363da320430ad2/aiohttp-3.14.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fc0cacab7ba4e56f0f81c82a98c09bed2f39c940107b03a34b168bdf7597edd3", size = 1877095, upload-time = "2026-06-07T21:09:09.011Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/f1/4745806578d447db4a784a8591e2dae3afdfc2bcb96f8f81271b13df6543/aiohttp-3.14.1-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:979ed4717f59b8bb12e3963378fa285d93d367e15bcd66c721311826d3c44a6c", size = 1676222, upload-time = "2026-06-07T21:09:11.461Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/c9/48255813cca749a229ef0ab476004ec623728ad79a9c0840616f6c076325/aiohttp-3.14.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:38e1e7daaea81df51c952e18483f323d878499a1e2bfe564790e0f9701d6f203", size = 1842922, upload-time = "2026-06-07T21:09:14.118Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/c0/bbd054e2bee909f529523a5af3891052606af5143c09f5f183ec3b234676/aiohttp-3.14.1-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:4132e72c608fe9fecb8f409113567605915b83e9bdd3ea56538d2f9cd35002f1", size = 1825035, upload-time = "2026-06-07T21:09:16.447Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/ae/90395d4376deceb74e09ec26b6adf7d2015a6f8802d6d84446af860fef04/aiohttp-3.14.1-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:eefd9cc9b6d4a2db5f00a26bc3e4f9acf71926a6ec557cd56c9c6f27c290b665", size = 1849512, upload-time = "2026-06-07T21:09:18.742Z" },
+    { url = "https://files.pythonhosted.org/packages/93/bd/fb25f3049957553d4ce0ba6ae480aa2f592a6985497fca590837d16c1be0/aiohttp-3.14.1-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:b165790117eea512d7f3fb22f1f6dad3d55a7189571993eb015591c1401276d1", size = 1668571, upload-time = "2026-06-07T21:09:21.458Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/22/7f73303d64dd567ff3addca90b556690ed1233a47b8f55d242fb90af3681/aiohttp-3.14.1-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:ed09c7eb1c391271c2ed0314a51903e72a3acb653d5ccfc264cdf3ef11f8269d", size = 1881159, upload-time = "2026-06-07T21:09:23.813Z" },
+    { url = "https://files.pythonhosted.org/packages/44/be/0474c5a8b5640e1e4aa1923430a91f4151be82e511373fe764189b89aef5/aiohttp-3.14.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:99abd37084b82f5830c635fddd0b4993b9742a66eb746dacf433c8590e8f9e3c", size = 1841409, upload-time = "2026-06-07T21:09:26.207Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/3c/bb4a7cba26956cb3da4553cc2056cf67be5b5ff6e6d8fa4fbdff73bfb7ae/aiohttp-3.14.1-cp314-cp314t-win32.whl", hash = "sha256:47ddf841cdecc810749921d25606dee45857d12d2ad5ddb7b5bd7eab12e4b365", size = 494166, upload-time = "2026-06-07T21:09:28.505Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/84/ec80c2c1f66a952555a9f86df6b33af65108a6febfa0471b69013a12f807/aiohttp-3.14.1-cp314-cp314t-win_amd64.whl", hash = "sha256:5e78b522b7a6e27e0b25d19b247b75039ac4c94f99823e3c9e53ae1603a9f7e9", size = 530255, upload-time = "2026-06-07T21:09:30.843Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/71/6e22be134a4061ada85a92951b842f2657f17d926b727f3f94c56ae963d6/aiohttp-3.14.1-cp314-cp314t-win_arm64.whl", hash = "sha256:90d53f1609c29ccc2193945ef732428382a28f78d0456ae4d3daf0d48b74f0f6", size = 469640, upload-time = "2026-06-07T21:09:33.028Z" },
 ]
 
 [[package]]
@@ -1191,55 +1218,55 @@ wheels = [
 
 [[package]]
 name = "cryptography"
-version = "46.0.5"
+version = "48.0.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "cffi", marker = "platform_python_implementation != 'PyPy'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/60/04/ee2a9e8542e4fa2773b81771ff8349ff19cdd56b7258a0cc442639052edb/cryptography-46.0.5.tar.gz", hash = "sha256:abace499247268e3757271b2f1e244b36b06f8515cf27c4d49468fc9eb16e93d", size = 750064, upload-time = "2026-02-10T19:18:38.255Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/f7/81/b0bb27f2ba931a65409c6b8a8b358a7f03c0e46eceacddff55f7c84b1f3b/cryptography-46.0.5-cp311-abi3-macosx_10_9_universal2.whl", hash = "sha256:351695ada9ea9618b3500b490ad54c739860883df6c1f555e088eaf25b1bbaad", size = 7176289, upload-time = "2026-02-10T19:17:08.274Z" },
-    { url = "https://files.pythonhosted.org/packages/ff/9e/6b4397a3e3d15123de3b1806ef342522393d50736c13b20ec4c9ea6693a6/cryptography-46.0.5-cp311-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:c18ff11e86df2e28854939acde2d003f7984f721eba450b56a200ad90eeb0e6b", size = 4275637, upload-time = "2026-02-10T19:17:10.53Z" },
-    { url = "https://files.pythonhosted.org/packages/63/e7/471ab61099a3920b0c77852ea3f0ea611c9702f651600397ac567848b897/cryptography-46.0.5-cp311-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:4d7e3d356b8cd4ea5aff04f129d5f66ebdc7b6f8eae802b93739ed520c47c79b", size = 4424742, upload-time = "2026-02-10T19:17:12.388Z" },
-    { url = "https://files.pythonhosted.org/packages/37/53/a18500f270342d66bf7e4d9f091114e31e5ee9e7375a5aba2e85a91e0044/cryptography-46.0.5-cp311-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:50bfb6925eff619c9c023b967d5b77a54e04256c4281b0e21336a130cd7fc263", size = 4277528, upload-time = "2026-02-10T19:17:13.853Z" },
-    { url = "https://files.pythonhosted.org/packages/22/29/c2e812ebc38c57b40e7c583895e73c8c5adb4d1e4a0cc4c5a4fdab2b1acc/cryptography-46.0.5-cp311-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:803812e111e75d1aa73690d2facc295eaefd4439be1023fefc4995eaea2af90d", size = 4947993, upload-time = "2026-02-10T19:17:15.618Z" },
-    { url = "https://files.pythonhosted.org/packages/6b/e7/237155ae19a9023de7e30ec64e5d99a9431a567407ac21170a046d22a5a3/cryptography-46.0.5-cp311-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:3ee190460e2fbe447175cda91b88b84ae8322a104fc27766ad09428754a618ed", size = 4456855, upload-time = "2026-02-10T19:17:17.221Z" },
-    { url = "https://files.pythonhosted.org/packages/2d/87/fc628a7ad85b81206738abbd213b07702bcbdada1dd43f72236ef3cffbb5/cryptography-46.0.5-cp311-abi3-manylinux_2_31_armv7l.whl", hash = "sha256:f145bba11b878005c496e93e257c1e88f154d278d2638e6450d17e0f31e558d2", size = 3984635, upload-time = "2026-02-10T19:17:18.792Z" },
-    { url = "https://files.pythonhosted.org/packages/84/29/65b55622bde135aedf4565dc509d99b560ee4095e56989e815f8fd2aa910/cryptography-46.0.5-cp311-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:e9251e3be159d1020c4030bd2e5f84d6a43fe54b6c19c12f51cde9542a2817b2", size = 4277038, upload-time = "2026-02-10T19:17:20.256Z" },
-    { url = "https://files.pythonhosted.org/packages/bc/36/45e76c68d7311432741faf1fbf7fac8a196a0a735ca21f504c75d37e2558/cryptography-46.0.5-cp311-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:47fb8a66058b80e509c47118ef8a75d14c455e81ac369050f20ba0d23e77fee0", size = 4912181, upload-time = "2026-02-10T19:17:21.825Z" },
-    { url = "https://files.pythonhosted.org/packages/6d/1a/c1ba8fead184d6e3d5afcf03d569acac5ad063f3ac9fb7258af158f7e378/cryptography-46.0.5-cp311-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:4c3341037c136030cb46e4b1e17b7418ea4cbd9dd207e4a6f3b2b24e0d4ac731", size = 4456482, upload-time = "2026-02-10T19:17:25.133Z" },
-    { url = "https://files.pythonhosted.org/packages/f9/e5/3fb22e37f66827ced3b902cf895e6a6bc1d095b5b26be26bd13c441fdf19/cryptography-46.0.5-cp311-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:890bcb4abd5a2d3f852196437129eb3667d62630333aacc13dfd470fad3aaa82", size = 4405497, upload-time = "2026-02-10T19:17:26.66Z" },
-    { url = "https://files.pythonhosted.org/packages/1a/df/9d58bb32b1121a8a2f27383fabae4d63080c7ca60b9b5c88be742be04ee7/cryptography-46.0.5-cp311-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:80a8d7bfdf38f87ca30a5391c0c9ce4ed2926918e017c29ddf643d0ed2778ea1", size = 4667819, upload-time = "2026-02-10T19:17:28.569Z" },
-    { url = "https://files.pythonhosted.org/packages/ea/ed/325d2a490c5e94038cdb0117da9397ece1f11201f425c4e9c57fe5b9f08b/cryptography-46.0.5-cp311-abi3-win32.whl", hash = "sha256:60ee7e19e95104d4c03871d7d7dfb3d22ef8a9b9c6778c94e1c8fcc8365afd48", size = 3028230, upload-time = "2026-02-10T19:17:30.518Z" },
-    { url = "https://files.pythonhosted.org/packages/e9/5a/ac0f49e48063ab4255d9e3b79f5def51697fce1a95ea1370f03dc9db76f6/cryptography-46.0.5-cp311-abi3-win_amd64.whl", hash = "sha256:38946c54b16c885c72c4f59846be9743d699eee2b69b6988e0a00a01f46a61a4", size = 3480909, upload-time = "2026-02-10T19:17:32.083Z" },
-    { url = "https://files.pythonhosted.org/packages/00/13/3d278bfa7a15a96b9dc22db5a12ad1e48a9eb3d40e1827ef66a5df75d0d0/cryptography-46.0.5-cp314-cp314t-macosx_10_9_universal2.whl", hash = "sha256:94a76daa32eb78d61339aff7952ea819b1734b46f73646a07decb40e5b3448e2", size = 7119287, upload-time = "2026-02-10T19:17:33.801Z" },
-    { url = "https://files.pythonhosted.org/packages/67/c8/581a6702e14f0898a0848105cbefd20c058099e2c2d22ef4e476dfec75d7/cryptography-46.0.5-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:5be7bf2fb40769e05739dd0046e7b26f9d4670badc7b032d6ce4db64dddc0678", size = 4265728, upload-time = "2026-02-10T19:17:35.569Z" },
-    { url = "https://files.pythonhosted.org/packages/dd/4a/ba1a65ce8fc65435e5a849558379896c957870dd64fecea97b1ad5f46a37/cryptography-46.0.5-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:fe346b143ff9685e40192a4960938545c699054ba11d4f9029f94751e3f71d87", size = 4408287, upload-time = "2026-02-10T19:17:36.938Z" },
-    { url = "https://files.pythonhosted.org/packages/f8/67/8ffdbf7b65ed1ac224d1c2df3943553766914a8ca718747ee3871da6107e/cryptography-46.0.5-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:c69fd885df7d089548a42d5ec05be26050ebcd2283d89b3d30676eb32ff87dee", size = 4270291, upload-time = "2026-02-10T19:17:38.748Z" },
-    { url = "https://files.pythonhosted.org/packages/f8/e5/f52377ee93bc2f2bba55a41a886fd208c15276ffbd2569f2ddc89d50e2c5/cryptography-46.0.5-cp314-cp314t-manylinux_2_28_ppc64le.whl", hash = "sha256:8293f3dea7fc929ef7240796ba231413afa7b68ce38fd21da2995549f5961981", size = 4927539, upload-time = "2026-02-10T19:17:40.241Z" },
-    { url = "https://files.pythonhosted.org/packages/3b/02/cfe39181b02419bbbbcf3abdd16c1c5c8541f03ca8bda240debc467d5a12/cryptography-46.0.5-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:1abfdb89b41c3be0365328a410baa9df3ff8a9110fb75e7b52e66803ddabc9a9", size = 4442199, upload-time = "2026-02-10T19:17:41.789Z" },
-    { url = "https://files.pythonhosted.org/packages/c0/96/2fcaeb4873e536cf71421a388a6c11b5bc846e986b2b069c79363dc1648e/cryptography-46.0.5-cp314-cp314t-manylinux_2_31_armv7l.whl", hash = "sha256:d66e421495fdb797610a08f43b05269e0a5ea7f5e652a89bfd5a7d3c1dee3648", size = 3960131, upload-time = "2026-02-10T19:17:43.379Z" },
-    { url = "https://files.pythonhosted.org/packages/d8/d2/b27631f401ddd644e94c5cf33c9a4069f72011821cf3dc7309546b0642a0/cryptography-46.0.5-cp314-cp314t-manylinux_2_34_aarch64.whl", hash = "sha256:4e817a8920bfbcff8940ecfd60f23d01836408242b30f1a708d93198393a80b4", size = 4270072, upload-time = "2026-02-10T19:17:45.481Z" },
-    { url = "https://files.pythonhosted.org/packages/f4/a7/60d32b0370dae0b4ebe55ffa10e8599a2a59935b5ece1b9f06edb73abdeb/cryptography-46.0.5-cp314-cp314t-manylinux_2_34_ppc64le.whl", hash = "sha256:68f68d13f2e1cb95163fa3b4db4bf9a159a418f5f6e7242564fc75fcae667fd0", size = 4892170, upload-time = "2026-02-10T19:17:46.997Z" },
-    { url = "https://files.pythonhosted.org/packages/d2/b9/cf73ddf8ef1164330eb0b199a589103c363afa0cf794218c24d524a58eab/cryptography-46.0.5-cp314-cp314t-manylinux_2_34_x86_64.whl", hash = "sha256:a3d1fae9863299076f05cb8a778c467578262fae09f9dc0ee9b12eb4268ce663", size = 4441741, upload-time = "2026-02-10T19:17:48.661Z" },
-    { url = "https://files.pythonhosted.org/packages/5f/eb/eee00b28c84c726fe8fa0158c65afe312d9c3b78d9d01daf700f1f6e37ff/cryptography-46.0.5-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:c4143987a42a2397f2fc3b4d7e3a7d313fbe684f67ff443999e803dd75a76826", size = 4396728, upload-time = "2026-02-10T19:17:50.058Z" },
-    { url = "https://files.pythonhosted.org/packages/65/f4/6bc1a9ed5aef7145045114b75b77c2a8261b4d38717bd8dea111a63c3442/cryptography-46.0.5-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:7d731d4b107030987fd61a7f8ab512b25b53cef8f233a97379ede116f30eb67d", size = 4652001, upload-time = "2026-02-10T19:17:51.54Z" },
-    { url = "https://files.pythonhosted.org/packages/86/ef/5d00ef966ddd71ac2e6951d278884a84a40ffbd88948ef0e294b214ae9e4/cryptography-46.0.5-cp314-cp314t-win32.whl", hash = "sha256:c3bcce8521d785d510b2aad26ae2c966092b7daa8f45dd8f44734a104dc0bc1a", size = 3003637, upload-time = "2026-02-10T19:17:52.997Z" },
-    { url = "https://files.pythonhosted.org/packages/b7/57/f3f4160123da6d098db78350fdfd9705057aad21de7388eacb2401dceab9/cryptography-46.0.5-cp314-cp314t-win_amd64.whl", hash = "sha256:4d8ae8659ab18c65ced284993c2265910f6c9e650189d4e3f68445ef82a810e4", size = 3469487, upload-time = "2026-02-10T19:17:54.549Z" },
-    { url = "https://files.pythonhosted.org/packages/e2/fa/a66aa722105ad6a458bebd64086ca2b72cdd361fed31763d20390f6f1389/cryptography-46.0.5-cp38-abi3-macosx_10_9_universal2.whl", hash = "sha256:4108d4c09fbbf2789d0c926eb4152ae1760d5a2d97612b92d508d96c861e4d31", size = 7170514, upload-time = "2026-02-10T19:17:56.267Z" },
-    { url = "https://files.pythonhosted.org/packages/0f/04/c85bdeab78c8bc77b701bf0d9bdcf514c044e18a46dcff330df5448631b0/cryptography-46.0.5-cp38-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:7d1f30a86d2757199cb2d56e48cce14deddf1f9c95f1ef1b64ee91ea43fe2e18", size = 4275349, upload-time = "2026-02-10T19:17:58.419Z" },
-    { url = "https://files.pythonhosted.org/packages/5c/32/9b87132a2f91ee7f5223b091dc963055503e9b442c98fc0b8a5ca765fab0/cryptography-46.0.5-cp38-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:039917b0dc418bb9f6edce8a906572d69e74bd330b0b3fea4f79dab7f8ddd235", size = 4420667, upload-time = "2026-02-10T19:18:00.619Z" },
-    { url = "https://files.pythonhosted.org/packages/a1/a6/a7cb7010bec4b7c5692ca6f024150371b295ee1c108bdc1c400e4c44562b/cryptography-46.0.5-cp38-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:ba2a27ff02f48193fc4daeadf8ad2590516fa3d0adeeb34336b96f7fa64c1e3a", size = 4276980, upload-time = "2026-02-10T19:18:02.379Z" },
-    { url = "https://files.pythonhosted.org/packages/8e/7c/c4f45e0eeff9b91e3f12dbd0e165fcf2a38847288fcfd889deea99fb7b6d/cryptography-46.0.5-cp38-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:61aa400dce22cb001a98014f647dc21cda08f7915ceb95df0c9eaf84b4b6af76", size = 4939143, upload-time = "2026-02-10T19:18:03.964Z" },
-    { url = "https://files.pythonhosted.org/packages/37/19/e1b8f964a834eddb44fa1b9a9976f4e414cbb7aa62809b6760c8803d22d1/cryptography-46.0.5-cp38-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:3ce58ba46e1bc2aac4f7d9290223cead56743fa6ab94a5d53292ffaac6a91614", size = 4453674, upload-time = "2026-02-10T19:18:05.588Z" },
-    { url = "https://files.pythonhosted.org/packages/db/ed/db15d3956f65264ca204625597c410d420e26530c4e2943e05a0d2f24d51/cryptography-46.0.5-cp38-abi3-manylinux_2_31_armv7l.whl", hash = "sha256:420d0e909050490d04359e7fdb5ed7e667ca5c3c402b809ae2563d7e66a92229", size = 3978801, upload-time = "2026-02-10T19:18:07.167Z" },
-    { url = "https://files.pythonhosted.org/packages/41/e2/df40a31d82df0a70a0daf69791f91dbb70e47644c58581d654879b382d11/cryptography-46.0.5-cp38-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:582f5fcd2afa31622f317f80426a027f30dc792e9c80ffee87b993200ea115f1", size = 4276755, upload-time = "2026-02-10T19:18:09.813Z" },
-    { url = "https://files.pythonhosted.org/packages/33/45/726809d1176959f4a896b86907b98ff4391a8aa29c0aaaf9450a8a10630e/cryptography-46.0.5-cp38-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:bfd56bb4b37ed4f330b82402f6f435845a5f5648edf1ad497da51a8452d5d62d", size = 4901539, upload-time = "2026-02-10T19:18:11.263Z" },
-    { url = "https://files.pythonhosted.org/packages/99/0f/a3076874e9c88ecb2ecc31382f6e7c21b428ede6f55aafa1aa272613e3cd/cryptography-46.0.5-cp38-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:a3d507bb6a513ca96ba84443226af944b0f7f47dcc9a399d110cd6146481d24c", size = 4452794, upload-time = "2026-02-10T19:18:12.914Z" },
-    { url = "https://files.pythonhosted.org/packages/02/ef/ffeb542d3683d24194a38f66ca17c0a4b8bf10631feef44a7ef64e631b1a/cryptography-46.0.5-cp38-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:9f16fbdf4da055efb21c22d81b89f155f02ba420558db21288b3d0035bafd5f4", size = 4404160, upload-time = "2026-02-10T19:18:14.375Z" },
-    { url = "https://files.pythonhosted.org/packages/96/93/682d2b43c1d5f1406ed048f377c0fc9fc8f7b0447a478d5c65ab3d3a66eb/cryptography-46.0.5-cp38-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:ced80795227d70549a411a4ab66e8ce307899fad2220ce5ab2f296e687eacde9", size = 4667123, upload-time = "2026-02-10T19:18:15.886Z" },
-    { url = "https://files.pythonhosted.org/packages/45/2d/9c5f2926cb5300a8eefc3f4f0b3f3df39db7f7ce40c8365444c49363cbda/cryptography-46.0.5-cp38-abi3-win32.whl", hash = "sha256:02f547fce831f5096c9a567fd41bc12ca8f11df260959ecc7c3202555cc47a72", size = 3010220, upload-time = "2026-02-10T19:18:17.361Z" },
-    { url = "https://files.pythonhosted.org/packages/48/ef/0c2f4a8e31018a986949d34a01115dd057bf536905dca38897bacd21fac3/cryptography-46.0.5-cp38-abi3-win_amd64.whl", hash = "sha256:556e106ee01aa13484ce9b0239bca667be5004efb0aabbed28d353df86445595", size = 3467050, upload-time = "2026-02-10T19:18:18.899Z" },
+sdist = { url = "https://files.pythonhosted.org/packages/12/45/870e7f4bef50e5f53b9f51d4428aee5290eedf58ba443f16b1ebb7ab8e66/cryptography-48.0.1.tar.gz", hash = "sha256:266f4ee051abb2f725b74ef8072b521ce1feacf685a3364fa6a6b45548db791a", size = 832989, upload-time = "2026-06-09T22:32:31.8Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1b/bc/ee4137cbbe105652c0ee4252792b78fc8e7afa4b8e61d9d5dc05a7f45731/cryptography-48.0.1-cp311-abi3-macosx_10_9_universal2.whl", hash = "sha256:3e4a1a3232eef2e6c732827d5722db29a0cc8b27af2a4d865b094cf954be9ca1", size = 8008324, upload-time = "2026-06-09T22:31:00.702Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/85/6379d42181bfc713094f081360fc5784d6c816b599d45e7f082502d173ce/cryptography-48.0.1-cp311-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:32143b24adb918f078134e1e230f1eb8cc04886b92c28b5f0041aaf3e5699225", size = 4696243, upload-time = "2026-06-09T22:32:33.446Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/87/c85d147b53323c7eb4d850920c8901377323c2a0ff8d79c262d4fee89aa2/cryptography-48.0.1-cp311-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:f0d27a5696721ef7a672b8c810f6aded391058e0b9486e63e6d93baf765da691", size = 4713235, upload-time = "2026-06-09T22:31:40.141Z" },
+    { url = "https://files.pythonhosted.org/packages/79/58/67cbf8cf1ee7c54b439ca07bbecf8362c07afc11a3724fea70f745784add/cryptography-48.0.1-cp311-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:eb86ce1af36fe65041b6db9a8bb064ee621a7e5fded0f80d475ec243477cd242", size = 4702323, upload-time = "2026-06-09T22:31:42.191Z" },
+    { url = "https://files.pythonhosted.org/packages/89/c6/24266ac10c47f6cd2a865f4446062b466da1d1f10b27189eac00e61bf0c9/cryptography-48.0.1-cp311-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:b024e784ad6c077ee0147b35ea9cbfc1e34e1fd4c1dcca214c2794d73a12df08", size = 5300085, upload-time = "2026-06-09T22:31:58.703Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/bb/cc4b78784f97efc8c5874c2a9743708d172be6663024b34a0467885ae0c8/cryptography-48.0.1-cp311-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:3752f2dbc8f07a30aad2932c986cea495b03bb554887828225da104f732852b6", size = 4746137, upload-time = "2026-06-09T22:31:31.01Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/52/0c44de3f5267f8fbe8e835138017522a333436166e406f0db9b9e6e3033f/cryptography-48.0.1-cp311-abi3-manylinux_2_31_armv7l.whl", hash = "sha256:bd81490cd5801d755cf97bb68ac191f14b708470b1c7cf4580f669b9c9264cd8", size = 4333867, upload-time = "2026-06-09T22:32:28.096Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/2e/772d7adbfa931537bc401640b7cac9976bff689bda187833e5d63b428e49/cryptography-48.0.1-cp311-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:66fd0771e7b9c6dcd44cf1120690d2338d16d72795cf40cae2786a39eba65429", size = 4701805, upload-time = "2026-06-09T22:31:38.284Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/a3/b06844f303873493c963caf581c04df31c7035e0c1b0f02c4814d319ec80/cryptography-48.0.1-cp311-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:3fd2ca57062b241c856670b073487d2e86c4637937ca5601e48f97bf8e11fc8f", size = 5258461, upload-time = "2026-06-09T22:31:04.187Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/13/8b765e2e12b07c74941caadb9d1c8fdc006c4dfbf2b8f2d610519758954d/cryptography-48.0.1-cp311-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:0ee6ea481db1ab889cba043ec1eda17bb9c1ea79db6722f779c3667f9f70322f", size = 4745488, upload-time = "2026-06-09T22:32:30.07Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/aa/48972bce55049b32a94f4907eda4d75fa385aad8a39506cc2fc72196ecf0/cryptography-48.0.1-cp311-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:f2ceef93cb096aa3c4cc4b5c94ca6131f9196d28c64d6111533402a9b2054d41", size = 4830256, upload-time = "2026-06-09T22:31:43.868Z" },
+    { url = "https://files.pythonhosted.org/packages/47/a2/e5079a032fb85cf6005046ca92bbd78b0c82dad2b5751ab8c311659da06f/cryptography-48.0.1-cp311-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:9bd3f92d76217892b15df84ca256c2c113d386fdda7a7d8691aeeced976507c6", size = 4979117, upload-time = "2026-06-09T22:31:05.845Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/a0/8f50cae9c74e718ed769d63ed5c74bd0ea830c9550a74629cebd1b9c7bc7/cryptography-48.0.1-cp311-abi3-win32.whl", hash = "sha256:b9a32b876490d66c8bcc9963ef220199569748434ab01a9d6aaeabf88e7f5158", size = 3304154, upload-time = "2026-06-09T22:32:16.845Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/69/0572c77dbace6fef72f33755bd52ea399c71367250d366237f8691826b9e/cryptography-48.0.1-cp311-abi3-win_amd64.whl", hash = "sha256:39489bfca54c7a1f6b297efcd8bc608ab92d16c4ca631b0cad4da46724588b24", size = 3817138, upload-time = "2026-06-09T22:32:00.388Z" },
+    { url = "https://files.pythonhosted.org/packages/42/06/3e768b4c3bc78201583fa35a0e18f640dd782ff41afba88f8545481a8874/cryptography-48.0.1-cp314-cp314t-macosx_10_9_universal2.whl", hash = "sha256:f817adc181390bd54f2f700107a7419040fb7c1bdf2fc26f36551a06a68c3345", size = 7989830, upload-time = "2026-06-09T22:31:07.8Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/13/6476736484b94041110c8340a3eb63962fea4975baea8cb4a512adb44d4d/cryptography-48.0.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d5d30989c6917b478b5817902e85fddaea2261efa8648383d965381ccb9e1ac4", size = 4689201, upload-time = "2026-06-09T22:31:09.745Z" },
+    { url = "https://files.pythonhosted.org/packages/79/62/65a87f34d2a431546e2509b85d55e8c90df86d668f6731da64d538512ac2/cryptography-48.0.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:df637c05205ea7c1d7fbcbe54bbfea648a52951155f997af13d895d0ecc96991", size = 4702822, upload-time = "2026-06-09T22:32:24.409Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/59/810b5204b0a9b10f4b6bc06bd551a8b609803cd931806bc3b71884b225e5/cryptography-48.0.1-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:869c3b8a53bfe27147832df48b32adadf558249d50e76cb3769d40e986b13265", size = 4694875, upload-time = "2026-06-09T22:32:08.737Z" },
+    { url = "https://files.pythonhosted.org/packages/24/dc/d8ca05ffea724eec6d232ea6f18e74c269eb6bdfdcc9bfba689790d1325f/cryptography-48.0.1-cp314-cp314t-manylinux_2_28_ppc64le.whl", hash = "sha256:e361afba8918070d376df76f408a4f67fec0ee9cff81a99e48fe9a233ef59e17", size = 5290385, upload-time = "2026-06-09T22:31:15.212Z" },
+    { url = "https://files.pythonhosted.org/packages/03/8c/3be6cb4da181f5bb6c19cf560c2359d60644a6b5fc5b57854e528f47b296/cryptography-48.0.1-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:d069066deead00ac7f090be101be875a06855908f7ec004c27b8fefb4acfb411", size = 4737082, upload-time = "2026-06-09T22:32:22.66Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/f6/d5f60a5a1434dbfd949e227fd0065d194c7e6b6ac526b17f5c06152b8231/cryptography-48.0.1-cp314-cp314t-manylinux_2_31_armv7l.whl", hash = "sha256:09f73a725d582cef64b91281a322cd798d14a33b2b6f2b7ad9531dc336d84c02", size = 4325328, upload-time = "2026-06-09T22:32:10.777Z" },
+    { url = "https://files.pythonhosted.org/packages/17/b7/ba75dd947a14b6ad907b01ae8f6b5b348cdd1b48142f0063dee9e20c1d9d/cryptography-48.0.1-cp314-cp314t-manylinux_2_34_aarch64.whl", hash = "sha256:15254441469dd6bf027039453288e2072124f8b6603563f5d759e1c9b69273fa", size = 4694530, upload-time = "2026-06-09T22:31:53.105Z" },
+    { url = "https://files.pythonhosted.org/packages/62/29/50d6b9e8aff12d8b67afaeb3569335e32dc83a5723e3bbded24fdac9f809/cryptography-48.0.1-cp314-cp314t-manylinux_2_34_ppc64le.whl", hash = "sha256:8ace4507d1e6533c125f4fac754f8bb8b6a74c08e92179dabd7e16571a3efbf3", size = 5245046, upload-time = "2026-06-09T22:31:25.774Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/04/618f4115cfc0add0838c82507aa18a346089428da8653ad38b3ff36f5cb3/cryptography-48.0.1-cp314-cp314t-manylinux_2_34_x86_64.whl", hash = "sha256:b4e391975f038e66432328639620a4aff2d307513b004f1ca06d6225bced815c", size = 4736660, upload-time = "2026-06-09T22:32:12.676Z" },
+    { url = "https://files.pythonhosted.org/packages/24/9c/06e062462a0de28a3b3911322eded4c16deb9f441b1b7575d3dc59488ab5/cryptography-48.0.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:42fcd8e26fe555d9b3577a135f5091fefa0aa4e99129c23fb56787a1bd4ada72", size = 4822229, upload-time = "2026-06-09T22:31:17.062Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/be/0561971eaaee4b8a0e7d5113c536921063ab91aaf23278ac374eaf881e11/cryptography-48.0.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:c1400da5e32a43253392277eac7490a60e497d810a63dd5608d71bbd7af507c9", size = 4966364, upload-time = "2026-06-09T22:31:32.842Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/27/728c77876f12b000820b69ae490f3c4083775e79e07827e9e60be07ad209/cryptography-48.0.1-cp314-cp314t-win32.whl", hash = "sha256:0df56b056bc17c1b7d6821dfa65216e62bd232d8ab05eb3db44e71d235651471", size = 3278498, upload-time = "2026-06-09T22:31:29.154Z" },
+    { url = "https://files.pythonhosted.org/packages/06/e3/79a612c6d7b1e6ee0edd43633d53035bec2cfb78c82b76f7864f39e36f34/cryptography-48.0.1-cp314-cp314t-win_amd64.whl", hash = "sha256:9de21387aa95e2a895823d0745b430bed4f33503ba9ab5e0b5311f33e37d66d2", size = 3798790, upload-time = "2026-06-09T22:31:56.697Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/6c/00fa2a95997164c8b2072ce327c23d4ab20809ccc323ea5fab91e53a4bba/cryptography-48.0.1-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:4fdc69f8e4316bcf0c8c8ec1f26f285d12e8142d88d96c876a59a03be3f6ae67", size = 7987408, upload-time = "2026-06-09T22:32:20.777Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/d9/45f309a7e4e5f3f8f121d6d3be9e94024a7726ec598d6e08ae04edb2f04d/cryptography-48.0.1-cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:48fe40804d4caa2288f24e70ca8c64c42dd826da0ad7e4f1b41b2128d679e6c8", size = 4690196, upload-time = "2026-06-09T22:31:54.74Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/9f/a1bc8bcc798811b8527eb374bbccf30a3f3e806829d967118222bf1125eb/cryptography-48.0.1-cp39-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:86be3b1b0b6bf09482fb50a979c508d2950ed95f5621ec77f4e385962006b83a", size = 4696782, upload-time = "2026-06-09T22:31:45.615Z" },
+    { url = "https://files.pythonhosted.org/packages/66/c2/81a4fb4e4373c500bb526bc337ac5719dd31dd15b970b84a238168c6aa08/cryptography-48.0.1-cp39-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:4ab0a343c807bbcd90c971cd1ecf072937cd01847a9e002bef88fb47ac6be577", size = 4696618, upload-time = "2026-06-09T22:31:11.564Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/0b/aa68b221dde92d09cb29a024ede17550ee21e77a404e59fc093c82bb51e1/cryptography-48.0.1-cp39-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:9621de99d2da096006b629979efd8ae7eb2d8b822488d0c89ee4000c306c59b1", size = 5289970, upload-time = "2026-06-09T22:31:20.368Z" },
+    { url = "https://files.pythonhosted.org/packages/78/13/fba657f958d2af66ea959a4ba01212632089249d34af1ae48054136344d7/cryptography-48.0.1-cp39-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:88c852a0ae366e262e5a1744b685e6a433dc8788dd2a277e418bf4904203609d", size = 4731873, upload-time = "2026-06-09T22:31:22.253Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/4c/9a964756d24a26b3e34dfcb16f961b89838786e6700b635b0d1e3adff4b6/cryptography-48.0.1-cp39-abi3-manylinux_2_31_armv7l.whl", hash = "sha256:43c5835e2cb98c8733d86f57d6fc879b613f5c3478607281c3e36daffc6dd8a6", size = 4330804, upload-time = "2026-06-09T22:31:36.56Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/0f/a10f3a6eb12950a10e3a874070283aa2dd5875b2bfd15fad8a3e17b3f13e/cryptography-48.0.1-cp39-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:fe0180af5bf9236518a087e35bf2d9a347d5f5f51e63c579d683ddff424e3d46", size = 4696217, upload-time = "2026-06-09T22:31:13.351Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/6f/5cd12f951165ea73ef85266775d97e4c763b2474ccfd816dd69d3a18d6f8/cryptography-48.0.1-cp39-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:b7a2d1a937a738a881737cec135a38bb61470589b17515b9f73f571d0ae10401", size = 5245252, upload-time = "2026-06-09T22:32:02.193Z" },
+    { url = "https://files.pythonhosted.org/packages/68/ab/8aaa12e4516ec4464033ab79b6f3b592bd5a92102467c4ace8a0d970203f/cryptography-48.0.1-cp39-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:b74ca3b8e5ecdd833bf6a002ca41b4793bb27fb8f1c06ffaf2643c9e9140e31b", size = 4731388, upload-time = "2026-06-09T22:32:04.019Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/24/50027ea4dca85ec1f40688f3c24fb32ccacd520583c9592c3cc95628e6fb/cryptography-48.0.1-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:2c37f2461406063b417837f5f3daab668652acd82423efcd7f0a9f04be972de1", size = 4824186, upload-time = "2026-06-09T22:32:18.707Z" },
+    { url = "https://files.pythonhosted.org/packages/52/41/04cb5eb17085ade6f50cc611fb657df6a0f5885350de8764ece89c050197/cryptography-48.0.1-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:86fe77abb1bd87afb251d4d02ada7ecf53a32cee9b67d976abb2e45a13297475", size = 4964539, upload-time = "2026-06-09T22:31:18.793Z" },
+    { url = "https://files.pythonhosted.org/packages/36/bf/ed70785c496e89d7e73b7cda2d21f2447fd6d4e821714b8d04ff217fed92/cryptography-48.0.1-cp39-abi3-win32.whl", hash = "sha256:6b2c0c3e6ccf3ade7750f836ef3ee36eea250cc467d45c256895573ac08cc6f1", size = 3282307, upload-time = "2026-06-09T22:30:53.162Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/ff/371ea7d252656ee1eb6d83eeeef3d1d0c6baf1d6497687d081ea03814670/cryptography-48.0.1-cp39-abi3-win_amd64.whl", hash = "sha256:9a49ca6c81417f6a5edb50375a60cccdd70fa0a91a5211829dbea74eba94d2ac", size = 3793408, upload-time = "2026-06-09T22:32:15.191Z" },
 ]
 
 [[package]]
@@ -1949,14 +1976,14 @@ wheels = [
 
 [[package]]
 name = "gitpython"
-version = "3.1.46"
+version = "3.1.50"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "gitdb" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/df/b5/59d16470a1f0dfe8c793f9ef56fd3826093fc52b3bd96d6b9d6c26c7e27b/gitpython-3.1.46.tar.gz", hash = "sha256:400124c7d0ef4ea03f7310ac2fbf7151e09ff97f2a3288d64a440c584a29c37f", size = 215371, upload-time = "2026-01-01T15:37:32.073Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/33/f6/354ae6491228b5eb40e10d89c4d13c651fe1cf7556e35ebdded50cff57ce/gitpython-3.1.50.tar.gz", hash = "sha256:80da2d12504d52e1f998772dc5baf6e553f8d2fcfe1fcc226c9d9a2ee3372dcc", size = 219798, upload-time = "2026-05-06T04:01:26.571Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/6a/09/e21df6aef1e1ffc0c816f0522ddc3f6dcded766c3261813131c78a704470/gitpython-3.1.46-py3-none-any.whl", hash = "sha256:79812ed143d9d25b6d176a10bb511de0f9c67b1fa641d82097b0ab90398a2058", size = 208620, upload-time = "2026-01-01T15:37:30.574Z" },
+    { url = "https://files.pythonhosted.org/packages/20/7a/1c6e3562dfd8950adbb11ffbc65d21e7c89d01a6e4f137fa981056de25c5/gitpython-3.1.50-py3-none-any.whl", hash = "sha256:d352abe2908d07355014abdd21ddf798c2a961469239afec4962e9da884858f9", size = 212507, upload-time = "2026-05-06T04:01:23.799Z" },
 ]
 
 [[package]]
@@ -2210,11 +2237,11 @@ wheels = [
 
 [[package]]
 name = "idna"
-version = "3.11"
+version = "3.18"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/6f/6d/0703ccc57f3a7233505399edb88de3cbd678da106337b9fcde432b65ed60/idna-3.11.tar.gz", hash = "sha256:795dafcc9c04ed0c1fb032c2aa73654d8e8c5023a7df64a53f39190ada629902", size = 194582, upload-time = "2025-10-12T14:55:20.501Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/cd/63/9496c57188a2ee585e0f1db071d75089a11e98aa86eb99d9d7618fc1edce/idna-3.18.tar.gz", hash = "sha256:ffb385a7e039654cef1ab9ef32c6fafe283c0c0467bba1d9029738ce4a14a848", size = 196711, upload-time = "2026-06-02T14:34:07.794Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/0e/61/66938bbb5fc52dbdf84594873d5b51fb1f7c7794e9c0f5bd885f30bc507b/idna-3.11-py3-none-any.whl", hash = "sha256:771a87f49d9defaf64091e6e6fe9c18d4833f140bd19464795bc32d966ca37ea", size = 71008, upload-time = "2025-10-12T14:55:18.883Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/5e/d4e9f1a599fb8e573b7b87160658329fbf28d19eac2718f51fc3def3aa5a/idna-3.18-py3-none-any.whl", hash = "sha256:7f952cbe720b688055e3f87de14f5c3e5fdaa8bc3928985c4077ca689de849a2", size = 65455, upload-time = "2026-06-02T14:34:06.319Z" },
 ]
 
 [[package]]
@@ -2711,7 +2738,7 @@ wheels = [
 
 [[package]]
 name = "jupyter-server"
-version = "2.17.0"
+version = "2.19.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "anyio" },
@@ -2733,9 +2760,9 @@ dependencies = [
     { name = "traitlets" },
     { name = "websocket-client" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/5b/ac/e040ec363d7b6b1f11304cc9f209dac4517ece5d5e01821366b924a64a50/jupyter_server-2.17.0.tar.gz", hash = "sha256:c38ea898566964c888b4772ae1ed58eca84592e88251d2cfc4d171f81f7e99d5", size = 731949, upload-time = "2025-08-21T14:42:54.042Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/76/a0/eb3c511f54df7b54ca5fc7bff3f4d2277d69052d6a7f521643dfed5279d6/jupyter_server-2.19.0.tar.gz", hash = "sha256:1731236bc32b680223e1ceb9d68209a845203475012ef68773a81434b46a31a7", size = 754561, upload-time = "2026-05-29T11:21:26.057Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/92/80/a24767e6ca280f5a49525d987bf3e4d7552bf67c8be07e8ccf20271f8568/jupyter_server-2.17.0-py3-none-any.whl", hash = "sha256:e8cb9c7db4251f51ed307e329b81b72ccf2056ff82d50524debde1ee1870e13f", size = 388221, upload-time = "2025-08-21T14:42:52.034Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/78/d2881e68894cecdcd05912a9c585cfb776ef1fb38b62c8dba98f12ab3adc/jupyter_server-2.19.0-py3-none-any.whl", hash = "sha256:cb76591b76d7093584c2ad2ae72ac3d58614a4b597507a1bb04e1f9f683cf9ea", size = 392244, upload-time = "2026-05-29T11:21:23.871Z" },
 ]
 
 [[package]]
@@ -2753,7 +2780,7 @@ wheels = [
 
 [[package]]
 name = "jupyterlab"
-version = "4.5.6"
+version = "4.5.8"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "async-lru" },
@@ -2770,9 +2797,9 @@ dependencies = [
     { name = "tornado" },
     { name = "traitlets" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/ac/d5/730628e03fff2e8a8e8ccdaedde1489ab1309f9a4fa2536248884e30b7c7/jupyterlab-4.5.6.tar.gz", hash = "sha256:642fe2cfe7f0f5922a8a558ba7a0d246c7bc133b708dfe43f7b3a826d163cf42", size = 23970670, upload-time = "2026-03-11T14:17:04.531Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/0e/74/089613e6099e851a6130816f2df592c839d8565f8746a701edada05a33e4/jupyterlab-4.5.8.tar.gz", hash = "sha256:af54d7242cc689a1e6c3ad213cc9b6d9781787d9ec67c52ec9a8f4707088cadd", size = 23994076, upload-time = "2026-06-04T12:32:12.906Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/e1/1b/dad6fdcc658ed7af26fdf3841e7394072c9549a8b896c381ab49dd11e2d9/jupyterlab-4.5.6-py3-none-any.whl", hash = "sha256:d6b3dac883aa4d9993348e0f8e95b24624f75099aed64eab6a4351a9cdd1e580", size = 12447124, upload-time = "2026-03-11T14:17:00.229Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/d1/56a400100559cbf154a23cd29989261941ae5c9f743898fc10e8a5508b7c/jupyterlab-4.5.8-py3-none-any.whl", hash = "sha256:7d514c856d0d607601ec7692374da4f26e2aaf3b6e7cd363136b422a50588d6c", size = 12449443, upload-time = "2026-06-04T12:32:08.442Z" },
 ]
 
 [[package]]
@@ -3311,11 +3338,11 @@ image = [
 
 [[package]]
 name = "mistune"
-version = "3.2.0"
+version = "3.2.1"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/9d/55/d01f0c4b45ade6536c51170b9043db8b2ec6ddf4a35c7ea3f5f559ac935b/mistune-3.2.0.tar.gz", hash = "sha256:708487c8a8cdd99c9d90eb3ed4c3ed961246ff78ac82f03418f5183ab70e398a", size = 95467, upload-time = "2025-12-23T11:36:34.994Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/ca/84/620cc3f7e3adf6f5067e10f4dbae71295d8f9e16d5d3f9ef97c40f2f592c/mistune-3.2.1.tar.gz", hash = "sha256:7c8e5501d38bac1582e067e46c8343f17d57ea1aaa735823f3aba1fd59c88a28", size = 98003, upload-time = "2026-05-03T14:33:22.312Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/9b/f7/4a5e785ec9fbd65146a27b6b70b6cdc161a66f2024e4b04ac06a67f5578b/mistune-3.2.0-py3-none-any.whl", hash = "sha256:febdc629a3c78616b94393c6580551e0e34cc289987ec6c35ed3f4be42d0eee1", size = 53598, upload-time = "2025-12-23T11:36:33.211Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/7f/a946aa4f8752b37102b41e64dca18a1976ac705c3a0d1dfe74d820a02552/mistune-3.2.1-py3-none-any.whl", hash = "sha256:78cdb0ba5e938053ccf63651b352508d2efa9411dc8810bfb05f2dc5140c0048", size = 53749, upload-time = "2026-05-03T14:33:20.551Z" },
 ]
 
 [[package]]

From 424077c91b61d76c83a5f9b8c520d3bde2a2b7a1 Mon Sep 17 00:00:00 2001
From: Aravind N <aravindn1308@outlook.com>
Date: Thu, 11 Jun 2026 17:14:52 -0400
Subject: [PATCH 12/15] fix(ci): resolve pip-audit CVEs and fix unit-test
 import errors

- Bump security lower-bounds: aiohttp, cryptography, gitpython, idna,
  jupyter-server, mistune, nbconvert, notebook, pillow, pyjwt,
  pymdown-extensions, python-multipart, requests, urllib3, xgrammar
- Upgrade vllm>=0.22.0; remove numpy<2.0 cap (vllm 0.22 requires numpy>=2)
- Add json-repair>=0.25.2 to main deps (was only transitive via crewai group)
- Move `from crewai import LLM` back inside build_crewai_llm() as lazy import
  (noqa: PLC0415) so unit-test CI doesn't fail without agentic-xai-eval group
- Bump uv to 0.11.15 in both CI workflows; add pip>=26.1.2, uv>=0.11.15
  to dev deps for their own CVE fixes
- Add ignore-vulns entries for no-fix / acceptable-risk CVEs
- Regenerate uv.lock (391 packages)
---
 .github/workflows/code_checks.yml      |    8 +-
 .github/workflows/unit_tests.yml       |    2 +-
 pyproject.toml                         |   19 +-
 src/agentfinvqa/utils/openai_compat.py |    3 +-
 uv.lock                                | 1585 ++++++++++++++++--------
 5 files changed, 1093 insertions(+), 524 deletions(-)

diff --git a/.github/workflows/code_checks.yml b/.github/workflows/code_checks.yml
index 4153008..5652446 100644
--- a/.github/workflows/code_checks.yml
+++ b/.github/workflows/code_checks.yml
@@ -35,7 +35,7 @@ jobs:
         uses: astral-sh/setup-uv@v7.6.0
         with:
           # Install a specific version of uv.
-          version: "0.9.11"
+          version: "0.11.15"
           enable-cache: true
 
       - name: "Set up Python"
@@ -60,3 +60,9 @@ jobs:
             CVE-2026-4539
             CVE-2026-45829
             CVE-2025-69872
+            PYSEC-2026-139
+            CVE-2025-3000
+            CVE-2025-3001
+            PYSEC-2025-217
+            CVE-2026-1839
+            PYSEC-2026-161
diff --git a/.github/workflows/unit_tests.yml b/.github/workflows/unit_tests.yml
index a005697..9a91759 100644
--- a/.github/workflows/unit_tests.yml
+++ b/.github/workflows/unit_tests.yml
@@ -45,7 +45,7 @@ jobs:
         uses: astral-sh/setup-uv@v7.6.0
         with:
           # Install a specific version of uv.
-          version: "0.9.11"
+          version: "0.11.15"
           enable-cache: true
 
       - name: "Set up Python"
diff --git a/pyproject.toml b/pyproject.toml
index e952dae..26f201a 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -15,7 +15,7 @@ dependencies = [
     "jupyter>=1.1.1",
     "jupyterlab>=4.5.7",  # PYSEC-2026-164, CVE-2026-42557
     "matplotlib>=3.10.5",
-    "numpy>=1.26,<2.0",
+    "numpy>=2.0",
     "opencv-python-headless>=4.8.0",
     "openai>=2.8.0",
     "pandas>=2.3.2",
@@ -26,10 +26,11 @@ dependencies = [
     "google-genai>=1.34.0",
     "seaborn>=0.13.2",
     "mypy>=1.19.1",
-    "pytest>=9.0.2",
-    "vllm>=0.14.0",
+    "pytest>=9.0.3",  # CVE-2025-71176
+    "vllm>=0.22.0",   # CVE-2026-22778, -24779, -27893, -34756, -44222, -47155, PYSEC-2026-144
     "qwen-vl-utils==0.0.14",
     "litellm>=1.84.0",
+    "json-repair>=0.25.2",
     # Security lower bounds for transitive dependencies
     "aiohttp>=3.14.0",       # CVE-2026-34993, CVE-2026-47265
     "cryptography>=46.0.7",  # PYSEC-2026-35, PYSEC-2026-36
@@ -37,6 +38,15 @@ dependencies = [
     "idna>=3.15",            # CVE-2026-45409
     "jupyter-server>=2.18.0",  # PYSEC-2026-67/68/69, CVE-2026-40110
     "mistune>=3.2.1",        # PYSEC-2026-168, CVE-2026-33079
+    "nbconvert>=7.17.1",     # CVE-2026-39377, CVE-2026-39378
+    "notebook>=7.5.6",       # CVE-2026-40171
+    "pillow>=12.2.0",        # PYSEC-2026-165, CVE-2026-40192, -42309, -42310, -42311
+    "pyjwt>=2.13.0",         # PYSEC-2026-175, -177, -178, -179
+    "pymdown-extensions>=10.21.3",  # CVE-2026-46338
+    "python-multipart>=0.0.27",     # CVE-2026-40347, CVE-2026-42561
+    "requests>=2.33.0",      # CVE-2026-25645
+    "urllib3>=2.7.0",        # PYSEC-2026-141, PYSEC-2026-142
+    "xgrammar>=0.1.32",      # CVE-2026-25048
 ]
 
 [build-system]
@@ -55,7 +65,8 @@ dev = [
     "codecov>=2.1.13",
     "mypy>=1.14.1",
     "nbqa>=1.9.1",
-    "pip>=26.0", # Pinning version to address vulnerability CVE-2026-1703
+    "pip>=26.1.2",  # CVE-2026-1703, PYSEC-2026-196, CVE-2026-3219, CVE-2026-6357
+    "uv>=0.11.15",  # GHSA-pjjw-68hj-v9mw, GHSA-4gg8-gxpx-9rph
     "pip-audit>=2.7.3",
     "pre-commit>=4.1.0",
     "pytest>=8.3.4",
diff --git a/src/agentfinvqa/utils/openai_compat.py b/src/agentfinvqa/utils/openai_compat.py
index 6b51b7c..619daad 100644
--- a/src/agentfinvqa/utils/openai_compat.py
+++ b/src/agentfinvqa/utils/openai_compat.py
@@ -14,7 +14,6 @@
 import os
 from typing import Any, Optional, Tuple
 
-from crewai import LLM
 from openai import OpenAI
 
 from .model_compat import openai_temperature
@@ -86,6 +85,8 @@ def build_crewai_llm(
     For local vLLM, prefixes the model with ``openai/`` so LiteLLM uses the
     custom base URL.
     """
+    from crewai import LLM  # noqa: PLC0415
+
     if backend == "openai":
         resolved_key = api_key or os.environ.get("OPENAI_API_KEY", "")
         resolved_base = api_base or os.environ.get("OPENAI_BASE_URL", "") or None
diff --git a/uv.lock b/uv.lock
index 4edace0..79aa4e9 100644
--- a/uv.lock
+++ b/uv.lock
@@ -33,6 +33,7 @@ dependencies = [
     { name = "ipykernel" },
     { name = "ipython" },
     { name = "ipywidgets" },
+    { name = "json-repair" },
     { name = "jupyter" },
     { name = "jupyter-server" },
     { name = "jupyterlab" },
@@ -41,17 +42,27 @@ dependencies = [
     { name = "matplotlib" },
     { name = "mistune" },
     { name = "mypy" },
-    { name = "numpy" },
+    { name = "nbconvert" },
+    { name = "notebook" },
+    { name = "numpy", version = "2.3.5", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.13'" },
+    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.13'" },
     { name = "openai" },
     { name = "opencv-python-headless" },
     { name = "pandas" },
+    { name = "pillow" },
+    { name = "pyjwt" },
+    { name = "pymdown-extensions" },
     { name = "pytest" },
     { name = "python-dotenv" },
+    { name = "python-multipart" },
     { name = "qwen-vl-utils" },
+    { name = "requests" },
     { name = "scikit-learn" },
     { name = "seaborn" },
     { name = "transformers" },
+    { name = "urllib3" },
     { name = "vllm" },
+    { name = "xgrammar" },
 ]
 
 [package.dev-dependencies]
@@ -74,6 +85,7 @@ dev = [
     { name = "pytest-cov" },
     { name = "pytest-mock" },
     { name = "ruff" },
+    { name = "uv" },
 ]
 docs = [
     { name = "ipykernel" },
@@ -96,6 +108,7 @@ requires-dist = [
     { name = "ipykernel", specifier = ">=6.29.5" },
     { name = "ipython", specifier = ">=9.4.0" },
     { name = "ipywidgets", specifier = ">=8.1.7" },
+    { name = "json-repair", specifier = ">=0.25.2" },
     { name = "jupyter", specifier = ">=1.1.1" },
     { name = "jupyter-server", specifier = ">=2.18.0" },
     { name = "jupyterlab", specifier = ">=4.5.7" },
@@ -104,17 +117,26 @@ requires-dist = [
     { name = "matplotlib", specifier = ">=3.10.5" },
     { name = "mistune", specifier = ">=3.2.1" },
     { name = "mypy", specifier = ">=1.19.1" },
-    { name = "numpy", specifier = ">=1.26,<2.0" },
+    { name = "nbconvert", specifier = ">=7.17.1" },
+    { name = "notebook", specifier = ">=7.5.6" },
+    { name = "numpy", specifier = ">=2.0" },
     { name = "openai", specifier = ">=2.8.0" },
     { name = "opencv-python-headless", specifier = ">=4.8.0" },
     { name = "pandas", specifier = ">=2.3.2" },
-    { name = "pytest", specifier = ">=9.0.2" },
+    { name = "pillow", specifier = ">=12.2.0" },
+    { name = "pyjwt", specifier = ">=2.13.0" },
+    { name = "pymdown-extensions", specifier = ">=10.21.3" },
+    { name = "pytest", specifier = ">=9.0.3" },
     { name = "python-dotenv", specifier = ">=1.2.2" },
+    { name = "python-multipart", specifier = ">=0.0.27" },
     { name = "qwen-vl-utils", specifier = "==0.0.14" },
+    { name = "requests", specifier = ">=2.33.0" },
     { name = "scikit-learn", specifier = ">=1.5.2" },
     { name = "seaborn", specifier = ">=0.13.2" },
     { name = "transformers", specifier = ">=4.47.0" },
-    { name = "vllm", specifier = ">=0.14.0" },
+    { name = "urllib3", specifier = ">=2.7.0" },
+    { name = "vllm", specifier = ">=0.22.0" },
+    { name = "xgrammar", specifier = ">=0.1.32" },
 ]
 
 [package.metadata.requires-dev]
@@ -129,7 +151,7 @@ dev = [
     { name = "codecov", specifier = ">=2.1.13" },
     { name = "mypy", specifier = ">=1.14.1" },
     { name = "nbqa", specifier = ">=1.9.1" },
-    { name = "pip", specifier = ">=26.0" },
+    { name = "pip", specifier = ">=26.1.2" },
     { name = "pip-audit", specifier = ">=2.7.3" },
     { name = "pre-commit", specifier = ">=4.1.0" },
     { name = "pytest", specifier = ">=8.3.4" },
@@ -137,6 +159,7 @@ dev = [
     { name = "pytest-cov", specifier = ">=6.0.0" },
     { name = "pytest-mock", specifier = ">=3.14.0" },
     { name = "ruff", specifier = ">=0.13.3" },
+    { name = "uv", specifier = ">=0.11.15" },
 ]
 docs = [
     { name = "ipykernel", specifier = ">=6.29.5" },
@@ -338,25 +361,25 @@ wheels = [
 
 [[package]]
 name = "apache-tvm-ffi"
-version = "0.1.11"
+version = "0.1.9"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/6d/3d/4b9226cd45aa800a6904603dda9b323d728f3c3869952a673f3483b78b19/apache_tvm_ffi-0.1.11.tar.gz", hash = "sha256:153cd2c5a9717804cb0bcd9b2709f22a1e5f80ed05b5a490faf5949b136eedba", size = 2798354, upload-time = "2026-05-04T17:48:43.852Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/6f/60/1e787a0b5ebf318483235be2a689ee367173983067e441b8379564f667c0/apache_tvm_ffi-0.1.9.tar.gz", hash = "sha256:d2d402587e8906de0a07f4746aa78f3d452c7efe3625d4bb39ac2ad693bce530", size = 2513731, upload-time = "2026-02-27T19:28:06.602Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/05/9d/0f81ca556e5836b3ca64818cdae3f47dc7822bd35d22ddef7a54106d801d/apache_tvm_ffi-0.1.11-cp312-abi3-macosx_11_0_arm64.whl", hash = "sha256:6ae51cc7df415b5f373a9df4baa1165a65608e519bea81e7dd23428f00eeb689", size = 2418793, upload-time = "2026-05-04T17:47:57.879Z" },
-    { url = "https://files.pythonhosted.org/packages/2a/a9/f48e5dd4ae1f6f0c5ffac259c0a9531b7d6a7c0a4c45bc2229d55de6adf8/apache_tvm_ffi-0.1.11-cp312-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:da2c8d07fdc737d1ba75f4de25c29f156905b9dc980f1da90c395b4db525f522", size = 2605176, upload-time = "2026-05-04T17:47:59.676Z" },
-    { url = "https://files.pythonhosted.org/packages/36/99/2848df4e8ed5bf51df1d286d1718510584fa61e88adbc9c5b23d71b38f7c/apache_tvm_ffi-0.1.11-cp312-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:78aa1857b04a2ea718317041ab3f01288b3d496e6036eb1b99ebdc9da0fdaef5", size = 2725887, upload-time = "2026-05-04T17:48:01.381Z" },
-    { url = "https://files.pythonhosted.org/packages/7d/80/963c991934a4eb0fa0c0178f51963333fe14a96b732009da642b6bf6b42e/apache_tvm_ffi-0.1.11-cp312-abi3-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a8b845c8dff498fb981c1dda36c954549204191b485a385845e604966594d0b2", size = 2513121, upload-time = "2026-05-04T17:48:03.43Z" },
-    { url = "https://files.pythonhosted.org/packages/4d/18/95569107ee83619d61a3bb0d28743a0599f85c5161981e3e098c82c2b185/apache_tvm_ffi-0.1.11-cp312-abi3-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2843f084cdc94dedacd8b257a395a2b71b8a3dc7fc99711b148bf1d161983128", size = 2697683, upload-time = "2026-05-04T17:48:05.222Z" },
-    { url = "https://files.pythonhosted.org/packages/dc/99/f352cf1cce8f6f05584c4adf11de9eca07e6d217229bad6af35fb372926c/apache_tvm_ffi-0.1.11-cp312-abi3-win_amd64.whl", hash = "sha256:bd67e03759d25ff59f4e0ed9c8630a16872afc9dd8792f46ac3c927554015e60", size = 2365545, upload-time = "2026-05-04T17:48:07.295Z" },
-    { url = "https://files.pythonhosted.org/packages/27/ae/09242a668eb75ea06282d7cdc3947004cda69040885c340005a23b0aefe3/apache_tvm_ffi-0.1.11-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:f47435e41bf8a2018ef126fad41f18e0c8fe8be4d25fb3ed04b615278b7806d4", size = 2481373, upload-time = "2026-05-04T17:48:09.388Z" },
-    { url = "https://files.pythonhosted.org/packages/9d/d1/dc0c26cf68635a1184ba39cccb6cb3cf9675c7030f135f47205e56bdd2b6/apache_tvm_ffi-0.1.11-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:a05b36530d7cd5bb93b1a21a3b81ff060968c20456c4870b1a80d65966d5114f", size = 2639857, upload-time = "2026-05-04T17:48:11.1Z" },
-    { url = "https://files.pythonhosted.org/packages/fe/ad/4e3d4c5ec36e2ecadf6e5eb81cde065c69218cf722606b73af0ea6fdab75/apache_tvm_ffi-0.1.11-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:9b158f93bdfc497ead9fce5ffdd4d132708de60970ffc97d890dd62fa39d9fb4", size = 2755683, upload-time = "2026-05-04T17:48:13.016Z" },
-    { url = "https://files.pythonhosted.org/packages/51/37/54deceea6bac0e93844bd572a2fae8549e86e6309c732a0acaeb07a88c6b/apache_tvm_ffi-0.1.11-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0f77406e2773ad18109369417b5ccf6aee3c813867dbd5d2d97170bfa7b491f1", size = 2552014, upload-time = "2026-05-04T17:48:14.692Z" },
-    { url = "https://files.pythonhosted.org/packages/14/e8/52c9544be5850c7c0e5edce08f2dc9d05c3ecb10b7ae9b3a9313d1b2857e/apache_tvm_ffi-0.1.11-cp314-cp314t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:78f0c9dc69727665de58faebacf6a3f4a1d75a355591e963e1bc691fc9bf5cd5", size = 2730358, upload-time = "2026-05-04T17:48:16.39Z" },
-    { url = "https://files.pythonhosted.org/packages/93/b2/afe8a6b8553f51255afdd8063c5d6fd3f4e1978aad424de706440c59fdba/apache_tvm_ffi-0.1.11-cp314-cp314t-win_amd64.whl", hash = "sha256:2f5d417da48dbabbe08933a4d0964b3d2f43d1a4a2c3a6c0092de670c71a8a87", size = 2476516, upload-time = "2026-05-04T17:48:18.022Z" },
+    { url = "https://files.pythonhosted.org/packages/df/f2/b8c4b151169f6d7ba8773c8af68b2e0c1013d7fb3f1bdf87573f47157ce9/apache_tvm_ffi-0.1.9-cp312-abi3-macosx_11_0_arm64.whl", hash = "sha256:49e52350b0470654847de752e65603b604a4d3323e7e9f5e8a982f44acc4c143", size = 2041756, upload-time = "2026-02-27T19:27:23.931Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/c0/6d3d54f50012255b41bc3e24944c086f63c4707c8686c7c6780e9283eb96/apache_tvm_ffi-0.1.9-cp312-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:7d503029e66c43b1a1cb1a42a1e9bb428c8a28dcbdec31c28e705472ca648a3a", size = 2203712, upload-time = "2026-02-27T19:27:25.867Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/dd/2bab4c6cd86257dbf99e93452a1af833113f8dc3e25a25579f6e4e4c8a94/apache_tvm_ffi-0.1.9-cp312-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:28241371934ea8af10d5067087ba1229ebddded7b2c02d33a258ec2a96df8c46", size = 2299704, upload-time = "2026-02-27T19:27:27.477Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/4a/b469bcb2e1014cb84d336d2a59f42958a058251c577a4c2680cacad346e2/apache_tvm_ffi-0.1.9-cp312-abi3-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:87cacce81df55685fc6a76e1e3c5db1200e85e87bf5974b692c59d131b7bc622", size = 2130865, upload-time = "2026-02-27T19:27:29.092Z" },
+    { url = "https://files.pythonhosted.org/packages/70/ef/5402da5d37f5270fd88ea0348acca78dba9be8bdbf6c2bcae0935eb03ef1/apache_tvm_ffi-0.1.9-cp312-abi3-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f45eb43499acac45ff6c93564f0ff2d3ca27b69656d540fd56ce59d51c0b4c65", size = 2278991, upload-time = "2026-02-27T19:27:30.729Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/23/1b7dc5f0807f83098183a57db6ee85b2c93b646d74a6e03781c9208aaeb0/apache_tvm_ffi-0.1.9-cp312-abi3-win_amd64.whl", hash = "sha256:d1dcf4c041d5ec05e3da1d545800c33cdbb95c113baa7705085ff79fa262752b", size = 1973200, upload-time = "2026-02-27T19:27:32.367Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/1e/991ae65e64ce132c1ba665562db6638f5696d6133f580e20c653de33b9af/apache_tvm_ffi-0.1.9-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c3349f72ddb8ce206472d0380a729f213017a2180707096f8d57114b81097dd1", size = 2072944, upload-time = "2026-02-27T19:27:34.261Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/a7/1e0643949e683fb3cfababd87058c0cfef122d1a3bb6ce703f719051b842/apache_tvm_ffi-0.1.9-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d1f4d2b7ec7b1213632e9a104e9330bfc3dec48decffa62114c33aa188c9f43a", size = 2215954, upload-time = "2026-02-27T19:27:35.872Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/06/5016191ab61d2db4c3a7d754a3c1184e0836f575a7d08491669738c5e4b9/apache_tvm_ffi-0.1.9-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:e4f01d16ba53fe118e363f7257253f07003797e4abe6fc9567f23b6a930dbff2", size = 2307291, upload-time = "2026-02-27T19:27:37.527Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/f5/40bf0667330938efbfc0a51743cc53c79e41b4ece1a8abad3076192c9674/apache_tvm_ffi-0.1.9-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3c0581dd6bfbce7b017ef85cfda08bbe38891cc4b3afbcfaa8bc2d383728e426", size = 2143850, upload-time = "2026-02-27T19:27:40.437Z" },
+    { url = "https://files.pythonhosted.org/packages/72/4a/421cbd4ed32e8bad3b88af3e8fa145c1f6f493bdd05be15b6f2d9b3cb7d6/apache_tvm_ffi-0.1.9-cp314-cp314t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7dfa14be2a49347791ef21222a8225ce7f99bfec17104a676cb4f1bf3a107088", size = 2289038, upload-time = "2026-02-27T19:27:41.972Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/1a/c8923d819b49872a612033b90d29299c0be73a7cbed1ddb3dc78dfe5e9f1/apache_tvm_ffi-0.1.9-cp314-cp314t-win_amd64.whl", hash = "sha256:a42d7ca27dce83efbdce7ec970fe3e773a69c31d928730ee5d9badb1229d106c", size = 2039007, upload-time = "2026-02-27T19:27:43.618Z" },
 ]
 
 [[package]]
@@ -945,7 +968,8 @@ dependencies = [
     { name = "jsonschema" },
     { name = "kubernetes" },
     { name = "mmh3" },
-    { name = "numpy" },
+    { name = "numpy", version = "2.3.5", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.13'" },
+    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.13'" },
     { name = "onnxruntime" },
     { name = "opentelemetry-api" },
     { name = "opentelemetry-exporter-otlp-proto-grpc" },
@@ -1028,7 +1052,7 @@ wheels = [
 
 [[package]]
 name = "compressed-tensors"
-version = "0.13.0"
+version = "0.15.0.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "loguru" },
@@ -1036,9 +1060,9 @@ dependencies = [
     { name = "torch" },
     { name = "transformers" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/fc/65/88dd1c58fb9d0ded51b5c86471b937a1525f91fad2211a6f051dc1ea822d/compressed_tensors-0.13.0.tar.gz", hash = "sha256:23893824d3498ea3f1a829f14a8fa85f9a5e76a34c711a038b8d7c619ca9a67c", size = 200995, upload-time = "2025-12-16T16:03:55.397Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/41/1b/c3c4a98ec5f2727656336f07a0c35862195c310d8eb0b2fa5b4be6848680/compressed_tensors-0.15.0.1.tar.gz", hash = "sha256:a8e93054e8a5ec49c980b09ed36c4c1249b4a8ee167920a8e461c4da26e78d99", size = 229412, upload-time = "2026-04-10T14:23:54.708Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/0b/b5/61ac2563c62490922b603c09113a083fd74af3630ec3931e769484d6dcb5/compressed_tensors-0.13.0-py3-none-any.whl", hash = "sha256:3518799c9baf034eb642efb551db6b0537b8713d45a64fe4def26f7f8d6cabec", size = 192620, upload-time = "2025-12-16T16:03:53.041Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/52/93833dc1610e017ac5b7dcd59b8304d8ef67d1114c2d124e728a2cbbea12/compressed_tensors-0.15.0.1-py3-none-any.whl", hash = "sha256:e1b1f322e82e475715e242bad46925a304ea8e5c98b5055a15b8eb22fb6bfea9", size = 194260, upload-time = "2026-04-10T14:23:53.098Z" },
 ]
 
 [[package]]
@@ -1046,7 +1070,8 @@ name = "contourpy"
 version = "1.3.3"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "numpy" },
+    { name = "numpy", version = "2.3.5", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.13'" },
+    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.13'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/58/01/1253e6698a07380cd31a736d248a3f2a50a7c88779a1813da27503cadc2a/contourpy-1.3.3.tar.gz", hash = "sha256:083e12155b210502d0bca491432bb04d56dc3432f95a979b429f2848c3dbe880", size = 13466174, upload-time = "2025-07-26T12:03:12.549Z" }
 wheels = [
@@ -1312,20 +1337,68 @@ wheels = [
 ]
 
 [[package]]
-name = "cupy-cuda12x"
-version = "13.6.0"
+name = "cuda-tile"
+version = "1.4.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "fastrlock", marker = "sys_platform != 'darwin'" },
-    { name = "numpy", marker = "sys_platform != 'darwin'" },
+    { name = "typing-extensions" },
 ]
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/12/c5/7e7fc4816d0de0154e5d9053242c3a08a0ca8b43ee656a6f7b3b95055a7b/cupy_cuda12x-13.6.0-cp312-cp312-manylinux2014_aarch64.whl", hash = "sha256:a6970ceefe40f9acbede41d7fe17416bd277b1bd2093adcde457b23b578c5a59", size = 127334633, upload-time = "2025-08-18T08:24:43.065Z" },
-    { url = "https://files.pythonhosted.org/packages/e0/95/d7e1295141e7d530674a3cc567e13ed0eb6b81524cb122d797ed996b5bea/cupy_cuda12x-13.6.0-cp312-cp312-manylinux2014_x86_64.whl", hash = "sha256:79b0cacb5e8b190ef409f9e03f06ac8de1b021b0c0dda47674d446f5557e0eb1", size = 112886268, upload-time = "2025-08-18T08:24:49.294Z" },
-    { url = "https://files.pythonhosted.org/packages/ae/8c/14555b63fd78cfac7b88af0094cea0a3cb845d243661ec7da69f7b3ea0de/cupy_cuda12x-13.6.0-cp312-cp312-win_amd64.whl", hash = "sha256:ca06fede7b8b83ca9ad80062544ef2e5bb8d4762d1c4fc3ac8349376de9c8a5e", size = 89785108, upload-time = "2025-08-18T08:24:54.527Z" },
-    { url = "https://files.pythonhosted.org/packages/19/ec/f62cb991f11fb41291c4c15b6936d7b67ffa71ddb344ad6e8894e06ce58d/cupy_cuda12x-13.6.0-cp313-cp313-manylinux2014_aarch64.whl", hash = "sha256:e5426ae3b1b9cf59927481e457a89e3f0b50a35b114a8034ec9110e7a833434c", size = 126904601, upload-time = "2025-08-18T08:24:59.951Z" },
-    { url = "https://files.pythonhosted.org/packages/f8/b8/30127bcdac53a25f94ee201bf4802fcd8d012145567d77c54174d6d01c01/cupy_cuda12x-13.6.0-cp313-cp313-manylinux2014_x86_64.whl", hash = "sha256:52d9e7f83d920da7d81ec2e791c2c2c747fdaa1d7b811971b34865ce6371e98a", size = 112654824, upload-time = "2025-08-18T08:25:05.944Z" },
-    { url = "https://files.pythonhosted.org/packages/72/36/c9e24acb19f039f814faea880b3704a3661edaa6739456b73b27540663e3/cupy_cuda12x-13.6.0-cp313-cp313-win_amd64.whl", hash = "sha256:297b4268f839de67ef7865c2202d3f5a0fb8d20bd43360bc51b6e60cb4406447", size = 89750580, upload-time = "2025-08-18T08:25:10.972Z" },
+    { url = "https://files.pythonhosted.org/packages/42/93/64ef40d3982dcda7a97ebfa3e3bb9045b573d4eb3877fa5d1fa3cd2541d3/cuda_tile-1.4.0-cp312-cp312-manylinux2014_aarch64.whl", hash = "sha256:9e358a85a153820aa0a51d0e09346d884a3c14b88c0313d20d0fb9f53952abae", size = 280953, upload-time = "2026-05-27T17:46:53.03Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/9a/7fbdbdb30c375f80818941165adfc4f1dc6cebaf937c6a9081a02d5871f0/cuda_tile-1.4.0-cp312-cp312-manylinux2014_x86_64.whl", hash = "sha256:1d9d99b6fa57366af3f8707ac4fd91411275af2ee736996a60620240fcf92070", size = 282503, upload-time = "2026-05-27T17:45:05.543Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/bb/4152dc08a8de5bcdc4b9d80b6917216289526f6e786b09ee80d4df27bcfb/cuda_tile-1.4.0-cp312-cp312-win_amd64.whl", hash = "sha256:616f13cbc7af6caa7b92430b85ba0a429d1f96ca9e7e04a29d89114cfe859663", size = 269813, upload-time = "2026-05-27T17:46:20.583Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/ad/42f0655e6aee5c59015634b46d7f13bc22e74af28d10fb2008a062b37349/cuda_tile-1.4.0-cp313-cp313-manylinux2014_aarch64.whl", hash = "sha256:fc74185efd81f6153af0a19549d111dec6861ee9b9bc27927a2cef6e19173eb5", size = 280958, upload-time = "2026-05-27T17:46:53.061Z" },
+    { url = "https://files.pythonhosted.org/packages/11/0b/4770f9e36b8108ce8c9078f71eb21c65e594d79c0770dd38daa045cfbd6c/cuda_tile-1.4.0-cp313-cp313-manylinux2014_x86_64.whl", hash = "sha256:45be74f6568c440446f510bc7799b953858e64c6abf26e96f2c9598a79084860", size = 282508, upload-time = "2026-05-27T17:45:18.515Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/67/41f1acdf21bf6214a3a1c3b46d39b8eb0f9eba7aecc6b57005db35d56f9a/cuda_tile-1.4.0-cp313-cp313-win_amd64.whl", hash = "sha256:edd1df4d7955032c7be2a26c6d7e47261415ba7c87587705e0f4f1fd0d61650a", size = 269783, upload-time = "2026-05-27T17:47:16.631Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/c6/46a329f4c56ce54471784366394e235804423df2531307e14112e4636c76/cuda_tile-1.4.0-cp314-cp314-manylinux2014_aarch64.whl", hash = "sha256:738593650784ebb3c601486914b563e7569144fe596048766ea9e12280ac3bb9", size = 281208, upload-time = "2026-05-27T17:46:48.325Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/fb/bf3849ad68b1858ba50e6992863d266892d7d7db02d11c485c26cd090a1b/cuda_tile-1.4.0-cp314-cp314-manylinux2014_x86_64.whl", hash = "sha256:4b1a591c26836a550c2bf87c22d31c4716e5f83d24d255f843d9429625cca973", size = 282630, upload-time = "2026-05-27T17:45:10.789Z" },
+    { url = "https://files.pythonhosted.org/packages/61/bb/211c0d5121230ee76cfc1a9ee107ec28aaae9e6ffb43a04aa172d0d4f4dc/cuda_tile-1.4.0-cp314-cp314-win_amd64.whl", hash = "sha256:c19e10fe70ba92709b6ca446d1c52a8a346b56f4f8ad7c8941736f60e32f3c87", size = 270644, upload-time = "2026-05-27T17:45:01.914Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/df/f7f1dfa4d1ee7cc5b69e11d756be6ffec1561a5c7e3836fd0f71ca49adcf/cuda_tile-1.4.0-cp314-cp314t-manylinux2014_aarch64.whl", hash = "sha256:b3cbeffbe0fedac4936edcf00b6ba13ab5ddb74d3b7ce4a287dfc04491b5f6af", size = 283249, upload-time = "2026-05-27T17:46:12.032Z" },
+    { url = "https://files.pythonhosted.org/packages/18/c0/fee527a085fca414fc993769912eb8ba2e15ce388f3168b868706e6d4c61/cuda_tile-1.4.0-cp314-cp314t-manylinux2014_x86_64.whl", hash = "sha256:675b2afff62af5d4e72c34bc72d0be27b0933a44933b8a449f590fbded8c1107", size = 284336, upload-time = "2026-05-27T17:44:59.489Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/ab/0883194457932150a5ad334d609ac17bd704345974d21c8bae6ea251e7ed/cuda_tile-1.4.0-cp314-cp314t-win_amd64.whl", hash = "sha256:3f58eac5577ea3ed7c17bfcab015a506fd2cf61f8848407c5b403f1bf46c55ca", size = 275861, upload-time = "2026-05-27T17:46:36.285Z" },
+]
+
+[[package]]
+name = "cuda-toolkit"
+version = "13.0.2"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/57/b2/453099f5f3b698d7d0eab38916aac44c7f76229f451709e2eb9db6615dcd/cuda_toolkit-13.0.2-py2.py3-none-any.whl", hash = "sha256:b198824cf2f54003f50d64ada3a0f184b42ca0846c1c94192fa269ecd97a66eb", size = 2364, upload-time = "2025-12-19T23:24:07.328Z" },
+]
+
+[package.optional-dependencies]
+cublas = [
+    { name = "nvidia-cublas", marker = "sys_platform == 'linux'" },
+]
+cudart = [
+    { name = "nvidia-cuda-runtime", version = "13.0.96", source = { registry = "https://pypi.org/simple" }, marker = "sys_platform == 'linux'" },
+]
+cufft = [
+    { name = "nvidia-cufft", marker = "sys_platform == 'linux'" },
+]
+cufile = [
+    { name = "nvidia-cufile", marker = "sys_platform == 'linux'" },
+]
+cupti = [
+    { name = "nvidia-cuda-cupti", marker = "sys_platform == 'linux'" },
+]
+curand = [
+    { name = "nvidia-curand", marker = "sys_platform == 'linux'" },
+]
+cusolver = [
+    { name = "nvidia-cusolver", marker = "sys_platform == 'linux'" },
+]
+cusparse = [
+    { name = "nvidia-cusparse", marker = "sys_platform == 'linux'" },
+]
+nvjitlink = [
+    { name = "nvidia-nvjitlink", marker = "sys_platform == 'linux'" },
+]
+nvrtc = [
+    { name = "nvidia-cuda-nvrtc", version = "13.0.88", source = { registry = "https://pypi.org/simple" }, marker = "sys_platform == 'linux'" },
+]
+nvtx = [
+    { name = "nvidia-nvtx", marker = "sys_platform == 'linux'" },
 ]
 
 [[package]]
@@ -1364,7 +1437,8 @@ dependencies = [
     { name = "httpx" },
     { name = "huggingface-hub" },
     { name = "multiprocess" },
-    { name = "numpy" },
+    { name = "numpy", version = "2.3.5", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.13'" },
+    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.13'" },
     { name = "packaging" },
     { name = "pandas" },
     { name = "pyarrow" },
@@ -1683,21 +1757,23 @@ wheels = [
 ]
 
 [[package]]
-name = "fastrlock"
-version = "0.8.3"
+name = "fastsafetensors"
+version = "0.3.2"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/73/b1/1c3d635d955f2b4bf34d45abf8f35492e04dbd7804e94ce65d9f928ef3ec/fastrlock-0.8.3.tar.gz", hash = "sha256:4af6734d92eaa3ab4373e6c9a1dd0d5ad1304e172b1521733c6c3b3d73c8fa5d", size = 79327, upload-time = "2024-12-17T11:03:39.638Z" }
+dependencies = [
+    { name = "typer" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c8/33/c97b2bcbe06e0f011eedee0f41d4060f6344901a53c2703acc3dd7429713/fastsafetensors-0.3.2.tar.gz", hash = "sha256:9e358fce238684613a5c3ebb7800c52c5b3270c0bb5e4ed2191ee8f3d0431de1", size = 70409, upload-time = "2026-05-22T05:39:34.787Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/57/21/ea1511b0ef0d5457efca3bf1823effb9c5cad4fc9dca86ce08e4d65330ce/fastrlock-0.8.3-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:85a49a1f1e020097d087e1963e42cea6f307897d5ebe2cb6daf4af47ffdd3eed", size = 52201, upload-time = "2024-12-17T11:02:19.512Z" },
-    { url = "https://files.pythonhosted.org/packages/80/07/cdecb7aa976f34328372f1c4efd6c9dc1b039b3cc8d3f38787d640009a25/fastrlock-0.8.3-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5f13ec08f1adb1aa916c384b05ecb7dbebb8df9ea81abd045f60941c6283a670", size = 53924, upload-time = "2024-12-17T11:02:20.85Z" },
-    { url = "https://files.pythonhosted.org/packages/88/6d/59c497f8db9a125066dd3a7442fab6aecbe90d6fec344c54645eaf311666/fastrlock-0.8.3-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:0ea4e53a04980d646def0f5e4b5e8bd8c7884288464acab0b37ca0c65c482bfe", size = 52140, upload-time = "2024-12-17T11:02:22.263Z" },
-    { url = "https://files.pythonhosted.org/packages/62/04/9138943c2ee803d62a48a3c17b69de2f6fa27677a6896c300369e839a550/fastrlock-0.8.3-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:38340f6635bd4ee2a4fb02a3a725759fe921f2ca846cb9ca44531ba739cc17b4", size = 53261, upload-time = "2024-12-17T11:02:24.418Z" },
-    { url = "https://files.pythonhosted.org/packages/e2/4b/db35a52589764c7745a613b6943bbd018f128d42177ab92ee7dde88444f6/fastrlock-0.8.3-cp312-cp312-win_amd64.whl", hash = "sha256:da06d43e1625e2ffddd303edcd6d2cd068e1c486f5fd0102b3f079c44eb13e2c", size = 31235, upload-time = "2024-12-17T11:02:25.708Z" },
-    { url = "https://files.pythonhosted.org/packages/06/77/f06a907f9a07d26d0cca24a4385944cfe70d549a2c9f1c3e3217332f4f12/fastrlock-0.8.3-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4a98ba46b3e14927550c4baa36b752d0d2f7387b8534864a8767f83cce75c160", size = 50954, upload-time = "2024-12-17T11:02:32.12Z" },
-    { url = "https://files.pythonhosted.org/packages/f9/4e/94480fb3fd93991dd6f4e658b77698edc343f57caa2870d77b38c89c2e3b/fastrlock-0.8.3-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:dbdea6deeccea1917c6017d353987231c4e46c93d5338ca3e66d6cd88fbce259", size = 52535, upload-time = "2024-12-17T11:02:33.402Z" },
-    { url = "https://files.pythonhosted.org/packages/7d/a7/ee82bb55b6c0ca30286dac1e19ee9417a17d2d1de3b13bb0f20cefb86086/fastrlock-0.8.3-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:c6e5bfecbc0d72ff07e43fed81671747914d6794e0926700677ed26d894d4f4f", size = 50942, upload-time = "2024-12-17T11:02:34.688Z" },
-    { url = "https://files.pythonhosted.org/packages/63/1d/d4b7782ef59e57dd9dde69468cc245adafc3674281905e42fa98aac30a79/fastrlock-0.8.3-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:2a83d558470c520ed21462d304e77a12639859b205759221c8144dd2896b958a", size = 52044, upload-time = "2024-12-17T11:02:36.613Z" },
-    { url = "https://files.pythonhosted.org/packages/28/a3/2ad0a0a69662fd4cf556ab8074f0de978ee9b56bff6ddb4e656df4aa9e8e/fastrlock-0.8.3-cp313-cp313-win_amd64.whl", hash = "sha256:8d1d6a28291b4ace2a66bd7b49a9ed9c762467617febdd9ab356b867ed901af8", size = 30472, upload-time = "2024-12-17T11:02:37.983Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/bb/9f821eac9bddd41ea1c5cd9b6a597c002741f022ecf6f3ba5cfcc3e9c950/fastsafetensors-0.3.2-cp312-cp312-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:69f4d8cbd3b542e5ddf7fee8136cf35e1524f9c30e118f64a0e846dab7e8de6b", size = 1877989, upload-time = "2026-06-04T09:02:56.11Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/68/a31c1661adf4d1b5ec29470ff991bde9094e4f347b0e6d1af8ba6b560d32/fastsafetensors-0.3.2-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6a932d7166c9e17e48aca3e5503d326bc6fc73fce6dc985ae6bd2ccc0f308b14", size = 1907188, upload-time = "2026-05-22T05:39:30.242Z" },
+    { url = "https://files.pythonhosted.org/packages/45/d3/8c05a01aa9518c5118d133a6554334f642ef08f050d0b94f7daac539d265/fastsafetensors-0.3.2-cp312-cp312-win_amd64.whl", hash = "sha256:b02dd7a2332013c24cce1fb9cd037326c6b52dd25e84fa07d02d61c6301b54e8", size = 201967, upload-time = "2026-06-04T09:02:57.412Z" },
+    { url = "https://files.pythonhosted.org/packages/37/39/9e5ba486b82f547bec40543e10077e44b3eca4d92da381bcb0780b1169fd/fastsafetensors-0.3.2-cp313-cp313-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:93cd3fd6f3c66334edbfc64f3e2457f4b622c38c16074616a0dc2d972b0a65b7", size = 1877661, upload-time = "2026-06-04T09:02:58.577Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/43/57fd9ee68a39f1a5fba0dd9be6b62f14460bab532840eb8198202fd73d30/fastsafetensors-0.3.2-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:41297f01d3e2585e86fbc56df499f140b233ec8d6cb17c3f95b5e81a8b98a53e", size = 1906826, upload-time = "2026-05-22T05:39:31.805Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/9e/666806437c65acec5471d73af36a8cf5875db762dd9e4197531c6ad8e7c4/fastsafetensors-0.3.2-cp313-cp313-win_amd64.whl", hash = "sha256:19459e96f4e732ae8470a44362bd30d00da20a76c61cd75e894855d4d0739205", size = 202019, upload-time = "2026-06-04T09:02:59.921Z" },
+    { url = "https://files.pythonhosted.org/packages/89/5f/536d5000e3468fc0b00e0b96c388fd8071477c32fb4325d1ae4f71e5ec52/fastsafetensors-0.3.2-cp314-cp314-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:826079a657a222a6c9c9fe749a303509386f88719569d53358ac53a8823bfbcd", size = 1875966, upload-time = "2026-06-04T09:03:01.041Z" },
+    { url = "https://files.pythonhosted.org/packages/09/6f/cafbb1e1089593c919f8a73575e1b332c111aa990e8f07844fee4246dd07/fastsafetensors-0.3.2-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a50da42cf2d85cc8a50f945126decb4ce18aa4151506dd416482dd50a613fa97", size = 1904609, upload-time = "2026-05-22T05:39:33.322Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/d0/a60adcec19b13446f7711755c251f3fd0cadb21d3943d8b714b84c0605bb/fastsafetensors-0.3.2-cp314-cp314-win_amd64.whl", hash = "sha256:100c3c631bcac88062512ba7b650a192a5b51fca218accac1b523db68d27a402", size = 204931, upload-time = "2026-06-04T09:03:02.379Z" },
 ]
 
 [[package]]
@@ -1750,16 +1826,26 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/a4/a5/842ae8f0c08b61d6484b52f99a03510a3a72d23141942d216ebe81fefbce/filelock-3.25.2-py3-none-any.whl", hash = "sha256:ca8afb0da15f229774c9ad1b455ed96e85a81373065fb10446672f64444ddf70", size = 26759, upload-time = "2026-03-11T20:45:37.437Z" },
 ]
 
+[[package]]
+name = "flashinfer-cubin"
+version = "0.6.11.post2"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/29/96/da75a9f61c64c87b16baa339fc8216a6c3743c5d263c555fded30fcbe6f7/flashinfer_cubin-0.6.11.post2-py3-none-any.whl", hash = "sha256:eb01c2801ee31d145bbf7afb2c223150333e602c8208216017b0190b1087b990", size = 360908523, upload-time = "2026-05-14T04:57:41.355Z" },
+]
+
 [[package]]
 name = "flashinfer-python"
-version = "0.5.3"
+version = "0.6.11.post2"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "apache-tvm-ffi" },
     { name = "click" },
+    { name = "cuda-tile" },
     { name = "einops" },
     { name = "ninja" },
-    { name = "numpy" },
+    { name = "numpy", version = "2.3.5", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.13'" },
+    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.13'" },
     { name = "nvidia-cudnn-frontend" },
     { name = "nvidia-cutlass-dsl" },
     { name = "nvidia-ml-py" },
@@ -1769,9 +1855,9 @@ dependencies = [
     { name = "torch" },
     { name = "tqdm" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/b4/91/cca69baeff24bb3efd12c7479a026432c8717ee47193694010494c528b22/flashinfer_python-0.5.3.tar.gz", hash = "sha256:100d59b0ede47878d2808cd3a1b9039d7a952d66338bc9f68dac192ae1b2e3f1", size = 4682367, upload-time = "2025-11-20T21:22:46.976Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/db/53/dbf2157f2bbb96d6f7a6891cf6abfb2e6e18963760a0c53e96c2de5c59db/flashinfer_python-0.6.11.post2.tar.gz", hash = "sha256:e9fdac56aea9f0f58a4e69b0645c54993760d3cc6c7bf5c2df4ce5a0aecc7953", size = 9248515, upload-time = "2026-05-14T04:57:32.83Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/76/78/6dc7e7da8cb87c9965644ea0d2439457a1bc9256c45ceda0044595be4143/flashinfer_python-0.5.3-py3-none-any.whl", hash = "sha256:b601293b72f9138bad173edc28df84b9f239a013be974e2e79d4ba98aeb38cf5", size = 6998069, upload-time = "2025-11-20T21:22:45.104Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/bc/518b092473f37d904ae07766ad37c772b93da13ea788777b22a80c3f1a7c/flashinfer_python-0.6.11.post2-py3-none-any.whl", hash = "sha256:550cbdb760f9f7ec0e42055e06636b9489d05f1a38989cafd77e6eb820de0138", size = 13746417, upload-time = "2026-05-14T04:57:30.25Z" },
 ]
 
 [[package]]
@@ -1940,7 +2026,8 @@ name = "gguf"
 version = "0.19.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "numpy" },
+    { name = "numpy", version = "2.3.5", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.13'" },
+    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.13'" },
     { name = "pyyaml" },
     { name = "requests" },
     { name = "tqdm" },
@@ -2087,19 +2174,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/48/b2/b096ccce418882fbfda4f7496f9357aaa9a5af1896a9a7f60d9f2b275a06/grpcio-1.78.0-cp314-cp314-win_amd64.whl", hash = "sha256:dce09d6116df20a96acfdbf85e4866258c3758180e8c49845d6ba8248b6d0bbb", size = 4929852, upload-time = "2026-02-06T09:56:45.885Z" },
 ]
 
-[[package]]
-name = "grpcio-reflection"
-version = "1.78.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "grpcio" },
-    { name = "protobuf" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/31/06/337546aae558675f79cae2a8c1ce0c9b1952cbc5c28b01878f68d040f5bb/grpcio_reflection-1.78.0.tar.gz", hash = "sha256:e6e60c0b85dbcdf963b4d4d150c0f1d238ba891d805b575c52c0365d07fc0c40", size = 19098, upload-time = "2026-02-06T10:01:52.225Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/df/6d/4d095d27ccd049865ecdafc467754e9e47ad0f677a30dda969c3590f6582/grpcio_reflection-1.78.0-py3-none-any.whl", hash = "sha256:06fcfde9e6888cdd12e9dd1cf6dc7c440c2e9acf420f696ccbe008672ed05b60", size = 22800, upload-time = "2026-02-06T10:01:33.822Z" },
-]
-
 [[package]]
 name = "h11"
 version = "0.16.0"
@@ -2226,6 +2300,39 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/a8/af/48ac8483240de756d2438c380746e7130d1c6f75802ef22f3c6d49982787/huggingface_hub-0.36.2-py3-none-any.whl", hash = "sha256:48f0c8eac16145dfce371e9d2d7772854a4f591bcb56c9cf548accf531d54270", size = 566395, upload-time = "2026-02-06T09:24:11.133Z" },
 ]
 
+[[package]]
+name = "humming-kernels"
+version = "0.1.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "cuda-bindings" },
+    { name = "jinja2" },
+    { name = "numpy", version = "2.3.5", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.13'" },
+    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.13'" },
+    { name = "nvidia-ml-py" },
+    { name = "pyelftools" },
+    { name = "safetensors" },
+    { name = "tabulate" },
+    { name = "torch" },
+    { name = "tqdm" },
+    { name = "triton", version = "3.5.1", source = { registry = "https://pypi.org/simple" }, marker = "sys_platform == 'darwin' or sys_platform == 'emscripten' or sys_platform == 'win32'" },
+    { name = "triton", version = "3.6.0", source = { registry = "https://pypi.org/simple" }, marker = "sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/06/f4/e141f45697b7d0d38bfaf8766a7362d8f0136e3cff2620624f24f68e2700/humming_kernels-0.1.2.tar.gz", hash = "sha256:7894c80061c7866591bef12617da720ac4e925636ffc99464af433a5dcb035eb", size = 117251, upload-time = "2026-05-23T16:18:08.084Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/6d/41/288bf756d921dbe98982eeb3ec4c20e7cb5224ea6dcb164f2df3d2f68a7f/humming_kernels-0.1.2-py3-none-any.whl", hash = "sha256:f7434b0424946445ef5ad5682bcabf309d97721818ed5bdc4c6f61de3c6b9d2f", size = 160951, upload-time = "2026-05-23T16:18:06.405Z" },
+]
+
+[package.optional-dependencies]
+cu13 = [
+    { name = "nvidia-cuda-cccl" },
+    { name = "nvidia-cuda-nvcc" },
+    { name = "nvidia-cuda-nvrtc", version = "13.0.88", source = { registry = "https://pypi.org/simple" }, marker = "sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32'" },
+    { name = "nvidia-cuda-nvrtc", version = "13.3.33", source = { registry = "https://pypi.org/simple" }, marker = "sys_platform == 'darwin' or sys_platform == 'emscripten' or sys_platform == 'win32'" },
+    { name = "nvidia-cuda-runtime", version = "13.0.96", source = { registry = "https://pypi.org/simple" }, marker = "sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32'" },
+    { name = "nvidia-cuda-runtime", version = "13.3.29", source = { registry = "https://pypi.org/simple" }, marker = "sys_platform == 'darwin' or sys_platform == 'emscripten' or sys_platform == 'win32'" },
+]
+
 [[package]]
 name = "identify"
 version = "2.6.15"
@@ -3062,33 +3169,44 @@ wheels = [
 
 [[package]]
 name = "llguidance"
-version = "1.3.0"
+version = "1.7.6"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/95/48/3f7a9d3ff1b36bba92b5107a3a21286821227afe9ea464736133994d61fb/llguidance-1.3.0.tar.gz", hash = "sha256:861249afd51dc325646834462ea827e57a5c2b2042e108e6aae7059fdad9104d", size = 1070460, upload-time = "2025-10-20T19:58:44.164Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/da/91/6bc8bb503dc259e46d253b5424385a54fe06c38a4c7a12befe69a3c2455a/llguidance-1.7.6.tar.gz", hash = "sha256:db7febbe412ed2015501904646750071d7e00e6df7f85c4b956ad4f206fd2df7", size = 1156574, upload-time = "2026-06-03T20:13:25.316Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/3b/33/be5acb85cd8cdc4afde33d9c234eece9f318e087920255af3c05864cd3e7/llguidance-1.3.0-cp39-abi3-macosx_10_12_x86_64.whl", hash = "sha256:f7685222660a762e481ac633d49cc559c64980fe2ee59c8f932a5bb5cbc0c2c2", size = 3220647, upload-time = "2025-10-20T19:58:42.542Z" },
-    { url = "https://files.pythonhosted.org/packages/82/e6/b48bda5b15efeaeb62bd0dba8fc6a01d4ae5457a85dbb5d18632385fe15c/llguidance-1.3.0-cp39-abi3-macosx_11_0_arm64.whl", hash = "sha256:098030ff0687261a3f1bd54cf21fe951fc861d56d37a0671250dd36677eaf224", size = 3099830, upload-time = "2025-10-20T19:58:40.826Z" },
-    { url = "https://files.pythonhosted.org/packages/aa/11/44389d3d1526d7a5c38ffd587a5ebc61d7bee443ac1dea95f2089ad58f5f/llguidance-1.3.0-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6f6caca5d78db7f76e1fbb0fff8607b861c32d47fa3d5dee2fc49de27ee269df", size = 2835242, upload-time = "2025-10-20T19:58:34.518Z" },
-    { url = "https://files.pythonhosted.org/packages/83/a8/1ff2bedb8f9acb46a2d2d603415d272bb622c142ea86f5b95445cc6e366c/llguidance-1.3.0-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bc17e9dd602c3879bf91664a64bf72f54c74dbfbeb24ccfab6a5fe435b12f7aa", size = 3033133, upload-time = "2025-10-20T19:58:38.721Z" },
-    { url = "https://files.pythonhosted.org/packages/5a/7e/809349638231f469b9056c0e1bfd924d5ef5558b3b3ec72d093b6fad33b1/llguidance-1.3.0-cp39-abi3-win_amd64.whl", hash = "sha256:1d1cd1c8618d1a13605d3e057c978651e551c8c469b481ee4041f1d6c436002d", size = 2789946, upload-time = "2025-10-20T19:58:45.958Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/70/fec801b305437f946aefc52b126534766415810771172f3f615d0fd7ef8b/llguidance-1.7.6-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:c88787845b94d301d91c4e9ad27eac9d05c334a1ba2c7ff29cca66f26d5b5c3c", size = 3218286, upload-time = "2026-06-03T20:12:55.042Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/22/f45b19379e162511a60b655037b1c3a3fadcb0c05aee082055a7be36fc15/llguidance-1.7.6-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:7def42f7866239b3b940982ed1dcae6b142c212fbd68b57107c1560d778f94f8", size = 3131216, upload-time = "2026-06-03T20:12:57.733Z" },
+    { url = "https://files.pythonhosted.org/packages/67/da/28756068fa9f7147874fcd712e7317c24785f25d762a96e901850d9a2f5f/llguidance-1.7.6-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0444020249cde1292f13acf786e35c245fd3572d466877d2734824a9026e55aa", size = 3470362, upload-time = "2026-06-03T20:12:59.813Z" },
+    { url = "https://files.pythonhosted.org/packages/11/90/37cc12dd44c1f8fd84d5cc4e293467febe5a9899d6b55805485af7c21c9a/llguidance-1.7.6-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4e4f2a489c1c3943bb1b3c206b45794153cb6954f45cd3de8e02198319ddc6b1", size = 3485304, upload-time = "2026-06-03T20:13:03.504Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/14/3d1b0d0738c7843e074e38a45e4641302565a1ec9f4eb4dfbc7b394b3314/llguidance-1.7.6-cp314-cp314t-win_amd64.whl", hash = "sha256:d0e1f5402bbc2688bc790d56995f0263978b55771493fceddc09b805dacc83b6", size = 2871993, upload-time = "2026-06-03T20:13:07.416Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/1d/5a9a13421b1f3f1c1acf82beb63ed72fa4d302e65099b72f4a4fe5a098ab/llguidance-1.7.6-cp39-abi3-macosx_10_12_x86_64.whl", hash = "sha256:eabf4572c8731734c0444c353b9ea06bc5c156986d2ff0a4ec0499159271381f", size = 3227892, upload-time = "2026-06-03T20:13:09.533Z" },
+    { url = "https://files.pythonhosted.org/packages/46/fe/bb185f11bad82f2637e3cd8cbf6b200cbb6ed56ac395de47ea05a60d4649/llguidance-1.7.6-cp39-abi3-macosx_11_0_arm64.whl", hash = "sha256:9c54c899db8cb4b4fba128a7d844730066576c70d806c95ada92b2bd2d6ab498", size = 3138127, upload-time = "2026-06-03T20:13:11.649Z" },
+    { url = "https://files.pythonhosted.org/packages/51/b9/dc76d7716e04dc7b3427cae52eaa32bd20771382d4d1dd9f4538a9dd2086/llguidance-1.7.6-cp39-abi3-manylinux_2_31_aarch64.whl", hash = "sha256:e70fa25ed550c2b50c2fd70baa9e2808b4ecb859d01e453bd5459aff62ba38c3", size = 2899993, upload-time = "2026-06-03T20:13:13.563Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/64/d74336f22242ef94356a456057d4ff1be7c1bc9c7dbc867171c6982a5512/llguidance-1.7.6-cp39-abi3-manylinux_2_31_x86_64.whl", hash = "sha256:ceec951d29a74309984e3be0fe7f5f56c1362434cd937abd517b259a60908b1e", size = 3074809, upload-time = "2026-06-03T20:13:15.498Z" },
+    { url = "https://files.pythonhosted.org/packages/49/37/99d700f0e2c83acf25a8d8946b2bee9f5eac47bc530bfbd53ba3126c667f/llguidance-1.7.6-cp39-abi3-win_amd64.whl", hash = "sha256:ace7e81cd31950a87186356ab24bd7f75fbc10a05ca9d9f7f8748f931963f763", size = 2879207, upload-time = "2026-06-03T20:13:23.341Z" },
 ]
 
 [[package]]
 name = "llvmlite"
-version = "0.44.0"
+version = "0.47.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/89/6a/95a3d3610d5c75293d5dbbb2a76480d5d4eeba641557b69fe90af6c5b84e/llvmlite-0.44.0.tar.gz", hash = "sha256:07667d66a5d150abed9157ab6c0b9393c9356f229784a4385c02f99e94fc94d4", size = 171880, upload-time = "2025-01-20T11:14:41.342Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/01/88/a8952b6d5c21e74cbf158515b779666f692846502623e9e3c39d8e8ba25f/llvmlite-0.47.0.tar.gz", hash = "sha256:62031ce968ec74e95092184d4b0e857e444f8fdff0b8f9213707699570c33ccc", size = 193614, upload-time = "2026-03-31T18:29:53.497Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/15/86/e3c3195b92e6e492458f16d233e58a1a812aa2bfbef9bdd0fbafcec85c60/llvmlite-0.44.0-cp312-cp312-macosx_10_14_x86_64.whl", hash = "sha256:1d671a56acf725bf1b531d5ef76b86660a5ab8ef19bb6a46064a705c6ca80aad", size = 28132297, upload-time = "2025-01-20T11:13:32.57Z" },
-    { url = "https://files.pythonhosted.org/packages/d6/53/373b6b8be67b9221d12b24125fd0ec56b1078b660eeae266ec388a6ac9a0/llvmlite-0.44.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:5f79a728e0435493611c9f405168682bb75ffd1fbe6fc360733b850c80a026db", size = 26201105, upload-time = "2025-01-20T11:13:38.744Z" },
-    { url = "https://files.pythonhosted.org/packages/cb/da/8341fd3056419441286c8e26bf436923021005ece0bff5f41906476ae514/llvmlite-0.44.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c0143a5ef336da14deaa8ec26c5449ad5b6a2b564df82fcef4be040b9cacfea9", size = 42361901, upload-time = "2025-01-20T11:13:46.711Z" },
-    { url = "https://files.pythonhosted.org/packages/53/ad/d79349dc07b8a395a99153d7ce8b01d6fcdc9f8231355a5df55ded649b61/llvmlite-0.44.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d752f89e31b66db6f8da06df8b39f9b91e78c5feea1bf9e8c1fba1d1c24c065d", size = 41184247, upload-time = "2025-01-20T11:13:56.159Z" },
-    { url = "https://files.pythonhosted.org/packages/e2/3b/a9a17366af80127bd09decbe2a54d8974b6d8b274b39bf47fbaedeec6307/llvmlite-0.44.0-cp312-cp312-win_amd64.whl", hash = "sha256:eae7e2d4ca8f88f89d315b48c6b741dcb925d6a1042da694aa16ab3dd4cbd3a1", size = 30332380, upload-time = "2025-01-20T11:14:02.442Z" },
-    { url = "https://files.pythonhosted.org/packages/89/24/4c0ca705a717514c2092b18476e7a12c74d34d875e05e4d742618ebbf449/llvmlite-0.44.0-cp313-cp313-macosx_10_14_x86_64.whl", hash = "sha256:319bddd44e5f71ae2689859b7203080716448a3cd1128fb144fe5c055219d516", size = 28132306, upload-time = "2025-01-20T11:14:09.035Z" },
-    { url = "https://files.pythonhosted.org/packages/01/cf/1dd5a60ba6aee7122ab9243fd614abcf22f36b0437cbbe1ccf1e3391461c/llvmlite-0.44.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:9c58867118bad04a0bb22a2e0068c693719658105e40009ffe95c7000fcde88e", size = 26201090, upload-time = "2025-01-20T11:14:15.401Z" },
-    { url = "https://files.pythonhosted.org/packages/d2/1b/656f5a357de7135a3777bd735cc7c9b8f23b4d37465505bd0eaf4be9befe/llvmlite-0.44.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:46224058b13c96af1365290bdfebe9a6264ae62fb79b2b55693deed11657a8bf", size = 42361904, upload-time = "2025-01-20T11:14:22.949Z" },
-    { url = "https://files.pythonhosted.org/packages/d8/e1/12c5f20cb9168fb3464a34310411d5ad86e4163c8ff2d14a2b57e5cc6bac/llvmlite-0.44.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:aa0097052c32bf721a4efc03bd109d335dfa57d9bffb3d4c24cc680711b8b4fc", size = 41184245, upload-time = "2025-01-20T11:14:31.731Z" },
-    { url = "https://files.pythonhosted.org/packages/d0/81/e66fc86539293282fd9cb7c9417438e897f369e79ffb62e1ae5e5154d4dd/llvmlite-0.44.0-cp313-cp313-win_amd64.whl", hash = "sha256:2fb7c4f2fb86cbae6dca3db9ab203eeea0e22d73b99bc2341cdf9de93612e930", size = 30331193, upload-time = "2025-01-20T11:14:38.578Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/48/4b7fe0e34c169fa2f12532916133e0b219d2823b540733651b34fdac509a/llvmlite-0.47.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:306a265f408c259067257a732c8e159284334018b4083a9e35f67d19792b164f", size = 37232769, upload-time = "2026-03-31T18:28:43.735Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/4b/e3f2cd17822cf772a4a51a0a8080b0032e6d37b2dbe8cfb724eac4e31c52/llvmlite-0.47.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:5853bf26160857c0c2573415ff4efe01c4c651e59e2c55c2a088740acfee51cd", size = 56275178, upload-time = "2026-03-31T18:28:48.342Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/55/a3b4a543185305a9bdf3d9759d53646ed96e55e7dfd43f53e7a421b8fbae/llvmlite-0.47.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:003bcf7fa579e14db59c1a1e113f93ab8a06b56a4be31c7f08264d1d4072d077", size = 55128632, upload-time = "2026-03-31T18:28:52.901Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/f5/d281ae0f79378a5a91f308ea9fdb9f9cc068fddd09629edc0725a5a8fde1/llvmlite-0.47.0-cp312-cp312-win_amd64.whl", hash = "sha256:f3079f25bdc24cd9d27c4b2b5e68f5f60c4fdb7e8ad5ee2b9b006007558f9df7", size = 38138692, upload-time = "2026-03-31T18:28:57.147Z" },
+    { url = "https://files.pythonhosted.org/packages/77/6f/4615353e016799f80fa52ccb270a843c413b22361fadda2589b2922fb9b0/llvmlite-0.47.0-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:a3c6a735d4e1041808434f9d440faa3d78d9b4af2ee64d05a66f351883b6ceec", size = 37232771, upload-time = "2026-03-31T18:29:01.324Z" },
+    { url = "https://files.pythonhosted.org/packages/31/b8/69f5565f1a280d032525878a86511eebed0645818492feeb169dfb20ae8e/llvmlite-0.47.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:2699a74321189e812d476a43d6d7f652f51811e7b5aad9d9bba842a1c7927acb", size = 56275178, upload-time = "2026-03-31T18:29:05.748Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/da/b32cafcb926fb0ce2aa25553bf32cb8764af31438f40e2481df08884c947/llvmlite-0.47.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6c6951e2b29930227963e53ee152441f0e14be92e9d4231852102d986c761e40", size = 55128632, upload-time = "2026-03-31T18:29:11.235Z" },
+    { url = "https://files.pythonhosted.org/packages/46/9f/4898b44e4042c60fafcb1162dfb7014f6f15b1ec19bf29cfea6bf26df90d/llvmlite-0.47.0-cp313-cp313-win_amd64.whl", hash = "sha256:c2e9adf8698d813a9a5efb2d4370caf344dbc1e145019851fee6a6f319ba760e", size = 38138695, upload-time = "2026-03-31T18:29:15.43Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/d4/33c8af00f0bf6f552d74f3a054f648af2c5bc6bece97972f3bfadce4f5ec/llvmlite-0.47.0-cp314-cp314-macosx_12_0_arm64.whl", hash = "sha256:de966c626c35c9dff5ae7bf12db25637738d0df83fc370cf793bc94d43d92d14", size = 37232773, upload-time = "2026-03-31T18:29:19.453Z" },
+    { url = "https://files.pythonhosted.org/packages/64/1d/a760e993e0c0ba6db38d46b9f48f6c7dceb8ac838824997fb9e25f97bc04/llvmlite-0.47.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:ddbccff2aeaff8670368340a158abefc032fe9b3ccf7d9c496639263d00151aa", size = 56275176, upload-time = "2026-03-31T18:29:24.149Z" },
+    { url = "https://files.pythonhosted.org/packages/84/3b/e679bc3b29127182a7f4aa2d2e9e5bea42adb93fb840484147d59c236299/llvmlite-0.47.0-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d4a7b778a2e144fc64468fb9bf509ac1226c9813a00b4d7afea5d988c4e22fca", size = 55128631, upload-time = "2026-03-31T18:29:29.536Z" },
+    { url = "https://files.pythonhosted.org/packages/be/f7/19e2a09c62809c9e63bbd14ce71fb92c6ff7b7b3045741bb00c781efc3c9/llvmlite-0.47.0-cp314-cp314-win_amd64.whl", hash = "sha256:694e3c2cdc472ed2bd8bd4555ca002eec4310961dd58ef791d508f57b5cc4c94", size = 39153826, upload-time = "2026-03-31T18:29:33.681Z" },
+    { url = "https://files.pythonhosted.org/packages/40/a1/581a8c707b5e80efdbbe1dd94527404d33fe50bceb71f39d5a7e11bd57b7/llvmlite-0.47.0-cp314-cp314t-macosx_12_0_arm64.whl", hash = "sha256:92ec8a169a20b473c1c54d4695e371bde36489fc1efa3688e11e99beba0abf9c", size = 37232772, upload-time = "2026-03-31T18:29:37.952Z" },
+    { url = "https://files.pythonhosted.org/packages/11/03/16090dd6f74ba2b8b922276047f15962fbeea0a75d5601607edb301ba945/llvmlite-0.47.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:fa1cbd800edd3b20bc141521f7fd45a6185a5b84109aa6855134e81397ffe72b", size = 56275178, upload-time = "2026-03-31T18:29:42.58Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/cb/0abf1dd4c5286a95ffe0c1d8c67aec06b515894a0dd2ac97f5e27b82ab0b/llvmlite-0.47.0-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f6725179b89f03b17dabe236ff3422cb8291b4c1bf40af152826dfd34e350ae8", size = 55128632, upload-time = "2026-03-31T18:29:46.939Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/79/d3bbab197e86e0ff4f9c07122895b66a3e0d024247fcff7f12c473cb36d9/llvmlite-0.47.0-cp314-cp314t-win_amd64.whl", hash = "sha256:6842cf6f707ec4be3d985a385ad03f72b2d724439e118fcbe99b2929964f0453", size = 39153839, upload-time = "2026-03-31T18:29:51.004Z" },
 ]
 
 [[package]]
@@ -3212,7 +3330,8 @@ dependencies = [
     { name = "cycler" },
     { name = "fonttools" },
     { name = "kiwisolver" },
-    { name = "numpy" },
+    { name = "numpy", version = "2.3.5", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.13'" },
+    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.13'" },
     { name = "packaging" },
     { name = "pillow" },
     { name = "pyparsing" },
@@ -3318,7 +3437,8 @@ version = "1.11.2"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "jsonschema" },
-    { name = "numpy" },
+    { name = "numpy", version = "2.3.5", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.13'" },
+    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.13'" },
     { name = "pillow" },
     { name = "pydantic" },
     { name = "pydantic-extra-types", extra = ["pycountry"] },
@@ -3460,50 +3580,40 @@ wheels = [
 ]
 
 [[package]]
-name = "mlx"
-version = "0.31.2"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "mlx-metal", marker = "sys_platform == 'darwin'" },
-]
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/c3/47/5f33906cb03d6a378a697cd2d2641a26b37dea17ee3d9124d7e39e8eca01/mlx-0.31.2-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:e5067aaf2be1f3d7bba5be52348775804f111173c1ed04639618fd713b1a530f", size = 584863, upload-time = "2026-04-22T03:14:38.211Z" },
-    { url = "https://files.pythonhosted.org/packages/08/e7/a851a451b1327af9fb4df3991b9ae87d066b6f6630e854af55c288b0995a/mlx-0.31.2-cp312-cp312-macosx_15_0_arm64.whl", hash = "sha256:edb9797db7d852477ca1c99708058654ee860d4148fe5765f0d55528e2b1aa22", size = 584860, upload-time = "2026-04-22T03:14:39.746Z" },
-    { url = "https://files.pythonhosted.org/packages/3b/15/0d1dc0597644e5e7b011ca954ba0c47e13cd880a3b909b0c3f1b4d8bf8f1/mlx-0.31.2-cp312-cp312-macosx_26_0_arm64.whl", hash = "sha256:51ca102db641b01e7cb083ce8ecb580e281530a141a7ca12544bb370641630ae", size = 584887, upload-time = "2026-04-22T03:14:41.585Z" },
-    { url = "https://files.pythonhosted.org/packages/a3/3f/888f8664d4f8e23a1363a5f50024be5216e199ab7ad0ba20988c7ed6d729/mlx-0.31.2-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:1b3fb0dda955b0d552ce57bdd6f42b3309ab21b067e40587d6848443d307e91f", size = 584796, upload-time = "2026-04-22T03:14:47.215Z" },
-    { url = "https://files.pythonhosted.org/packages/dd/14/e9cd18b51f9e1dbcb060eec0fafc2d2428c8e1eacd9b0a02d7c5ce75b661/mlx-0.31.2-cp313-cp313-macosx_15_0_arm64.whl", hash = "sha256:34b0171cd9eb5c43fdd82091f6135d6ccc5a065363a4a3e68fac64fb4e53d37c", size = 584790, upload-time = "2026-04-22T03:14:48.519Z" },
-    { url = "https://files.pythonhosted.org/packages/ca/20/c6c5fb998c7834d094b2bfb9f003b5246cb270f0266da055c55546c34999/mlx-0.31.2-cp313-cp313-macosx_26_0_arm64.whl", hash = "sha256:c05981684279a8935d58b0dde3ea5b02d210c3bad3319aa0e9934ec2df165752", size = 584795, upload-time = "2026-04-22T03:14:49.904Z" },
-    { url = "https://files.pythonhosted.org/packages/8b/f5/e63f6a9316ded2d14a8ebc7a9ca25734c784e8c54d064a78b4dceeacec0e/mlx-0.31.2-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:a13c9ce23c3deef6aa5a09315e7953e1a5dc311e851fa16fc74c81fb2509c0b9", size = 588417, upload-time = "2026-04-22T03:14:54.094Z" },
-    { url = "https://files.pythonhosted.org/packages/31/50/9d0c03ea3134cd85c132df7b0e4b75e6344bd8b4881a0b9c465cfa27f724/mlx-0.31.2-cp314-cp314-macosx_15_0_arm64.whl", hash = "sha256:b0764bf11fc3a71dee988e19275eef67775cab63112d8bb7ef173ca8b2a1247c", size = 588421, upload-time = "2026-04-22T03:14:55.898Z" },
-    { url = "https://files.pythonhosted.org/packages/ef/5b/d364cc793bcb504621313acb55627cf0d5403ab2e0a594aa081cdbe4591f/mlx-0.31.2-cp314-cp314-macosx_26_0_arm64.whl", hash = "sha256:59ccbd0f0044d4f97f11ebcbf0c480bc9e962935fd96275f120954afea65be8a", size = 588384, upload-time = "2026-04-22T03:14:57.439Z" },
-]
-
-[[package]]
-name = "mlx-lm"
-version = "0.29.1"
+name = "ml-dtypes"
+version = "0.5.4"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "jinja2", marker = "sys_platform == 'darwin'" },
-    { name = "mlx", marker = "sys_platform == 'darwin'" },
-    { name = "numpy", marker = "sys_platform == 'darwin'" },
-    { name = "protobuf", marker = "sys_platform == 'darwin'" },
-    { name = "pyyaml", marker = "sys_platform == 'darwin'" },
-    { name = "sentencepiece", marker = "sys_platform == 'darwin'" },
-    { name = "transformers", marker = "sys_platform == 'darwin'" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/e3/62/f46e1355256a114808517947f8e83ad6be310c7288c551db0fa678f47923/mlx_lm-0.29.1.tar.gz", hash = "sha256:b99180d8f33d33a077b814e550bfb2d8a59ae003d668fd1f4b3fff62a381d34b", size = 232302, upload-time = "2025-12-16T16:58:27.959Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/e5/53/913099c91d384e115ea078325efd9a0bc1ea3eb3458c694b4596cbd267f2/mlx_lm-0.29.1-py3-none-any.whl", hash = "sha256:440941b3054c2a2216e97615de584cc90fa1ea874782e20699b9895721fad8dc", size = 324884, upload-time = "2025-12-16T16:58:26.36Z" },
-]
-
-[[package]]
-name = "mlx-metal"
-version = "0.31.2"
-source = { registry = "https://pypi.org/simple" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/3f/69/fe3b783ebe999f3118234e1e940feb622518bfb1dea6ac5d13b1d36a8449/mlx_metal-0.31.2-py3-none-macosx_14_0_arm64.whl", hash = "sha256:b25385bcee18fc194092255b8b53b9a3d8489eb650e59160f1b57aadd07aa2dc", size = 40055588, upload-time = "2026-04-22T03:14:14.43Z" },
-    { url = "https://files.pythonhosted.org/packages/4f/5d/4c690d5b93c30ba002656c37363159d978705bf8eb801b8481840fb942c2/mlx_metal-0.31.2-py3-none-macosx_15_0_arm64.whl", hash = "sha256:e9d4e5fce6ca10a87a0e388597f99519ad594d09e674708b5312bd8bd4f5997d", size = 40053220, upload-time = "2026-04-22T03:14:18.048Z" },
-    { url = "https://files.pythonhosted.org/packages/99/82/11fd62a8d7a3e96e5c43220b17de0151e3f10101f8bb3b865f5bd9cdd074/mlx_metal-0.31.2-py3-none-macosx_26_0_arm64.whl", hash = "sha256:84ffb60ee503f03eb684f5fb168d5cff31e2a16b7f27c1731eaf7662bd6e9b46", size = 55792151, upload-time = "2026-04-22T03:14:22.059Z" },
+    { name = "numpy", version = "2.3.5", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.13'" },
+    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.13'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/0e/4a/c27b42ed9b1c7d13d9ba8b6905dece787d6259152f2309338aed29b2447b/ml_dtypes-0.5.4.tar.gz", hash = "sha256:8ab06a50fb9bf9666dd0fe5dfb4676fa2b0ac0f31ecff72a6c3af8e22c063453", size = 692314, upload-time = "2025-11-17T22:32:31.031Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a8/b8/3c70881695e056f8a32f8b941126cf78775d9a4d7feba8abcb52cb7b04f2/ml_dtypes-0.5.4-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:a174837a64f5b16cab6f368171a1a03a27936b31699d167684073ff1c4237dac", size = 676927, upload-time = "2025-11-17T22:31:48.182Z" },
+    { url = "https://files.pythonhosted.org/packages/54/0f/428ef6881782e5ebb7eca459689448c0394fa0a80bea3aa9262cba5445ea/ml_dtypes-0.5.4-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a7f7c643e8b1320fd958bf098aa7ecf70623a42ec5154e3be3be673f4c34d900", size = 5028464, upload-time = "2025-11-17T22:31:50.135Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/cb/28ce52eb94390dda42599c98ea0204d74799e4d8047a0eb559b6fd648056/ml_dtypes-0.5.4-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9ad459e99793fa6e13bd5b7e6792c8f9190b4e5a1b45c63aba14a4d0a7f1d5ff", size = 5009002, upload-time = "2025-11-17T22:31:52.001Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/f0/0cfadd537c5470378b1b32bd859cf2824972174b51b873c9d95cfd7475a5/ml_dtypes-0.5.4-cp312-cp312-win_amd64.whl", hash = "sha256:c1a953995cccb9e25a4ae19e34316671e4e2edaebe4cf538229b1fc7109087b7", size = 212222, upload-time = "2025-11-17T22:31:53.742Z" },
+    { url = "https://files.pythonhosted.org/packages/16/2e/9acc86985bfad8f2c2d30291b27cd2bb4c74cea08695bd540906ed744249/ml_dtypes-0.5.4-cp312-cp312-win_arm64.whl", hash = "sha256:9bad06436568442575beb2d03389aa7456c690a5b05892c471215bfd8cf39460", size = 160793, upload-time = "2025-11-17T22:31:55.358Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/a1/4008f14bbc616cfb1ac5b39ea485f9c63031c4634ab3f4cf72e7541f816a/ml_dtypes-0.5.4-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:8c760d85a2f82e2bed75867079188c9d18dae2ee77c25a54d60e9cc79be1bc48", size = 676888, upload-time = "2025-11-17T22:31:56.907Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/b7/dff378afc2b0d5a7d6cd9d3209b60474d9819d1189d347521e1688a60a53/ml_dtypes-0.5.4-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ce756d3a10d0c4067172804c9cc276ba9cc0ff47af9078ad439b075d1abdc29b", size = 5036993, upload-time = "2025-11-17T22:31:58.497Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/33/40cd74219417e78b97c47802037cf2d87b91973e18bb968a7da48a96ea44/ml_dtypes-0.5.4-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:533ce891ba774eabf607172254f2e7260ba5f57bdd64030c9a4fcfbd99815d0d", size = 5010956, upload-time = "2025-11-17T22:31:59.931Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/8b/200088c6859d8221454825959df35b5244fa9bdf263fd0249ac5fb75e281/ml_dtypes-0.5.4-cp313-cp313-win_amd64.whl", hash = "sha256:f21c9219ef48ca5ee78402d5cc831bd58ea27ce89beda894428bc67a52da5328", size = 212224, upload-time = "2025-11-17T22:32:01.349Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/75/dfc3775cb36367816e678f69a7843f6f03bd4e2bcd79941e01ea960a068e/ml_dtypes-0.5.4-cp313-cp313-win_arm64.whl", hash = "sha256:35f29491a3e478407f7047b8a4834e4640a77d2737e0b294d049746507af5175", size = 160798, upload-time = "2025-11-17T22:32:02.864Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/74/e9ddb35fd1dd43b1106c20ced3f53c2e8e7fc7598c15638e9f80677f81d4/ml_dtypes-0.5.4-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:304ad47faa395415b9ccbcc06a0350800bc50eda70f0e45326796e27c62f18b6", size = 702083, upload-time = "2025-11-17T22:32:04.08Z" },
+    { url = "https://files.pythonhosted.org/packages/74/f5/667060b0aed1aa63166b22897fdf16dca9eb704e6b4bbf86848d5a181aa7/ml_dtypes-0.5.4-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6a0df4223b514d799b8a1629c65ddc351b3efa833ccf7f8ea0cf654a61d1e35d", size = 5354111, upload-time = "2025-11-17T22:32:05.546Z" },
+    { url = "https://files.pythonhosted.org/packages/40/49/0f8c498a28c0efa5f5c95a9e374c83ec1385ca41d0e85e7cf40e5d519a21/ml_dtypes-0.5.4-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:531eff30e4d368cb6255bc2328d070e35836aa4f282a0fb5f3a0cd7260257298", size = 5366453, upload-time = "2025-11-17T22:32:07.115Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/27/12607423d0a9c6bbbcc780ad19f1f6baa2b68b18ce4bddcdc122c4c68dc9/ml_dtypes-0.5.4-cp313-cp313t-win_amd64.whl", hash = "sha256:cb73dccfc991691c444acc8c0012bee8f2470da826a92e3a20bb333b1a7894e6", size = 225612, upload-time = "2025-11-17T22:32:08.615Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/80/5a5929e92c72936d5b19872c5fb8fc09327c1da67b3b68c6a13139e77e20/ml_dtypes-0.5.4-cp313-cp313t-win_arm64.whl", hash = "sha256:3bbbe120b915090d9dd1375e4684dd17a20a2491ef25d640a908281da85e73f1", size = 164145, upload-time = "2025-11-17T22:32:09.782Z" },
+    { url = "https://files.pythonhosted.org/packages/72/4e/1339dc6e2557a344f5ba5590872e80346f76f6cb2ac3dd16e4666e88818c/ml_dtypes-0.5.4-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:2b857d3af6ac0d39db1de7c706e69c7f9791627209c3d6dedbfca8c7e5faec22", size = 673781, upload-time = "2025-11-17T22:32:11.364Z" },
+    { url = "https://files.pythonhosted.org/packages/04/f9/067b84365c7e83bda15bba2b06c6ca250ce27b20630b1128c435fb7a09aa/ml_dtypes-0.5.4-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:805cef3a38f4eafae3a5bf9ebdcdb741d0bcfd9e1bd90eb54abd24f928cd2465", size = 5036145, upload-time = "2025-11-17T22:32:12.783Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/bb/82c7dcf38070b46172a517e2334e665c5bf374a262f99a283ea454bece7c/ml_dtypes-0.5.4-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:14a4fd3228af936461db66faccef6e4f41c1d82fcc30e9f8d58a08916b1d811f", size = 5010230, upload-time = "2025-11-17T22:32:14.38Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/93/2bfed22d2498c468f6bcd0d9f56b033eaa19f33320389314c19ef6766413/ml_dtypes-0.5.4-cp314-cp314-win_amd64.whl", hash = "sha256:8c6a2dcebd6f3903e05d51960a8058d6e131fe69f952a5397e5dbabc841b6d56", size = 221032, upload-time = "2025-11-17T22:32:15.763Z" },
+    { url = "https://files.pythonhosted.org/packages/76/a3/9c912fe6ea747bb10fe2f8f54d027eb265db05dfb0c6335e3e063e74e6e8/ml_dtypes-0.5.4-cp314-cp314-win_arm64.whl", hash = "sha256:5a0f68ca8fd8d16583dfa7793973feb86f2fbb56ce3966daf9c9f748f52a2049", size = 163353, upload-time = "2025-11-17T22:32:16.932Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/02/48aa7d84cc30ab4ee37624a2fd98c56c02326785750cd212bc0826c2f15b/ml_dtypes-0.5.4-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:bfc534409c5d4b0bf945af29e5d0ab075eae9eecbb549ff8a29280db822f34f9", size = 702085, upload-time = "2025-11-17T22:32:18.175Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/e7/85cb99fe80a7a5513253ec7faa88a65306be071163485e9a626fce1b6e84/ml_dtypes-0.5.4-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2314892cdc3fcf05e373d76d72aaa15fda9fb98625effa73c1d646f331fcecb7", size = 5355358, upload-time = "2025-11-17T22:32:19.7Z" },
+    { url = "https://files.pythonhosted.org/packages/79/2b/a826ba18d2179a56e144aef69e57fb2ab7c464ef0b2111940ee8a3a223a2/ml_dtypes-0.5.4-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0d2ffd05a2575b1519dc928c0b93c06339eb67173ff53acb00724502cda231cf", size = 5366332, upload-time = "2025-11-17T22:32:21.193Z" },
+    { url = "https://files.pythonhosted.org/packages/84/44/f4d18446eacb20ea11e82f133ea8f86e2bf2891785b67d9da8d0ab0ef525/ml_dtypes-0.5.4-cp314-cp314t-win_amd64.whl", hash = "sha256:4381fe2f2452a2d7589689693d3162e876b3ddb0a832cde7a414f8e1adf7eab1", size = 236612, upload-time = "2025-11-17T22:32:22.579Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/3f/3d42e9a78fe5edf792a83c074b13b9b770092a4fbf3462872f4303135f09/ml_dtypes-0.5.4-cp314-cp314t-win_arm64.whl", hash = "sha256:11942cbf2cf92157db91e5022633c0d9474d4dfd813a909383bd23ce828a4b7d", size = 168825, upload-time = "2025-11-17T22:32:23.766Z" },
 ]
 
 [[package]]
@@ -3883,7 +3993,7 @@ wheels = [
 
 [[package]]
 name = "nbconvert"
-version = "7.17.0"
+version = "7.17.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "beautifulsoup4" },
@@ -3901,9 +4011,9 @@ dependencies = [
     { name = "pygments" },
     { name = "traitlets" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/38/47/81f886b699450d0569f7bc551df2b1673d18df7ff25cc0c21ca36ed8a5ff/nbconvert-7.17.0.tar.gz", hash = "sha256:1b2696f1b5be12309f6c7d707c24af604b87dfaf6d950794c7b07acab96dda78", size = 862855, upload-time = "2026-01-29T16:37:48.478Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/01/b1/708e53fe2e429c103c6e6e159106bcf0357ac41aa4c28772bd8402339051/nbconvert-7.17.1.tar.gz", hash = "sha256:34d0d0a7e73ce3cbab6c5aae8f4f468797280b01fd8bd2ca746da8569eddd7d2", size = 865311, upload-time = "2026-04-08T00:44:14.914Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/0d/4b/8d5f796a792f8a25f6925a96032f098789f448571eb92011df1ae59e8ea8/nbconvert-7.17.0-py3-none-any.whl", hash = "sha256:4f99a63b337b9a23504347afdab24a11faa7d86b405e5c8f9881cd313336d518", size = 261510, upload-time = "2026-01-29T16:37:46.322Z" },
+    { url = "https://files.pythonhosted.org/packages/67/f8/bb0a9d5f46819c821dc1f004aa2cc29b1d91453297dbf5ff20470f00f193/nbconvert-7.17.1-py3-none-any.whl", hash = "sha256:aa85c087b435e7bf1ffd03319f658e285f2b89eccab33bc1ba7025495ab3e7c8", size = 261927, upload-time = "2026-04-08T00:44:12.845Z" },
 ]
 
 [[package]]
@@ -3991,7 +4101,7 @@ wheels = [
 
 [[package]]
 name = "notebook"
-version = "7.5.5"
+version = "7.5.7"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "jupyter-server" },
@@ -4000,9 +4110,9 @@ dependencies = [
     { name = "notebook-shim" },
     { name = "tornado" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/1f/6d/41052c48d6f6349ca0a7c4d1f6a78464de135e6d18f5829ba2510e62184c/notebook-7.5.5.tar.gz", hash = "sha256:dc0bfab0f2372c8278c457423d3256c34154ac2cc76bf20e9925260c461013c3", size = 14169167, upload-time = "2026-03-11T16:32:51.922Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/3e/c4/f71f8716f2903e9e817a47f534b9fd84831e155e2acb32c26691c8e06243/notebook-7.5.7.tar.gz", hash = "sha256:d6d59288a25303b25e1dcb71e9b017ec3a785f7d92f38b9bc288ca1970d5b0a8", size = 14171612, upload-time = "2026-06-04T18:33:45.224Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/f8/aa/cbd1deb9f07446241e88f8d5fecccd95b249bca0b4e5482214a4d1714c49/notebook-7.5.5-py3-none-any.whl", hash = "sha256:a7c14dbeefa6592e87f72290ca982e0c10f5bbf3786be2a600fda9da2764a2b8", size = 14578929, upload-time = "2026-03-11T16:32:48.021Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/4d/b3347f7073a377273531efe4ffc738fc910e93718fd2838c7ebf6736c6af/notebook-7.5.7-py3-none-any.whl", hash = "sha256:1f95f79d117e47d20b5555b5c85a397d2cfecf136978aaab767cf0314b09165b", size = 14583767, upload-time = "2026-06-04T18:33:40.987Z" },
 ]
 
 [[package]]
@@ -4019,190 +4129,452 @@ wheels = [
 
 [[package]]
 name = "numba"
-version = "0.61.2"
+version = "0.65.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "llvmlite" },
-    { name = "numpy" },
+    { name = "numpy", version = "2.3.5", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.13'" },
+    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.13'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/49/61/7299643b9c18d669e04be7c5bcb64d985070d07553274817b45b049e7bfe/numba-0.65.0.tar.gz", hash = "sha256:edad0d9f6682e93624c00125a471ae4df186175d71fd604c983c377cdc03e68b", size = 2764131, upload-time = "2026-04-01T03:52:01.946Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/6c/2f/8bd31a1ea43c01ac215283d83aa5f8d5acbe7a36c85b82f1757bfe9ccb31/numba-0.65.0-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:b27ee4847e1bfb17e9604d100417ee7c1d10f15a6711c6213404b3da13a0b2aa", size = 2680705, upload-time = "2026-04-01T03:51:32.597Z" },
+    { url = "https://files.pythonhosted.org/packages/73/36/88406bd58600cc696417b8e5dd6a056478da808f3eaf48d18e2421e0c2d9/numba-0.65.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:a52d92ffd297c10364bce60cd1fcb88f99284ab5df085f2c6bcd1cb33b529a6f", size = 3801411, upload-time = "2026-04-01T03:51:34.321Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/61/ce753a1d7646dd477e16d15e89473703faebb8995d2f71d7ad69a540b565/numba-0.65.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:da8e371e328c06d0010c3d8b44b21858652831b85bcfba78cb22c042e22dbd8e", size = 3501622, upload-time = "2026-04-01T03:51:36.348Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/86/db87a5393f1b1fabef53ac3ba4e6b938bb27e40a04ad7cc512098fcae032/numba-0.65.0-cp312-cp312-win_amd64.whl", hash = "sha256:59bb9f2bb9f1238dfd8e927ba50645c18ae769fef4f3d58ea0ea22a2683b91f5", size = 2749979, upload-time = "2026-04-01T03:51:37.88Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/f8/eee0f1ff456218db036bfc9023995ec1f85a9dc8f2422f1594f6a87829e0/numba-0.65.0-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:c6334094563a456a695c812e6846288376ca02327cf246cdcc83e1bb27862367", size = 2680679, upload-time = "2026-04-01T03:51:39.491Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/8f/3d116e4b8e92f6abace431afa4b2b944f4d65bdee83af886f5c4b263df95/numba-0.65.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:b8a9008411615c69d083d1dcf477f75a5aa727b30beb16e139799e2be945cdfd", size = 3809537, upload-time = "2026-04-01T03:51:41.42Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/2c/6a3ca4128e253cb67affe06deb47688f51ce968f5111e2a06d010e6f1fa6/numba-0.65.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:af96c0cba53664efcb361528b8c75e011a6556c859c7e08424c2715201c6cf7a", size = 3508615, upload-time = "2026-04-01T03:51:43.444Z" },
+    { url = "https://files.pythonhosted.org/packages/96/0e/267f9a36fb282c104a971d7eecb685b411c47dce2a740fe69cf5fc2945d9/numba-0.65.0-cp313-cp313-win_amd64.whl", hash = "sha256:6254e73b9c929dc736a1fbd3d6f5680789709a5067cae1fa7198707385129c04", size = 2749938, upload-time = "2026-04-01T03:51:45.218Z" },
+    { url = "https://files.pythonhosted.org/packages/56/a4/90edb01e9176053578e343d7a7276bc28356741ee67059aed8ed2c1a4e59/numba-0.65.0-cp314-cp314-macosx_12_0_arm64.whl", hash = "sha256:ee336b398a6fca51b1f626034de99f50cb1bd87d537a166275158a3cee744b82", size = 2680878, upload-time = "2026-04-01T03:51:46.91Z" },
+    { url = "https://files.pythonhosted.org/packages/24/8d/e12d6ff4b9119db3cbf7b2db1ce257576441bd3c76388c786dea74f20b02/numba-0.65.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:05c0a9fdf75d85f57dee47b719e8d6415707b80aae45d75f63f9dc1b935c29f7", size = 3778456, upload-time = "2026-04-01T03:51:48.552Z" },
+    { url = "https://files.pythonhosted.org/packages/17/89/abcd83e76f6a773276fe76244140671bcc5bf820f6e2ae1a15362ae4c8c9/numba-0.65.0-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:583680e0e8faf124d362df23b4b593f3221a8996341a63d1b664c122401bec2f", size = 3478464, upload-time = "2026-04-01T03:51:50.527Z" },
+    { url = "https://files.pythonhosted.org/packages/73/5b/fbce55ce3d933afbc7ade04df826853e4a846aaa47d58d2fbb669b8f2d08/numba-0.65.0-cp314-cp314-win_amd64.whl", hash = "sha256:add297d3e1c08dd884f44100152612fa41e66a51d15fdf91307f9dde31d06830", size = 2752012, upload-time = "2026-04-01T03:51:52.691Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/ab/af705f4257d9388fb2fd6d7416573e98b6ca9c786e8b58f02720978557bd/numba-0.65.0-cp314-cp314t-macosx_12_0_arm64.whl", hash = "sha256:194a243ba53a9157c8538cbb3166ec015d785a8c5d584d06cdd88bee902233c7", size = 2683961, upload-time = "2026-04-01T03:51:54.281Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/e5/8267b0adb0c01b52b553df5062fbbb42c30ed5362d08b85cc913a36f838f/numba-0.65.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c7fa502960f7a2f3f5cb025bc7bff888a3551277b92431bfdc5ba2f11a375749", size = 3816373, upload-time = "2026-04-01T03:51:56.18Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/f5/b8397ca360971669a93706b9274592b6864e4367a37d498fbbcb62aa2d48/numba-0.65.0-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5046c63f783ca3eb6195f826a50797465e7c4ce811daa17c9bea47e310c9b964", size = 3532782, upload-time = "2026-04-01T03:51:58.387Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/21/1e73fa16bf0393ebb74c5bb208d712152ffdfc84600a8e93a3180317856e/numba-0.65.0-cp314-cp314t-win_amd64.whl", hash = "sha256:46fd679ae4f68c7a5d5721efbd29ecee0b0f3013211591891d79b51bfdf73113", size = 2757611, upload-time = "2026-04-01T03:52:00.083Z" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/1c/a0/e21f57604304aa03ebb8e098429222722ad99176a4f979d34af1d1ee80da/numba-0.61.2.tar.gz", hash = "sha256:8750ee147940a6637b80ecf7f95062185ad8726c8c28a2295b8ec1160a196f7d", size = 2820615, upload-time = "2025-04-09T02:58:07.659Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/b4/a0/c6b7b9c615cfa3b98c4c63f4316e3f6b3bbe2387740277006551784218cd/numba-0.61.2-cp312-cp312-macosx_10_14_x86_64.whl", hash = "sha256:34fba9406078bac7ab052efbf0d13939426c753ad72946baaa5bf9ae0ebb8dd2", size = 2776626, upload-time = "2025-04-09T02:57:51.857Z" },
-    { url = "https://files.pythonhosted.org/packages/92/4a/fe4e3c2ecad72d88f5f8cd04e7f7cff49e718398a2fac02d2947480a00ca/numba-0.61.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:4ddce10009bc097b080fc96876d14c051cc0c7679e99de3e0af59014dab7dfe8", size = 2779287, upload-time = "2025-04-09T02:57:53.658Z" },
-    { url = "https://files.pythonhosted.org/packages/9a/2d/e518df036feab381c23a624dac47f8445ac55686ec7f11083655eb707da3/numba-0.61.2-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:5b1bb509d01f23d70325d3a5a0e237cbc9544dd50e50588bc581ba860c213546", size = 3885928, upload-time = "2025-04-09T02:57:55.206Z" },
-    { url = "https://files.pythonhosted.org/packages/10/0f/23cced68ead67b75d77cfcca3df4991d1855c897ee0ff3fe25a56ed82108/numba-0.61.2-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:48a53a3de8f8793526cbe330f2a39fe9a6638efcbf11bd63f3d2f9757ae345cd", size = 3577115, upload-time = "2025-04-09T02:57:56.818Z" },
-    { url = "https://files.pythonhosted.org/packages/68/1d/ddb3e704c5a8fb90142bf9dc195c27db02a08a99f037395503bfbc1d14b3/numba-0.61.2-cp312-cp312-win_amd64.whl", hash = "sha256:97cf4f12c728cf77c9c1d7c23707e4d8fb4632b46275f8f3397de33e5877af18", size = 2831929, upload-time = "2025-04-09T02:57:58.45Z" },
-    { url = "https://files.pythonhosted.org/packages/0b/f3/0fe4c1b1f2569e8a18ad90c159298d862f96c3964392a20d74fc628aee44/numba-0.61.2-cp313-cp313-macosx_10_14_x86_64.whl", hash = "sha256:3a10a8fc9afac40b1eac55717cece1b8b1ac0b946f5065c89e00bde646b5b154", size = 2771785, upload-time = "2025-04-09T02:57:59.96Z" },
-    { url = "https://files.pythonhosted.org/packages/e9/71/91b277d712e46bd5059f8a5866862ed1116091a7cb03bd2704ba8ebe015f/numba-0.61.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:7d3bcada3c9afba3bed413fba45845f2fb9cd0d2b27dd58a1be90257e293d140", size = 2773289, upload-time = "2025-04-09T02:58:01.435Z" },
-    { url = "https://files.pythonhosted.org/packages/0d/e0/5ea04e7ad2c39288c0f0f9e8d47638ad70f28e275d092733b5817cf243c9/numba-0.61.2-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:bdbca73ad81fa196bd53dc12e3aaf1564ae036e0c125f237c7644fe64a4928ab", size = 3893918, upload-time = "2025-04-09T02:58:02.933Z" },
-    { url = "https://files.pythonhosted.org/packages/17/58/064f4dcb7d7e9412f16ecf80ed753f92297e39f399c905389688cf950b81/numba-0.61.2-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:5f154aaea625fb32cfbe3b80c5456d514d416fcdf79733dd69c0df3a11348e9e", size = 3584056, upload-time = "2025-04-09T02:58:04.538Z" },
-    { url = "https://files.pythonhosted.org/packages/af/a4/6d3a0f2d3989e62a18749e1e9913d5fa4910bbb3e3311a035baea6caf26d/numba-0.61.2-cp313-cp313-win_amd64.whl", hash = "sha256:59321215e2e0ac5fa928a8020ab00b8e57cda8a97384963ac0dfa4d4e6aa54e7", size = 2831846, upload-time = "2025-04-09T02:58:06.125Z" },
+
+[[package]]
+name = "numpy"
+version = "2.3.5"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version < '3.13' and sys_platform == 'win32'",
+    "python_full_version < '3.13' and sys_platform == 'emscripten'",
+    "python_full_version < '3.13' and sys_platform == 'darwin'",
+    "python_full_version < '3.13' and platform_machine == 'aarch64' and sys_platform == 'linux'",
+    "(python_full_version < '3.13' and platform_machine != 'aarch64' and sys_platform == 'linux') or (python_full_version < '3.13' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'linux' and sys_platform != 'win32')",
+]
+sdist = { url = "https://files.pythonhosted.org/packages/76/65/21b3bc86aac7b8f2862db1e808f1ea22b028e30a225a34a5ede9bf8678f2/numpy-2.3.5.tar.gz", hash = "sha256:784db1dcdab56bf0517743e746dfb0f885fc68d948aba86eeec2cba234bdf1c0", size = 20584950, upload-time = "2025-11-16T22:52:42.067Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/44/37/e669fe6cbb2b96c62f6bbedc6a81c0f3b7362f6a59230b23caa673a85721/numpy-2.3.5-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:74ae7b798248fe62021dbf3c914245ad45d1a6b0cb4a29ecb4b31d0bfbc4cc3e", size = 16733873, upload-time = "2025-11-16T22:49:49.84Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/65/df0db6c097892c9380851ab9e44b52d4f7ba576b833996e0080181c0c439/numpy-2.3.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ee3888d9ff7c14604052b2ca5535a30216aa0a58e948cdd3eeb8d3415f638769", size = 12259838, upload-time = "2025-11-16T22:49:52.863Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/e1/1ee06e70eb2136797abe847d386e7c0e830b67ad1d43f364dd04fa50d338/numpy-2.3.5-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:612a95a17655e213502f60cfb9bf9408efdc9eb1d5f50535cc6eb365d11b42b5", size = 5088378, upload-time = "2025-11-16T22:49:55.055Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/9c/1ca85fb86708724275103b81ec4cf1ac1d08f465368acfc8da7ab545bdae/numpy-2.3.5-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:3101e5177d114a593d79dd79658650fe28b5a0d8abeb8ce6f437c0e6df5be1a4", size = 6628559, upload-time = "2025-11-16T22:49:57.371Z" },
+    { url = "https://files.pythonhosted.org/packages/74/78/fcd41e5a0ce4f3f7b003da85825acddae6d7ecb60cf25194741b036ca7d6/numpy-2.3.5-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8b973c57ff8e184109db042c842423ff4f60446239bd585a5131cc47f06f789d", size = 14250702, upload-time = "2025-11-16T22:49:59.632Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/23/2a1b231b8ff672b4c450dac27164a8b2ca7d9b7144f9c02d2396518352eb/numpy-2.3.5-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0d8163f43acde9a73c2a33605353a4f1bc4798745a8b1d73183b28e5b435ae28", size = 16606086, upload-time = "2025-11-16T22:50:02.127Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/c5/5ad26fbfbe2012e190cc7d5003e4d874b88bb18861d0829edc140a713021/numpy-2.3.5-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:51c1e14eb1e154ebd80e860722f9e6ed6ec89714ad2db2d3aa33c31d7c12179b", size = 16025985, upload-time = "2025-11-16T22:50:04.536Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/fa/dd48e225c46c819288148d9d060b047fd2a6fb1eb37eae25112ee4cb4453/numpy-2.3.5-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:b46b4ec24f7293f23adcd2d146960559aaf8020213de8ad1909dba6c013bf89c", size = 18542976, upload-time = "2025-11-16T22:50:07.557Z" },
+    { url = "https://files.pythonhosted.org/packages/05/79/ccbd23a75862d95af03d28b5c6901a1b7da4803181513d52f3b86ed9446e/numpy-2.3.5-cp312-cp312-win32.whl", hash = "sha256:3997b5b3c9a771e157f9aae01dd579ee35ad7109be18db0e85dbdbe1de06e952", size = 6285274, upload-time = "2025-11-16T22:50:10.746Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/57/8aeaf160312f7f489dea47ab61e430b5cb051f59a98ae68b7133ce8fa06a/numpy-2.3.5-cp312-cp312-win_amd64.whl", hash = "sha256:86945f2ee6d10cdfd67bcb4069c1662dd711f7e2a4343db5cecec06b87cf31aa", size = 12782922, upload-time = "2025-11-16T22:50:12.811Z" },
+    { url = "https://files.pythonhosted.org/packages/78/a6/aae5cc2ca78c45e64b9ef22f089141d661516856cf7c8a54ba434576900d/numpy-2.3.5-cp312-cp312-win_arm64.whl", hash = "sha256:f28620fe26bee16243be2b7b874da327312240a7cdc38b769a697578d2100013", size = 10194667, upload-time = "2025-11-16T22:50:16.16Z" },
+    { url = "https://files.pythonhosted.org/packages/db/69/9cde09f36da4b5a505341180a3f2e6fadc352fd4d2b7096ce9778db83f1a/numpy-2.3.5-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:d0f23b44f57077c1ede8c5f26b30f706498b4862d3ff0a7298b8411dd2f043ff", size = 16728251, upload-time = "2025-11-16T22:50:19.013Z" },
+    { url = "https://files.pythonhosted.org/packages/79/fb/f505c95ceddd7027347b067689db71ca80bd5ecc926f913f1a23e65cf09b/numpy-2.3.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:aa5bc7c5d59d831d9773d1170acac7893ce3a5e130540605770ade83280e7188", size = 12254652, upload-time = "2025-11-16T22:50:21.487Z" },
+    { url = "https://files.pythonhosted.org/packages/78/da/8c7738060ca9c31b30e9301ee0cf6c5ffdbf889d9593285a1cead337f9a5/numpy-2.3.5-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:ccc933afd4d20aad3c00bcef049cb40049f7f196e0397f1109dba6fed63267b0", size = 5083172, upload-time = "2025-11-16T22:50:24.562Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/b4/ee5bb2537fb9430fd2ef30a616c3672b991a4129bb1c7dcc42aa0abbe5d7/numpy-2.3.5-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:afaffc4393205524af9dfa400fa250143a6c3bc646c08c9f5e25a9f4b4d6a903", size = 6622990, upload-time = "2025-11-16T22:50:26.47Z" },
+    { url = "https://files.pythonhosted.org/packages/95/03/dc0723a013c7d7c19de5ef29e932c3081df1c14ba582b8b86b5de9db7f0f/numpy-2.3.5-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9c75442b2209b8470d6d5d8b1c25714270686f14c749028d2199c54e29f20b4d", size = 14248902, upload-time = "2025-11-16T22:50:28.861Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/10/ca162f45a102738958dcec8023062dad0cbc17d1ab99d68c4e4a6c45fb2b/numpy-2.3.5-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:11e06aa0af8c0f05104d56450d6093ee639e15f24ecf62d417329d06e522e017", size = 16597430, upload-time = "2025-11-16T22:50:31.56Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/51/c1e29be863588db58175175f057286900b4b3327a1351e706d5e0f8dd679/numpy-2.3.5-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ed89927b86296067b4f81f108a2271d8926467a8868e554eaf370fc27fa3ccaf", size = 16024551, upload-time = "2025-11-16T22:50:34.242Z" },
+    { url = "https://files.pythonhosted.org/packages/83/68/8236589d4dbb87253d28259d04d9b814ec0ecce7cb1c7fed29729f4c3a78/numpy-2.3.5-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:51c55fe3451421f3a6ef9a9c1439e82101c57a2c9eab9feb196a62b1a10b58ce", size = 18533275, upload-time = "2025-11-16T22:50:37.651Z" },
+    { url = "https://files.pythonhosted.org/packages/40/56/2932d75b6f13465239e3b7b7e511be27f1b8161ca2510854f0b6e521c395/numpy-2.3.5-cp313-cp313-win32.whl", hash = "sha256:1978155dd49972084bd6ef388d66ab70f0c323ddee6f693d539376498720fb7e", size = 6277637, upload-time = "2025-11-16T22:50:40.11Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/88/e2eaa6cffb115b85ed7c7c87775cb8bcf0816816bc98ca8dbfa2ee33fe6e/numpy-2.3.5-cp313-cp313-win_amd64.whl", hash = "sha256:00dc4e846108a382c5869e77c6ed514394bdeb3403461d25a829711041217d5b", size = 12779090, upload-time = "2025-11-16T22:50:42.503Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/88/3f41e13a44ebd4034ee17baa384acac29ba6a4fcc2aca95f6f08ca0447d1/numpy-2.3.5-cp313-cp313-win_arm64.whl", hash = "sha256:0472f11f6ec23a74a906a00b48a4dcf3849209696dff7c189714511268d103ae", size = 10194710, upload-time = "2025-11-16T22:50:44.971Z" },
+    { url = "https://files.pythonhosted.org/packages/13/cb/71744144e13389d577f867f745b7df2d8489463654a918eea2eeb166dfc9/numpy-2.3.5-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:414802f3b97f3c1eef41e530aaba3b3c1620649871d8cb38c6eaff034c2e16bd", size = 16827292, upload-time = "2025-11-16T22:50:47.715Z" },
+    { url = "https://files.pythonhosted.org/packages/71/80/ba9dc6f2a4398e7f42b708a7fdc841bb638d353be255655498edbf9a15a8/numpy-2.3.5-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:5ee6609ac3604fa7780e30a03e5e241a7956f8e2fcfe547d51e3afa5247ac47f", size = 12378897, upload-time = "2025-11-16T22:50:51.327Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/6d/db2151b9f64264bcceccd51741aa39b50150de9b602d98ecfe7e0c4bff39/numpy-2.3.5-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:86d835afea1eaa143012a2d7a3f45a3adce2d7adc8b4961f0b362214d800846a", size = 5207391, upload-time = "2025-11-16T22:50:54.542Z" },
+    { url = "https://files.pythonhosted.org/packages/80/ae/429bacace5ccad48a14c4ae5332f6aa8ab9f69524193511d60ccdfdc65fa/numpy-2.3.5-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:30bc11310e8153ca664b14c5f1b73e94bd0503681fcf136a163de856f3a50139", size = 6721275, upload-time = "2025-11-16T22:50:56.794Z" },
+    { url = "https://files.pythonhosted.org/packages/74/5b/1919abf32d8722646a38cd527bc3771eb229a32724ee6ba340ead9b92249/numpy-2.3.5-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1062fde1dcf469571705945b0f221b73928f34a20c904ffb45db101907c3454e", size = 14306855, upload-time = "2025-11-16T22:50:59.208Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/87/6831980559434973bebc30cd9c1f21e541a0f2b0c280d43d3afd909b66d0/numpy-2.3.5-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ce581db493ea1a96c0556360ede6607496e8bf9b3a8efa66e06477267bc831e9", size = 16657359, upload-time = "2025-11-16T22:51:01.991Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/91/c797f544491ee99fd00495f12ebb7802c440c1915811d72ac5b4479a3356/numpy-2.3.5-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:cc8920d2ec5fa99875b670bb86ddeb21e295cb07aa331810d9e486e0b969d946", size = 16093374, upload-time = "2025-11-16T22:51:05.291Z" },
+    { url = "https://files.pythonhosted.org/packages/74/a6/54da03253afcbe7a72785ec4da9c69fb7a17710141ff9ac5fcb2e32dbe64/numpy-2.3.5-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:9ee2197ef8c4f0dfe405d835f3b6a14f5fee7782b5de51ba06fb65fc9b36e9f1", size = 18594587, upload-time = "2025-11-16T22:51:08.585Z" },
+    { url = "https://files.pythonhosted.org/packages/80/e9/aff53abbdd41b0ecca94285f325aff42357c6b5abc482a3fcb4994290b18/numpy-2.3.5-cp313-cp313t-win32.whl", hash = "sha256:70b37199913c1bd300ff6e2693316c6f869c7ee16378faf10e4f5e3275b299c3", size = 6405940, upload-time = "2025-11-16T22:51:11.541Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/81/50613fec9d4de5480de18d4f8ef59ad7e344d497edbef3cfd80f24f98461/numpy-2.3.5-cp313-cp313t-win_amd64.whl", hash = "sha256:b501b5fa195cc9e24fe102f21ec0a44dffc231d2af79950b451e0d99cea02234", size = 12920341, upload-time = "2025-11-16T22:51:14.312Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/ab/08fd63b9a74303947f34f0bd7c5903b9c5532c2d287bead5bdf4c556c486/numpy-2.3.5-cp313-cp313t-win_arm64.whl", hash = "sha256:a80afd79f45f3c4a7d341f13acbe058d1ca8ac017c165d3fa0d3de6bc1a079d7", size = 10262507, upload-time = "2025-11-16T22:51:16.846Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/97/1a914559c19e32d6b2e233cf9a6a114e67c856d35b1d6babca571a3e880f/numpy-2.3.5-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:bf06bc2af43fa8d32d30fae16ad965663e966b1a3202ed407b84c989c3221e82", size = 16735706, upload-time = "2025-11-16T22:51:19.558Z" },
+    { url = "https://files.pythonhosted.org/packages/57/d4/51233b1c1b13ecd796311216ae417796b88b0616cfd8a33ae4536330748a/numpy-2.3.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:052e8c42e0c49d2575621c158934920524f6c5da05a1d3b9bab5d8e259e045f0", size = 12264507, upload-time = "2025-11-16T22:51:22.492Z" },
+    { url = "https://files.pythonhosted.org/packages/45/98/2fe46c5c2675b8306d0b4a3ec3494273e93e1226a490f766e84298576956/numpy-2.3.5-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:1ed1ec893cff7040a02c8aa1c8611b94d395590d553f6b53629a4461dc7f7b63", size = 5093049, upload-time = "2025-11-16T22:51:25.171Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/0e/0698378989bb0ac5f1660c81c78ab1fe5476c1a521ca9ee9d0710ce54099/numpy-2.3.5-cp314-cp314-macosx_14_0_x86_64.whl", hash = "sha256:2dcd0808a421a482a080f89859a18beb0b3d1e905b81e617a188bd80422d62e9", size = 6626603, upload-time = "2025-11-16T22:51:27Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/a6/9ca0eecc489640615642a6cbc0ca9e10df70df38c4d43f5a928ff18d8827/numpy-2.3.5-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:727fd05b57df37dc0bcf1a27767a3d9a78cbbc92822445f32cc3436ba797337b", size = 14262696, upload-time = "2025-11-16T22:51:29.402Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/f6/07ec185b90ec9d7217a00eeeed7383b73d7e709dae2a9a021b051542a708/numpy-2.3.5-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fffe29a1ef00883599d1dc2c51aa2e5d80afe49523c261a74933df395c15c520", size = 16597350, upload-time = "2025-11-16T22:51:32.167Z" },
+    { url = "https://files.pythonhosted.org/packages/75/37/164071d1dde6a1a84c9b8e5b414fa127981bad47adf3a6b7e23917e52190/numpy-2.3.5-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:8f7f0e05112916223d3f438f293abf0727e1181b5983f413dfa2fefc4098245c", size = 16040190, upload-time = "2025-11-16T22:51:35.403Z" },
+    { url = "https://files.pythonhosted.org/packages/08/3c/f18b82a406b04859eb026d204e4e1773eb41c5be58410f41ffa511d114ae/numpy-2.3.5-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:2e2eb32ddb9ccb817d620ac1d8dae7c3f641c1e5f55f531a33e8ab97960a75b8", size = 18536749, upload-time = "2025-11-16T22:51:39.698Z" },
+    { url = "https://files.pythonhosted.org/packages/40/79/f82f572bf44cf0023a2fe8588768e23e1592585020d638999f15158609e1/numpy-2.3.5-cp314-cp314-win32.whl", hash = "sha256:66f85ce62c70b843bab1fb14a05d5737741e74e28c7b8b5a064de10142fad248", size = 6335432, upload-time = "2025-11-16T22:51:42.476Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/2e/235b4d96619931192c91660805e5e49242389742a7a82c27665021db690c/numpy-2.3.5-cp314-cp314-win_amd64.whl", hash = "sha256:e6a0bc88393d65807d751a614207b7129a310ca4fe76a74e5c7da5fa5671417e", size = 12919388, upload-time = "2025-11-16T22:51:45.275Z" },
+    { url = "https://files.pythonhosted.org/packages/07/2b/29fd75ce45d22a39c61aad74f3d718e7ab67ccf839ca8b60866054eb15f8/numpy-2.3.5-cp314-cp314-win_arm64.whl", hash = "sha256:aeffcab3d4b43712bb7a60b65f6044d444e75e563ff6180af8f98dd4b905dfd2", size = 10476651, upload-time = "2025-11-16T22:51:47.749Z" },
+    { url = "https://files.pythonhosted.org/packages/17/e1/f6a721234ebd4d87084cfa68d081bcba2f5cfe1974f7de4e0e8b9b2a2ba1/numpy-2.3.5-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:17531366a2e3a9e30762c000f2c43a9aaa05728712e25c11ce1dbe700c53ad41", size = 16834503, upload-time = "2025-11-16T22:51:50.443Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/1c/baf7ffdc3af9c356e1c135e57ab7cf8d247931b9554f55c467efe2c69eff/numpy-2.3.5-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:d21644de1b609825ede2f48be98dfde4656aefc713654eeee280e37cadc4e0ad", size = 12381612, upload-time = "2025-11-16T22:51:53.609Z" },
+    { url = "https://files.pythonhosted.org/packages/74/91/f7f0295151407ddc9ba34e699013c32c3c91944f9b35fcf9281163dc1468/numpy-2.3.5-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:c804e3a5aba5460c73955c955bdbd5c08c354954e9270a2c1565f62e866bdc39", size = 5210042, upload-time = "2025-11-16T22:51:56.213Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/3b/78aebf345104ec50dd50a4d06ddeb46a9ff5261c33bcc58b1c4f12f85ec2/numpy-2.3.5-cp314-cp314t-macosx_14_0_x86_64.whl", hash = "sha256:cc0a57f895b96ec78969c34f682c602bf8da1a0270b09bc65673df2e7638ec20", size = 6724502, upload-time = "2025-11-16T22:51:58.584Z" },
+    { url = "https://files.pythonhosted.org/packages/02/c6/7c34b528740512e57ef1b7c8337ab0b4f0bddf34c723b8996c675bc2bc91/numpy-2.3.5-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:900218e456384ea676e24ea6a0417f030a3b07306d29d7ad843957b40a9d8d52", size = 14308962, upload-time = "2025-11-16T22:52:01.698Z" },
+    { url = "https://files.pythonhosted.org/packages/80/35/09d433c5262bc32d725bafc619e095b6a6651caf94027a03da624146f655/numpy-2.3.5-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:09a1bea522b25109bf8e6f3027bd810f7c1085c64a0c7ce050c1676ad0ba010b", size = 16655054, upload-time = "2025-11-16T22:52:04.267Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/ab/6a7b259703c09a88804fa2430b43d6457b692378f6b74b356155283566ac/numpy-2.3.5-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:04822c00b5fd0323c8166d66c701dc31b7fbd252c100acd708c48f763968d6a3", size = 16091613, upload-time = "2025-11-16T22:52:08.651Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/88/330da2071e8771e60d1038166ff9d73f29da37b01ec3eb43cb1427464e10/numpy-2.3.5-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:d6889ec4ec662a1a37eb4b4fb26b6100841804dac55bd9df579e326cdc146227", size = 18591147, upload-time = "2025-11-16T22:52:11.453Z" },
+    { url = "https://files.pythonhosted.org/packages/51/41/851c4b4082402d9ea860c3626db5d5df47164a712cb23b54be028b184c1c/numpy-2.3.5-cp314-cp314t-win32.whl", hash = "sha256:93eebbcf1aafdf7e2ddd44c2923e2672e1010bddc014138b229e49725b4d6be5", size = 6479806, upload-time = "2025-11-16T22:52:14.641Z" },
+    { url = "https://files.pythonhosted.org/packages/90/30/d48bde1dfd93332fa557cff1972fbc039e055a52021fbef4c2c4b1eefd17/numpy-2.3.5-cp314-cp314t-win_amd64.whl", hash = "sha256:c8a9958e88b65c3b27e22ca2a076311636850b612d6bbfb76e8d156aacde2aaf", size = 13105760, upload-time = "2025-11-16T22:52:17.975Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/fd/4b5eb0b3e888d86aee4d198c23acec7d214baaf17ea93c1adec94c9518b9/numpy-2.3.5-cp314-cp314t-win_arm64.whl", hash = "sha256:6203fdf9f3dc5bdaed7319ad8698e685c7a3be10819f41d32a0723e611733b42", size = 10545459, upload-time = "2025-11-16T22:52:20.55Z" },
 ]
 
 [[package]]
 name = "numpy"
-version = "1.26.4"
+version = "2.4.6"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/65/6e/09db70a523a96d25e115e71cc56a6f9031e7b8cd166c1ac8438307c14058/numpy-1.26.4.tar.gz", hash = "sha256:2a02aba9ed12e4ac4eb3ea9421c420301a0c6460d9830d74a9df87efa4912010", size = 15786129, upload-time = "2024-02-06T00:26:44.495Z" }
+resolution-markers = [
+    "python_full_version >= '3.14' and sys_platform == 'win32'",
+    "python_full_version >= '3.14' and sys_platform == 'emscripten'",
+    "python_full_version >= '3.14' and sys_platform == 'darwin'",
+    "python_full_version >= '3.14' and platform_machine == 'aarch64' and sys_platform == 'linux'",
+    "(python_full_version >= '3.14' and platform_machine != 'aarch64' and sys_platform == 'linux') or (python_full_version >= '3.14' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'linux' and sys_platform != 'win32')",
+    "python_full_version == '3.13.*' and sys_platform == 'win32'",
+    "python_full_version == '3.13.*' and sys_platform == 'emscripten'",
+    "python_full_version == '3.13.*' and sys_platform == 'darwin'",
+    "python_full_version == '3.13.*' and platform_machine == 'aarch64' and sys_platform == 'linux'",
+    "(python_full_version == '3.13.*' and platform_machine != 'aarch64' and sys_platform == 'linux') or (python_full_version == '3.13.*' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'linux' and sys_platform != 'win32')",
+]
+sdist = { url = "https://files.pythonhosted.org/packages/d0/ad/fed0499ce6a338d2a03ebae59cd15093910c8875328855781952abf6c2fe/numpy-2.4.6.tar.gz", hash = "sha256:f3a3570c4a2a16746ac2c31a7c7c7b0c186b95ce902e33db6f28094ed7387dda", size = 20735807, upload-time = "2026-05-18T23:37:14.07Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/95/12/8f2020a8e8b8383ac0177dc9570aad031a3beb12e38847f7129bacd96228/numpy-1.26.4-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:b3ce300f3644fb06443ee2222c2201dd3a89ea6040541412b8fa189341847218", size = 20335901, upload-time = "2024-02-05T23:55:32.801Z" },
-    { url = "https://files.pythonhosted.org/packages/75/5b/ca6c8bd14007e5ca171c7c03102d17b4f4e0ceb53957e8c44343a9546dcc/numpy-1.26.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:03a8c78d01d9781b28a6989f6fa1bb2c4f2d51201cf99d3dd875df6fbd96b23b", size = 13685868, upload-time = "2024-02-05T23:55:56.28Z" },
-    { url = "https://files.pythonhosted.org/packages/79/f8/97f10e6755e2a7d027ca783f63044d5b1bc1ae7acb12afe6a9b4286eac17/numpy-1.26.4-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9fad7dcb1aac3c7f0584a5a8133e3a43eeb2fe127f47e3632d43d677c66c102b", size = 13925109, upload-time = "2024-02-05T23:56:20.368Z" },
-    { url = "https://files.pythonhosted.org/packages/0f/50/de23fde84e45f5c4fda2488c759b69990fd4512387a8632860f3ac9cd225/numpy-1.26.4-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:675d61ffbfa78604709862923189bad94014bef562cc35cf61d3a07bba02a7ed", size = 17950613, upload-time = "2024-02-05T23:56:56.054Z" },
-    { url = "https://files.pythonhosted.org/packages/4c/0c/9c603826b6465e82591e05ca230dfc13376da512b25ccd0894709b054ed0/numpy-1.26.4-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:ab47dbe5cc8210f55aa58e4805fe224dac469cde56b9f731a4c098b91917159a", size = 13572172, upload-time = "2024-02-05T23:57:21.56Z" },
-    { url = "https://files.pythonhosted.org/packages/76/8c/2ba3902e1a0fc1c74962ea9bb33a534bb05984ad7ff9515bf8d07527cadd/numpy-1.26.4-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:1dda2e7b4ec9dd512f84935c5f126c8bd8b9f2fc001e9f54af255e8c5f16b0e0", size = 17786643, upload-time = "2024-02-05T23:57:56.585Z" },
-    { url = "https://files.pythonhosted.org/packages/28/4a/46d9e65106879492374999e76eb85f87b15328e06bd1550668f79f7b18c6/numpy-1.26.4-cp312-cp312-win32.whl", hash = "sha256:50193e430acfc1346175fcbdaa28ffec49947a06918b7b92130744e81e640110", size = 5677803, upload-time = "2024-02-05T23:58:08.963Z" },
-    { url = "https://files.pythonhosted.org/packages/16/2e/86f24451c2d530c88daf997cb8d6ac622c1d40d19f5a031ed68a4b73a374/numpy-1.26.4-cp312-cp312-win_amd64.whl", hash = "sha256:08beddf13648eb95f8d867350f6a018a4be2e5ad54c8d8caed89ebca558b2818", size = 15517754, upload-time = "2024-02-05T23:58:36.364Z" },
+    { url = "https://files.pythonhosted.org/packages/95/2a/3d7b5ac8aac24feaf9ad7ed58f45b0bbc06d37e4338ae84c9f2298b570f9/numpy-2.4.6-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:001fbb8e08d942dd57599e781f2472269ee7f2755fae407b4f67b2f0b17da3f1", size = 16689119, upload-time = "2026-05-18T23:33:54.065Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/12/92c4c131527599e8288d6918e888d88726f84d805d784b771f32408aeaef/numpy-2.4.6-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ebfb099f8dcf083deef3ac1ca4c1503f387cf76296fcb3816b66f5ecb5f54fdb", size = 14699246, upload-time = "2026-05-18T23:33:57.621Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/fe/c0a6b7b2ca128a8fb228575147073b660656734b8ebe4d76c8fd748dcc79/numpy-2.4.6-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:3213d622a0283a39a93d188f3cf72b26862df52fbb4ca3697f51705016523d41", size = 5204410, upload-time = "2026-05-18T23:34:00.302Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/d4/9770d14ba719432bb90a421bfd443872ed0f70f7264b64bec12ea363d5fd/numpy-2.4.6-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:357cc07a6d7b0b182ff02249616a03742827ebb1277546b5c7cd7f7620a45698", size = 6551240, upload-time = "2026-05-18T23:34:02.852Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/c6/50a46a6205feba2343f1d6d17438107c5dc491ed1c736e6ea68689fd906b/numpy-2.4.6-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5f9fb9157b4ce2971008323afe46053787b526ef624fea915b261468a8421a0f", size = 15671012, upload-time = "2026-05-18T23:34:05.485Z" },
+    { url = "https://files.pythonhosted.org/packages/99/60/14115e6364fa676c5397c2ad3004e527e9aa487abf5d0706ec81bbd08529/numpy-2.4.6-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:90f9849678c75fe7afa2d348ac842c168b0a4d3d61919687216dfc547976d853", size = 16645538, upload-time = "2026-05-18T23:34:09.265Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/c5/693cbe59e57db94d2231fa519ca3978dc9e19da5a8f088588f5c6e947ff2/numpy-2.4.6-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:c1a2af6c6ef86344a6b0db6b97834208bf598db514f2b155042439b62605601a", size = 17020706, upload-time = "2026-05-18T23:34:13.053Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/fc/85b7c4eff9b4966ade25c2273cf7e7012e92366c032058653934b37de044/numpy-2.4.6-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e5805d5a22fd19c8ccff10a9561f9df94436b0545619ea579db2d3c35294bce2", size = 18368541, upload-time = "2026-05-18T23:34:17.024Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/81/e1b27545deedce7f4a0b348618c6b62d74e36a4dc9ccd42f3eb2f85eee32/numpy-2.4.6-cp312-cp312-win32.whl", hash = "sha256:e3eeb0aabd6bd5ce64faae67e9935203a6991b4bc2a485a767fbafb2c5125f45", size = 5962825, upload-time = "2026-05-18T23:34:20.3Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/ca/feab00bd44aa5fe1ad2c18f08b4d3bb92e26484b0b1d1443897809ed528c/numpy-2.4.6-cp312-cp312-win_amd64.whl", hash = "sha256:d8e8286dd7cea7895157318d1b91cdacac64c479f3cbc8dce548331728484751", size = 12321687, upload-time = "2026-05-18T23:34:23.095Z" },
+    { url = "https://files.pythonhosted.org/packages/63/cf/5a6d34850a39d1093558564f77ee8e8e0bee5061151b8f05a55711001ec7/numpy-2.4.6-cp312-cp312-win_arm64.whl", hash = "sha256:4081eb135ac24158bd51cdfbef16f1c64df7063b1143f24731387137c092bec8", size = 10221482, upload-time = "2026-05-18T23:34:25.876Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/82/bdab26d7438c6791ca31b7c024ca37c1eab8b726ba236129005cd4a06e45/numpy-2.4.6-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:511dbaf848decaaaf4b4ca48032619fb3138710c4bf7da7617765edad1ef96b0", size = 16684648, upload-time = "2026-05-18T23:34:29.41Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/30/a80189bcc7f5e4258b3fbc3968d909d1756f54d023299ecc39ad6fdb9ef8/numpy-2.4.6-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:bf162abab1c1a736333192707cef898e735a5ca00f38f27eeedf44b39d9e85eb", size = 14693902, upload-time = "2026-05-18T23:34:33.013Z" },
+    { url = "https://files.pythonhosted.org/packages/97/12/70b5d0d7c15e1ebb8a6a84a8caa1d19e181d84fb58bb6d70aca29099dec1/numpy-2.4.6-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:043191bfa8eab18c776647b62723ac9dddece59743b13f49b2016094129c2b3f", size = 5198992, upload-time = "2026-05-18T23:34:36.132Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/8c/ebd2a8f8a83541f8d38cc5667e8c2b69cecfd30da6e45693e8158857d44b/numpy-2.4.6-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:6180d8b35af935aed8ece3a85e0a43f87393ae0ac87c8d2c8bd2c993f7270ef3", size = 6546944, upload-time = "2026-05-18T23:34:38.484Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/c5/7b863a97a91671a0338f4253bd3b5a3d3852f0692dae91711c9f4a10e787/numpy-2.4.6-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:72fbe16c6fac95aedf5937fa873445cec2110be35d8a4e9433d7501fd98dae6b", size = 15669392, upload-time = "2026-05-18T23:34:41.257Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/9d/3584b9984ca4c047aea75214ce1a4c4c73d849bd71b604264b7f5653f8a8/numpy-2.4.6-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a7830bab239b79cda9c08c2da014761cafb48da6150e1da17ac06283f43b6089", size = 16633220, upload-time = "2026-05-18T23:34:45.075Z" },
+    { url = "https://files.pythonhosted.org/packages/05/ae/7c67fba23bd98caec7c99261f3a16072ade14813486b0282cb29846de832/numpy-2.4.6-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ef4aea96ce4d3b074422cb4f2f64e216bf9e213004bb58ecfdf50ea02ea8eb9a", size = 17020800, upload-time = "2026-05-18T23:34:49.065Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/5d/3b6725cb31d983c5e66916f5d36f6d7e5521129e4c4404d64f918292a5b6/numpy-2.4.6-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:dfa20cc6ca228e6b155b11da03825975ce66aea520985dbbddf0f2a5a495c605", size = 18357600, upload-time = "2026-05-18T23:34:52.709Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/da/2ccc6c2fe8898dee01d90c75c5f5f914a23daf99e3e0f59516a08760c8b5/numpy-2.4.6-cp313-cp313-win32.whl", hash = "sha256:56b39e5e0622a09a25bf5baf62f4bcf0cb8a41ae6e2819cf49bbc5a74c083f91", size = 5961134, upload-time = "2026-05-18T23:34:55.618Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/cd/9cc4dc876fb065d5c220aae4d5e14826b2715331bb7618ce1fb07a679d99/numpy-2.4.6-cp313-cp313-win_amd64.whl", hash = "sha256:c4fc99836233ea196540b17ab0983aff60ed07941751930f5f4d05bc3b3b7359", size = 12318598, upload-time = "2026-05-18T23:34:58.928Z" },
+    { url = "https://files.pythonhosted.org/packages/39/1e/c0bcba1f8694116485fe28fd1be698c278fcda4141c5b0e53a2aed8b12a8/numpy-2.4.6-cp313-cp313-win_arm64.whl", hash = "sha256:a7c711e21628b52034bb5ab8d1bce291f752fcc5e92accc615778acee1ff4778", size = 10222272, upload-time = "2026-05-18T23:35:02.167Z" },
+    { url = "https://files.pythonhosted.org/packages/63/6d/cc5619247c8f4204e507f5883528372e4ac4bb189e579fb859a12e480b1f/numpy-2.4.6-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:112b06a867b235ef466ed3508ddf0238050df9c727cafb5301ac385b899189a1", size = 14821197, upload-time = "2026-05-18T23:35:05.468Z" },
+    { url = "https://files.pythonhosted.org/packages/00/58/f1c39161c87d9e9bed660f1ed4bafc0e403d5ec9650b6dd77aead07d489b/numpy-2.4.6-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:eaf7fa2de5c0be8ae6ff8e9bea2ccd725e980541244521d8d4b5f3354a27babe", size = 5326287, upload-time = "2026-05-18T23:35:08.693Z" },
+    { url = "https://files.pythonhosted.org/packages/af/57/3917ab0fd97f271a8694513581b8a36c655f111c446852c302f04ccdb6fc/numpy-2.4.6-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:7265a2f3d436e54ef9f2b52b5c937e6be778781bd97a590319d7348f1c1ca997", size = 6646763, upload-time = "2026-05-18T23:35:11.459Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/0f/037e64c494b67581ae18193d770adef354c41f3f2c8ebf865602d949bf8f/numpy-2.4.6-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f74a575920ab21fe304421a3fc28793d82e299cae9eccb37084e9fc7f3617c20", size = 15728070, upload-time = "2026-05-18T23:35:14.79Z" },
+    { url = "https://files.pythonhosted.org/packages/21/a6/5d2bae9c9542eb4df16dc9c46dc79c186e9bad53805dfa5399a6023c6db0/numpy-2.4.6-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ede83e07a75dd06bc501566c1eca2afc0d61677c1472ac9ad93fdee6e638a48d", size = 16681752, upload-time = "2026-05-18T23:35:18.836Z" },
+    { url = "https://files.pythonhosted.org/packages/92/14/23d1dfb410ae362cd59ce53e936b1513d545eb40db3949ced632e19a459e/numpy-2.4.6-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:68bb27509ac1b9a3443094260f6326150663b06abe40b73a2f81160623da5b67", size = 17086024, upload-time = "2026-05-18T23:35:22.52Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/6e/23595a2c642cdf3bc567877064bdd7f91c8b0038a4453cf2daf7248eafe9/numpy-2.4.6-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:a0df0043bdb289bde1f62da130d20df23d58b45429f752bc7a8fc5325a225ecd", size = 18403398, upload-time = "2026-05-18T23:35:26.398Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/90/0ac3bc947217e66dec77e7cbc6a1979d1af70b6461b82f620d3bccd5e4c8/numpy-2.4.6-cp313-cp313t-win32.whl", hash = "sha256:29a287e0cf63ff528da061de6b9f64a4618da591ca1046aafc54062e40ca7eab", size = 6084971, upload-time = "2026-05-18T23:35:29.387Z" },
+    { url = "https://files.pythonhosted.org/packages/77/71/5673e351671a1d2bd6063b91b44f70c0affea7d1516fa7a6572941ba4aa1/numpy-2.4.6-cp313-cp313t-win_amd64.whl", hash = "sha256:25c692919ac5a01f170a3bfcd62d745b24fd095c353d50812637d6fcab442e75", size = 12458532, upload-time = "2026-05-18T23:35:32.175Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/88/19d3503c5046e688f049274b27a3ef3d771152fa80d3ba3d01a3dff61abe/numpy-2.4.6-cp313-cp313t-win_arm64.whl", hash = "sha256:1e978ec1e8bd0e0e4de6bb75de9d30cbb74db6b6a2bb727618613703ca0167dd", size = 10291881, upload-time = "2026-05-18T23:35:35.465Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/91/3ab2044d05fd16d343c5ac2e69b127f1b2854040dd20b193257c78028bd3/numpy-2.4.6-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:06ca2f61ec4385a07a6977c55ba998a4466c123642b4a32694d3128fce18c079", size = 16683458, upload-time = "2026-05-18T23:35:38.353Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/62/764ce66fa4147ae6d73071a3abf804ffe606f174618697c571acdf26a7c9/numpy-2.4.6-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:38efbc8de75c7a0fc1ac190162d892787f3f47b57cc291231aafee36b80982b7", size = 14704559, upload-time = "2026-05-18T23:35:42.14Z" },
+    { url = "https://files.pythonhosted.org/packages/60/61/23f27c172f022e04025b7dc2367f4d63c1a398120607ec896228649a6f48/numpy-2.4.6-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:d581b735e177fdcdce6fed8e7e8880a3fb6ee4e3653a3ac6af01c6f4c03effc5", size = 5209716, upload-time = "2026-05-18T23:35:45.377Z" },
+    { url = "https://files.pythonhosted.org/packages/03/71/21cf70dc6ea3e3acb95fc53a265b2fc248b981f0194ceb5b475271b8809d/numpy-2.4.6-cp314-cp314-macosx_14_0_x86_64.whl", hash = "sha256:0a041d3d761dc3c35cc56ce0351506a02bcbc25f7b169f652435141a17db9096", size = 6543947, upload-time = "2026-05-18T23:35:47.926Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/91/64288395ee1799bd2e0b04a305dce9666da90c961e1f3fe982a05ee1c036/numpy-2.4.6-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:40fdc1ae7125e518ea98e53e69a4ebc27e1fd50510c47b7ea130cf21e5e1d42b", size = 15685197, upload-time = "2026-05-18T23:35:50.863Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/eb/ebffaa97dc55502df69584a8f0dcf07f69a3e0b3e2323670a2722db9aa39/numpy-2.4.6-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a2c306dea656c12c68f51f4cea133cbe78ca7435eb28c735eac1d3ebe73be6e8", size = 16638245, upload-time = "2026-05-18T23:35:54.752Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/0b/54f9da33128d7e350fab89c7455902eeae70349ee52bddb448dc4a576f45/numpy-2.4.6-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:33111801a01c12a8a1e3721f0a9232f8cfc8ae2c6b7098167e6f623c6073f402", size = 17036587, upload-time = "2026-05-18T23:35:58.355Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/f0/fdebc1052db1cc37c64beb22072d67cd6d1c71adca1299f53dec2b5e20d3/numpy-2.4.6-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:ae506e6902902557576a26ff33eda8695e7ecb3cb36c3b573a0765dee114ebdb", size = 18363226, upload-time = "2026-05-18T23:36:02.845Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/b4/298628d98c72b57e57f7165ae6a481a1deaf6f3c28262a6e4c739c275930/numpy-2.4.6-cp314-cp314-win32.whl", hash = "sha256:aaf159caa35993cb1f56fb9b8e4610d35758e7ca005412eb1daa856a78c9c4b1", size = 6010196, upload-time = "2026-05-18T23:36:05.92Z" },
+    { url = "https://files.pythonhosted.org/packages/df/ac/46de6dda46478f7942f839e094970be2d4a861e005c4b3bf07c92e291a09/numpy-2.4.6-cp314-cp314-win_amd64.whl", hash = "sha256:b507f5c4c1d508876d1819b6bf9a49d365b96320b5d4993426b33a23ca4b8261", size = 12450334, upload-time = "2026-05-18T23:36:09.107Z" },
+    { url = "https://files.pythonhosted.org/packages/78/92/b8b798ac784102c0da830d2257d59358e3d3d90d1e2b3f2575dad976c5cf/numpy-2.4.6-cp314-cp314-win_arm64.whl", hash = "sha256:6f41ae150c4e32db4f3310cdaf64b1593a03dbabe29eec77fc9b50fe64061df6", size = 10495678, upload-time = "2026-05-18T23:36:12.766Z" },
+    { url = "https://files.pythonhosted.org/packages/30/34/ec28d1aa8115971537c01469ab2011ee96827930f0a124de1000cc2a7ed7/numpy-2.4.6-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:ece3d2cfe132e7d51f44a832b303895e6f2d499c5e74dfbdb06ee246147a304a", size = 14823672, upload-time = "2026-05-18T23:36:16.473Z" },
+    { url = "https://files.pythonhosted.org/packages/16/bd/f6d1fede4e54e8042a7ff97bb495510f3c220f94bcd9e8b228e87c92cc0d/numpy-2.4.6-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:e3e5193ef5a3dc73bceee50f7fdc2c90dbb76c42df8d8fae3d1067a583df579e", size = 5328731, upload-time = "2026-05-18T23:36:19.767Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/f0/e105b9e2fd728a9910103884decd6951d9dd73896b914a98d9a231de02ee/numpy-2.4.6-cp314-cp314t-macosx_14_0_x86_64.whl", hash = "sha256:17f9ade344e7d9b464a084d69bcf18fc691cb1db67c62ed80820bf4926d78f0e", size = 6649805, upload-time = "2026-05-18T23:36:22.266Z" },
+    { url = "https://files.pythonhosted.org/packages/82/dd/1206a7ca6ab15e3f02069707ca96222e202af681bb73756da7527f3cb837/numpy-2.4.6-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9cd5ffd25db4e7ba6a375693b3fc0fc1791ec636c17db3720da19bde7180ec43", size = 15730496, upload-time = "2026-05-18T23:36:25.713Z" },
+    { url = "https://files.pythonhosted.org/packages/51/e7/38d3ea825dcab85a591734decb2f6c67caa7c8367d374df1a1c3842f9b07/numpy-2.4.6-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7d92c3819208a60205a12a245c91ad70cb0a85336659b19b834205573ac8456e", size = 16679616, upload-time = "2026-05-18T23:36:29.652Z" },
+    { url = "https://files.pythonhosted.org/packages/93/b7/caabfdf53edf663e0b4eb74d7d405d83baef09eb5e83bcd32d601d72b93e/numpy-2.4.6-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e85b752a1e912b70eaad4fafbd4d1238007ab221de2009b9a2f5ae7461239895", size = 17085145, upload-time = "2026-05-18T23:36:33.449Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/45/68d7c33a6bcf3e5aa3bdbd57a367e6f615286dfd6482f97e8ffeb734306e/numpy-2.4.6-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:29cb7f67d10b479ff07c17d33e39f78c07f71c40ef30d63c153d340e96cd3fb4", size = 18403813, upload-time = "2026-05-18T23:36:37.369Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/50/0753655aa844c99cd9e018aacf76f130f1bd81d881bb74bc0aef5d73a8ba/numpy-2.4.6-cp314-cp314t-win32.whl", hash = "sha256:260a5d70215b61ab4fadf5c7baacd64821842975eea312125ed3c39a6391b063", size = 6156982, upload-time = "2026-05-18T23:36:40.817Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/d4/7c67becf668f973cb490cec3e98dfd799d866f9c989a54d355672cfa0db6/numpy-2.4.6-cp314-cp314t-win_amd64.whl", hash = "sha256:81a1cca95ed5bb92aa8b10dd2cdc9a0d3853a50fad926c28b5d7e8ea54389627", size = 12638908, upload-time = "2026-05-18T23:36:43.996Z" },
+    { url = "https://files.pythonhosted.org/packages/43/bb/e1c71a4295b1b1d1393d50dbb4f2a36283c6859d9d3892e84f00ec5a91d5/numpy-2.4.6-cp314-cp314t-win_arm64.whl", hash = "sha256:0c9136e14ed34a9e343a31c533d78a9813a69a3148332bce5e9821cb2f996e66", size = 10565867, upload-time = "2026-05-18T23:36:47.114Z" },
 ]
 
 [[package]]
-name = "nvidia-cublas-cu12"
-version = "12.8.4.1"
+name = "nvidia-cublas"
+version = "13.1.0.3"
 source = { registry = "https://pypi.org/simple" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/dc/61/e24b560ab2e2eaeb3c839129175fb330dfcfc29e5203196e5541a4c44682/nvidia_cublas_cu12-12.8.4.1-py3-none-manylinux_2_27_x86_64.whl", hash = "sha256:8ac4e771d5a348c551b2a426eda6193c19aa630236b418086020df5ba9667142", size = 594346921, upload-time = "2025-03-07T01:44:31.254Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/a5/fce49e2ae977e0ccc084e5adafceb4f0ac0c8333cb6863501618a7277f67/nvidia_cublas-13.1.0.3-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:c86fc7f7ae36d7528288c5d88098edcb7b02c633d262e7ddbb86b0ad91be5df2", size = 542851226, upload-time = "2025-10-09T08:59:04.818Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/44/423ac00af4dd95a5aeb27207e2c0d9b7118702149bf4704c3ddb55bb7429/nvidia_cublas-13.1.0.3-py3-none-manylinux_2_27_x86_64.whl", hash = "sha256:ee8722c1f0145ab246bccb9e452153b5e0515fd094c3678df50b2a0888b8b171", size = 423133236, upload-time = "2025-10-09T08:59:32.536Z" },
 ]
 
 [[package]]
-name = "nvidia-cuda-cupti-cu12"
-version = "12.8.90"
+name = "nvidia-cuda-cccl"
+version = "13.3.3.3.1"
 source = { registry = "https://pypi.org/simple" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/f8/02/2adcaa145158bf1a8295d83591d22e4103dbfd821bcaf6f3f53151ca4ffa/nvidia_cuda_cupti_cu12-12.8.90-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:ea0cb07ebda26bb9b29ba82cda34849e73c166c18162d3913575b0c9db9a6182", size = 10248621, upload-time = "2025-03-07T01:40:21.213Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/7a/9cb8a7fb87a85b11e8753548ae1422be847c5dddf3ca9ff5b080b309e271/nvidia_cuda_cccl-13.3.3.3.1-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:4dbc9dd84fbaeae267cbd80a9ed76d35171dba78639695dbdff0bae50e4503fa", size = 3453010, upload-time = "2026-05-26T16:27:45.179Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/fb/195d50d25ab68a76b817ffc68c45b1fb828598ce35a8e5c1736060628dab/nvidia_cuda_cccl-13.3.3.3.1-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:40ba1fa0b2c694ddc06cc791ed5c8bdad4638e2735b784960d68ac3086399c97", size = 3453013, upload-time = "2026-05-26T16:28:08.209Z" },
+    { url = "https://files.pythonhosted.org/packages/57/44/37cf1596880e7712f357b3f4991cd34d0f322c26e2bc814d1bdeffb2f420/nvidia_cuda_cccl-13.3.3.3.1-py3-none-win_amd64.whl", hash = "sha256:d1ac746f57ab83403f01e64e2b292101caf5b3445babca9f1c1c34f344766adf", size = 3452993, upload-time = "2026-05-26T16:58:59.166Z" },
 ]
 
 [[package]]
-name = "nvidia-cuda-nvrtc-cu12"
-version = "12.8.93"
+name = "nvidia-cuda-crt"
+version = "13.3.33"
 source = { registry = "https://pypi.org/simple" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/05/6b/32f747947df2da6994e999492ab306a903659555dddc0fbdeb9d71f75e52/nvidia_cuda_nvrtc_cu12-12.8.93-py3-none-manylinux2010_x86_64.manylinux_2_12_x86_64.whl", hash = "sha256:a7756528852ef889772a84c6cd89d41dfa74667e24cca16bb31f8f061e3e9994", size = 88040029, upload-time = "2025-03-07T01:42:13.562Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/32/5ea57f8cd6ad5df2173d175ac5db4e06edde40028b1b1f6c539ea4c10290/nvidia_cuda_crt-13.3.33-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:c8c257393f9c9146a85d3644f352be8154843d760031f756e673222c768a4930", size = 157348, upload-time = "2026-05-26T16:28:40.446Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/a7/998af901511d5efdc6e42fc597d32a69f34eecf86f1591a9d230ab3ab951/nvidia_cuda_crt-13.3.33-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:01ff37600c7b880a14cab4ade763b4c10c0ff92f25cc9dca30f0881ce52693c4", size = 157350, upload-time = "2026-05-26T16:29:22.315Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/5f/fc8ce6b7719c825e0e519d2922e3b7630238e860222ad3f972dd9b8b7fa9/nvidia_cuda_crt-13.3.33-py3-none-win_amd64.whl", hash = "sha256:7e89c6dbb807a47ee0628907488b158e57c36fa31af3756a8f826a9ec482715f", size = 158284, upload-time = "2026-05-26T16:59:37.309Z" },
 ]
 
 [[package]]
-name = "nvidia-cuda-runtime-cu12"
-version = "12.8.90"
+name = "nvidia-cuda-cupti"
+version = "13.0.85"
 source = { registry = "https://pypi.org/simple" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/0d/9b/a997b638fcd068ad6e4d53b8551a7d30fe8b404d6f1804abf1df69838932/nvidia_cuda_runtime_cu12-12.8.90-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:adade8dcbd0edf427b7204d480d6066d33902cab2a4707dcfc48a2d0fd44ab90", size = 954765, upload-time = "2025-03-07T01:40:01.615Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/2a/80353b103fc20ce05ef51e928daed4b6015db4aaa9162ed0997090fe2250/nvidia_cuda_cupti-13.0.85-py3-none-manylinux_2_25_aarch64.whl", hash = "sha256:796bd679890ee55fb14a94629b698b6db54bcfd833d391d5e94017dd9d7d3151", size = 10310827, upload-time = "2025-09-04T08:26:42.012Z" },
+    { url = "https://files.pythonhosted.org/packages/33/6d/737d164b4837a9bbd202f5ae3078975f0525a55730fe871d8ed4e3b952b0/nvidia_cuda_cupti-13.0.85-py3-none-manylinux_2_25_x86_64.whl", hash = "sha256:4eb01c08e859bf924d222250d2e8f8b8ff6d3db4721288cf35d14252a4d933c8", size = 10715597, upload-time = "2025-09-04T08:26:51.312Z" },
 ]
 
 [[package]]
-name = "nvidia-cudnn-cu12"
-version = "9.10.2.21"
+name = "nvidia-cuda-nvcc"
+version = "13.3.33"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "nvidia-cublas-cu12", marker = "(platform_machine != 'aarch64' and sys_platform == 'linux') or (sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'linux' and sys_platform != 'win32')" },
+    { name = "nvidia-cuda-crt" },
+    { name = "nvidia-cuda-runtime", version = "13.0.96", source = { registry = "https://pypi.org/simple" }, marker = "sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32'" },
+    { name = "nvidia-cuda-runtime", version = "13.3.29", source = { registry = "https://pypi.org/simple" }, marker = "sys_platform == 'darwin' or sys_platform == 'emscripten' or sys_platform == 'win32'" },
+    { name = "nvidia-nvvm" },
+]
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/be/b6/bb07a3a63b5b7b55516366747892abbf3ee62d616684c40bb51e6cbfe956/nvidia_cuda_nvcc-13.3.33-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:8c348623b1434aebd234da9ec1f81022587ae4995d65c3dc8a7743245cc441f7", size = 39515074, upload-time = "2026-05-26T16:34:28.489Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/af/e1b107f034f7c133255c162b922bbad3da5be20ebf76df17662ae4bd31f6/nvidia_cuda_nvcc-13.3.33-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:53b5f1be1731574368b8be931b77b6313492266c464aef3dd3f431569ce90deb", size = 44943276, upload-time = "2026-05-26T16:35:05.912Z" },
+    { url = "https://files.pythonhosted.org/packages/47/c2/831fa54020621a64d44cff47f1ed5eb0611794495fce01c857f6999d76b1/nvidia_cuda_nvcc-13.3.33-py3-none-win_amd64.whl", hash = "sha256:21c93aeef695a81b688137119f9120fe08a67292bf0ad730d94dc2b18bec23f0", size = 32723421, upload-time = "2026-05-26T17:01:47.511Z" },
+]
+
+[[package]]
+name = "nvidia-cuda-nvrtc"
+version = "13.0.88"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version >= '3.14' and platform_machine == 'aarch64' and sys_platform == 'linux'",
+    "(python_full_version >= '3.14' and platform_machine != 'aarch64' and sys_platform == 'linux') or (python_full_version >= '3.14' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'linux' and sys_platform != 'win32')",
+    "python_full_version == '3.13.*' and platform_machine == 'aarch64' and sys_platform == 'linux'",
+    "(python_full_version == '3.13.*' and platform_machine != 'aarch64' and sys_platform == 'linux') or (python_full_version == '3.13.*' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'linux' and sys_platform != 'win32')",
+    "python_full_version < '3.13' and platform_machine == 'aarch64' and sys_platform == 'linux'",
+    "(python_full_version < '3.13' and platform_machine != 'aarch64' and sys_platform == 'linux') or (python_full_version < '3.13' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'linux' and sys_platform != 'win32')",
 ]
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/ba/51/e123d997aa098c61d029f76663dedbfb9bc8dcf8c60cbd6adbe42f76d049/nvidia_cudnn_cu12-9.10.2.21-py3-none-manylinux_2_27_x86_64.whl", hash = "sha256:949452be657fa16687d0930933f032835951ef0892b37d2d53824d1a84dc97a8", size = 706758467, upload-time = "2025-06-06T21:54:08.597Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/68/483a78f5e8f31b08fb1bb671559968c0ca3a065ac7acabfc7cee55214fd6/nvidia_cuda_nvrtc-13.0.88-py3-none-manylinux2010_x86_64.manylinux_2_12_x86_64.whl", hash = "sha256:ad9b6d2ead2435f11cbb6868809d2adeeee302e9bb94bcf0539c7a40d80e8575", size = 90215200, upload-time = "2025-09-04T08:28:44.204Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/dc/6bb80850e0b7edd6588d560758f17e0550893a1feaf436807d64d2da040f/nvidia_cuda_nvrtc-13.0.88-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d27f20a0ca67a4bb34268a5e951033496c5b74870b868bacd046b1b8e0c3267b", size = 43015449, upload-time = "2025-09-04T08:28:20.239Z" },
+]
+
+[[package]]
+name = "nvidia-cuda-nvrtc"
+version = "13.3.33"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version >= '3.14' and sys_platform == 'win32'",
+    "python_full_version >= '3.14' and sys_platform == 'emscripten'",
+    "python_full_version >= '3.14' and sys_platform == 'darwin'",
+    "python_full_version == '3.13.*' and sys_platform == 'win32'",
+    "python_full_version < '3.13' and sys_platform == 'win32'",
+    "python_full_version == '3.13.*' and sys_platform == 'emscripten'",
+    "python_full_version < '3.13' and sys_platform == 'emscripten'",
+    "python_full_version == '3.13.*' and sys_platform == 'darwin'",
+    "python_full_version < '3.13' and sys_platform == 'darwin'",
+]
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a1/42/edce72f2c5a0f587168109c867f25f4a9a6cd7289ecf0d68ed2b1070f273/nvidia_cuda_nvrtc-13.3.33-py3-none-win_amd64.whl", hash = "sha256:7d2af818851c0c224d5f92221e9226e51ee23c236df4b51f9194563979c888be", size = 45319163, upload-time = "2026-05-26T17:02:49.217Z" },
+]
+
+[[package]]
+name = "nvidia-cuda-runtime"
+version = "13.0.96"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version >= '3.14' and platform_machine == 'aarch64' and sys_platform == 'linux'",
+    "(python_full_version >= '3.14' and platform_machine != 'aarch64' and sys_platform == 'linux') or (python_full_version >= '3.14' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'linux' and sys_platform != 'win32')",
+    "python_full_version == '3.13.*' and platform_machine == 'aarch64' and sys_platform == 'linux'",
+    "(python_full_version == '3.13.*' and platform_machine != 'aarch64' and sys_platform == 'linux') or (python_full_version == '3.13.*' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'linux' and sys_platform != 'win32')",
+    "python_full_version < '3.13' and platform_machine == 'aarch64' and sys_platform == 'linux'",
+    "(python_full_version < '3.13' and platform_machine != 'aarch64' and sys_platform == 'linux') or (python_full_version < '3.13' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'linux' and sys_platform != 'win32')",
+]
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/87/4f/17d7b9b8e285199c58ce28e31b5c5bbaa4d8271af06a89b6405258245de2/nvidia_cuda_runtime-13.0.96-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:ef9bcbe90493a2b9d810e43d249adb3d02e98dd30200d86607d8d02687c43f55", size = 2261060, upload-time = "2025-10-09T08:55:15.78Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/24/d1558f3b68b1d26e706813b1d10aa1d785e4698c425af8db8edc3dced472/nvidia_cuda_runtime-13.0.96-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:7f82250d7782aa23b6cfe765ecc7db554bd3c2870c43f3d1821f1d18aebf0548", size = 2243632, upload-time = "2025-10-09T08:55:36.117Z" },
+]
+
+[[package]]
+name = "nvidia-cuda-runtime"
+version = "13.3.29"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version >= '3.14' and sys_platform == 'win32'",
+    "python_full_version >= '3.14' and sys_platform == 'emscripten'",
+    "python_full_version >= '3.14' and sys_platform == 'darwin'",
+    "python_full_version == '3.13.*' and sys_platform == 'win32'",
+    "python_full_version < '3.13' and sys_platform == 'win32'",
+    "python_full_version == '3.13.*' and sys_platform == 'emscripten'",
+    "python_full_version < '3.13' and sys_platform == 'emscripten'",
+    "python_full_version == '3.13.*' and sys_platform == 'darwin'",
+    "python_full_version < '3.13' and sys_platform == 'darwin'",
+]
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d2/27/b53a5e0397842a5c11f0e1a39d4e5b2f22638a4126e83b3c4e196f62c969/nvidia_cuda_runtime-13.3.29-py3-none-win_amd64.whl", hash = "sha256:0667ec61c3d897388efa305ed4f7609ace88849a753ba9c6311d06dca55fff4f", size = 2630354, upload-time = "2026-05-26T17:00:05.389Z" },
+]
+
+[[package]]
+name = "nvidia-cudnn-cu13"
+version = "9.19.0.56"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "nvidia-cublas", marker = "sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32'" },
+]
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f1/84/26025437c1e6b61a707442184fa0c03d083b661adf3a3eecfd6d21677740/nvidia_cudnn_cu13-9.19.0.56-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:6ed29ffaee1176c612daf442e4dd6cfeb6a0caa43ddcbeb59da94953030b1be4", size = 433781201, upload-time = "2026-02-03T20:40:53.805Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/22/0b4b932655d17a6da1b92fa92ab12844b053bb2ac2475e179ba6f043da1e/nvidia_cudnn_cu13-9.19.0.56-py3-none-manylinux_2_27_x86_64.whl", hash = "sha256:d20e1734305e9d68889a96e3f35094d733ff1f83932ebe462753973e53a572bf", size = 366066321, upload-time = "2026-02-03T20:44:52.837Z" },
 ]
 
 [[package]]
 name = "nvidia-cudnn-frontend"
-version = "1.23.0"
+version = "1.18.0"
 source = { registry = "https://pypi.org/simple" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/e9/88/fbcfeb1826806a3f6e5ca6670700b4a7da758436ec2ce9b56f113cc15263/nvidia_cudnn_frontend-1.23.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:32b2ba9ef8e2c97536dd7fed3985f22e93c2c13d30a3d12543bd3c1ef8b25cdd", size = 2936016, upload-time = "2026-04-29T19:14:13.027Z" },
-    { url = "https://files.pythonhosted.org/packages/b2/78/35832dc0b32995a0418533749f9d01c0fcd0b55b89abdaeb30195ad27712/nvidia_cudnn_frontend-1.23.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:36c9bbaeae94e40157c6119cdd9eb52dbdfdb0cedb195984910ea32827029198", size = 3082860, upload-time = "2026-04-29T19:14:41.481Z" },
-    { url = "https://files.pythonhosted.org/packages/3a/9d/e3f68f9c03b51bb63ca8fd5796b48593e64e5ab24d8df2d85a8e32ec5369/nvidia_cudnn_frontend-1.23.0-cp312-cp312-win_amd64.whl", hash = "sha256:b864b498c1330979b54e6509c1d69a064cc47622661408837dc872cb6bb7ea1c", size = 2494915, upload-time = "2026-04-29T19:14:56.614Z" },
-    { url = "https://files.pythonhosted.org/packages/55/bc/eed9ae32a00a7c501f6ca3b93782fe50b3c9fd9168d500586b761f42f2bd/nvidia_cudnn_frontend-1.23.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:aa35283da087d65cdc1ea12a7872f90ed5a725e8ed0d8009b82d801bf92ad0ae", size = 2935910, upload-time = "2026-04-29T19:15:20.96Z" },
-    { url = "https://files.pythonhosted.org/packages/ad/14/4e0b66650d68f32d4c7b46e8b33cb98e69497f3fc1a9f63a02328a45d694/nvidia_cudnn_frontend-1.23.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a8b817a0deb94f394b082f1ca389829ec0c9c85411a1092f08719c66bbaa1e39", size = 3082233, upload-time = "2026-04-29T19:15:48.864Z" },
-    { url = "https://files.pythonhosted.org/packages/e3/c8/f5fad0e91e43df3a85e7c29b15bd11b587f27a096b7096abd3b3fbc8f761/nvidia_cudnn_frontend-1.23.0-cp313-cp313-win_amd64.whl", hash = "sha256:b78c70b40c389f9e844eae73f5686bb72b15763399aede5c3995d81e78c5547c", size = 2494849, upload-time = "2026-04-29T19:16:11.571Z" },
-    { url = "https://files.pythonhosted.org/packages/72/40/b7604cb8aac79405c03102570800c62689110d6df77c844a22eecefdf46d/nvidia_cudnn_frontend-1.23.0-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0a309e6a3ae3932943a50fa1e25f73f384fa9062c653ef79269741079b24c69f", size = 2937026, upload-time = "2026-04-29T19:16:31.103Z" },
-    { url = "https://files.pythonhosted.org/packages/db/46/89130d26afff6f95330bb271aeb6180c8fd2d1e1ef6ab22d115fa8e68ef3/nvidia_cudnn_frontend-1.23.0-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0aa008cc386089b9d11bed6ddc5e8b294679611da85ed33be3fb4bfe9a66d744", size = 3082954, upload-time = "2026-04-29T19:16:54.608Z" },
-    { url = "https://files.pythonhosted.org/packages/c2/b2/e7519d264a665a5940d5f34438d0000e75083a576915af21997223d78442/nvidia_cudnn_frontend-1.23.0-cp314-cp314-win_amd64.whl", hash = "sha256:873569d2eeaff62fc4279e7722f1ee071448f9c492c7c17f3a856c3cf1f7ae11", size = 2496340, upload-time = "2026-04-29T19:17:17.069Z" },
-    { url = "https://files.pythonhosted.org/packages/c6/45/8666a48f092ff7217a19ae14b6d354e747d3f963ac302e7eecda5438d955/nvidia_cudnn_frontend-1.23.0-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:40c6c13c0af42778779d667fbcc422c81be40a7eb2b97458d5147f2e7549c550", size = 2938384, upload-time = "2026-04-29T19:17:45.503Z" },
-    { url = "https://files.pythonhosted.org/packages/16/6d/b35239ec7ae0d3700bbcb1149cd2e08e1f5b0fb2867a79d6b505dc80d8c6/nvidia_cudnn_frontend-1.23.0-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fbfac68eb48af0b011f2410d22bd70c9a495174b4f6509358a04994a02a1465e", size = 3086506, upload-time = "2026-04-29T19:18:09.159Z" },
-    { url = "https://files.pythonhosted.org/packages/a1/55/6f34b3b453060c251d40f41ee44fe742170c9271305f23b0879d1604e0f8/nvidia_cudnn_frontend-1.23.0-cp314-cp314t-win_amd64.whl", hash = "sha256:c6990ab239367487c4f135f6aa9cea41d8114a7c6ac03927df3c240c7589d000", size = 2520867, upload-time = "2026-04-29T19:18:30.147Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/b4/604e230378680ee117849a4e1045baca092f93161a829291a84d5acce70c/nvidia_cudnn_frontend-1.18.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:310b417f2848a83d1437203fcaeea320a74fb7f28af20bf42bf5afc9c01f1c12", size = 2027408, upload-time = "2026-01-27T23:32:46.576Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/52/08f98262e77b1cbcc834cc1a5db494d0661ea1dbdea58c2e2d51a57fdaca/nvidia_cudnn_frontend-1.18.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6c023539ca6de99234cf5102c3ec0d6af817f5396fc93028a22ba5b834a35b8a", size = 2159245, upload-time = "2026-01-27T23:07:32.664Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/1f/751a5a8cfdc95fb4dc556192d37369ae488c30c473fe9a3ec720b23d07ea/nvidia_cudnn_frontend-1.18.0-cp312-cp312-win_amd64.whl", hash = "sha256:e13f7dd46cdb4762dde87f181f06d1c5e15e9478bbdd547bfa74d9b11f415aae", size = 1591041, upload-time = "2026-01-27T23:09:04.118Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/bd/db791a26ebb6a6e1268f518e18c82d8ad18546f7008f4b0d5bde15f927de/nvidia_cudnn_frontend-1.18.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5a6e2b7bd43705ffa4af3b187374fdd5e7d09fc228a4d65fc8b4b0a537a8e605", size = 2027249, upload-time = "2026-01-27T23:33:22.46Z" },
+    { url = "https://files.pythonhosted.org/packages/19/74/3038cf496d5de7cfdff730f5202e438c17d9123de507059340e02ddff9d7/nvidia_cudnn_frontend-1.18.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c0544206b02cae9da4f044ca3fe7416b99e0c8a8052285dd3e5a8fc445d34f9c", size = 2160001, upload-time = "2026-01-27T23:07:50.248Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/5e/148cc6609dba326e620e4d949246020dfba05ca07d0387442e62b71d19b6/nvidia_cudnn_frontend-1.18.0-cp313-cp313-win_amd64.whl", hash = "sha256:7eefa5f10cc003df5f3593f82f1ee6c001fc3412bdc78430c751914dfceefd7f", size = 1591270, upload-time = "2026-01-27T23:09:21.435Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/0a/515209dd2afc6027bf1112bf415f575bfe9628d18877abe7424cb597dd7b/nvidia_cudnn_frontend-1.18.0-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b489da1b30f1d7da822b37b89cc4f68afd80e020eb57e4ab24921f8b57f6e946", size = 2028689, upload-time = "2026-02-11T21:32:04.235Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/57/52d18e1f50979eeabfafb408ec73068afc5a1e1ccd21636240317cd456d4/nvidia_cudnn_frontend-1.18.0-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:37688c81a34ac590aff9de4c34d2968bab949411af707baa327616ebd4b34ae1", size = 2160182, upload-time = "2026-02-11T21:25:18.437Z" },
+    { url = "https://files.pythonhosted.org/packages/67/53/df2810b56d259ef96fa6beaa1381bd14c29fbe82836b409516e864c5e177/nvidia_cudnn_frontend-1.18.0-cp314-cp314-win_amd64.whl", hash = "sha256:5053b473fa74168b5fbf35934cd6187f88aa03b8447b9f2cd417332d5e5c9569", size = 1592759, upload-time = "2026-02-11T21:32:33.87Z" },
 ]
 
 [[package]]
-name = "nvidia-cufft-cu12"
-version = "11.3.3.83"
+name = "nvidia-cufft"
+version = "12.0.0.61"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "nvidia-nvjitlink-cu12", marker = "(platform_machine != 'aarch64' and sys_platform == 'linux') or (sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'linux' and sys_platform != 'win32')" },
+    { name = "nvidia-nvjitlink", marker = "sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32'" },
 ]
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/1f/13/ee4e00f30e676b66ae65b4f08cb5bcbb8392c03f54f2d5413ea99a5d1c80/nvidia_cufft_cu12-11.3.3.83-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:4d2dd21ec0b88cf61b62e6b43564355e5222e4a3fb394cac0db101f2dd0d4f74", size = 193118695, upload-time = "2025-03-07T01:45:27.821Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/ae/f417a75c0259e85c1d2f83ca4e960289a5f814ed0cea74d18c353d3e989d/nvidia_cufft-12.0.0.61-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:2708c852ef8cd89d1d2068bdbece0aa188813a0c934db3779b9b1faa8442e5f5", size = 214053554, upload-time = "2025-09-04T08:31:38.196Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/2f/7b57e29836ea8714f81e9898409196f47d772d5ddedddf1592eadb8ab743/nvidia_cufft-12.0.0.61-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:6c44f692dce8fd5ffd3e3df134b6cdb9c2f72d99cf40b62c32dde45eea9ddad3", size = 214085489, upload-time = "2025-09-04T08:31:56.044Z" },
 ]
 
 [[package]]
-name = "nvidia-cufile-cu12"
-version = "1.13.1.3"
+name = "nvidia-cufile"
+version = "1.15.1.6"
 source = { registry = "https://pypi.org/simple" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/bb/fe/1bcba1dfbfb8d01be8d93f07bfc502c93fa23afa6fd5ab3fc7c1df71038a/nvidia_cufile_cu12-1.13.1.3-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:1d069003be650e131b21c932ec3d8969c1715379251f8d23a1860554b1cb24fc", size = 1197834, upload-time = "2025-03-07T01:45:50.723Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/70/4f193de89a48b71714e74602ee14d04e4019ad36a5a9f20c425776e72cd6/nvidia_cufile-1.15.1.6-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:08a3ecefae5a01c7f5117351c64f17c7c62efa5fffdbe24fc7d298da19cd0b44", size = 1223672, upload-time = "2025-09-04T08:32:22.779Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/73/cc4a14c9813a8a0d509417cf5f4bdaba76e924d58beb9864f5a7baceefbf/nvidia_cufile-1.15.1.6-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:bdc0deedc61f548bddf7733bdc216456c2fdb101d020e1ab4b88d232d5e2f6d1", size = 1136992, upload-time = "2025-09-04T08:32:14.119Z" },
 ]
 
 [[package]]
-name = "nvidia-curand-cu12"
-version = "10.3.9.90"
+name = "nvidia-curand"
+version = "10.4.0.35"
 source = { registry = "https://pypi.org/simple" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/fb/aa/6584b56dc84ebe9cf93226a5cde4d99080c8e90ab40f0c27bda7a0f29aa1/nvidia_curand_cu12-10.3.9.90-py3-none-manylinux_2_27_x86_64.whl", hash = "sha256:b32331d4f4df5d6eefa0554c565b626c7216f87a06a4f56fab27c3b68a830ec9", size = 63619976, upload-time = "2025-03-07T01:46:23.323Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/72/7c2ae24fb6b63a32e6ae5d241cc65263ea18d08802aaae087d9f013335a2/nvidia_curand-10.4.0.35-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:133df5a7509c3e292aaa2b477afd0194f06ce4ea24d714d616ff36439cee349a", size = 61962106, upload-time = "2025-08-04T10:21:41.128Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/9f/be0a41ca4a4917abf5cb9ae0daff1a6060cc5de950aec0396de9f3b52bc5/nvidia_curand-10.4.0.35-py3-none-manylinux_2_27_x86_64.whl", hash = "sha256:1aee33a5da6e1db083fe2b90082def8915f30f3248d5896bcec36a579d941bfc", size = 59544258, upload-time = "2025-08-04T10:22:03.992Z" },
 ]
 
 [[package]]
-name = "nvidia-cusolver-cu12"
-version = "11.7.3.90"
+name = "nvidia-cusolver"
+version = "12.0.4.66"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "nvidia-cublas-cu12", marker = "(platform_machine != 'aarch64' and sys_platform == 'linux') or (sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'linux' and sys_platform != 'win32')" },
-    { name = "nvidia-cusparse-cu12", marker = "(platform_machine != 'aarch64' and sys_platform == 'linux') or (sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'linux' and sys_platform != 'win32')" },
-    { name = "nvidia-nvjitlink-cu12", marker = "(platform_machine != 'aarch64' and sys_platform == 'linux') or (sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'linux' and sys_platform != 'win32')" },
+    { name = "nvidia-cublas", marker = "sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32'" },
+    { name = "nvidia-cusparse", marker = "sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32'" },
+    { name = "nvidia-nvjitlink", marker = "sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32'" },
 ]
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/85/48/9a13d2975803e8cf2777d5ed57b87a0b6ca2cc795f9a4f59796a910bfb80/nvidia_cusolver_cu12-11.7.3.90-py3-none-manylinux_2_27_x86_64.whl", hash = "sha256:4376c11ad263152bd50ea295c05370360776f8c3427b30991df774f9fb26c450", size = 267506905, upload-time = "2025-03-07T01:47:16.273Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/c3/b30c9e935fc01e3da443ec0116ed1b2a009bb867f5324d3f2d7e533e776b/nvidia_cusolver-12.0.4.66-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:02c2457eaa9e39de20f880f4bd8820e6a1cfb9f9a34f820eb12a155aa5bc92d2", size = 223467760, upload-time = "2025-09-04T08:33:04.222Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/67/cba3777620cdacb99102da4042883709c41c709f4b6323c10781a9c3aa34/nvidia_cusolver-12.0.4.66-py3-none-manylinux_2_27_x86_64.whl", hash = "sha256:0a759da5dea5c0ea10fd307de75cdeb59e7ea4fcb8add0924859b944babf1112", size = 200941980, upload-time = "2025-09-04T08:33:22.767Z" },
 ]
 
 [[package]]
-name = "nvidia-cusparse-cu12"
-version = "12.5.8.93"
+name = "nvidia-cusparse"
+version = "12.6.3.3"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "nvidia-nvjitlink-cu12", marker = "(platform_machine != 'aarch64' and sys_platform == 'linux') or (sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'linux' and sys_platform != 'win32')" },
+    { name = "nvidia-nvjitlink", marker = "sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32'" },
 ]
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/c2/f5/e1854cb2f2bcd4280c44736c93550cc300ff4b8c95ebe370d0aa7d2b473d/nvidia_cusparse_cu12-12.5.8.93-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:1ec05d76bbbd8b61b06a80e1eaf8cf4959c3d4ce8e711b65ebd0443bb0ebb13b", size = 288216466, upload-time = "2025-03-07T01:48:13.779Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/94/5c26f33738ae35276672f12615a64bd008ed5be6d1ebcb23579285d960a9/nvidia_cusparse-12.6.3.3-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:80bcc4662f23f1054ee334a15c72b8940402975e0eab63178fc7e670aa59472c", size = 162155568, upload-time = "2025-09-04T08:33:42.864Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/18/623c77619c31d62efd55302939756966f3ecc8d724a14dab2b75f1508850/nvidia_cusparse-12.6.3.3-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:2b3c89c88d01ee0e477cb7f82ef60a11a4bcd57b6b87c33f789350b59759360b", size = 145942937, upload-time = "2025-09-04T08:33:58.029Z" },
 ]
 
 [[package]]
-name = "nvidia-cusparselt-cu12"
-version = "0.7.1"
+name = "nvidia-cusparselt-cu13"
+version = "0.8.0"
 source = { registry = "https://pypi.org/simple" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/56/79/12978b96bd44274fe38b5dde5cfb660b1d114f70a65ef962bcbbed99b549/nvidia_cusparselt_cu12-0.7.1-py3-none-manylinux2014_x86_64.whl", hash = "sha256:f1bb701d6b930d5a7cea44c19ceb973311500847f81b634d802b7b539dc55623", size = 287193691, upload-time = "2025-02-26T00:15:44.104Z" },
+    { url = "https://files.pythonhosted.org/packages/46/10/8dcd1175260706a2fc92a16a52e306b71d4c1ea0b0cc4a9484183399818a/nvidia_cusparselt_cu13-0.8.0-py3-none-manylinux2014_aarch64.whl", hash = "sha256:400c6ed1cf6780fc6efedd64ec9f1345871767e6a1a0a552a1ea0578117ea77c", size = 220791277, upload-time = "2025-08-13T19:22:40.982Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/53/43b0d71f4e702fa9733f8b4571fdca50a8813f1e450b656c239beff12315/nvidia_cusparselt_cu13-0.8.0-py3-none-manylinux2014_x86_64.whl", hash = "sha256:25e30a8a7323935d4ad0340b95a0b69926eee755767e8e0b1cf8dd85b197d3fd", size = 169884119, upload-time = "2025-08-13T19:23:41.967Z" },
 ]
 
 [[package]]
 name = "nvidia-cutlass-dsl"
-version = "4.5.0"
+version = "4.5.2"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "nvidia-cutlass-dsl-libs-base" },
 ]
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/71/a3/46fdf77d373b06bc65a0eda6c921c746985fb3e496c90a09be476291ea80/nvidia_cutlass_dsl-4.5.0-py3-none-any.whl", hash = "sha256:3b051fe02ca69422ab840e64d9865667aba288a3984a7ca4ccd038a82aef1344", size = 10178, upload-time = "2026-05-06T01:17:33.592Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/15/575d7df4fe2f3406f1cfc68be72aeff2834f8a696daf1cd5bee8017e4507/nvidia_cutlass_dsl-4.5.2-py3-none-any.whl", hash = "sha256:68ed1b63ca74aae87955012da9dfd7fdaae471329d0028b229b841c7192ccf52", size = 10179, upload-time = "2026-05-25T03:38:56.364Z" },
+]
+
+[package.optional-dependencies]
+cu13 = [
+    { name = "nvidia-cutlass-dsl-libs-cu13" },
 ]
 
 [[package]]
 name = "nvidia-cutlass-dsl-libs-base"
-version = "4.5.0"
+version = "4.5.2"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "cuda-python" },
-    { name = "numpy" },
+    { name = "numpy", version = "2.3.5", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.13'" },
+    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.13'" },
     { name = "typing-extensions" },
 ]
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/f8/d0/924048cfa43e1cb546735cb332b05a4fb92c63c1a1ac566f06445f9eca58/nvidia_cutlass_dsl_libs_base-4.5.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:3f7c133d31fa82ae7db697fd6943a5f9a2c97c8a40ee1056c67ef29fe00974d8", size = 75630723, upload-time = "2026-05-06T01:24:49.842Z" },
-    { url = "https://files.pythonhosted.org/packages/c3/8b/2c187400d85f7d2acb328f20499b7b05745dca8485cf6ad247d5f2b434cf/nvidia_cutlass_dsl_libs_base-4.5.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:bd18322d9247f8c033a10ed4e519c4985ca6b4fb578ade382e5a264422ebd915", size = 74505487, upload-time = "2026-05-06T01:26:52.755Z" },
-    { url = "https://files.pythonhosted.org/packages/ff/2c/21d5fc62e030a43c0f1a3dab6749fb632026a27d6a60f59975cd29a5d165/nvidia_cutlass_dsl_libs_base-4.5.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:90a4d802a03963fa36eb287fbc9b40a1374590fc7e8cc1b9673dee8872f75713", size = 75632646, upload-time = "2026-05-06T01:24:19.623Z" },
-    { url = "https://files.pythonhosted.org/packages/1c/79/0dca3b465711ffb4c44b4252940cc5f51d2d4905e405707e5c6c2a83d3d6/nvidia_cutlass_dsl_libs_base-4.5.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:8e58b016da5bb09bd1d809d0c025433edb36b279adfbcd107e96361b214bd8bc", size = 74505936, upload-time = "2026-05-06T01:25:52.728Z" },
-    { url = "https://files.pythonhosted.org/packages/59/85/2799e4de2fe7070cc4126ac501443d1cd7796b07ed880118e31956ae266a/nvidia_cutlass_dsl_libs_base-4.5.0-cp314-cp314-manylinux_2_28_aarch64.whl", hash = "sha256:2e121b20f0a48122c9b48227d00a7d681189e1de2fd4d211f9661a4e1658f066", size = 75634241, upload-time = "2026-05-06T01:22:48.964Z" },
-    { url = "https://files.pythonhosted.org/packages/04/c6/5aaa2dff6dfc615a83687df4462a91dad2ac1af85d6a9c91d9a6b9760a02/nvidia_cutlass_dsl_libs_base-4.5.0-cp314-cp314-manylinux_2_28_x86_64.whl", hash = "sha256:0a60dfce3349984315306ef719ed1edf0e225527158f26019a5cf266e06cc45d", size = 74504851, upload-time = "2026-05-06T01:23:48.613Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/ef/e827e3c67d72adbf4e8f680bdf03b1b67723d9e1ae7c3d0a1751f39f69ce/nvidia_cutlass_dsl_libs_base-4.5.2-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:d2a3c412287e356fbe48fe9f845d6d33cd35dea5e20d7e4f628c20957967cacd", size = 75643473, upload-time = "2026-05-25T03:49:15.857Z" },
+    { url = "https://files.pythonhosted.org/packages/97/68/c1247ab848f26c4ab56e562eea0e3f31fc14c9aaf0d883afaa92d8f05592/nvidia_cutlass_dsl_libs_base-4.5.2-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:15ef6a59193667e663934ef4873f8ccad37455e9b7c3c419c3072113b8aedf61", size = 74513226, upload-time = "2026-05-25T03:51:32.496Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/f8/b192015e273ff023a35741d6d5e4a93e4819160dee3955fc5d3d53534450/nvidia_cutlass_dsl_libs_base-4.5.2-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:395bd77cf642aeef311313453e6582f11c9357a4b81fe620ea3daccd1fccab9b", size = 75645002, upload-time = "2026-05-25T03:48:01.887Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/6e/bfe256ac08e5a6dfb11444809e54c76c3a2f05fff38dd173e2e71b95e4d2/nvidia_cutlass_dsl_libs_base-4.5.2-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:e59da7d89e5e4f8514c6530843f910f9d8734d8042dcaa079c9d9c5063eb3514", size = 74514312, upload-time = "2026-05-25T03:50:56.343Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/b2/7a5de500bb74915ab8b3875f4952ae07d562f33d06eef9b2569adf4c09ab/nvidia_cutlass_dsl_libs_base-4.5.2-cp314-cp314-manylinux_2_28_aarch64.whl", hash = "sha256:216eee6aa8107d35569f9451b66b03a3c53167841d1af9b630b966ef8d966e19", size = 75636795, upload-time = "2026-05-25T03:47:31.081Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/bc/5f9dd8c05c3e2f435228224f0b0e76e324c1bf0a6dcd3cfb917b5e94bad7/nvidia_cutlass_dsl_libs_base-4.5.2-cp314-cp314-manylinux_2_28_x86_64.whl", hash = "sha256:12c29f7c1f1f82851092ba3869264dafafb035228c0d9827a8db08b884fb80ca", size = 74511193, upload-time = "2026-05-25T03:52:39.444Z" },
+    { url = "https://files.pythonhosted.org/packages/61/7c/76a9d1ce5ade3f43ab6f10e361a9c1962d02177deeaf46f2c3684a7ae959/nvidia_cutlass_dsl_libs_base-4.5.2-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:5aca392063ffbc7da30442a267928b22d4a2d37f9ea1db32e4487aa31b0fcc33", size = 75644393, upload-time = "2026-05-25T03:47:02.706Z" },
+    { url = "https://files.pythonhosted.org/packages/15/84/08d695d2e0fa95891a2e5abd978f359d50125e4d1f056e54697d465fccc3/nvidia_cutlass_dsl_libs_base-4.5.2-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:abab8a0d2f3f5661533c366df78f973052b86a3b52b868d997a95dce5aa8f17b", size = 74514399, upload-time = "2026-05-25T03:50:20.841Z" },
+]
+
+[[package]]
+name = "nvidia-cutlass-dsl-libs-cu13"
+version = "4.5.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "cuda-python" },
+    { name = "numpy", version = "2.3.5", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.13'" },
+    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.13'" },
+    { name = "nvidia-cutlass-dsl-libs-base" },
+    { name = "typing-extensions" },
+]
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/21/e5/aeb570713a7bd6c2cb08102c2ebe6de234ef1bbc276d1af4643266cd71a8/nvidia_cutlass_dsl_libs_cu13-4.5.2-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:3032405dff28892340f96b467e744a822079cae454dce534fc17b77e85190e42", size = 79084280, upload-time = "2026-05-25T03:40:57.547Z" },
+    { url = "https://files.pythonhosted.org/packages/03/60/443e559139da15ab544761ac14f4206dffb981af48cc9856cd5b5b7cf0e7/nvidia_cutlass_dsl_libs_cu13-4.5.2-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:80f0cd402e0f1d1571e5aed33bfa17dbc9cb90cc5b1352f0f806b4788558e80e", size = 78759198, upload-time = "2026-05-25T03:45:59.297Z" },
+    { url = "https://files.pythonhosted.org/packages/98/57/bc7248c02c3e4ee2ed03e194ceda9861a46fa23f0da5140bd8060a086b1e/nvidia_cutlass_dsl_libs_cu13-4.5.2-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:64e994554af4da59f75754b9df1a2b1bdfdb96b58c2457802da13d586fb58cde", size = 79086223, upload-time = "2026-05-25T03:41:27.363Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/9f/b7928ff505e577c1021c07b206ce32d285aae793763d524023c1800b6dc9/nvidia_cutlass_dsl_libs_cu13-4.5.2-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:c7a5ce1c01616fc4c3ac492e011c543a79c3dde86aaf20a8af55e9d40ef2b2e6", size = 78759546, upload-time = "2026-05-25T03:45:25.834Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/65/a8e16a9647acef4f43ea2e046cd7eeb3e5779e89089c3939a5d25fe47f57/nvidia_cutlass_dsl_libs_cu13-4.5.2-cp314-cp314-manylinux_2_28_aarch64.whl", hash = "sha256:aabd41c980083db94950a4010c2c1ca156d4ab56701605739a3fba388ac9736b", size = 79087704, upload-time = "2026-05-25T03:41:57.202Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/83/d335575e1d37f6c436b1e3203ded6f352678937b9f30b900b643f9df0f9d/nvidia_cutlass_dsl_libs_cu13-4.5.2-cp314-cp314-manylinux_2_28_x86_64.whl", hash = "sha256:888edad4fe1e9b683fddcbc6969437527ccd0eb8740e60dce8f29f6a3a22c825", size = 78758331, upload-time = "2026-05-25T03:43:08.093Z" },
+    { url = "https://files.pythonhosted.org/packages/89/7c/2bf50f2649f06a97a935919f71d2d0e40d7648364319b834548ed664d6d3/nvidia_cutlass_dsl_libs_cu13-4.5.2-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:c4d3ea9080c5a92f8f4a69451ef7036f43bfc3d7f8a426dd70258f0e237c05fb", size = 79092929, upload-time = "2026-05-25T03:39:51.239Z" },
+    { url = "https://files.pythonhosted.org/packages/36/80/8ced4c7e1ead8d1e3ac6c823db9e387dbcfd41232e11655d5bc94e950c75/nvidia_cutlass_dsl_libs_cu13-4.5.2-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:1d255f4a308eb0d228d2466a415a8489b8337db1d322f5d8428e60139b41a317", size = 78765148, upload-time = "2026-05-25T03:44:52.411Z" },
 ]
 
 [[package]]
@@ -4215,35 +4587,49 @@ wheels = [
 ]
 
 [[package]]
-name = "nvidia-nccl-cu12"
-version = "2.27.5"
+name = "nvidia-nccl-cu13"
+version = "2.28.9"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/39/55/1920646a2e43ffd4fc958536b276197ed740e9e0c54105b4bb3521591fc7/nvidia_nccl_cu13-2.28.9-py3-none-manylinux_2_18_aarch64.whl", hash = "sha256:01c873ba1626b54caa12272ed228dc5b2781545e0ae8ba3f432a8ef1c6d78643", size = 196561677, upload-time = "2025-11-18T05:49:03.45Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/b4/878fefaad5b2bcc6fcf8d474a25e3e3774bc5133e4b58adff4d0bca238bc/nvidia_nccl_cu13-2.28.9-py3-none-manylinux_2_18_x86_64.whl", hash = "sha256:e4553a30f34195f3fa1da02a6da3d6337d28f2003943aa0a3d247bbc25fefc42", size = 196493177, upload-time = "2025-11-18T05:49:17.677Z" },
+]
+
+[[package]]
+name = "nvidia-nvjitlink"
+version = "13.0.88"
 source = { registry = "https://pypi.org/simple" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/6e/89/f7a07dc961b60645dbbf42e80f2bc85ade7feb9a491b11a1e973aa00071f/nvidia_nccl_cu12-2.27.5-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:ad730cf15cb5d25fe849c6e6ca9eb5b76db16a80f13f425ac68d8e2e55624457", size = 322348229, upload-time = "2025-06-26T04:11:28.385Z" },
+    { url = "https://files.pythonhosted.org/packages/56/7a/123e033aaff487c77107195fa5a2b8686795ca537935a24efae476c41f05/nvidia_nvjitlink-13.0.88-py3-none-manylinux2010_x86_64.manylinux_2_12_x86_64.whl", hash = "sha256:13a74f429e23b921c1109976abefacc69835f2f433ebd323d3946e11d804e47b", size = 40713933, upload-time = "2025-09-04T08:35:43.553Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/2c/93c5250e64df4f894f1cbb397c6fd71f79813f9fd79d7cd61de3f97b3c2d/nvidia_nvjitlink-13.0.88-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:e931536ccc7d467a98ba1d8b89ff7fa7f1fa3b13f2b0069118cd7f47bff07d0c", size = 38768748, upload-time = "2025-09-04T08:35:20.008Z" },
 ]
 
 [[package]]
-name = "nvidia-nvjitlink-cu12"
-version = "12.8.93"
+name = "nvidia-nvshmem-cu13"
+version = "3.4.5"
 source = { registry = "https://pypi.org/simple" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/f6/74/86a07f1d0f42998ca31312f998bd3b9a7eff7f52378f4f270c8679c77fb9/nvidia_nvjitlink_cu12-12.8.93-py3-none-manylinux2010_x86_64.manylinux_2_12_x86_64.whl", hash = "sha256:81ff63371a7ebd6e6451970684f916be2eab07321b73c9d244dc2b4da7f73b88", size = 39254836, upload-time = "2025-03-07T01:49:55.661Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/0f/05cc9c720236dcd2db9c1ab97fff629e96821be2e63103569da0c9b72f19/nvidia_nvshmem_cu13-3.4.5-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:6dc2a197f38e5d0376ad52cd1a2a3617d3cdc150fd5966f4aee9bcebb1d68fe9", size = 60215947, upload-time = "2025-09-06T00:32:20.022Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/35/a9bf80a609e74e3b000fef598933235c908fcefcef9026042b8e6dfde2a9/nvidia_nvshmem_cu13-3.4.5-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:290f0a2ee94c9f3687a02502f3b9299a9f9fe826e6d0287ee18482e78d495b80", size = 60412546, upload-time = "2025-09-06T00:32:41.564Z" },
 ]
 
 [[package]]
-name = "nvidia-nvshmem-cu12"
-version = "3.3.20"
+name = "nvidia-nvtx"
+version = "13.0.85"
 source = { registry = "https://pypi.org/simple" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/3b/6c/99acb2f9eb85c29fc6f3a7ac4dccfd992e22666dd08a642b303311326a97/nvidia_nvshmem_cu12-3.3.20-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d00f26d3f9b2e3c3065be895e3059d6479ea5c638a3f38c9fec49b1b9dd7c1e5", size = 124657145, upload-time = "2025-08-04T20:25:19.995Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/f3/d86c845465a2723ad7e1e5c36dcd75ddb82898b3f53be47ebd429fb2fa5d/nvidia_nvtx-13.0.85-py3-none-manylinux1_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:4936d1d6780fbe68db454f5e72a42ff64d1fd6397df9f363ae786930fd5c1cd4", size = 148047, upload-time = "2025-09-04T08:29:01.761Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/64/3708a90d1ebe202ffdeb7185f878a3c84d15c2b2c31858da2ce0583e2def/nvidia_nvtx-13.0.85-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:cb7780edb6b14107373c835bf8b72e7a178bac7367e23da7acb108f973f157a6", size = 148878, upload-time = "2025-09-04T08:28:53.627Z" },
 ]
 
 [[package]]
-name = "nvidia-nvtx-cu12"
-version = "12.8.90"
+name = "nvidia-nvvm"
+version = "13.3.33"
 source = { registry = "https://pypi.org/simple" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/a2/eb/86626c1bbc2edb86323022371c39aa48df6fd8b0a1647bc274577f72e90b/nvidia_nvtx_cu12-12.8.90-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:5b17e2001cc0d751a5bc2c6ec6d26ad95913324a4adb86788c944f8ce9ba441f", size = 89954, upload-time = "2025-03-07T01:42:44.131Z" },
+    { url = "https://files.pythonhosted.org/packages/01/8a/f767031dcd0d24c2bbab4b696dbcf004da4f3284e5e4649fc47bc0e2bb78/nvidia_nvvm-13.3.33-py3-none-manylinux2010_x86_64.manylinux_2_12_x86_64.whl", hash = "sha256:aafaf73246b6126bc88f521e5dab1d196395ee87739d9f5b7c39c9fee0ead9c7", size = 69250604, upload-time = "2026-05-26T16:57:56.875Z" },
+    { url = "https://files.pythonhosted.org/packages/83/36/ce0d42d3a4465c858c379932f0080d29d22f04383ab79119c7c4f4cdd5ef/nvidia_nvvm-13.3.33-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:fd74a1c5ef284ba04c1ba75f886404dff953c54731a3a9c7b45e9aedaf1a226b", size = 66984524, upload-time = "2026-05-26T16:57:30.778Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/96/4de7a37803d168337ab36f81ecbc496c7c21c9b06ec68ce0ecc381af88d4/nvidia_nvvm-13.3.33-py3-none-win_amd64.whl", hash = "sha256:b1c63cf8972d8a1ff153c5ac4cc7038fe6ef705aa38415f12007b0e5e4c31b79", size = 60175824, upload-time = "2026-05-26T17:13:27.588Z" },
 ]
 
 [[package]]
@@ -4261,7 +4647,8 @@ version = "1.24.4"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "flatbuffers" },
-    { name = "numpy" },
+    { name = "numpy", version = "2.3.5", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.13'" },
+    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.13'" },
     { name = "packaging" },
     { name = "protobuf" },
     { name = "sympy" },
@@ -4332,19 +4719,21 @@ wheels = [
 
 [[package]]
 name = "opencv-python-headless"
-version = "4.11.0.86"
+version = "4.13.0.92"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "numpy" },
+    { name = "numpy", version = "2.3.5", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.13'" },
+    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.13'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/36/2f/5b2b3ba52c864848885ba988f24b7f105052f68da9ab0e693cc7c25b0b30/opencv-python-headless-4.11.0.86.tar.gz", hash = "sha256:996eb282ca4b43ec6a3972414de0e2331f5d9cda2b41091a49739c19fb843798", size = 95177929, upload-time = "2025-01-16T13:53:40.22Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/dc/53/2c50afa0b1e05ecdb4603818e85f7d174e683d874ef63a6abe3ac92220c8/opencv_python_headless-4.11.0.86-cp37-abi3-macosx_13_0_arm64.whl", hash = "sha256:48128188ade4a7e517237c8e1e11a9cdf5c282761473383e77beb875bb1e61ca", size = 37326460, upload-time = "2025-01-16T13:52:57.015Z" },
-    { url = "https://files.pythonhosted.org/packages/3b/43/68555327df94bb9b59a1fd645f63fafb0762515344d2046698762fc19d58/opencv_python_headless-4.11.0.86-cp37-abi3-macosx_13_0_x86_64.whl", hash = "sha256:a66c1b286a9de872c343ee7c3553b084244299714ebb50fbdcd76f07ebbe6c81", size = 56723330, upload-time = "2025-01-16T13:55:45.731Z" },
-    { url = "https://files.pythonhosted.org/packages/45/be/1438ce43ebe65317344a87e4b150865c5585f4c0db880a34cdae5ac46881/opencv_python_headless-4.11.0.86-cp37-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6efabcaa9df731f29e5ea9051776715b1bdd1845d7c9530065c7951d2a2899eb", size = 29487060, upload-time = "2025-01-16T13:51:59.625Z" },
-    { url = "https://files.pythonhosted.org/packages/dd/5c/c139a7876099916879609372bfa513b7f1257f7f1a908b0bdc1c2328241b/opencv_python_headless-4.11.0.86-cp37-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0e0a27c19dd1f40ddff94976cfe43066fbbe9dfbb2ec1907d66c19caef42a57b", size = 49969856, upload-time = "2025-01-16T13:53:29.654Z" },
-    { url = "https://files.pythonhosted.org/packages/95/dd/ed1191c9dc91abcc9f752b499b7928aacabf10567bb2c2535944d848af18/opencv_python_headless-4.11.0.86-cp37-abi3-win32.whl", hash = "sha256:f447d8acbb0b6f2808da71fddd29c1cdd448d2bc98f72d9bb78a7a898fc9621b", size = 29324425, upload-time = "2025-01-16T13:52:49.048Z" },
-    { url = "https://files.pythonhosted.org/packages/86/8a/69176a64335aed183529207ba8bc3d329c2999d852b4f3818027203f50e6/opencv_python_headless-4.11.0.86-cp37-abi3-win_amd64.whl", hash = "sha256:6c304df9caa7a6a5710b91709dd4786bf20a74d57672b3c31f7033cc638174ca", size = 39402386, upload-time = "2025-01-16T13:52:56.418Z" },
+    { url = "https://files.pythonhosted.org/packages/79/42/2310883be3b8826ac58c3f2787b9358a2d46923d61f88fedf930bc59c60c/opencv_python_headless-4.13.0.92-cp37-abi3-macosx_13_0_arm64.whl", hash = "sha256:1a7d040ac656c11b8c38677cc8cccdc149f98535089dbe5b081e80a4e5903209", size = 46247192, upload-time = "2026-02-05T07:01:35.187Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/1e/6f9e38005a6f7f22af785df42a43139d0e20f169eb5787ce8be37ee7fcc9/opencv_python_headless-4.13.0.92-cp37-abi3-macosx_14_0_x86_64.whl", hash = "sha256:3e0a6f0a37994ec6ce5f59e936be21d5d6384a4556f2d2da9c2f9c5dc948394c", size = 32568914, upload-time = "2026-02-05T07:01:51.989Z" },
+    { url = "https://files.pythonhosted.org/packages/21/76/9417a6aef9def70e467a5bf560579f816148a4c658b7d525581b356eda9e/opencv_python_headless-4.13.0.92-cp37-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:5c8cfc8e87ed452b5cecb9419473ee5560a989859fe1d10d1ce11ae87b09a2cb", size = 33703709, upload-time = "2026-02-05T10:24:46.469Z" },
+    { url = "https://files.pythonhosted.org/packages/92/ce/bd17ff5772938267fd49716e94ca24f616ff4cb1ff4c6be13085108037be/opencv_python_headless-4.13.0.92-cp37-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:0525a3d2c0b46c611e2130b5fdebc94cf404845d8fa64d2f3a3b679572a5bd22", size = 56016764, upload-time = "2026-02-05T10:26:48.904Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/b4/b7bcbf7c874665825a8c8e1097e93ea25d1f1d210a3e20d4451d01da30aa/opencv_python_headless-4.13.0.92-cp37-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:eb60e36b237b1ebd40a912da5384b348df8ed534f6f644d8e0b4f103e272ba7d", size = 35010236, upload-time = "2026-02-05T10:28:11.031Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/33/b5db29a6c00eb8f50708110d8d453747ca125c8b805bc437b289dbdcc057/opencv_python_headless-4.13.0.92-cp37-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:0bd48544f77c68b2941392fcdf9bcd2b9cdf00e98cb8c29b2455d194763cf99e", size = 60391106, upload-time = "2026-02-05T10:30:14.236Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/c3/52cfea47cd33e53e8c0fbd6e7c800b457245c1fda7d61660b4ffe9596a7f/opencv_python_headless-4.13.0.92-cp37-abi3-win32.whl", hash = "sha256:a7cf08e5b191f4ebb530791acc0825a7986e0d0dee2a3c491184bd8599848a4b", size = 30812232, upload-time = "2026-02-05T07:02:29.594Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/90/b338326131ccb2aaa3c2c85d00f41822c0050139a4bfe723cfd95455bd2d/opencv_python_headless-4.13.0.92-cp37-abi3-win_amd64.whl", hash = "sha256:77a82fe35ddcec0f62c15f2ba8a12ecc2ed4207c17b0902c7a3151ae29f37fb6", size = 40070414, upload-time = "2026-02-05T07:02:26.448Z" },
 ]
 
 [[package]]
@@ -4431,6 +4820,19 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/5f/bf/93795954016c522008da367da292adceed71cca6ee1717e1d64c83089099/opentelemetry_api-1.40.0-py3-none-any.whl", hash = "sha256:82dd69331ae74b06f6a874704be0cfaa49a1650e1537d4a813b86ecef7d0ecf9", size = 68676, upload-time = "2026-03-04T14:17:01.24Z" },
 ]
 
+[[package]]
+name = "opentelemetry-exporter-otlp"
+version = "1.40.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-exporter-otlp-proto-grpc" },
+    { name = "opentelemetry-exporter-otlp-proto-http" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/d0/37/b6708e0eff5c5fb9aba2e0ea09f7f3bcbfd12a592d2a780241b5f6014df7/opentelemetry_exporter_otlp-1.40.0.tar.gz", hash = "sha256:7caa0870b95e2fcb59d64e16e2b639ecffb07771b6cd0000b5d12e5e4fef765a", size = 6152, upload-time = "2026-03-04T14:17:23.235Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2d/fc/aea77c28d9f3ffef2fdafdc3f4a235aee4091d262ddabd25882f47ce5c5f/opentelemetry_exporter_otlp-1.40.0-py3-none-any.whl", hash = "sha256:48c87e539ec9afb30dc443775a1334cc5487de2f72a770a4c00b1610bf6c697d", size = 7023, upload-time = "2026-03-04T14:17:03.612Z" },
+]
+
 [[package]]
 name = "opentelemetry-exporter-otlp-proto-common"
 version = "1.40.0"
@@ -4533,6 +4935,19 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/b2/37/cc6a55e448deaa9b27377d087da8615a3416d8ad523d5960b78dbeadd02a/opentelemetry_semantic_conventions-0.61b0-py3-none-any.whl", hash = "sha256:fa530a96be229795f8cef353739b618148b0fe2b4b3f005e60e262926c4d38e2", size = 231621, upload-time = "2026-03-04T14:17:19.33Z" },
 ]
 
+[[package]]
+name = "opentelemetry-semantic-conventions-ai"
+version = "0.5.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-sdk" },
+    { name = "opentelemetry-semantic-conventions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/24/02/10aeacc37a38a3a8fa16ff67bec1ae3bf882539f6f9efb0f70acf802ca2d/opentelemetry_semantic_conventions_ai-0.5.1.tar.gz", hash = "sha256:153906200d8c1d2f8e09bd78dbef526916023de85ac3dab35912bfafb69ff04c", size = 26533, upload-time = "2026-03-26T14:20:38.73Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/55/22/41fb05f1dc5fda2c468e05a41814c20859016c85117b66c8a257cae814f6/opentelemetry_semantic_conventions_ai-0.5.1-py3-none-any.whl", hash = "sha256:25aeb22bd261543b4898a73824026d96770e5351209c7d07a0b1314762b1f6e4", size = 11250, upload-time = "2026-03-26T14:20:37.108Z" },
+]
+
 [[package]]
 name = "orjson"
 version = "3.11.7"
@@ -4588,26 +5003,34 @@ wheels = [
 
 [[package]]
 name = "outlines-core"
-version = "0.2.11"
+version = "0.2.14"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/1a/d3/e04e9145f8f806723dec9b9e5227ad695a3efcd3ced7794cf7c22b15df5e/outlines_core-0.2.11.tar.gz", hash = "sha256:dfce56f717ff5083e54cbcfdb66cad243365437fccbb5509adaa7e31e030f1d8", size = 197263, upload-time = "2025-05-19T10:12:51.719Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/5f/2c/c7636823244c70e2960060bf9bd978248dffb55c5e7c91c46d18354b2a24/outlines_core-0.2.11-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:4a9db4872bae083631d720994f4cee603bce0536b33d5a988814576863b657cf", size = 1957668, upload-time = "2025-05-19T10:12:18.29Z" },
-    { url = "https://files.pythonhosted.org/packages/c7/09/5c62047da139d722317a444a4d01cd5f11943a8c2eaecce784341dd0844a/outlines_core-0.2.11-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:8359a45c59f6a8f2eb717245806501a59044c75f6ea8bd08faaa131cc8cdec45", size = 2130493, upload-time = "2025-05-19T10:12:19.537Z" },
-    { url = "https://files.pythonhosted.org/packages/89/7a/d6a2810f90e37d550168e0c0a9a915086ea721444727e3ca2c630898d1ef/outlines_core-0.2.11-cp312-cp312-macosx_15_0_arm64.whl", hash = "sha256:5d26a46591377340e0b870b8a96ea8341058341a62ee0bded9098e0c88dd24f4", size = 1956804, upload-time = "2025-05-19T10:12:20.755Z" },
-    { url = "https://files.pythonhosted.org/packages/ca/ea/339e6c273b5581128c3b7ca27d428d8993c3085912af1a467aa32ef0e9d1/outlines_core-0.2.11-cp312-cp312-macosx_15_0_x86_64.whl", hash = "sha256:ae460a34675fb11d92a5c605a480fbae4cd6c1b2d11b3698da64a7fcaba64dcf", size = 2127085, upload-time = "2025-05-19T10:12:22.02Z" },
-    { url = "https://files.pythonhosted.org/packages/92/c7/a65d1fddf49830ebc41422294eacde35286d9f68994a8aa905cb14f5aade/outlines_core-0.2.11-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:86df9740368866295077346440d911df4972da2b3f1f54b8125e6f329e8a8891", size = 2287677, upload-time = "2025-05-19T10:12:24.24Z" },
-    { url = "https://files.pythonhosted.org/packages/23/79/8795aed8be9b77dd69d78e7cfbfcf28c179e6b08da6e56bbbf48a09fe55f/outlines_core-0.2.11-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:96ce4dd78f106799be4a0a5795cefd1352806162973756a4b6fce4bb6eddd7e4", size = 2113000, upload-time = "2025-05-19T10:12:25.446Z" },
-    { url = "https://files.pythonhosted.org/packages/59/e3/cbe9294b06d92ee1892dbb6f2125d833d68e8629d45d080d6daba54eec2d/outlines_core-0.2.11-cp312-cp312-win32.whl", hash = "sha256:358db161cce3650ba822e118dcf0a1efa571c7deb4864ab9d64ca2c9cca7425d", size = 1765703, upload-time = "2025-05-19T10:12:26.693Z" },
-    { url = "https://files.pythonhosted.org/packages/1d/c9/ed3cf362515fac16e313368b9b2f2497051f4ded88679205830b6f889f54/outlines_core-0.2.11-cp312-cp312-win_amd64.whl", hash = "sha256:231f9d20d2630c70665345821780d7808b29539620a75c99f65113b518c51032", size = 2060945, upload-time = "2025-05-19T10:12:28.294Z" },
-    { url = "https://files.pythonhosted.org/packages/11/58/df6f57546f7792c990a4380ceaf99243a0b26b24c199e34e0a9277c89976/outlines_core-0.2.11-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:0907ff25d79edbf8650268028de85a1b41b38696f147059e007da4626a1031f1", size = 1957172, upload-time = "2025-05-19T10:12:29.737Z" },
-    { url = "https://files.pythonhosted.org/packages/9b/cf/b07e33c44544e7865ec481554788807dfa6ad10fd86191ad21f2200f145e/outlines_core-0.2.11-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:f4146da5957f97550eebd19e80635e48035886fd10f03e9735cc111caaf74e93", size = 2130284, upload-time = "2025-05-19T10:12:31.408Z" },
-    { url = "https://files.pythonhosted.org/packages/83/70/8f981706e2620914c48fd1edb42f9409d76b84c72149d48e89d14820fab6/outlines_core-0.2.11-cp313-cp313-macosx_15_0_arm64.whl", hash = "sha256:8776a6db8843187c90e4c54bf94510cda68ca7a11c9b48d90587179fd3224bc2", size = 1956727, upload-time = "2025-05-19T10:12:32.996Z" },
-    { url = "https://files.pythonhosted.org/packages/89/de/fba234a9c3984408f017ee0b1ca2e9d6191f8086afa649d3e4b04ed055e2/outlines_core-0.2.11-cp313-cp313-macosx_15_0_x86_64.whl", hash = "sha256:d44f38a89028bed50494420b47d08ebefa78f34b129e2ea6383c801e5ba62c26", size = 2126905, upload-time = "2025-05-19T10:12:34.261Z" },
-    { url = "https://files.pythonhosted.org/packages/87/96/7dcdc5198844145ab35528f9f93a58c3d47b87e54d0f79357c631d7b7a9a/outlines_core-0.2.11-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:daef6eaaf8c3403455ab5cbf265cb5c6838df571eb7c4b23cddac19cfc701726", size = 2287320, upload-time = "2025-05-19T10:12:35.515Z" },
-    { url = "https://files.pythonhosted.org/packages/4d/68/b420b6a3beaadbf8e9f2a82132120027efd6424634013fbeca8c2fed7467/outlines_core-0.2.11-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:76b2512417c68863f8f227a080e87f755682dfd895e23b021121318be11da579", size = 2112861, upload-time = "2025-05-19T10:12:36.742Z" },
-    { url = "https://files.pythonhosted.org/packages/78/d6/7c2a016f7a5eab2f3df2b3a258f270872c78fe0dd7d9fbee87429f1b6b1f/outlines_core-0.2.11-cp313-cp313-win32.whl", hash = "sha256:707eeb3d190485f55a27ad9a6ad70df86688fa2bf405894a118283be7f59bd55", size = 1765574, upload-time = "2025-05-19T10:12:37.98Z" },
-    { url = "https://files.pythonhosted.org/packages/a5/39/4c07f1d1f8e6ed85db9fe73a021113795a05aae8a84f36f0bdebb08bfde8/outlines_core-0.2.11-cp313-cp313-win_amd64.whl", hash = "sha256:ad46698564c9b13cbfbc744067de12be73bd740d7b2de20ec6b979ad7511f7c9", size = 2060567, upload-time = "2025-05-19T10:12:39.228Z" },
+sdist = { url = "https://files.pythonhosted.org/packages/6a/04/4a0812eb27c086cfd2e66e7ec9150f33e105912a9b7f8b335e3479f03a06/outlines_core-0.2.14.tar.gz", hash = "sha256:64808deed1591ca3029ff64346ceb974cd5d780c916ea82504951fe83523039e", size = 191539, upload-time = "2026-01-09T15:59:10.016Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/66/93/30b9188648a479b32be429a24166db47a7bfdb0f9a8aac4c6dcf569e0a52/outlines_core-0.2.14-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:95e6476d9702d2fcc4e85370dbbfb6933a46c816e9c90107f6ce36eb68b5d64a", size = 2049651, upload-time = "2026-01-09T15:58:28.549Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/06/f3557daa8e87d5b95f64de269a301d73ec3c2202ab897c3e1f1cb93eb1db/outlines_core-0.2.14-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:f04731a5e29a190e2cc9f692a1f3fb2414a645355ca7d01b83df43439c38bea8", size = 2201046, upload-time = "2026-01-09T15:58:29.958Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/67/d8acf778990964c951080d568284e858d466f27dfd6f2674781927faba1c/outlines_core-0.2.14-cp312-cp312-macosx_15_0_arm64.whl", hash = "sha256:0e4c69f0a8565edb56464c4c9b6c291a10805f3a96dff84182980e90ae1a5e2f", size = 2049558, upload-time = "2026-01-09T15:58:31.003Z" },
+    { url = "https://files.pythonhosted.org/packages/17/e1/0320b14b49b8379ced1ab195ecf5875dbd2267b90148847541f43bfde6c1/outlines_core-0.2.14-cp312-cp312-macosx_15_0_x86_64.whl", hash = "sha256:63f53cfd9614e754499ae86dd699f3abcecf42d6a4e58d80fd80347881d85960", size = 2197854, upload-time = "2026-01-09T15:58:32.39Z" },
+    { url = "https://files.pythonhosted.org/packages/29/29/3a04944407207a5d214879ca5ca33c2bd3e65199a4e927051c1bdaaa4d50/outlines_core-0.2.14-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3bb2060c240c4507f334965a8948dbeeb22007560d797f6debd92346c0b620cb", size = 2341426, upload-time = "2026-01-09T15:58:33.553Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/a7/a77f746272504bac3f628047d56ea1731b61549a3e1d9bbfd226f2968246/outlines_core-0.2.14-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:1de34681c7e0e7e1551fc9036e4fa3c57986336c905a10536591ceb6d869c258", size = 2236941, upload-time = "2026-01-09T15:58:35.118Z" },
+    { url = "https://files.pythonhosted.org/packages/99/0d/9f599d938923ab8ceeff26fdf2f9ea53bea3c962085c4927a08338a32349/outlines_core-0.2.14-cp312-cp312-win32.whl", hash = "sha256:870e8e038853818cb202ccc8cde92251f300f96805bfcc3be1c883adda7b5297", size = 1842940, upload-time = "2026-01-09T15:58:36.544Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/df/0f145c52ebd156d80273e2f5278227ea57e0275b2aa863bed33f44f77923/outlines_core-0.2.14-cp312-cp312-win_amd64.whl", hash = "sha256:87b42440478764cce1353a87d8560ef82f3b39b9d753bfe93195ea3584f369e3", size = 2137266, upload-time = "2026-01-09T15:58:37.831Z" },
+    { url = "https://files.pythonhosted.org/packages/13/9d/e6c81c975c123f0639d5f6909c987e510d43e07c2e1e6495b21639c4dec6/outlines_core-0.2.14-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:8b3e8d668188282a1f7666732bb8a01958ab134db35bb792e7442a40e55ff1e7", size = 2049297, upload-time = "2026-01-09T15:58:39.184Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/d1/5ce55ef724aed0915edc877b6dd610d39b3169e4341154bb53daa022065a/outlines_core-0.2.14-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:66e695b375b180725fb534d9adf298531c152ec3d881e3b9e01c82b5dd269f52", size = 2200944, upload-time = "2026-01-09T15:58:40.257Z" },
+    { url = "https://files.pythonhosted.org/packages/32/e3/60ad781251eedcf1496317ecd58eb2e4488717ba63b10494ab49dfd05e5d/outlines_core-0.2.14-cp313-cp313-macosx_15_0_arm64.whl", hash = "sha256:6bd166d3b07acef2f60d4ede44592a26d3f7d8712876bfc8e22150045def5857", size = 2049607, upload-time = "2026-01-09T15:58:41.635Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/2d/662d6a76face5b4b3481f888900d00856c37aa2927341a023866457da212/outlines_core-0.2.14-cp313-cp313-macosx_15_0_x86_64.whl", hash = "sha256:9d45462d7548aa0e17176a691ae73447f3e6bed9658a0cd96fe72eadf7474475", size = 2197755, upload-time = "2026-01-09T15:58:42.861Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/9a/4b62903de006d991b58674ff033c1b6fb92be5767360376fc961f6771bdb/outlines_core-0.2.14-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6453e23f01d98ec48e3a4141d7112792ce77001dfb28d91d6fd89f47009f91ef", size = 2341051, upload-time = "2026-01-09T15:58:44.415Z" },
+    { url = "https://files.pythonhosted.org/packages/50/36/1532f7d9ab16c676812d94528e89964aa0d15f12adcb285e6ed86f86f2fe/outlines_core-0.2.14-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:7deef6df74cb247f2a3a62f03438ba967456504b0555ec7029f8db834e054448", size = 2236778, upload-time = "2026-01-09T15:58:45.437Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/5a/dfd94f15f4c04e691e7fdf30cf8b9b22bf2cbc426b3ef270af3e200596d5/outlines_core-0.2.14-cp313-cp313-win32.whl", hash = "sha256:bb008c7ecc034bcfda0ddc10a4d1f2181a4b61ec1643ee56183dd6fa64139c9d", size = 1842727, upload-time = "2026-01-09T15:58:46.723Z" },
+    { url = "https://files.pythonhosted.org/packages/34/35/e24ab5d2116812464380587435297d8ece2f0218c2ba8afc9f541e3a6911/outlines_core-0.2.14-cp313-cp313-win_amd64.whl", hash = "sha256:eb27e92204b296a063ac58f361153be4e78c8103a96e0b1c085b22d4fc3534cf", size = 2137108, upload-time = "2026-01-09T15:58:47.784Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/28/22fe8ee3bdf9cf13ab88a9d9b96729d9966c791c25227d0b7ca45c8d118f/outlines_core-0.2.14-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:69410e5b55bcbaad8c865d94bd01e7bff8a57996dcd2251b7d50dec70d7d9a63", size = 2050470, upload-time = "2026-01-09T15:58:49.217Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/3e/30ce0b13e4c4c82de606c8bbf60775ac6fca1978efa54cd553893795fd0b/outlines_core-0.2.14-cp314-cp314-macosx_14_0_x86_64.whl", hash = "sha256:adf96395759d7fdf6efeb8a67d3f36f520c1546bfd4df0752306db8c7cb7d6c5", size = 2202138, upload-time = "2026-01-09T15:58:50.281Z" },
+    { url = "https://files.pythonhosted.org/packages/53/13/bd2ff9e90b28fa0dcc345c9196731ed9126e366733c8ccbc559149e34893/outlines_core-0.2.14-cp314-cp314-macosx_15_0_arm64.whl", hash = "sha256:b02bb0fc21c5e23e2ff9b2d1459db2c1c3e813a7646c9d5db091c6931edb9c85", size = 2050325, upload-time = "2026-01-09T15:58:51.596Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/25/fc0ae7d04345d17267d4dd5c693ed9e86c7f44419cc04ad92348472781be/outlines_core-0.2.14-cp314-cp314-macosx_15_0_x86_64.whl", hash = "sha256:e75395b1cccecdf85d8d8265aba28841ddeb1e8da406f4b1e0135df5a6e9960f", size = 2199081, upload-time = "2026-01-09T15:58:53.17Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/63/dfa000239e46f17b47e6dc9bec3aab8a8136fe400312f1916320e02c8f38/outlines_core-0.2.14-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d1776ae984574461f249fe590314a439992eb9b883f4091b8fa7fc56f29f3717", size = 2343210, upload-time = "2026-01-09T15:58:54.282Z" },
+    { url = "https://files.pythonhosted.org/packages/36/4f/0e63da06c6054f154ef22b5ef3c6b9030cb22da9c03d2d2dd82836a1e795/outlines_core-0.2.14-cp314-cp314-manylinux_2_28_aarch64.whl", hash = "sha256:7eba2b41dac03d6e6e8d5ea0aecbbc03dacb4c57de3b1fc944d0bafb022941f7", size = 2238206, upload-time = "2026-01-09T15:58:55.705Z" },
+    { url = "https://files.pythonhosted.org/packages/74/4e/382271ab5ffe768055f11dddb50e82a0c46487f3766bf08a06cfcd35388b/outlines_core-0.2.14-cp314-cp314-win32.whl", hash = "sha256:0cd8ce3ce61df44fd9c5450d9744e2280586c2a6e6e3dfefa0dab1944764b424", size = 1845364, upload-time = "2026-01-09T15:58:56.795Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/11/13adf2d02c681b599c1eb550b0dbd763d1b818a106a13bd693019bdb5637/outlines_core-0.2.14-cp314-cp314-win_amd64.whl", hash = "sha256:3e67fc23b1a3ac9562488fb50f409c171538b76f64aa5f7e25d9b0bf14770204", size = 2139979, upload-time = "2026-01-09T15:58:57.984Z" },
 ]
 
 [[package]]
@@ -4651,7 +5074,8 @@ name = "pandas"
 version = "2.3.3"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "numpy" },
+    { name = "numpy", version = "2.3.5", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.13'" },
+    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.13'" },
     { name = "python-dateutil" },
     { name = "pytz" },
     { name = "tzdata" },
@@ -4770,80 +5194,80 @@ wheels = [
 
 [[package]]
 name = "pillow"
-version = "12.1.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/1f/42/5c74462b4fd957fcd7b13b04fb3205ff8349236ea74c7c375766d6c82288/pillow-12.1.1.tar.gz", hash = "sha256:9ad8fa5937ab05218e2b6a4cff30295ad35afd2f83ac592e68c0d871bb0fdbc4", size = 46980264, upload-time = "2026-02-11T04:23:07.146Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/07/d3/8df65da0d4df36b094351dce696f2989bec731d4f10e743b1c5f4da4d3bf/pillow-12.1.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:ab323b787d6e18b3d91a72fc99b1a2c28651e4358749842b8f8dfacd28ef2052", size = 5262803, upload-time = "2026-02-11T04:20:47.653Z" },
-    { url = "https://files.pythonhosted.org/packages/d6/71/5026395b290ff404b836e636f51d7297e6c83beceaa87c592718747e670f/pillow-12.1.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:adebb5bee0f0af4909c30db0d890c773d1a92ffe83da908e2e9e720f8edf3984", size = 4657601, upload-time = "2026-02-11T04:20:49.328Z" },
-    { url = "https://files.pythonhosted.org/packages/b1/2e/1001613d941c67442f745aff0f7cc66dd8df9a9c084eb497e6a543ee6f7e/pillow-12.1.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:bb66b7cc26f50977108790e2456b7921e773f23db5630261102233eb355a3b79", size = 6234995, upload-time = "2026-02-11T04:20:51.032Z" },
-    { url = "https://files.pythonhosted.org/packages/07/26/246ab11455b2549b9233dbd44d358d033a2f780fa9007b61a913c5b2d24e/pillow-12.1.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:aee2810642b2898bb187ced9b349e95d2a7272930796e022efaf12e99dccd293", size = 8045012, upload-time = "2026-02-11T04:20:52.882Z" },
-    { url = "https://files.pythonhosted.org/packages/b2/8b/07587069c27be7535ac1fe33874e32de118fbd34e2a73b7f83436a88368c/pillow-12.1.1-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a0b1cd6232e2b618adcc54d9882e4e662a089d5768cd188f7c245b4c8c44a397", size = 6349638, upload-time = "2026-02-11T04:20:54.444Z" },
-    { url = "https://files.pythonhosted.org/packages/ff/79/6df7b2ee763d619cda2fb4fea498e5f79d984dae304d45a8999b80d6cf5c/pillow-12.1.1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7aac39bcf8d4770d089588a2e1dd111cbaa42df5a94be3114222057d68336bd0", size = 7041540, upload-time = "2026-02-11T04:20:55.97Z" },
-    { url = "https://files.pythonhosted.org/packages/2c/5e/2ba19e7e7236d7529f4d873bdaf317a318896bac289abebd4bb00ef247f0/pillow-12.1.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:ab174cd7d29a62dd139c44bf74b698039328f45cb03b4596c43473a46656b2f3", size = 6462613, upload-time = "2026-02-11T04:20:57.542Z" },
-    { url = "https://files.pythonhosted.org/packages/03/03/31216ec124bb5c3dacd74ce8efff4cc7f52643653bad4825f8f08c697743/pillow-12.1.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:339ffdcb7cbeaa08221cd401d517d4b1fe7a9ed5d400e4a8039719238620ca35", size = 7166745, upload-time = "2026-02-11T04:20:59.196Z" },
-    { url = "https://files.pythonhosted.org/packages/1f/e7/7c4552d80052337eb28653b617eafdef39adfb137c49dd7e831b8dc13bc5/pillow-12.1.1-cp312-cp312-win32.whl", hash = "sha256:5d1f9575a12bed9e9eedd9a4972834b08c97a352bd17955ccdebfeca5913fa0a", size = 6328823, upload-time = "2026-02-11T04:21:01.385Z" },
-    { url = "https://files.pythonhosted.org/packages/3d/17/688626d192d7261bbbf98846fc98995726bddc2c945344b65bec3a29d731/pillow-12.1.1-cp312-cp312-win_amd64.whl", hash = "sha256:21329ec8c96c6e979cd0dfd29406c40c1d52521a90544463057d2aaa937d66a6", size = 7033367, upload-time = "2026-02-11T04:21:03.536Z" },
-    { url = "https://files.pythonhosted.org/packages/ed/fe/a0ef1f73f939b0eca03ee2c108d0043a87468664770612602c63266a43c4/pillow-12.1.1-cp312-cp312-win_arm64.whl", hash = "sha256:af9a332e572978f0218686636610555ae3defd1633597be015ed50289a03c523", size = 2453811, upload-time = "2026-02-11T04:21:05.116Z" },
-    { url = "https://files.pythonhosted.org/packages/d5/11/6db24d4bd7685583caeae54b7009584e38da3c3d4488ed4cd25b439de486/pillow-12.1.1-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:d242e8ac078781f1de88bf823d70c1a9b3c7950a44cdf4b7c012e22ccbcd8e4e", size = 4062689, upload-time = "2026-02-11T04:21:06.804Z" },
-    { url = "https://files.pythonhosted.org/packages/33/c0/ce6d3b1fe190f0021203e0d9b5b99e57843e345f15f9ef22fcd43842fd21/pillow-12.1.1-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:02f84dfad02693676692746df05b89cf25597560db2857363a208e393429f5e9", size = 4138535, upload-time = "2026-02-11T04:21:08.452Z" },
-    { url = "https://files.pythonhosted.org/packages/a0/c6/d5eb6a4fb32a3f9c21a8c7613ec706534ea1cf9f4b3663e99f0d83f6fca8/pillow-12.1.1-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:e65498daf4b583091ccbb2556c7000abf0f3349fcd57ef7adc9a84a394ed29f6", size = 3601364, upload-time = "2026-02-11T04:21:10.194Z" },
-    { url = "https://files.pythonhosted.org/packages/14/a1/16c4b823838ba4c9c52c0e6bbda903a3fe5a1bdbf1b8eb4fff7156f3e318/pillow-12.1.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:6c6db3b84c87d48d0088943bf33440e0c42370b99b1c2a7989216f7b42eede60", size = 5262561, upload-time = "2026-02-11T04:21:11.742Z" },
-    { url = "https://files.pythonhosted.org/packages/bb/ad/ad9dc98ff24f485008aa5cdedaf1a219876f6f6c42a4626c08bc4e80b120/pillow-12.1.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:8b7e5304e34942bf62e15184219a7b5ad4ff7f3bb5cca4d984f37df1a0e1aee2", size = 4657460, upload-time = "2026-02-11T04:21:13.786Z" },
-    { url = "https://files.pythonhosted.org/packages/9e/1b/f1a4ea9a895b5732152789326202a82464d5254759fbacae4deea3069334/pillow-12.1.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:18e5bddd742a44b7e6b1e773ab5db102bd7a94c32555ba656e76d319d19c3850", size = 6232698, upload-time = "2026-02-11T04:21:15.949Z" },
-    { url = "https://files.pythonhosted.org/packages/95/f4/86f51b8745070daf21fd2e5b1fe0eb35d4db9ca26e6d58366562fb56a743/pillow-12.1.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:fc44ef1f3de4f45b50ccf9136999d71abb99dca7706bc75d222ed350b9fd2289", size = 8041706, upload-time = "2026-02-11T04:21:17.723Z" },
-    { url = "https://files.pythonhosted.org/packages/29/9b/d6ecd956bb1266dd1045e995cce9b8d77759e740953a1c9aad9502a0461e/pillow-12.1.1-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5a8eb7ed8d4198bccbd07058416eeec51686b498e784eda166395a23eb99138e", size = 6346621, upload-time = "2026-02-11T04:21:19.547Z" },
-    { url = "https://files.pythonhosted.org/packages/71/24/538bff45bde96535d7d998c6fed1a751c75ac7c53c37c90dc2601b243893/pillow-12.1.1-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:47b94983da0c642de92ced1702c5b6c292a84bd3a8e1d1702ff923f183594717", size = 7038069, upload-time = "2026-02-11T04:21:21.378Z" },
-    { url = "https://files.pythonhosted.org/packages/94/0e/58cb1a6bc48f746bc4cb3adb8cabff73e2742c92b3bf7a220b7cf69b9177/pillow-12.1.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:518a48c2aab7ce596d3bf79d0e275661b846e86e4d0e7dec34712c30fe07f02a", size = 6460040, upload-time = "2026-02-11T04:21:23.148Z" },
-    { url = "https://files.pythonhosted.org/packages/6c/57/9045cb3ff11eeb6c1adce3b2d60d7d299d7b273a2e6c8381a524abfdc474/pillow-12.1.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:a550ae29b95c6dc13cf69e2c9dc5747f814c54eeb2e32d683e5e93af56caa029", size = 7164523, upload-time = "2026-02-11T04:21:25.01Z" },
-    { url = "https://files.pythonhosted.org/packages/73/f2/9be9cb99f2175f0d4dbadd6616ce1bf068ee54a28277ea1bf1fbf729c250/pillow-12.1.1-cp313-cp313-win32.whl", hash = "sha256:a003d7422449f6d1e3a34e3dd4110c22148336918ddbfc6a32581cd54b2e0b2b", size = 6332552, upload-time = "2026-02-11T04:21:27.238Z" },
-    { url = "https://files.pythonhosted.org/packages/3f/eb/b0834ad8b583d7d9d42b80becff092082a1c3c156bb582590fcc973f1c7c/pillow-12.1.1-cp313-cp313-win_amd64.whl", hash = "sha256:344cf1e3dab3be4b1fa08e449323d98a2a3f819ad20f4b22e77a0ede31f0faa1", size = 7040108, upload-time = "2026-02-11T04:21:29.462Z" },
-    { url = "https://files.pythonhosted.org/packages/d5/7d/fc09634e2aabdd0feabaff4a32f4a7d97789223e7c2042fd805ea4b4d2c2/pillow-12.1.1-cp313-cp313-win_arm64.whl", hash = "sha256:5c0dd1636633e7e6a0afe7bf6a51a14992b7f8e60de5789018ebbdfae55b040a", size = 2453712, upload-time = "2026-02-11T04:21:31.072Z" },
-    { url = "https://files.pythonhosted.org/packages/19/2a/b9d62794fc8a0dd14c1943df68347badbd5511103e0d04c035ffe5cf2255/pillow-12.1.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:0330d233c1a0ead844fc097a7d16c0abff4c12e856c0b325f231820fee1f39da", size = 5264880, upload-time = "2026-02-11T04:21:32.865Z" },
-    { url = "https://files.pythonhosted.org/packages/26/9d/e03d857d1347fa5ed9247e123fcd2a97b6220e15e9cb73ca0a8d91702c6e/pillow-12.1.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:5dae5f21afb91322f2ff791895ddd8889e5e947ff59f71b46041c8ce6db790bc", size = 4660616, upload-time = "2026-02-11T04:21:34.97Z" },
-    { url = "https://files.pythonhosted.org/packages/f7/ec/8a6d22afd02570d30954e043f09c32772bfe143ba9285e2fdb11284952cd/pillow-12.1.1-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:2e0c664be47252947d870ac0d327fea7e63985a08794758aa8af5b6cb6ec0c9c", size = 6269008, upload-time = "2026-02-11T04:21:36.623Z" },
-    { url = "https://files.pythonhosted.org/packages/3d/1d/6d875422c9f28a4a361f495a5f68d9de4a66941dc2c619103ca335fa6446/pillow-12.1.1-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:691ab2ac363b8217f7d31b3497108fb1f50faab2f75dfb03284ec2f217e87bf8", size = 8073226, upload-time = "2026-02-11T04:21:38.585Z" },
-    { url = "https://files.pythonhosted.org/packages/a1/cd/134b0b6ee5eda6dc09e25e24b40fdafe11a520bc725c1d0bbaa5e00bf95b/pillow-12.1.1-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e9e8064fb1cc019296958595f6db671fba95209e3ceb0c4734c9baf97de04b20", size = 6380136, upload-time = "2026-02-11T04:21:40.562Z" },
-    { url = "https://files.pythonhosted.org/packages/7a/a9/7628f013f18f001c1b98d8fffe3452f306a70dc6aba7d931019e0492f45e/pillow-12.1.1-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:472a8d7ded663e6162dafdf20015c486a7009483ca671cece7a9279b512fcb13", size = 7067129, upload-time = "2026-02-11T04:21:42.521Z" },
-    { url = "https://files.pythonhosted.org/packages/1e/f8/66ab30a2193b277785601e82ee2d49f68ea575d9637e5e234faaa98efa4c/pillow-12.1.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:89b54027a766529136a06cfebeecb3a04900397a3590fd252160b888479517bf", size = 6491807, upload-time = "2026-02-11T04:21:44.22Z" },
-    { url = "https://files.pythonhosted.org/packages/da/0b/a877a6627dc8318fdb84e357c5e1a758c0941ab1ddffdafd231983788579/pillow-12.1.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:86172b0831b82ce4f7877f280055892b31179e1576aa00d0df3bb1bbf8c3e524", size = 7190954, upload-time = "2026-02-11T04:21:46.114Z" },
-    { url = "https://files.pythonhosted.org/packages/83/43/6f732ff85743cf746b1361b91665d9f5155e1483817f693f8d57ea93147f/pillow-12.1.1-cp313-cp313t-win32.whl", hash = "sha256:44ce27545b6efcf0fdbdceb31c9a5bdea9333e664cda58a7e674bb74608b3986", size = 6336441, upload-time = "2026-02-11T04:21:48.22Z" },
-    { url = "https://files.pythonhosted.org/packages/3b/44/e865ef3986611bb75bfabdf94a590016ea327833f434558801122979cd0e/pillow-12.1.1-cp313-cp313t-win_amd64.whl", hash = "sha256:a285e3eb7a5a45a2ff504e31f4a8d1b12ef62e84e5411c6804a42197c1cf586c", size = 7045383, upload-time = "2026-02-11T04:21:50.015Z" },
-    { url = "https://files.pythonhosted.org/packages/a8/c6/f4fb24268d0c6908b9f04143697ea18b0379490cb74ba9e8d41b898bd005/pillow-12.1.1-cp313-cp313t-win_arm64.whl", hash = "sha256:cc7d296b5ea4d29e6570dabeaed58d31c3fea35a633a69679fb03d7664f43fb3", size = 2456104, upload-time = "2026-02-11T04:21:51.633Z" },
-    { url = "https://files.pythonhosted.org/packages/03/d0/bebb3ffbf31c5a8e97241476c4cf8b9828954693ce6744b4a2326af3e16b/pillow-12.1.1-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:417423db963cb4be8bac3fc1204fe61610f6abeed1580a7a2cbb2fbda20f12af", size = 4062652, upload-time = "2026-02-11T04:21:53.19Z" },
-    { url = "https://files.pythonhosted.org/packages/2d/c0/0e16fb0addda4851445c28f8350d8c512f09de27bbb0d6d0bbf8b6709605/pillow-12.1.1-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:b957b71c6b2387610f556a7eb0828afbe40b4a98036fc0d2acfa5a44a0c2036f", size = 4138823, upload-time = "2026-02-11T04:22:03.088Z" },
-    { url = "https://files.pythonhosted.org/packages/6b/fb/6170ec655d6f6bb6630a013dd7cf7bc218423d7b5fa9071bf63dc32175ae/pillow-12.1.1-cp314-cp314-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:097690ba1f2efdeb165a20469d59d8bb03c55fb6621eb2041a060ae8ea3e9642", size = 3601143, upload-time = "2026-02-11T04:22:04.909Z" },
-    { url = "https://files.pythonhosted.org/packages/59/04/dc5c3f297510ba9a6837cbb318b87dd2b8f73eb41a43cc63767f65cb599c/pillow-12.1.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:2815a87ab27848db0321fb78c7f0b2c8649dee134b7f2b80c6a45c6831d75ccd", size = 5266254, upload-time = "2026-02-11T04:22:07.656Z" },
-    { url = "https://files.pythonhosted.org/packages/05/30/5db1236b0d6313f03ebf97f5e17cda9ca060f524b2fcc875149a8360b21c/pillow-12.1.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:f7ed2c6543bad5a7d5530eb9e78c53132f93dfa44a28492db88b41cdab885202", size = 4657499, upload-time = "2026-02-11T04:22:09.613Z" },
-    { url = "https://files.pythonhosted.org/packages/6f/18/008d2ca0eb612e81968e8be0bbae5051efba24d52debf930126d7eaacbba/pillow-12.1.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:652a2c9ccfb556235b2b501a3a7cf3742148cd22e04b5625c5fe057ea3e3191f", size = 6232137, upload-time = "2026-02-11T04:22:11.434Z" },
-    { url = "https://files.pythonhosted.org/packages/70/f1/f14d5b8eeb4b2cd62b9f9f847eb6605f103df89ef619ac68f92f748614ea/pillow-12.1.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d6e4571eedf43af33d0fc233a382a76e849badbccdf1ac438841308652a08e1f", size = 8042721, upload-time = "2026-02-11T04:22:13.321Z" },
-    { url = "https://files.pythonhosted.org/packages/5a/d6/17824509146e4babbdabf04d8171491fa9d776f7061ff6e727522df9bd03/pillow-12.1.1-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b574c51cf7d5d62e9be37ba446224b59a2da26dc4c1bb2ecbe936a4fb1a7cb7f", size = 6347798, upload-time = "2026-02-11T04:22:15.449Z" },
-    { url = "https://files.pythonhosted.org/packages/d1/ee/c85a38a9ab92037a75615aba572c85ea51e605265036e00c5b67dfafbfe2/pillow-12.1.1-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a37691702ed687799de29a518d63d4682d9016932db66d4e90c345831b02fb4e", size = 7039315, upload-time = "2026-02-11T04:22:17.24Z" },
-    { url = "https://files.pythonhosted.org/packages/ec/f3/bc8ccc6e08a148290d7523bde4d9a0d6c981db34631390dc6e6ec34cacf6/pillow-12.1.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:f95c00d5d6700b2b890479664a06e754974848afaae5e21beb4d83c106923fd0", size = 6462360, upload-time = "2026-02-11T04:22:19.111Z" },
-    { url = "https://files.pythonhosted.org/packages/f6/ab/69a42656adb1d0665ab051eec58a41f169ad295cf81ad45406963105408f/pillow-12.1.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:559b38da23606e68681337ad74622c4dbba02254fc9cb4488a305dd5975c7eeb", size = 7165438, upload-time = "2026-02-11T04:22:21.041Z" },
-    { url = "https://files.pythonhosted.org/packages/02/46/81f7aa8941873f0f01d4b55cc543b0a3d03ec2ee30d617a0448bf6bd6dec/pillow-12.1.1-cp314-cp314-win32.whl", hash = "sha256:03edcc34d688572014ff223c125a3f77fb08091e4607e7745002fc214070b35f", size = 6431503, upload-time = "2026-02-11T04:22:22.833Z" },
-    { url = "https://files.pythonhosted.org/packages/40/72/4c245f7d1044b67affc7f134a09ea619d4895333d35322b775b928180044/pillow-12.1.1-cp314-cp314-win_amd64.whl", hash = "sha256:50480dcd74fa63b8e78235957d302d98d98d82ccbfac4c7e12108ba9ecbdba15", size = 7176748, upload-time = "2026-02-11T04:22:24.64Z" },
-    { url = "https://files.pythonhosted.org/packages/e4/ad/8a87bdbe038c5c698736e3348af5c2194ffb872ea52f11894c95f9305435/pillow-12.1.1-cp314-cp314-win_arm64.whl", hash = "sha256:5cb1785d97b0c3d1d1a16bc1d710c4a0049daefc4935f3a8f31f827f4d3d2e7f", size = 2544314, upload-time = "2026-02-11T04:22:26.685Z" },
-    { url = "https://files.pythonhosted.org/packages/6c/9d/efd18493f9de13b87ede7c47e69184b9e859e4427225ea962e32e56a49bc/pillow-12.1.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:1f90cff8aa76835cba5769f0b3121a22bd4eb9e6884cfe338216e557a9a548b8", size = 5268612, upload-time = "2026-02-11T04:22:29.884Z" },
-    { url = "https://files.pythonhosted.org/packages/f8/f1/4f42eb2b388eb2ffc660dcb7f7b556c1015c53ebd5f7f754965ef997585b/pillow-12.1.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:1f1be78ce9466a7ee64bfda57bdba0f7cc499d9794d518b854816c41bf0aa4e9", size = 4660567, upload-time = "2026-02-11T04:22:31.799Z" },
-    { url = "https://files.pythonhosted.org/packages/01/54/df6ef130fa43e4b82e32624a7b821a2be1c5653a5fdad8469687a7db4e00/pillow-12.1.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:42fc1f4677106188ad9a55562bbade416f8b55456f522430fadab3cef7cd4e60", size = 6269951, upload-time = "2026-02-11T04:22:33.921Z" },
-    { url = "https://files.pythonhosted.org/packages/a9/48/618752d06cc44bb4aae8ce0cd4e6426871929ed7b46215638088270d9b34/pillow-12.1.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:98edb152429ab62a1818039744d8fbb3ccab98a7c29fc3d5fcef158f3f1f68b7", size = 8074769, upload-time = "2026-02-11T04:22:35.877Z" },
-    { url = "https://files.pythonhosted.org/packages/c3/bd/f1d71eb39a72fa088d938655afba3e00b38018d052752f435838961127d8/pillow-12.1.1-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d470ab1178551dd17fdba0fef463359c41aaa613cdcd7ff8373f54be629f9f8f", size = 6381358, upload-time = "2026-02-11T04:22:37.698Z" },
-    { url = "https://files.pythonhosted.org/packages/64/ef/c784e20b96674ed36a5af839305f55616f8b4f8aa8eeccf8531a6e312243/pillow-12.1.1-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6408a7b064595afcab0a49393a413732a35788f2a5092fdc6266952ed67de586", size = 7068558, upload-time = "2026-02-11T04:22:39.597Z" },
-    { url = "https://files.pythonhosted.org/packages/73/cb/8059688b74422ae61278202c4e1ad992e8a2e7375227be0a21c6b87ca8d5/pillow-12.1.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:5d8c41325b382c07799a3682c1c258469ea2ff97103c53717b7893862d0c98ce", size = 6493028, upload-time = "2026-02-11T04:22:42.73Z" },
-    { url = "https://files.pythonhosted.org/packages/c6/da/e3c008ed7d2dd1f905b15949325934510b9d1931e5df999bb15972756818/pillow-12.1.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:c7697918b5be27424e9ce568193efd13d925c4481dd364e43f5dff72d33e10f8", size = 7191940, upload-time = "2026-02-11T04:22:44.543Z" },
-    { url = "https://files.pythonhosted.org/packages/01/4a/9202e8d11714c1fc5951f2e1ef362f2d7fbc595e1f6717971d5dd750e969/pillow-12.1.1-cp314-cp314t-win32.whl", hash = "sha256:d2912fd8114fc5545aa3a4b5576512f64c55a03f3ebcca4c10194d593d43ea36", size = 6438736, upload-time = "2026-02-11T04:22:46.347Z" },
-    { url = "https://files.pythonhosted.org/packages/f3/ca/cbce2327eb9885476b3957b2e82eb12c866a8b16ad77392864ad601022ce/pillow-12.1.1-cp314-cp314t-win_amd64.whl", hash = "sha256:4ceb838d4bd9dab43e06c363cab2eebf63846d6a4aeaea283bbdfd8f1a8ed58b", size = 7182894, upload-time = "2026-02-11T04:22:48.114Z" },
-    { url = "https://files.pythonhosted.org/packages/ec/d2/de599c95ba0a973b94410477f8bf0b6f0b5e67360eb89bcb1ad365258beb/pillow-12.1.1-cp314-cp314t-win_arm64.whl", hash = "sha256:7b03048319bfc6170e93bd60728a1af51d3dd7704935feb228c4d4faab35d334", size = 2546446, upload-time = "2026-02-11T04:22:50.342Z" },
+version = "12.2.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/8c/21/c2bcdd5906101a30244eaffc1b6e6ce71a31bd0742a01eb89e660ebfac2d/pillow-12.2.0.tar.gz", hash = "sha256:a830b1a40919539d07806aa58e1b114df53ddd43213d9c8b75847eee6c0182b5", size = 46987819, upload-time = "2026-04-01T14:46:17.687Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/58/be/7482c8a5ebebbc6470b3eb791812fff7d5e0216c2be3827b30b8bb6603ed/pillow-12.2.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:2d192a155bbcec180f8564f693e6fd9bccff5a7af9b32e2e4bf8c9c69dbad6b5", size = 5308279, upload-time = "2026-04-01T14:43:13.246Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/95/0a351b9289c2b5cbde0bacd4a83ebc44023e835490a727b2a3bd60ddc0f4/pillow-12.2.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f3f40b3c5a968281fd507d519e444c35f0ff171237f4fdde090dd60699458421", size = 4695490, upload-time = "2026-04-01T14:43:15.584Z" },
+    { url = "https://files.pythonhosted.org/packages/de/af/4e8e6869cbed569d43c416fad3dc4ecb944cb5d9492defaed89ddd6fe871/pillow-12.2.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:03e7e372d5240cc23e9f07deca4d775c0817bffc641b01e9c3af208dbd300987", size = 6284462, upload-time = "2026-04-01T14:43:18.268Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/9e/c05e19657fd57841e476be1ab46c4d501bffbadbafdc31a6d665f8b737b6/pillow-12.2.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:b86024e52a1b269467a802258c25521e6d742349d760728092e1bc2d135b4d76", size = 8094744, upload-time = "2026-04-01T14:43:20.716Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/54/1789c455ed10176066b6e7e6da1b01e50e36f94ba584dc68d9eebfe9156d/pillow-12.2.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7371b48c4fa448d20d2714c9a1f775a81155050d383333e0a6c15b1123dda005", size = 6398371, upload-time = "2026-04-01T14:43:23.443Z" },
+    { url = "https://files.pythonhosted.org/packages/43/e3/fdc657359e919462369869f1c9f0e973f353f9a9ee295a39b1fea8ee1a77/pillow-12.2.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:62f5409336adb0663b7caa0da5c7d9e7bdbaae9ce761d34669420c2a801b2780", size = 7087215, upload-time = "2026-04-01T14:43:26.758Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/f8/2f6825e441d5b1959d2ca5adec984210f1ec086435b0ed5f52c19b3b8a6e/pillow-12.2.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:01afa7cf67f74f09523699b4e88c73fb55c13346d212a59a2db1f86b0a63e8c5", size = 6509783, upload-time = "2026-04-01T14:43:29.56Z" },
+    { url = "https://files.pythonhosted.org/packages/67/f9/029a27095ad20f854f9dba026b3ea6428548316e057e6fc3545409e86651/pillow-12.2.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fc3d34d4a8fbec3e88a79b92e5465e0f9b842b628675850d860b8bd300b159f5", size = 7212112, upload-time = "2026-04-01T14:43:32.091Z" },
+    { url = "https://files.pythonhosted.org/packages/be/42/025cfe05d1be22dbfdb4f264fe9de1ccda83f66e4fc3aac94748e784af04/pillow-12.2.0-cp312-cp312-win32.whl", hash = "sha256:58f62cc0f00fd29e64b29f4fd923ffdb3859c9f9e6105bfc37ba1d08994e8940", size = 6378489, upload-time = "2026-04-01T14:43:34.601Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/7b/25a221d2c761c6a8ae21bfa3874988ff2583e19cf8a27bf2fee358df7942/pillow-12.2.0-cp312-cp312-win_amd64.whl", hash = "sha256:7f84204dee22a783350679a0333981df803dac21a0190d706a50475e361c93f5", size = 7084129, upload-time = "2026-04-01T14:43:37.213Z" },
+    { url = "https://files.pythonhosted.org/packages/10/e1/542a474affab20fd4a0f1836cb234e8493519da6b76899e30bcc5d990b8b/pillow-12.2.0-cp312-cp312-win_arm64.whl", hash = "sha256:af73337013e0b3b46f175e79492d96845b16126ddf79c438d7ea7ff27783a414", size = 2463612, upload-time = "2026-04-01T14:43:39.421Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/01/53d10cf0dbad820a8db274d259a37ba50b88b24768ddccec07355382d5ad/pillow-12.2.0-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:8297651f5b5679c19968abefd6bb84d95fe30ef712eb1b2d9b2d31ca61267f4c", size = 4100837, upload-time = "2026-04-01T14:43:41.506Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/98/f3a6657ecb698c937f6c76ee564882945f29b79bad496abcba0e84659ec5/pillow-12.2.0-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:50d8520da2a6ce0af445fa6d648c4273c3eeefbc32d7ce049f22e8b5c3daecc2", size = 4176528, upload-time = "2026-04-01T14:43:43.773Z" },
+    { url = "https://files.pythonhosted.org/packages/69/bc/8986948f05e3ea490b8442ea1c1d4d990b24a7e43d8a51b2c7d8b1dced36/pillow-12.2.0-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:766cef22385fa1091258ad7e6216792b156dc16d8d3fa607e7545b2b72061f1c", size = 3640401, upload-time = "2026-04-01T14:43:45.87Z" },
+    { url = "https://files.pythonhosted.org/packages/34/46/6c717baadcd62bc8ed51d238d521ab651eaa74838291bda1f86fe1f864c9/pillow-12.2.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:5d2fd0fa6b5d9d1de415060363433f28da8b1526c1c129020435e186794b3795", size = 5308094, upload-time = "2026-04-01T14:43:48.438Z" },
+    { url = "https://files.pythonhosted.org/packages/71/43/905a14a8b17fdb1ccb58d282454490662d2cb89a6bfec26af6d3520da5ec/pillow-12.2.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:56b25336f502b6ed02e889f4ece894a72612fe885889a6e8c4c80239ff6e5f5f", size = 4695402, upload-time = "2026-04-01T14:43:51.292Z" },
+    { url = "https://files.pythonhosted.org/packages/73/dd/42107efcb777b16fa0393317eac58f5b5cf30e8392e266e76e51cff28c3d/pillow-12.2.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:f1c943e96e85df3d3478f7b691f229887e143f81fedab9b20205349ab04d73ed", size = 6280005, upload-time = "2026-04-01T14:43:54.242Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/68/b93e09e5e8549019e61acf49f65b1a8530765a7f812c77a7461bca7e4494/pillow-12.2.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:03f6fab9219220f041c74aeaa2939ff0062bd5c364ba9ce037197f4c6d498cd9", size = 8090669, upload-time = "2026-04-01T14:43:57.335Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/6e/3ccb54ce8ec4ddd1accd2d89004308b7b0b21c4ac3d20fa70af4760a4330/pillow-12.2.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5cdfebd752ec52bf5bb4e35d9c64b40826bc5b40a13df7c3cda20a2c03a0f5ed", size = 6395194, upload-time = "2026-04-01T14:43:59.864Z" },
+    { url = "https://files.pythonhosted.org/packages/67/ee/21d4e8536afd1a328f01b359b4d3997b291ffd35a237c877b331c1c3b71c/pillow-12.2.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:eedf4b74eda2b5a4b2b2fb4c006d6295df3bf29e459e198c90ea48e130dc75c3", size = 7082423, upload-time = "2026-04-01T14:44:02.74Z" },
+    { url = "https://files.pythonhosted.org/packages/78/5f/e9f86ab0146464e8c133fe85df987ed9e77e08b29d8d35f9f9f4d6f917ba/pillow-12.2.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:00a2865911330191c0b818c59103b58a5e697cae67042366970a6b6f1b20b7f9", size = 6505667, upload-time = "2026-04-01T14:44:05.381Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/1e/409007f56a2fdce61584fd3acbc2bbc259857d555196cedcadc68c015c82/pillow-12.2.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:1e1757442ed87f4912397c6d35a0db6a7b52592156014706f17658ff58bbf795", size = 7208580, upload-time = "2026-04-01T14:44:08.39Z" },
+    { url = "https://files.pythonhosted.org/packages/23/c4/7349421080b12fb35414607b8871e9534546c128a11965fd4a7002ccfbee/pillow-12.2.0-cp313-cp313-win32.whl", hash = "sha256:144748b3af2d1b358d41286056d0003f47cb339b8c43a9ea42f5fea4d8c66b6e", size = 6375896, upload-time = "2026-04-01T14:44:11.197Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/82/8a3739a5e470b3c6cbb1d21d315800d8e16bff503d1f16b03a4ec3212786/pillow-12.2.0-cp313-cp313-win_amd64.whl", hash = "sha256:390ede346628ccc626e5730107cde16c42d3836b89662a115a921f28440e6a3b", size = 7081266, upload-time = "2026-04-01T14:44:13.947Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/25/f968f618a062574294592f668218f8af564830ccebdd1fa6200f598e65c5/pillow-12.2.0-cp313-cp313-win_arm64.whl", hash = "sha256:8023abc91fba39036dbce14a7d6535632f99c0b857807cbbbf21ecc9f4717f06", size = 2463508, upload-time = "2026-04-01T14:44:16.312Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/a4/b342930964e3cb4dce5038ae34b0eab4653334995336cd486c5a8c25a00c/pillow-12.2.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:042db20a421b9bafecc4b84a8b6e444686bd9d836c7fd24542db3e7df7baad9b", size = 5309927, upload-time = "2026-04-01T14:44:18.89Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/de/23198e0a65a9cf06123f5435a5d95cea62a635697f8f03d134d3f3a96151/pillow-12.2.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:dd025009355c926a84a612fecf58bb315a3f6814b17ead51a8e48d3823d9087f", size = 4698624, upload-time = "2026-04-01T14:44:21.115Z" },
+    { url = "https://files.pythonhosted.org/packages/01/a6/1265e977f17d93ea37aa28aa81bad4fa597933879fac2520d24e021c8da3/pillow-12.2.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:88ddbc66737e277852913bd1e07c150cc7bb124539f94c4e2df5344494e0a612", size = 6321252, upload-time = "2026-04-01T14:44:23.663Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/83/5982eb4a285967baa70340320be9f88e57665a387e3a53a7f0db8231a0cd/pillow-12.2.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d362d1878f00c142b7e1a16e6e5e780f02be8195123f164edf7eddd911eefe7c", size = 8126550, upload-time = "2026-04-01T14:44:26.772Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/48/6ffc514adce69f6050d0753b1a18fd920fce8cac87620d5a31231b04bfc5/pillow-12.2.0-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2c727a6d53cb0018aadd8018c2b938376af27914a68a492f59dfcaca650d5eea", size = 6433114, upload-time = "2026-04-01T14:44:29.615Z" },
+    { url = "https://files.pythonhosted.org/packages/36/a3/f9a77144231fb8d40ee27107b4463e205fa4677e2ca2548e14da5cf18dce/pillow-12.2.0-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:efd8c21c98c5cc60653bcb311bef2ce0401642b7ce9d09e03a7da87c878289d4", size = 7115667, upload-time = "2026-04-01T14:44:32.773Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/fc/ac4ee3041e7d5a565e1c4fd72a113f03b6394cc72ab7089d27608f8aaccb/pillow-12.2.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:9f08483a632889536b8139663db60f6724bfcb443c96f1b18855860d7d5c0fd4", size = 6538966, upload-time = "2026-04-01T14:44:35.252Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/a8/27fb307055087f3668f6d0a8ccb636e7431d56ed0750e07a60547b1e083e/pillow-12.2.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:dac8d77255a37e81a2efcbd1fc05f1c15ee82200e6c240d7e127e25e365c39ea", size = 7238241, upload-time = "2026-04-01T14:44:37.875Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/4b/926ab182c07fccae9fcb120043464e1ff1564775ec8864f21a0ebce6ac25/pillow-12.2.0-cp313-cp313t-win32.whl", hash = "sha256:ee3120ae9dff32f121610bb08e4313be87e03efeadfc6c0d18f89127e24d0c24", size = 6379592, upload-time = "2026-04-01T14:44:40.336Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/c4/f9e476451a098181b30050cc4c9a3556b64c02cf6497ea421ac047e89e4b/pillow-12.2.0-cp313-cp313t-win_amd64.whl", hash = "sha256:325ca0528c6788d2a6c3d40e3568639398137346c3d6e66bb61db96b96511c98", size = 7085542, upload-time = "2026-04-01T14:44:43.251Z" },
+    { url = "https://files.pythonhosted.org/packages/00/a4/285f12aeacbe2d6dc36c407dfbbe9e96d4a80b0fb710a337f6d2ad978c75/pillow-12.2.0-cp313-cp313t-win_arm64.whl", hash = "sha256:2e5a76d03a6c6dcef67edabda7a52494afa4035021a79c8558e14af25313d453", size = 2465765, upload-time = "2026-04-01T14:44:45.996Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/98/4595daa2365416a86cb0d495248a393dfc84e96d62ad080c8546256cb9c0/pillow-12.2.0-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:3adc9215e8be0448ed6e814966ecf3d9952f0ea40eb14e89a102b87f450660d8", size = 4100848, upload-time = "2026-04-01T14:44:48.48Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/79/40184d464cf89f6663e18dfcf7ca21aae2491fff1a16127681bf1fa9b8cf/pillow-12.2.0-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:6a9adfc6d24b10f89588096364cc726174118c62130c817c2837c60cf08a392b", size = 4176515, upload-time = "2026-04-01T14:44:51.353Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/63/703f86fd4c422a9cf722833670f4f71418fb116b2853ff7da722ea43f184/pillow-12.2.0-cp314-cp314-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:6a6e67ea2e6feda684ed370f9a1c52e7a243631c025ba42149a2cc5934dec295", size = 3640159, upload-time = "2026-04-01T14:44:53.588Z" },
+    { url = "https://files.pythonhosted.org/packages/71/e0/fb22f797187d0be2270f83500aab851536101b254bfa1eae10795709d283/pillow-12.2.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:2bb4a8d594eacdfc59d9e5ad972aa8afdd48d584ffd5f13a937a664c3e7db0ed", size = 5312185, upload-time = "2026-04-01T14:44:56.039Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/8c/1a9e46228571de18f8e28f16fabdfc20212a5d019f3e3303452b3f0a580d/pillow-12.2.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:80b2da48193b2f33ed0c32c38140f9d3186583ce7d516526d462645fd98660ae", size = 4695386, upload-time = "2026-04-01T14:44:58.663Z" },
+    { url = "https://files.pythonhosted.org/packages/70/62/98f6b7f0c88b9addd0e87c217ded307b36be024d4ff8869a812b241d1345/pillow-12.2.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:22db17c68434de69d8ecfc2fe821569195c0c373b25cccb9cbdacf2c6e53c601", size = 6280384, upload-time = "2026-04-01T14:45:01.5Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/03/688747d2e91cfbe0e64f316cd2e8005698f76ada3130d0194664174fa5de/pillow-12.2.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:7b14cc0106cd9aecda615dd6903840a058b4700fcb817687d0ee4fc8b6e389be", size = 8091599, upload-time = "2026-04-01T14:45:04.5Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/35/577e22b936fcdd66537329b33af0b4ccfefaeabd8aec04b266528cddb33c/pillow-12.2.0-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8cbeb542b2ebc6fcdacabf8aca8c1a97c9b3ad3927d46b8723f9d4f033288a0f", size = 6396021, upload-time = "2026-04-01T14:45:07.117Z" },
+    { url = "https://files.pythonhosted.org/packages/11/8d/d2532ad2a603ca2b93ad9f5135732124e57811d0168155852f37fbce2458/pillow-12.2.0-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4bfd07bc812fbd20395212969e41931001fd59eb55a60658b0e5710872e95286", size = 7083360, upload-time = "2026-04-01T14:45:09.763Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/26/d325f9f56c7e039034897e7380e9cc202b1e368bfd04d4cbe6a441f02885/pillow-12.2.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:9aba9a17b623ef750a4d11b742cbafffeb48a869821252b30ee21b5e91392c50", size = 6507628, upload-time = "2026-04-01T14:45:12.378Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/f7/769d5632ffb0988f1c5e7660b3e731e30f7f8ec4318e94d0a5d674eb65a4/pillow-12.2.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:deede7c263feb25dba4e82ea23058a235dcc2fe1f6021025dc71f2b618e26104", size = 7209321, upload-time = "2026-04-01T14:45:15.122Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/7a/c253e3c645cd47f1aceea6a8bacdba9991bf45bb7dfe927f7c893e89c93c/pillow-12.2.0-cp314-cp314-win32.whl", hash = "sha256:632ff19b2778e43162304d50da0181ce24ac5bb8180122cbe1bf4673428328c7", size = 6479723, upload-time = "2026-04-01T14:45:17.797Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/8b/601e6566b957ca50e28725cb6c355c59c2c8609751efbecd980db44e0349/pillow-12.2.0-cp314-cp314-win_amd64.whl", hash = "sha256:4e6c62e9d237e9b65fac06857d511e90d8461a32adcc1b9065ea0c0fa3a28150", size = 7217400, upload-time = "2026-04-01T14:45:20.529Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/94/220e46c73065c3e2951bb91c11a1fb636c8c9ad427ac3ce7d7f3359b9b2f/pillow-12.2.0-cp314-cp314-win_arm64.whl", hash = "sha256:b1c1fbd8a5a1af3412a0810d060a78b5136ec0836c8a4ef9aa11807f2a22f4e1", size = 2554835, upload-time = "2026-04-01T14:45:23.162Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/ab/1b426a3974cb0e7da5c29ccff4807871d48110933a57207b5a676cccc155/pillow-12.2.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:57850958fe9c751670e49b2cecf6294acc99e562531f4bd317fa5ddee2068463", size = 5314225, upload-time = "2026-04-01T14:45:25.637Z" },
+    { url = "https://files.pythonhosted.org/packages/19/1e/dce46f371be2438eecfee2a1960ee2a243bbe5e961890146d2dee1ff0f12/pillow-12.2.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:d5d38f1411c0ed9f97bcb49b7bd59b6b7c314e0e27420e34d99d844b9ce3b6f3", size = 4698541, upload-time = "2026-04-01T14:45:28.355Z" },
+    { url = "https://files.pythonhosted.org/packages/55/c3/7fbecf70adb3a0c33b77a300dc52e424dc22ad8cdc06557a2e49523b703d/pillow-12.2.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:5c0a9f29ca8e79f09de89293f82fc9b0270bb4af1d58bc98f540cc4aedf03166", size = 6322251, upload-time = "2026-04-01T14:45:30.924Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/3c/7fbc17cfb7e4fe0ef1642e0abc17fc6c94c9f7a16be41498e12e2ba60408/pillow-12.2.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:1610dd6c61621ae1cf811bef44d77e149ce3f7b95afe66a4512f8c59f25d9ebe", size = 8127807, upload-time = "2026-04-01T14:45:33.908Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/c3/a8ae14d6defd2e448493ff512fae903b1e9bd40b72efb6ec55ce0048c8ce/pillow-12.2.0-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0a34329707af4f73cf1782a36cd2289c0368880654a2c11f027bcee9052d35dd", size = 6433935, upload-time = "2026-04-01T14:45:36.623Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/32/2880fb3a074847ac159d8f902cb43278a61e85f681661e7419e6596803ed/pillow-12.2.0-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8e9c4f5b3c546fa3458a29ab22646c1c6c787ea8f5ef51300e5a60300736905e", size = 7116720, upload-time = "2026-04-01T14:45:39.258Z" },
+    { url = "https://files.pythonhosted.org/packages/46/87/495cc9c30e0129501643f24d320076f4cc54f718341df18cc70ec94c44e1/pillow-12.2.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:fb043ee2f06b41473269765c2feae53fc2e2fbf96e5e22ca94fb5ad677856f06", size = 6540498, upload-time = "2026-04-01T14:45:41.879Z" },
+    { url = "https://files.pythonhosted.org/packages/18/53/773f5edca692009d883a72211b60fdaf8871cbef075eaa9d577f0a2f989e/pillow-12.2.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:f278f034eb75b4e8a13a54a876cc4a5ab39173d2cdd93a638e1b467fc545ac43", size = 7239413, upload-time = "2026-04-01T14:45:44.705Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/e4/4b64a97d71b2a83158134abbb2f5bd3f8a2ea691361282f010998f339ec7/pillow-12.2.0-cp314-cp314t-win32.whl", hash = "sha256:6bb77b2dcb06b20f9f4b4a8454caa581cd4dd0643a08bacf821216a16d9c8354", size = 6482084, upload-time = "2026-04-01T14:45:47.568Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/13/306d275efd3a3453f72114b7431c877d10b1154014c1ebbedd067770d629/pillow-12.2.0-cp314-cp314t-win_amd64.whl", hash = "sha256:6562ace0d3fb5f20ed7290f1f929cae41b25ae29528f2af1722966a0a02e2aa1", size = 7225152, upload-time = "2026-04-01T14:45:50.032Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/6e/cf826fae916b8658848d7b9f38d88da6396895c676e8086fc0988073aaf8/pillow-12.2.0-cp314-cp314t-win_arm64.whl", hash = "sha256:aa88ccfe4e32d362816319ed727a004423aab09c5cea43c01a4b435643fa34eb", size = 2556579, upload-time = "2026-04-01T14:45:52.529Z" },
 ]
 
 [[package]]
 name = "pip"
-version = "26.0.1"
+version = "26.1.2"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/48/83/0d7d4e9efe3344b8e2fe25d93be44f64b65364d3c8d7bc6dc90198d5422e/pip-26.0.1.tar.gz", hash = "sha256:c4037d8a277c89b320abe636d59f91e6d0922d08a05b60e85e53b296613346d8", size = 1812747, upload-time = "2026-02-05T02:20:18.702Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/01/91/47e7d486260f618783899587af63ccf7980fb60245c3e63dd4571c6b57ad/pip-26.1.2.tar.gz", hash = "sha256:f49cd134c61cf2fd75e0ce2676db03e4054504a5a4986d00f8299ae632dc4605", size = 1840799, upload-time = "2026-05-31T17:33:58.56Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/de/f0/c81e05b613866b76d2d1066490adf1a3dbc4ee9d9c839961c3fc8a6997af/pip-26.0.1-py3-none-any.whl", hash = "sha256:bdb1b08f4274833d62c1aa29e20907365a2ceb950410df15fc9521bad440122b", size = 1787723, upload-time = "2026-02-05T02:20:16.416Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/95/6b5cb3461ea5673ba0995989746db58eb18b91b54dbf331e72f569540946/pip-26.1.2-py3-none-any.whl", hash = "sha256:382ff9f685ee3bc25864f820aa50505825f10f5458ffff07e30a6d96e5715cab", size = 1813144, upload-time = "2026-05-31T17:33:56.772Z" },
 ]
 
 [[package]]
@@ -5490,13 +5914,23 @@ version = "0.9.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "jinja2" },
-    { name = "numpy" },
+    { name = "numpy", version = "2.3.5", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.13'" },
+    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.13'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/a1/ca/40e14e196864a0f61a92abb14d09b3d3da98f94ccb03b49cf51688140dab/pydeck-0.9.1.tar.gz", hash = "sha256:f74475ae637951d63f2ee58326757f8d4f9cd9f2a457cf42950715003e2cb605", size = 3832240, upload-time = "2024-05-10T15:36:21.153Z" }
 wheels = [
     { url = "https://files.pythonhosted.org/packages/ab/4c/b888e6cf58bd9db9c93f40d1c6be8283ff49d88919231afe93a6bcf61626/pydeck-0.9.1-py2.py3-none-any.whl", hash = "sha256:b3f75ba0d273fc917094fa61224f3f6076ca8752b93d46faf3bcfd9f9d59b038", size = 6900403, upload-time = "2024-05-10T15:36:17.36Z" },
 ]
 
+[[package]]
+name = "pyelftools"
+version = "0.33"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/a3/11/767522582afab1b884d277de0e6e011640cb9d7292a38694b4b1a1df1ae8/pyelftools-0.33.tar.gz", hash = "sha256:660d82dcbeb8e83d1702bd97f223f761625da06111c0cc988eac6b8ab0c1b61f", size = 15068655, upload-time = "2026-05-29T12:56:22.553Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/46/2a/f9697576603dae937727827505a6126a066affb227034e77e6f9068910da/pyelftools-0.33-py3-none-any.whl", hash = "sha256:f215ad5f47d3f1373a21496a6c9e0707c622840d0622f23ff7ce08678b020036", size = 201178, upload-time = "2026-05-29T12:56:20.587Z" },
+]
+
 [[package]]
 name = "pygments"
 version = "2.19.2"
@@ -5508,11 +5942,11 @@ wheels = [
 
 [[package]]
 name = "pyjwt"
-version = "2.12.1"
+version = "2.13.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/c2/27/a3b6e5bf6ff856d2509292e95c8f57f0df7017cf5394921fc4e4ef40308a/pyjwt-2.12.1.tar.gz", hash = "sha256:c74a7a2adf861c04d002db713dd85f84beb242228e671280bf709d765b03672b", size = 102564, upload-time = "2026-03-13T19:27:37.25Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/3b/81/58d0ac84e1ef3a3843791d6954d94c0b33d526c75eeb1efbce9d0a4c4077/pyjwt-2.13.0.tar.gz", hash = "sha256:41571c89ca91598c79e8ef18a2d07367d4810fbbd6f637794879baf1b7703423", size = 107515, upload-time = "2026-05-21T19:54:36.618Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/e5/7a/8dd906bd22e79e47397a61742927f6747fe93242ef86645ee9092e610244/pyjwt-2.12.1-py3-none-any.whl", hash = "sha256:28ca37c070cad8ba8cd9790cd940535d40274d22f80ab87f3ac6a713e6e8454c", size = 29726, upload-time = "2026-03-13T19:27:35.677Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/5e/ecf12fdb62546d64385c158514e9b2b671f7832108ef2ecd2020ce0af2d1/pyjwt-2.13.0-py3-none-any.whl", hash = "sha256:66adcc2aff09b3f1bbd95fc1e1577df8ac8723c978552fd43304c8a290ac5728", size = 31274, upload-time = "2026-05-21T19:54:35.362Z" },
 ]
 
 [package.optional-dependencies]
@@ -5522,15 +5956,15 @@ crypto = [
 
 [[package]]
 name = "pymdown-extensions"
-version = "10.18"
+version = "10.21.3"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "markdown" },
     { name = "pyyaml" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/d4/95/e4fa281e3f13b3d9c4aaebb21ef44879840325fa418276dd921209a5e9f9/pymdown_extensions-10.18.tar.gz", hash = "sha256:20252abe6367354b24191431617a072ee6be9f68c5afcc74ea5573508a61f9e5", size = 847697, upload-time = "2025-12-07T17:22:12.857Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/9e/26/d1015444da4d952a1ca487a236b522eb979766f0295a0bd0c5fc089989a9/pymdown_extensions-10.21.3.tar.gz", hash = "sha256:72cfcf55f07aea0d4af2c4f11dd4e52466ddfb1bb819673146398e0bd3a77354", size = 854140, upload-time = "2026-05-13T12:57:32.267Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/46/a4/aa2bada4a2fd648f40f19affa55d2c01dc7ff5ea9cffd3dfdeb6114951db/pymdown_extensions-10.18-py3-none-any.whl", hash = "sha256:090bca72be43f7d3186374e23c782899dbef9dc153ef24c59dcd3c346f9ffcae", size = 266703, upload-time = "2025-12-07T17:22:11.22Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/85/545a951eecc270fcd688288c600017e2050a1aacb56c711d208586d3e470/pymdown_extensions-10.21.3-py3-none-any.whl", hash = "sha256:d7a5d08014fc571e80ca21dd6f854e31f94c489800350564d55d15b3c41e76b6", size = 269002, upload-time = "2026-05-13T12:57:30.296Z" },
 ]
 
 [[package]]
@@ -5591,7 +6025,7 @@ wheels = [
 
 [[package]]
 name = "pytest"
-version = "9.0.2"
+version = "9.0.3"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "colorama", marker = "sys_platform == 'win32'" },
@@ -5600,9 +6034,9 @@ dependencies = [
     { name = "pluggy" },
     { name = "pygments" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/d1/db/7ef3487e0fb0049ddb5ce41d3a49c235bf9ad299b6a25d5780a89f19230f/pytest-9.0.2.tar.gz", hash = "sha256:75186651a92bd89611d1d9fc20f0b4345fd827c41ccd5c299a868a05d70edf11", size = 1568901, upload-time = "2025-12-06T21:30:51.014Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/7d/0d/549bd94f1a0a402dc8cf64563a117c0f3765662e2e668477624baeec44d5/pytest-9.0.3.tar.gz", hash = "sha256:b86ada508af81d19edeb213c681b1d48246c1a91d304c6c81a427674c17eb91c", size = 1572165, upload-time = "2026-04-07T17:16:18.027Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/3b/ab/b3226f0bd7cdcf710fbede2b3548584366da3b19b5021e74f5bde2a8fa3f/pytest-9.0.2-py3-none-any.whl", hash = "sha256:711ffd45bf766d5264d487b917733b453d917afd2b0ad65223959f59089f875b", size = 374801, upload-time = "2025-12-06T21:30:49.154Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/24/a372aaf5c9b7208e7112038812994107bc65a84cd00e0354a88c2c77a617/pytest-9.0.3-py3-none-any.whl", hash = "sha256:2c5efc453d45394fdd706ade797c0a81091eccd1d6e4bccfcd476e2b8e0ab5d9", size = 375249, upload-time = "2026-04-07T17:16:16.13Z" },
 ]
 
 [[package]]
@@ -5676,11 +6110,11 @@ wheels = [
 
 [[package]]
 name = "python-multipart"
-version = "0.0.22"
+version = "0.0.32"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/94/01/979e98d542a70714b0cb2b6728ed0b7c46792b695e3eaec3e20711271ca3/python_multipart-0.0.22.tar.gz", hash = "sha256:7340bef99a7e0032613f56dc36027b959fd3b30a787ed62d310e951f7c3a3a58", size = 37612, upload-time = "2026-01-25T10:15:56.219Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/5b/42/55c32bb9b12693c092ad250a0e82edb5b31ddeda6eb772de5f308b3804ad/python_multipart-0.0.32.tar.gz", hash = "sha256:be54b7f3fa167bb83e4fcd936b887b708f4e57fe75911c02aebf53efaf8d938e", size = 46881, upload-time = "2026-06-04T16:18:58.647Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/1b/d0/397f9626e711ff749a95d96b7af99b9c566a9bb5129b8e4c10fc4d100304/python_multipart-0.0.22-py3-none-any.whl", hash = "sha256:2b2cd894c83d21bf49d702499531c7bafd057d730c201782048f7945d82de155", size = 24579, upload-time = "2026-01-25T10:15:54.811Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/04/e8135ebd1ad02c56ec633277529b2602ff99ff634be76cdba5744cf554fd/python_multipart-0.0.32-py3-none-any.whl", hash = "sha256:ff6d3f776f16878c894e52e107296ffc890e913c611b1a4ec6c44e2821fe2e23", size = 30042, upload-time = "2026-06-04T16:18:57.319Z" },
 ]
 
 [[package]]
@@ -5828,50 +6262,34 @@ wheels = [
 ]
 
 [[package]]
-name = "qwen-vl-utils"
-version = "0.0.14"
+name = "quack-kernels"
+version = "0.5.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "av" },
-    { name = "packaging" },
-    { name = "pillow" },
-    { name = "requests" },
+    { name = "apache-tvm-ffi" },
+    { name = "einops" },
+    { name = "nvidia-cutlass-dsl" },
+    { name = "torch" },
+    { name = "torch-c-dlpack-ext" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/b6/b1/ad4fc2260a3badd278b38d642f3b987412f1f6682f0ef2b31b0572d5caa8/qwen_vl_utils-0.0.14.tar.gz", hash = "sha256:9c7cad5ae803b3a10f8bb7194deb12aeacdd032f92f4224e880c73587a7346ad", size = 8453, upload-time = "2025-09-23T09:38:57.532Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/e1/94/ee76e3a3dc74d986b7b24c5928f1d14b01bd5152375688c2ede369f6d19b/quack_kernels-0.5.0.tar.gz", hash = "sha256:c7c7338b67243397b6ca166e648bba161076e99f3858b532e1c877dcc6eaa03d", size = 366426, upload-time = "2026-05-29T05:00:25.985Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/c4/43/80f67e0336cb2fc725f8e06f7fe35c1d0fe946f4d2b8b2175e797e07349e/qwen_vl_utils-0.0.14-py3-none-any.whl", hash = "sha256:5e28657bfd031e56bd447c5901b58ddfc3835285ed100f4c56580e0ade054e96", size = 8120, upload-time = "2025-09-23T09:38:56.297Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/2b/a8f171d5e172880885571bf89e93204aaf231a0e92c4c84714eaf18c271a/quack_kernels-0.5.0-py3-none-any.whl", hash = "sha256:08821ebfb8e638cc20308d5c59410c6dbb3b637ccc7b07bd57c7a9261a06af74", size = 327709, upload-time = "2026-05-29T05:00:24.679Z" },
 ]
 
 [[package]]
-name = "ray"
-version = "2.55.1"
+name = "qwen-vl-utils"
+version = "0.0.14"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "click" },
-    { name = "filelock" },
-    { name = "jsonschema" },
-    { name = "msgpack" },
+    { name = "av" },
     { name = "packaging" },
-    { name = "protobuf" },
-    { name = "pyyaml" },
+    { name = "pillow" },
     { name = "requests" },
 ]
+sdist = { url = "https://files.pythonhosted.org/packages/b6/b1/ad4fc2260a3badd278b38d642f3b987412f1f6682f0ef2b31b0572d5caa8/qwen_vl_utils-0.0.14.tar.gz", hash = "sha256:9c7cad5ae803b3a10f8bb7194deb12aeacdd032f92f4224e880c73587a7346ad", size = 8453, upload-time = "2025-09-23T09:38:57.532Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/ac/3a/4d34f471a68b958b7f94c974c19ad6836a61a2dc16393df4294169a2e4b0/ray-2.55.1-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:137f9006eee28caab8260803cca314f37bbda3fc94fdfa31c770b5d019626ad8", size = 65822379, upload-time = "2026-04-22T20:09:58.064Z" },
-    { url = "https://files.pythonhosted.org/packages/f1/13/0db535102d0256b350ca116d8987588aca1a1f9ebb4638e1e1ff88bbcef8/ray-2.55.1-cp312-cp312-manylinux2014_aarch64.whl", hash = "sha256:26541f69bb55607ef8335baac75b2ed12ff2ce02d56313219b29eda003039221", size = 72910802, upload-time = "2026-04-22T20:10:04.382Z" },
-    { url = "https://files.pythonhosted.org/packages/4c/f8/fffadf3f4285eebd460e4d7f2ed1c0cd641ed89613c3f49eb881ee9fa7e2/ray-2.55.1-cp312-cp312-manylinux2014_x86_64.whl", hash = "sha256:263705f6bab29e7622a94f82da25fd7f9cead76cdf89a07aab28f79cdf8f9d95", size = 73765203, upload-time = "2026-04-22T20:10:10.495Z" },
-    { url = "https://files.pythonhosted.org/packages/10/f7/5acb86fc9625a0e6bbc40e1c7d42c60770e78585439a921c32738b6d675a/ray-2.55.1-cp312-cp312-win_amd64.whl", hash = "sha256:9ad56704c8bd7e92130162f9c58e4ef473609515637673d5a36e761f95335206", size = 27865547, upload-time = "2026-04-22T20:10:15.364Z" },
-    { url = "https://files.pythonhosted.org/packages/d5/95/898699cc1a6a5f304ea95376d079843b5c05f4c8c1ec7e55a5cc7ffcea50/ray-2.55.1-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:f9844a9272ef2e6eb5771025866072cf4234cf4c7cc1a31e235b7de7111864be", size = 65766823, upload-time = "2026-04-22T20:10:20.786Z" },
-    { url = "https://files.pythonhosted.org/packages/c9/13/87deecc090c672e45a0cf6f5eef511de448b93f37ef18fd10eb8e8557a0d/ray-2.55.1-cp313-cp313-manylinux2014_aarch64.whl", hash = "sha256:b415d590e062f248907e0fe42994943f11726b7178fcf4b1cf5546721fb1a5f8", size = 72818676, upload-time = "2026-04-22T20:10:26.705Z" },
-    { url = "https://files.pythonhosted.org/packages/71/d7/fc95d3b8824c62105c64aa1b59c59600b581f608d78a2af753e010936dc9/ray-2.55.1-cp313-cp313-manylinux2014_x86_64.whl", hash = "sha256:1380e043eb57cde69b7e9199c6f2558ceeb8f0fc41c97d1d5e50ea042115f302", size = 73678908, upload-time = "2026-04-22T20:10:32.795Z" },
-    { url = "https://files.pythonhosted.org/packages/a9/03/7e552325572e067b23a4584bda8dc6a67af8bd7e03c424d2610bfa93112d/ray-2.55.1-cp314-cp314-macosx_12_0_arm64.whl", hash = "sha256:b062045c64c2bce39a51661624f7292c7bbf30f2a9d878627aae31d46da5712d", size = 65774106, upload-time = "2026-04-22T20:10:39.885Z" },
-    { url = "https://files.pythonhosted.org/packages/94/62/607a8859520ce350861425f11f8e15d66c15ee33e6aac812f9e2889b5df4/ray-2.55.1-cp314-cp314-manylinux2014_aarch64.whl", hash = "sha256:4e618d61e1b14b6fde9a586151f3fd9d435b0b85048b997bcaa7f4a533747b2b", size = 72814044, upload-time = "2026-04-22T20:10:46.985Z" },
-    { url = "https://files.pythonhosted.org/packages/04/5a/0699bef04a72d7dc54462960d07ef7a19cd8b1e09979880aba2b6d13cca2/ray-2.55.1-cp314-cp314-manylinux2014_x86_64.whl", hash = "sha256:156ed3e72ad95b645d2006cd71a8dddbcc89b56bfc00027f6225adf78bd9cb74", size = 73644244, upload-time = "2026-04-22T20:10:52.973Z" },
-]
-
-[package.optional-dependencies]
-cgraph = [
-    { name = "cupy-cuda12x", marker = "sys_platform != 'darwin'" },
+    { url = "https://files.pythonhosted.org/packages/c4/43/80f67e0336cb2fc725f8e06f7fe35c1d0fe946f4d2b8b2175e797e07349e/qwen_vl_utils-0.0.14-py3-none-any.whl", hash = "sha256:5e28657bfd031e56bd447c5901b58ddfc3835285ed100f4c56580e0ade054e96", size = 8120, upload-time = "2025-09-23T09:38:56.297Z" },
 ]
 
 [[package]]
@@ -5978,7 +6396,7 @@ wheels = [
 
 [[package]]
 name = "requests"
-version = "2.32.5"
+version = "2.34.2"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "certifi" },
@@ -5986,9 +6404,9 @@ dependencies = [
     { name = "idna" },
     { name = "urllib3" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/c9/74/b3ff8e6c8446842c3f5c837e9c3dfcfe2018ea6ecef224c710c85ef728f4/requests-2.32.5.tar.gz", hash = "sha256:dbba0bac56e100853db0ea71b82b4dfd5fe2bf6d3754a8893c3af500cec7d7cf", size = 134517, upload-time = "2025-08-18T20:46:02.573Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/ac/c3/e2a2b89f2d3e2179abd6d00ebd70bff6273f37fb3e0cc209f48b39d00cbf/requests-2.34.2.tar.gz", hash = "sha256:f288924cae4e29463698d6d60bc6a4da69c89185ad1e0bcc4104f584e960b9ed", size = 142856, upload-time = "2026-05-14T19:25:27.735Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/1e/db/4254e3eabe8020b458f1a747140d32277ec7a271daf1d235b70dc0b4e6e3/requests-2.32.5-py3-none-any.whl", hash = "sha256:2462f94637a34fd532264295e186976db0f5d453d1cdd31473c85a6a161affb6", size = 64738, upload-time = "2025-08-18T20:46:00.542Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/f4/c67b0b3f1b9245e8d266f0f112c500d50e5b4e83cb6f3b71b6528104182a/requests-2.34.2-py3-none-any.whl", hash = "sha256:2a0d60c172f83ac6ab31e4554906c0f3b3588d37b5cb939b1c061f4907e278e0", size = 73075, upload-time = "2026-05-14T19:25:26.443Z" },
 ]
 
 [[package]]
@@ -6266,7 +6684,8 @@ version = "1.8.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "joblib" },
-    { name = "numpy" },
+    { name = "numpy", version = "2.3.5", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.13'" },
+    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.13'" },
     { name = "scipy" },
     { name = "threadpoolctl" },
 ]
@@ -6309,7 +6728,8 @@ name = "scipy"
 version = "1.17.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "numpy" },
+    { name = "numpy", version = "2.3.5", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.13'" },
+    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.13'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/7a/97/5a3609c4f8d58b039179648e62dd220f89864f56f7357f5d4f45c29eb2cc/scipy-1.17.1.tar.gz", hash = "sha256:95d8e012d8cb8816c226aef832200b1d45109ed4464303e997c5b13122b297c0", size = 30573822, upload-time = "2026-02-23T00:26:24.851Z" }
 wheels = [
@@ -6371,7 +6791,8 @@ version = "0.13.2"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "matplotlib" },
-    { name = "numpy" },
+    { name = "numpy", version = "2.3.5", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.13'" },
+    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.13'" },
     { name = "pandas" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/86/59/a451d7420a77ab0b98f7affa3a1d78a313d2f7281a57afb1a34bae8ab412/seaborn-0.13.2.tar.gz", hash = "sha256:93e60a40988f4d65e9f4885df477e2fdaff6b73a9ded434c1ab356dd57eefff7", size = 1457696, upload-time = "2024-01-25T13:21:52.551Z" }
@@ -6620,7 +7041,8 @@ dependencies = [
     { name = "cachetools" },
     { name = "click" },
     { name = "gitpython" },
-    { name = "numpy" },
+    { name = "numpy", version = "2.3.5", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.13'" },
+    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.13'" },
     { name = "packaging" },
     { name = "pandas" },
     { name = "pillow" },
@@ -6748,6 +7170,31 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/af/df/c7891ef9d2712ad774777271d39fdef63941ffba0a9d59b7ad1fd2765e57/tiktoken-0.12.0-cp314-cp314t-win_amd64.whl", hash = "sha256:f61c0aea5565ac82e2ec50a05e02a6c44734e91b51c10510b084ea1b8e633a71", size = 920667, upload-time = "2025-10-06T20:22:34.444Z" },
 ]
 
+[[package]]
+name = "tilelang"
+version = "0.1.9"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "apache-tvm-ffi" },
+    { name = "cloudpickle" },
+    { name = "ml-dtypes" },
+    { name = "numpy", version = "2.3.5", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.13'" },
+    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.13'" },
+    { name = "psutil" },
+    { name = "setuptools", marker = "sys_platform == 'darwin'" },
+    { name = "torch" },
+    { name = "torch-c-dlpack-ext", marker = "python_full_version < '3.14'" },
+    { name = "tqdm" },
+    { name = "typing-extensions" },
+    { name = "z3-solver" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/56/70/5051f65821baa30a3d61fc48f8ba10c776490315e8c90f82559b92089756/tilelang-0.1.9.tar.gz", hash = "sha256:287f727c913bb648fcf6c1968809ba3390e55eeed257a5c6bb9a80bc05966af4", size = 93395292, upload-time = "2026-04-22T09:19:11.988Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/90/db/4dd76da8c8585c605639a21bc098d504e317fe324a72f01ce3c7370250b4/tilelang-0.1.9-cp38-abi3-macosx_11_0_arm64.whl", hash = "sha256:00ed594fdeb229c5505b9ffa895c3c5daeb28641c78f783fa1f724cf1e08cecd", size = 36599020, upload-time = "2026-04-22T09:14:39.366Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/8a/1cbeee79d62abaa02441c2d00621554e41aa62dbf3b94a4feb3867184b01/tilelang-0.1.9-cp38-abi3-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4bbccfe9035aed775ffafb6dc25a5994504b24e2c5d95d0f39643edfafa7bf12", size = 45419374, upload-time = "2026-04-22T09:15:56.014Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/a7/f4bfb86f87e107703146e703204cec2c0eae2492b633e0052b0ace3febb6/tilelang-0.1.9-cp38-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:77ab0ee2f40f66ea015b6b21426d482751e28cbc635ef9d1198cbd6502454a7c", size = 42110365, upload-time = "2026-04-22T09:17:18.292Z" },
+]
+
 [[package]]
 name = "tinycss2"
 version = "1.4.0"
@@ -6795,6 +7242,30 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/72/f4/0de46cfa12cdcbcd464cc59fde36912af405696f687e53a091fb432f694c/tokenizers-0.22.2-cp39-abi3-win_arm64.whl", hash = "sha256:9ce725d22864a1e965217204946f830c37876eee3b2ba6fc6255e8e903d5fcbc", size = 2612133, upload-time = "2026-01-05T10:45:17.232Z" },
 ]
 
+[[package]]
+name = "tokenspeed-mla"
+version = "0.1.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "apache-tvm-ffi" },
+    { name = "nvidia-cutlass-dsl" },
+    { name = "tokenspeed-triton" },
+    { name = "torch" },
+]
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/42/20/4110d624d81d63f0bee2f19dba7ea0e1d8a31ea50147e6c1db82223c88a4/tokenspeed_mla-0.1.2-py3-none-manylinux_2_28_aarch64.whl", hash = "sha256:592590f36d85e624ecdc5e357ff35e29e761e6d879900dce8b67a6785c8ce75c", size = 743769, upload-time = "2026-05-13T03:30:54.486Z" },
+    { url = "https://files.pythonhosted.org/packages/84/01/4bf8b74ead3e8e7c1c809435396254c067a33fde48acc20f602aae622d97/tokenspeed_mla-0.1.2-py3-none-manylinux_2_28_x86_64.whl", hash = "sha256:c9466a351fe039792e56cf49f3e79744c1dc28c7af10306a02e62b8e92fa5985", size = 748681, upload-time = "2026-05-13T03:30:56.718Z" },
+]
+
+[[package]]
+name = "tokenspeed-triton"
+version = "3.7.10.post20260531"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/84/58/fdb5fb70d99c1f18f01c2198420fa2a0f7e5301bd7dd5b5f34b22a3cb87b/tokenspeed_triton-3.7.10.post20260531-cp312-abi3-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:16cd0a3fc1cffeb458a7e03e8688714f49fdf0b5a108bfca999f46597c3faabb", size = 81636010, upload-time = "2026-05-31T01:29:17.699Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/49/7bae94729bfd7a3f331795251302f0b0c8e54a7ec25b3af5d5bfe133367c/tokenspeed_triton-3.7.10.post20260531-cp312-abi3-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b90ac41e7f15933797545ff1a9e803a9d8beb4ca9ba70f6d41a9e0fc26484f5c", size = 85888791, upload-time = "2026-05-31T01:29:25.584Z" },
+]
+
 [[package]]
 name = "toml"
 version = "0.10.2"
@@ -6856,116 +7327,128 @@ wheels = [
 
 [[package]]
 name = "torch"
-version = "2.9.1"
+version = "2.11.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
+    { name = "cuda-bindings", marker = "sys_platform == 'linux'" },
+    { name = "cuda-toolkit", extra = ["cublas", "cudart", "cufft", "cufile", "cupti", "curand", "cusolver", "cusparse", "nvjitlink", "nvrtc", "nvtx"], marker = "sys_platform == 'linux'" },
     { name = "filelock" },
     { name = "fsspec" },
     { name = "jinja2" },
     { name = "networkx" },
-    { name = "nvidia-cublas-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
-    { name = "nvidia-cuda-cupti-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
-    { name = "nvidia-cuda-nvrtc-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
-    { name = "nvidia-cuda-runtime-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
-    { name = "nvidia-cudnn-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
-    { name = "nvidia-cufft-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
-    { name = "nvidia-cufile-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
-    { name = "nvidia-curand-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
-    { name = "nvidia-cusolver-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
-    { name = "nvidia-cusparse-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
-    { name = "nvidia-cusparselt-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
-    { name = "nvidia-nccl-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
-    { name = "nvidia-nvjitlink-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
-    { name = "nvidia-nvshmem-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
-    { name = "nvidia-nvtx-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
+    { name = "nvidia-cudnn-cu13", marker = "sys_platform == 'linux'" },
+    { name = "nvidia-cusparselt-cu13", marker = "sys_platform == 'linux'" },
+    { name = "nvidia-nccl-cu13", marker = "sys_platform == 'linux'" },
+    { name = "nvidia-nvshmem-cu13", marker = "sys_platform == 'linux'" },
     { name = "setuptools" },
     { name = "sympy" },
-    { name = "triton", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
+    { name = "triton", version = "3.6.0", source = { registry = "https://pypi.org/simple" }, marker = "sys_platform == 'linux'" },
     { name = "typing-extensions" },
 ]
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/0f/27/07c645c7673e73e53ded71705045d6cb5bae94c4b021b03aa8d03eee90ab/torch-2.9.1-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:da5f6f4d7f4940a173e5572791af238cb0b9e21b1aab592bd8b26da4c99f1cd6", size = 104126592, upload-time = "2025-11-12T15:20:41.62Z" },
-    { url = "https://files.pythonhosted.org/packages/19/17/e377a460603132b00760511299fceba4102bd95db1a0ee788da21298ccff/torch-2.9.1-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:27331cd902fb4322252657f3902adf1c4f6acad9dcad81d8df3ae14c7c4f07c4", size = 899742281, upload-time = "2025-11-12T15:22:17.602Z" },
-    { url = "https://files.pythonhosted.org/packages/b1/1a/64f5769025db846a82567fa5b7d21dba4558a7234ee631712ee4771c436c/torch-2.9.1-cp312-cp312-win_amd64.whl", hash = "sha256:81a285002d7b8cfd3fdf1b98aa8df138d41f1a8334fd9ea37511517cedf43083", size = 110940568, upload-time = "2025-11-12T15:21:18.689Z" },
-    { url = "https://files.pythonhosted.org/packages/6e/ab/07739fd776618e5882661d04c43f5b5586323e2f6a2d7d84aac20d8f20bd/torch-2.9.1-cp312-none-macosx_11_0_arm64.whl", hash = "sha256:c0d25d1d8e531b8343bea0ed811d5d528958f1dcbd37e7245bc686273177ad7e", size = 74479191, upload-time = "2025-11-12T15:21:25.816Z" },
-    { url = "https://files.pythonhosted.org/packages/20/60/8fc5e828d050bddfab469b3fe78e5ab9a7e53dda9c3bdc6a43d17ce99e63/torch-2.9.1-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:c29455d2b910b98738131990394da3e50eea8291dfeb4b12de71ecf1fdeb21cb", size = 104135743, upload-time = "2025-11-12T15:21:34.936Z" },
-    { url = "https://files.pythonhosted.org/packages/f2/b7/6d3f80e6918213babddb2a37b46dbb14c15b14c5f473e347869a51f40e1f/torch-2.9.1-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:524de44cd13931208ba2c4bde9ec7741fd4ae6bfd06409a604fc32f6520c2bc9", size = 899749493, upload-time = "2025-11-12T15:24:36.356Z" },
-    { url = "https://files.pythonhosted.org/packages/a6/47/c7843d69d6de8938c1cbb1eba426b1d48ddf375f101473d3e31a5fc52b74/torch-2.9.1-cp313-cp313-win_amd64.whl", hash = "sha256:545844cc16b3f91e08ce3b40e9c2d77012dd33a48d505aed34b7740ed627a1b2", size = 110944162, upload-time = "2025-11-12T15:21:53.151Z" },
-    { url = "https://files.pythonhosted.org/packages/28/0e/2a37247957e72c12151b33a01e4df651d9d155dd74d8cfcbfad15a79b44a/torch-2.9.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:5be4bf7496f1e3ffb1dd44b672adb1ac3f081f204c5ca81eba6442f5f634df8e", size = 74830751, upload-time = "2025-11-12T15:21:43.792Z" },
-    { url = "https://files.pythonhosted.org/packages/4b/f7/7a18745edcd7b9ca2381aa03353647bca8aace91683c4975f19ac233809d/torch-2.9.1-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:30a3e170a84894f3652434b56d59a64a2c11366b0ed5776fab33c2439396bf9a", size = 104142929, upload-time = "2025-11-12T15:21:48.319Z" },
-    { url = "https://files.pythonhosted.org/packages/f4/dd/f1c0d879f2863ef209e18823a988dc7a1bf40470750e3ebe927efdb9407f/torch-2.9.1-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:8301a7b431e51764629208d0edaa4f9e4c33e6df0f2f90b90e261d623df6a4e2", size = 899748978, upload-time = "2025-11-12T15:23:04.568Z" },
-    { url = "https://files.pythonhosted.org/packages/1f/9f/6986b83a53b4d043e36f3f898b798ab51f7f20fdf1a9b01a2720f445043d/torch-2.9.1-cp313-cp313t-win_amd64.whl", hash = "sha256:2e1c42c0ae92bf803a4b2409fdfed85e30f9027a66887f5e7dcdbc014c7531db", size = 111176995, upload-time = "2025-11-12T15:22:01.618Z" },
-    { url = "https://files.pythonhosted.org/packages/40/60/71c698b466dd01e65d0e9514b5405faae200c52a76901baf6906856f17e4/torch-2.9.1-cp313-none-macosx_11_0_arm64.whl", hash = "sha256:2c14b3da5df416cf9cb5efab83aa3056f5b8cd8620b8fde81b4987ecab730587", size = 74480347, upload-time = "2025-11-12T15:21:57.648Z" },
-    { url = "https://files.pythonhosted.org/packages/48/50/c4b5112546d0d13cc9eaa1c732b823d676a9f49ae8b6f97772f795874a03/torch-2.9.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1edee27a7c9897f4e0b7c14cfc2f3008c571921134522d5b9b5ec4ebbc69041a", size = 74433245, upload-time = "2025-11-12T15:22:39.027Z" },
-    { url = "https://files.pythonhosted.org/packages/81/c9/2628f408f0518b3bae49c95f5af3728b6ab498c8624ab1e03a43dd53d650/torch-2.9.1-cp314-cp314-manylinux_2_28_aarch64.whl", hash = "sha256:19d144d6b3e29921f1fc70503e9f2fc572cde6a5115c0c0de2f7ca8b1483e8b6", size = 104134804, upload-time = "2025-11-12T15:22:35.222Z" },
-    { url = "https://files.pythonhosted.org/packages/28/fc/5bc91d6d831ae41bf6e9e6da6468f25330522e92347c9156eb3f1cb95956/torch-2.9.1-cp314-cp314-manylinux_2_28_x86_64.whl", hash = "sha256:c432d04376f6d9767a9852ea0def7b47a7bbc8e7af3b16ac9cf9ce02b12851c9", size = 899747132, upload-time = "2025-11-12T15:23:36.068Z" },
-    { url = "https://files.pythonhosted.org/packages/63/5d/e8d4e009e52b6b2cf1684bde2a6be157b96fb873732542fb2a9a99e85a83/torch-2.9.1-cp314-cp314-win_amd64.whl", hash = "sha256:d187566a2cdc726fc80138c3cdb260970fab1c27e99f85452721f7759bbd554d", size = 110934845, upload-time = "2025-11-12T15:22:48.367Z" },
-    { url = "https://files.pythonhosted.org/packages/bd/b2/2d15a52516b2ea3f414643b8de68fa4cb220d3877ac8b1028c83dc8ca1c4/torch-2.9.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:cb10896a1f7fedaddbccc2017ce6ca9ecaaf990f0973bdfcf405439750118d2c", size = 74823558, upload-time = "2025-11-12T15:22:43.392Z" },
-    { url = "https://files.pythonhosted.org/packages/86/5c/5b2e5d84f5b9850cd1e71af07524d8cbb74cba19379800f1f9f7c997fc70/torch-2.9.1-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:0a2bd769944991c74acf0c4ef23603b9c777fdf7637f115605a4b2d8023110c7", size = 104145788, upload-time = "2025-11-12T15:23:52.109Z" },
-    { url = "https://files.pythonhosted.org/packages/a9/8c/3da60787bcf70add986c4ad485993026ac0ca74f2fc21410bc4eb1bb7695/torch-2.9.1-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:07c8a9660bc9414c39cac530ac83b1fb1b679d7155824144a40a54f4a47bfa73", size = 899735500, upload-time = "2025-11-12T15:24:08.788Z" },
-    { url = "https://files.pythonhosted.org/packages/db/2b/f7818f6ec88758dfd21da46b6cd46af9d1b3433e53ddbb19ad1e0da17f9b/torch-2.9.1-cp314-cp314t-win_amd64.whl", hash = "sha256:c88d3299ddeb2b35dcc31753305612db485ab6f1823e37fb29451c8b2732b87e", size = 111163659, upload-time = "2025-11-12T15:23:20.009Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/8b/69e3008d78e5cee2b30183340cc425081b78afc5eff3d080daab0adda9aa/torch-2.11.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:4b5866312ee6e52ea625cd211dcb97d6a2cdc1131a5f15cc0d87eec948f6dd34", size = 80606338, upload-time = "2026-03-23T18:11:34.781Z" },
+    { url = "https://files.pythonhosted.org/packages/13/16/42e5915ebe4868caa6bac83a8ed59db57f12e9a61b7d749d584776ed53d5/torch-2.11.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:f99924682ef0aa6a4ab3b1b76f40dc6e273fca09f367d15a524266db100a723f", size = 419731115, upload-time = "2026-03-23T18:11:06.944Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/c9/82638ef24d7877510f83baf821f5619a61b45568ce21c0a87a91576510aa/torch-2.11.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:0f68f4ac6d95d12e896c3b7a912b5871619542ec54d3649cf48cc1edd4dd2756", size = 530712279, upload-time = "2026-03-23T18:10:31.481Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/ff/6756f1c7ee302f6d202120e0f4f05b432b839908f9071157302cedfc5232/torch-2.11.0-cp312-cp312-win_amd64.whl", hash = "sha256:fbf39280699d1b869f55eac536deceaa1b60bd6788ba74f399cc67e60a5fab10", size = 114556047, upload-time = "2026-03-23T18:10:55.931Z" },
+    { url = "https://files.pythonhosted.org/packages/87/89/5ea6722763acee56b045435fb84258db7375c48165ec8be7880ab2b281c5/torch-2.11.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:1e6debd97ccd3205bbb37eb806a9d8219e1139d15419982c09e23ef7d4369d18", size = 80606801, upload-time = "2026-03-23T18:10:18.649Z" },
+    { url = "https://files.pythonhosted.org/packages/32/d1/8ed2173589cbfe744ed54e5a73efc107c0085ba5777ee93a5f4c1ab90553/torch-2.11.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:63a68fa59de8f87acc7e85a5478bb2dddbb3392b7593ec3e78827c793c4b73fd", size = 419732382, upload-time = "2026-03-23T18:08:30.835Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/e1/b73f7c575a4b8f87a5928f50a1e35416b5e27295d8be9397d5293e7e8d4c/torch-2.11.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:cc89b9b173d9adfab59fd227f0ab5e5516d9a52b658ae41d64e59d2e55a418db", size = 530711509, upload-time = "2026-03-23T18:08:47.213Z" },
+    { url = "https://files.pythonhosted.org/packages/66/82/3e3fcdd388fbe54e29fd3f991f36846ff4ac90b0d0181e9c8f7236565f82/torch-2.11.0-cp313-cp313-win_amd64.whl", hash = "sha256:4dda3b3f52d121063a731ddb835f010dc137b920d7fec2778e52f60d8e4bf0cd", size = 114555842, upload-time = "2026-03-23T18:09:52.111Z" },
+    { url = "https://files.pythonhosted.org/packages/db/38/8ac78069621b8c2b4979c2f96dc8409ef5e9c4189f6aac629189a78677ca/torch-2.11.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:8b394322f49af4362d4f80e424bcaca7efcd049619af03a4cf4501520bdf0fb4", size = 80959574, upload-time = "2026-03-23T18:10:14.214Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/6c/56bfb37073e7136e6dd86bfc6af7339946dd684e0ecf2155ac0eee687ae1/torch-2.11.0-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:2658f34ce7e2dabf4ec73b45e2ca68aedad7a5be87ea756ad656eaf32bf1e1ea", size = 419732324, upload-time = "2026-03-23T18:09:36.604Z" },
+    { url = "https://files.pythonhosted.org/packages/07/f4/1b666b6d61d3394cca306ea543ed03a64aad0a201b6cd159f1d41010aeb1/torch-2.11.0-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:98bb213c3084cfe176302949bdc360074b18a9da7ab59ef2edc9d9f742504778", size = 530596026, upload-time = "2026-03-23T18:09:20.842Z" },
+    { url = "https://files.pythonhosted.org/packages/48/6b/30d1459fa7e4b67e9e3fe1685ca1d8bb4ce7c62ef436c3a615963c6c866c/torch-2.11.0-cp313-cp313t-win_amd64.whl", hash = "sha256:a97b94bbf62992949b4730c6cd2cc9aee7b335921ee8dc207d930f2ed09ae2db", size = 114793702, upload-time = "2026-03-23T18:09:47.304Z" },
+    { url = "https://files.pythonhosted.org/packages/26/0d/8603382f61abd0db35841148ddc1ffd607bf3100b11c6e1dab6d2fc44e72/torch-2.11.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:01018087326984a33b64e04c8cb5c2795f9120e0d775ada1f6638840227b04d7", size = 80573442, upload-time = "2026-03-23T18:09:10.117Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/86/7cd7c66cb9cec6be330fff36db5bd0eef386d80c031b581ec81be1d4b26c/torch-2.11.0-cp314-cp314-manylinux_2_28_aarch64.whl", hash = "sha256:2bb3cc54bd0dea126b0060bb1ec9de0f9c7f7342d93d436646516b0330cd5be7", size = 419749385, upload-time = "2026-03-23T18:07:33.77Z" },
+    { url = "https://files.pythonhosted.org/packages/47/e8/b98ca2d39b2e0e4730c0ee52537e488e7008025bc77ca89552ff91021f7c/torch-2.11.0-cp314-cp314-manylinux_2_28_x86_64.whl", hash = "sha256:4dc8b3809469b6c30b411bb8c4cad3828efd26236153d9beb6a3ec500f211a60", size = 530716756, upload-time = "2026-03-23T18:07:50.02Z" },
+    { url = "https://files.pythonhosted.org/packages/78/88/d4a4cda8362f8a30d1ed428564878c3cafb0d87971fbd3947d4c84552095/torch-2.11.0-cp314-cp314-win_amd64.whl", hash = "sha256:2b4e811728bd0cc58fb2b0948fe939a1ee2bf1422f6025be2fca4c7bd9d79718", size = 114552300, upload-time = "2026-03-23T18:09:05.617Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/46/4419098ed6d801750f26567b478fc185c3432e11e2cad712bc6b4c2ab0d0/torch-2.11.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:8245477871c3700d4370352ffec94b103cfcb737229445cf9946cddb7b2ca7cd", size = 80959460, upload-time = "2026-03-23T18:09:00.818Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/66/54a56a4a6ceaffb567231994a9745821d3af922a854ed33b0b3a278e0a99/torch-2.11.0-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:ab9a8482f475f9ba20e12db84b0e55e2f58784bdca43a854a6ccd3fd4b9f75e6", size = 419735835, upload-time = "2026-03-23T18:07:18.974Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/e7/0b6665f533aa9e337662dc190425abc0af1fe3234088f4454c52393ded61/torch-2.11.0-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:563ed3d25542d7e7bbc5b235ccfacfeb97fb470c7fee257eae599adb8005c8a2", size = 530613405, upload-time = "2026-03-23T18:08:07.014Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/bf/c8d12a2c86dbfd7f40fb2f56fbf5a505ccf2d9ce131eb559dfc7c51e1a04/torch-2.11.0-cp314-cp314t-win_amd64.whl", hash = "sha256:b2a43985ff5ef6ddd923bbcf99943e5f58059805787c5c9a2622bf05ca2965b0", size = 114792991, upload-time = "2026-03-23T18:08:19.216Z" },
 ]
 
 [[package]]
-name = "torchaudio"
-version = "2.9.1"
+name = "torch-c-dlpack-ext"
+version = "0.1.5"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "torch" },
 ]
+sdist = { url = "https://files.pythonhosted.org/packages/37/de/921b6491efce5c389a5ef9bbed3d2d6660005840dae488124173180859ab/torch_c_dlpack_ext-0.1.5.tar.gz", hash = "sha256:d06f0357d575d22a168cc77acb9020fc4bae30968ceb6718a055dcbe92bacabe", size = 12913, upload-time = "2026-01-12T11:25:08.484Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/f1/83/71cbadd7b66753818b5775f2088bad4f721d581de276996df4968000a626/torchaudio-2.9.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:7581ef170794c599aed55918e00d0acd9e5c9a0f19400c9a9a840955180365c5", size = 808098, upload-time = "2025-11-12T15:26:01.408Z" },
-    { url = "https://files.pythonhosted.org/packages/ef/2d/32e8bec360459107f9b451cc1a5b6fdd5f1d3e653e65a111502084f21e3a/torchaudio-2.9.1-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:742f9d24db5f1f46d8c7e29c599fe55b866d92c4a8181fcb95eab12da225ceb0", size = 474604, upload-time = "2025-11-12T15:25:49.122Z" },
-    { url = "https://files.pythonhosted.org/packages/fe/0d/b5af1d55ede1ca07769a2cf71256073d8958e2a5521fc734fc19f5343283/torchaudio-2.9.1-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:4533fdafba73d7bcfcb5f1225b2cc8974a290ed0fe54c44638d6f440e91b8999", size = 2059899, upload-time = "2025-11-12T15:26:19.363Z" },
-    { url = "https://files.pythonhosted.org/packages/2e/7c/df90eb0b337cbad59296ed91778e32be069330f5186256d4ce9ea603d324/torchaudio-2.9.1-cp312-cp312-win_amd64.whl", hash = "sha256:923dccc67be4a6cbb45c3dcc2d69ee182bda75b09b69bc88cd3bcdfc739883a2", size = 665337, upload-time = "2025-11-12T15:26:07.407Z" },
-    { url = "https://files.pythonhosted.org/packages/c0/1b/3321ad6379ac2d968064704e8d015c31ccae5d1ece070f87fb44b17d90e6/torchaudio-2.9.1-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:bb69557484c92513a980027ec4cb314b0f43cf4442bbfd97440e66528dbad22d", size = 808136, upload-time = "2025-11-12T15:26:00.276Z" },
-    { url = "https://files.pythonhosted.org/packages/76/e2/fe55b3882157fd57aa131f5bcad90f0329be90827e1c0e0c482662ddef38/torchaudio-2.9.1-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:ba2799ceec5e4373a0aa26df30d608f1eaaefd8ac4a7ae0c3446f63106f5b5a5", size = 474349, upload-time = "2025-11-12T15:26:02.78Z" },
-    { url = "https://files.pythonhosted.org/packages/74/d3/0b090c03cac5a20691507e0945589a696fb10402ccd2457eea47dbf8a71b/torchaudio-2.9.1-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:bc3c8e9a240bfad8bc61f769324a4f3ce5d60eec161369d457c595c35dbb10c7", size = 2060343, upload-time = "2025-11-12T15:26:03.88Z" },
-    { url = "https://files.pythonhosted.org/packages/a0/db/2555cfd428f4bf09a4df1c6f9204d0acc217c46edb35776c16e7a2a9a1c9/torchaudio-2.9.1-cp313-cp313-win_amd64.whl", hash = "sha256:13ee96ea9bbbc85e198cb671273af06f010e6981d7b912d001eef6bc74e23f4f", size = 665301, upload-time = "2025-11-12T15:26:04.952Z" },
-    { url = "https://files.pythonhosted.org/packages/0c/58/e82d8b5f447abdddc950965f1395f36baef3602643dd069100c6369ba73e/torchaudio-2.9.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:9290f6a6409deb1f9113d5aef97ec646eeee6410b6bcc57ab8b57066b54da7c1", size = 813456, upload-time = "2025-11-12T15:26:13.963Z" },
-    { url = "https://files.pythonhosted.org/packages/ce/45/dd9ad6af9bb595095cd98028d270f933760968b92a3497282e31289ef3b4/torchaudio-2.9.1-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:eeae7ca60b64c4bfb78fbd104a089d072b151423d5d2f90da1da00787f03b800", size = 476577, upload-time = "2025-11-12T15:26:09.54Z" },
-    { url = "https://files.pythonhosted.org/packages/79/97/c49aeb01d8a9ced2b8215a38b69b8eafd1afe295a487a73b7030c6ff3396/torchaudio-2.9.1-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:5f445e896215e6f7bba497dc68aab1e6cb077ae0ab3a90095067f16df6a9bb98", size = 2062158, upload-time = "2025-11-12T15:26:10.487Z" },
-    { url = "https://files.pythonhosted.org/packages/ba/70/30b2a0ecca2a0a5e6a8cee8952fdea3872854ea5bcd86fe3df369fdc2543/torchaudio-2.9.1-cp313-cp313t-win_amd64.whl", hash = "sha256:c558ba70d548f7491245ed7a35310f6310d83fc7591f073ab5fed9fd38cef987", size = 669253, upload-time = "2025-11-12T15:26:06.285Z" },
-    { url = "https://files.pythonhosted.org/packages/5b/38/0dabf362f946ab5773d3db3322718d652d70ad12a82f500d54c6c8b9cc88/torchaudio-2.9.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:69a582650279ee16ff9087f99b4234fe5d766e1bf7f0be352db5f46991854c1e", size = 810496, upload-time = "2025-11-12T15:26:11.515Z" },
-    { url = "https://files.pythonhosted.org/packages/05/1c/e05a32ee6868dc05463242db672f23dba5d042423fefcf294db4dac343a8/torchaudio-2.9.1-cp314-cp314-manylinux_2_28_aarch64.whl", hash = "sha256:9c0d004f784c49078017f8217fdc901df0eb9724e50fb269b3a6c99b1d4eae75", size = 474566, upload-time = "2025-11-12T15:26:08.628Z" },
-    { url = "https://files.pythonhosted.org/packages/15/52/8cec1fe90f05b888f9060467e1eb8c27f9295b8729a83d443e3bd7c471d3/torchaudio-2.9.1-cp314-cp314-manylinux_2_28_x86_64.whl", hash = "sha256:d2743b28ff5538d5fdf2ff6657d392852ccdfe640ede46f566b2907ca32d8dca", size = 2060358, upload-time = "2025-11-12T15:26:12.885Z" },
-    { url = "https://files.pythonhosted.org/packages/04/73/6ba396813d714f895f86c82be61b590fbe14255ebe6866f5ea5916c075a3/torchaudio-2.9.1-cp314-cp314-win_amd64.whl", hash = "sha256:234c7a9d4d0a6ed735cd37965baa9a89ca36bdbebece8a6a5ff7727acbb43026", size = 665039, upload-time = "2025-11-12T15:26:18.308Z" },
-    { url = "https://files.pythonhosted.org/packages/9c/f6/237e00a04dea497a40a8567d024dfb39193abec3ca3695ad51919ad633d1/torchaudio-2.9.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:e13cb38971ac259fc4e102282a3e48f6df5f0ab00eb785ca5155e3392d1e86f1", size = 813463, upload-time = "2025-11-12T15:26:16.261Z" },
-    { url = "https://files.pythonhosted.org/packages/57/99/5fcd46a80086030899badeb5a934fab337c88325b3f68c60faa0b672d4d2/torchaudio-2.9.1-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:35c96ed1011b50eaf17948da173b09450cdc5bb7f908687571adb4a4c072c05e", size = 476577, upload-time = "2025-11-12T15:26:17.355Z" },
-    { url = "https://files.pythonhosted.org/packages/a4/4c/bc428f71d5ef728fba2ecb151a3a6d187e6f0b9446b76e4f87e46d2206a3/torchaudio-2.9.1-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:c220c4acf9914cce2dc81c3624d7c84008ef436dc31bcbb89e8f4416d3615a34", size = 2062170, upload-time = "2025-11-12T15:26:20.837Z" },
-    { url = "https://files.pythonhosted.org/packages/07/0e/be41f412e1225bdbd9b7fd7f41a20f070c707f5274b82542eeccf6dc2b79/torchaudio-2.9.1-cp314-cp314t-win_amd64.whl", hash = "sha256:cfd12934c7b54b41d4c79dfd26fbfe88fafa9cc5cc77c074e953bb7018d9322c", size = 669265, upload-time = "2025-11-12T15:26:14.976Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/67/10d236698525d7b7db4d74ec0a4b01f5b2db33968995fdd9ac6b4635e327/torch_c_dlpack_ext-0.1.5-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:c0f2bd51fcd99c0e5b50314e1985f2728c4941bfa821f065e6c30951d1f995ca", size = 5291237, upload-time = "2026-01-12T11:24:44.011Z" },
+    { url = "https://files.pythonhosted.org/packages/87/06/8d760997307a5c3be4384424667bf31aae0a42060838c532c7d846516175/torch_c_dlpack_ext-0.1.5-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3562ee411258676f9c38b8ad39306d1c8d027b6a86f6a87c920d2d009a9d1510", size = 443069, upload-time = "2026-01-12T11:24:45.451Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/79/a914539b4785f3e44f891aa012a886edb8bc10fe081c440981c57543ce21/torch_c_dlpack_ext-0.1.5-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e6f9da4bb9af70e27facc777458be62e10dbbbddda7672d16138db0553c5a524", size = 897846, upload-time = "2026-01-12T11:24:48.168Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/e6/7d7a97a3953208d6d6ce749180c34d1dab48464ded9a76cecabe9d021ce6/torch_c_dlpack_ext-0.1.5-cp312-cp312-win_amd64.whl", hash = "sha256:670fbbab70123cc228bed41693a3720757af57a0ad22669063c9db25321e8f55", size = 1482855, upload-time = "2026-01-12T11:24:49.581Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/c6/65346a201d921b616731311fc9941f15137672b444cebdad702cb52ccee0/torch_c_dlpack_ext-0.1.5-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:74acea2ed395cadda63342845b9e9ee7cd4537846223dacfb4431b4610109265", size = 1993243, upload-time = "2026-01-12T11:24:51.079Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/ec/faf10be09a5812b1c5ec9922b53fb5def5fc4080b81a653b9347bb169ebb/torch_c_dlpack_ext-0.1.5-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:49f1e99d13c64e22dac0a34a1560e9e5a398a49a9fa81df83053e04fde6ec5bd", size = 443798, upload-time = "2026-01-12T11:24:52.754Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/68/f434b48700f3e04f33882f54d8d3910327b935f55e14ec49da7d607bf470/torch_c_dlpack_ext-0.1.5-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:debe62e5ef93e631065d6b9f6e60d3d39bae6b89fa1b25d9523f40b3efbf8aba", size = 755004, upload-time = "2026-01-12T11:24:54.004Z" },
+    { url = "https://files.pythonhosted.org/packages/03/a8/cc64e563f05ea99bd79bdb43f71f0f46452d3acd734da4843ede5fc73a35/torch_c_dlpack_ext-0.1.5-cp313-cp313-win_amd64.whl", hash = "sha256:30e3eab616dbc81dfdb7492aca557be551a9163ba9b585f97394a42b336b113a", size = 999126, upload-time = "2026-01-12T11:24:55.44Z" },
+    { url = "https://files.pythonhosted.org/packages/96/5e/449324ca8e81573e650b6851fc31c1038f750d1de85d0b185d788e1c7a3a/torch_c_dlpack_ext-0.1.5-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:cac94a4905d391889e679a8da31e46dc325af5d55d13b7c70c0ce3d71d1ced6d", size = 1982154, upload-time = "2026-01-12T11:24:58.038Z" },
+    { url = "https://files.pythonhosted.org/packages/20/62/11c05b99f69aa5152bca0313e0dfa6d125a020cf890dc888ef009aa7891c/torch_c_dlpack_ext-0.1.5-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3a58fdf45fb0bda7bc459632cec891570f31c11636d5851c825cf308ec8b73c2", size = 163825, upload-time = "2026-01-12T11:24:59.474Z" },
+    { url = "https://files.pythonhosted.org/packages/15/b5/be613cd8e71c9982bd07af530f86c5a7f30df7831d14cec5414857af7149/torch_c_dlpack_ext-0.1.5-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7b985a324c68241cf83a9474b28015524b66775b12a91930dd4c0760aa628d01", size = 171740, upload-time = "2026-01-12T11:25:00.776Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/11/52e291f1659e2ec70a09f5ca4ad27e015eb4f0a1371ae68d23a9fbd1c704/torch_c_dlpack_ext-0.1.5-cp314-cp314-win_amd64.whl", hash = "sha256:d794e19fa3f330ab7a29987c07e031fc08e4953aec516d35701d0827863e356b", size = 277086, upload-time = "2026-01-12T11:25:01.901Z" },
+]
+
+[[package]]
+name = "torchaudio"
+version = "2.11.0"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f1/b1/77658817acacd01a72b714440c62f419efc4d90170e704e8e7a2c0918988/torchaudio-2.11.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:a1cf1acc883bee9cb906a933572fed6a8a933f86ef34e9ea7d803f72317e8c1b", size = 684226, upload-time = "2026-03-23T18:13:40.023Z" },
+    { url = "https://files.pythonhosted.org/packages/78/28/c7adc053039f286c2aca0038b766cbe3294e66fec6b29a820e95128f9ede/torchaudio-2.11.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:bc653defca1c16154398517a1adc98d0fb7f1dd08e58ced217558d213c2c6e29", size = 1626670, upload-time = "2026-03-23T18:13:42.162Z" },
+    { url = "https://files.pythonhosted.org/packages/88/d8/d6d0f896e064aa67377484efef4911cdcc07bce2929474e1417cc0af18c2/torchaudio-2.11.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:6503c0bdb29daf2e6281bb70ea2dfe2c3553b782b619eb5d73bdadd8a3f7cecf", size = 1771992, upload-time = "2026-03-23T18:13:33.188Z" },
+    { url = "https://files.pythonhosted.org/packages/23/a8/941277ecc39f7a0a169d554302a1f1afd87c1d94a8aec828891916cea59a/torchaudio-2.11.0-cp312-cp312-win_amd64.whl", hash = "sha256:478110f981e5d40a8d82221732c57a56c85a1d5895fb8fe646e86ee15eded3bd", size = 328663, upload-time = "2026-03-23T18:13:19.218Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/9e/f76fcd9877c8c78f258ee34e0fb8291fdb91e6218d582d9ca66b1e4bd4ae/torchaudio-2.11.0-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:e3f9696a9ef1d49acc452159b052370c636406d072e9d8f10895fda87b591ea9", size = 679904, upload-time = "2026-03-23T18:13:28.329Z" },
+    { url = "https://files.pythonhosted.org/packages/85/70/249c1498ebdad3e7752866635ec0855fc0dcf898beccda5a9d2b9df8e4d0/torchaudio-2.11.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:b034d7672f1c415434f48ef17807f2cce47f29e8795338c751d4e596c9fbe8b5", size = 1618523, upload-time = "2026-03-23T18:13:15.703Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/98/be13fe35d9aa5c26381c0e453c828a789d15c007f8f7d08c95341d19974d/torchaudio-2.11.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:1c1101c1243ef0e4063ec63298977e2d3655c15cf88d9eb0a1bd4fe2db9f47ea", size = 1771992, upload-time = "2026-03-23T18:13:35.343Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/8b/2bbb3dca6ff28cba0de250874d5ef4fc2822c47a934b59b3974cff3219ef/torchaudio-2.11.0-cp313-cp313-win_amd64.whl", hash = "sha256:986f4df5ed17b003dc52489468601720090e65f964f8bebccf90eb45bba75744", size = 328662, upload-time = "2026-03-23T18:13:18.308Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/ce/52c652d30af7d6e96c8f1735d26131e94708e3f38d852b8fa97958804dd8/torchaudio-2.11.0-cp313-cp313t-macosx_12_0_arm64.whl", hash = "sha256:bda09ea630ae7207384fb0f28c35e4f8c0d82dd6eba020b6b335ad0caa9fed49", size = 680814, upload-time = "2026-03-23T18:13:17.08Z" },
+    { url = "https://files.pythonhosted.org/packages/06/95/1ad1507482e7263e556709a3f5f87fecd375a0742cdaf238806c8e72eaad/torchaudio-2.11.0-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:9fe3083c62e035646483a14e180d33561bdc2eed436c9ab1259c137fb7120b4a", size = 1618546, upload-time = "2026-03-23T18:13:29.686Z" },
+    { url = "https://files.pythonhosted.org/packages/98/4c/480328ba07487eb9890406720304d0d460dd7a6a64098614f5aa53b662ca/torchaudio-2.11.0-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:13cff988697ccbad539987599f9dc672f40c417bed67570b365e4e5002bbd096", size = 1771991, upload-time = "2026-03-23T18:13:30.843Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/98/5d4790e2d6548768999acd34999d5aeefce8bcc23a07afaa5f03e723f557/torchaudio-2.11.0-cp313-cp313t-win_amd64.whl", hash = "sha256:ed404c4399ad7f172c86a47c1b25293d322d1d58e26b10b0456a86cf67d37d84", size = 328661, upload-time = "2026-03-23T18:13:34.359Z" },
+    { url = "https://files.pythonhosted.org/packages/39/fe/ffa618b4f0d9732d7df7a2fa2bd48657d896599bc224e5af3c70d46c546b/torchaudio-2.11.0-cp314-cp314-macosx_12_0_arm64.whl", hash = "sha256:cc09cd1f6015b8549e7fe255fb1be5346b57e7fee06541d3f3dbb012d8c4715f", size = 679901, upload-time = "2026-03-23T18:13:25.472Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/54/f414d7b92dd0b3094a2409c95a97bd6c49aa0620da722a0e55462f9bd9cb/torchaudio-2.11.0-cp314-cp314-manylinux_2_28_aarch64.whl", hash = "sha256:79fb3cb99169fd41bd9719647261402a164da0d105a4d81f42a3260844ec5e79", size = 1618527, upload-time = "2026-03-23T18:13:26.68Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/a8/bf2e1f6ce24c990192400ae49b4acc1a0d0295b6c6a06bceecdc46ce08de/torchaudio-2.11.0-cp314-cp314-manylinux_2_28_x86_64.whl", hash = "sha256:00e9f71ab9c656f0abdb40c515bd65d4658ab0ad380dee27a2efd7d51dabd3d6", size = 1771995, upload-time = "2026-03-23T18:13:23.373Z" },
+    { url = "https://files.pythonhosted.org/packages/83/6f/b0efb44e0bfe8dd4d78d76ae3be280354e1fb5c8631c782785d74cd8a7b1/torchaudio-2.11.0-cp314-cp314-win_amd64.whl", hash = "sha256:1424638adb8bb40087bc7b6eb103e8e4fe398210f09076f33b7b5e61501b5d66", size = 328662, upload-time = "2026-03-23T18:13:32.243Z" },
+    { url = "https://files.pythonhosted.org/packages/60/84/1c792b0b700eac9a96772cfd9f96c097b17bca3234a2fde3c64b8063660d/torchaudio-2.11.0-cp314-cp314t-macosx_12_0_arm64.whl", hash = "sha256:da2725e250866da42a12934c9a6552f65a18b7187fd7a6221387f0e605fb3b96", size = 679926, upload-time = "2026-03-23T18:13:24.452Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/a0/62a5842062f739239691f2e57523e0570dd06704ad987755f7644a3afa23/torchaudio-2.11.0-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:1be3767064364ae82705bdf2b15c1e8b41fea82c4cd04d47428a8684b634b6ed", size = 1618552, upload-time = "2026-03-23T18:13:21.09Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/89/c293d818f9f899db93bf291b42401c05ae29acfb2e53d5341c30ea703e62/torchaudio-2.11.0-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:67f6edac29ed004652c11db5c19d9debb5d835695930574f564efc8bdd061bba", size = 1771986, upload-time = "2026-03-23T18:13:22.153Z" },
+    { url = "https://files.pythonhosted.org/packages/93/f7/ee5da8c03f1a3c7662c6c6a119f24a4b3e646da94be56dce3201e3a6ee9b/torchaudio-2.11.0-cp314-cp314t-win_amd64.whl", hash = "sha256:88fb5e29f670a33d9bac6aabb1d2734460cf6e461bde5cdc352826035851b16d", size = 328661, upload-time = "2026-03-23T18:13:20.1Z" },
 ]
 
 [[package]]
 name = "torchvision"
-version = "0.24.1"
+version = "0.26.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "numpy" },
+    { name = "numpy", version = "2.3.5", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.13'" },
+    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.13'" },
     { name = "pillow" },
     { name = "torch" },
 ]
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/f0/af/18e2c6b9538a045f60718a0c5a058908ccb24f88fde8e6f0fc12d5ff7bd3/torchvision-0.24.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:e48bf6a8ec95872eb45763f06499f87bd2fb246b9b96cb00aae260fda2f96193", size = 1891433, upload-time = "2025-11-12T15:25:03.232Z" },
-    { url = "https://files.pythonhosted.org/packages/9d/43/600e5cfb0643d10d633124f5982d7abc2170dfd7ce985584ff16edab3e76/torchvision-0.24.1-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:7fb7590c737ebe3e1c077ad60c0e5e2e56bb26e7bccc3b9d04dbfc34fd09f050", size = 2386737, upload-time = "2025-11-12T15:25:08.288Z" },
-    { url = "https://files.pythonhosted.org/packages/93/b1/db2941526ecddd84884132e2742a55c9311296a6a38627f9e2627f5ac889/torchvision-0.24.1-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:66a98471fc18cad9064123106d810a75f57f0838eee20edc56233fd8484b0cc7", size = 8049868, upload-time = "2025-11-12T15:25:13.058Z" },
-    { url = "https://files.pythonhosted.org/packages/69/98/16e583f59f86cd59949f59d52bfa8fc286f86341a229a9d15cbe7a694f0c/torchvision-0.24.1-cp312-cp312-win_amd64.whl", hash = "sha256:4aa6cb806eb8541e92c9b313e96192c6b826e9eb0042720e2fa250d021079952", size = 4302006, upload-time = "2025-11-12T15:25:16.184Z" },
-    { url = "https://files.pythonhosted.org/packages/e4/97/ab40550f482577f2788304c27220e8ba02c63313bd74cf2f8920526aac20/torchvision-0.24.1-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:8a6696db7fb71eadb2c6a48602106e136c785642e598eb1533e0b27744f2cce6", size = 1891435, upload-time = "2025-11-12T15:25:28.642Z" },
-    { url = "https://files.pythonhosted.org/packages/30/65/ac0a3f9be6abdbe4e1d82c915d7e20de97e7fd0e9a277970508b015309f3/torchvision-0.24.1-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:db2125c46f9cb25dc740be831ce3ce99303cfe60439249a41b04fd9f373be671", size = 2338718, upload-time = "2025-11-12T15:25:26.19Z" },
-    { url = "https://files.pythonhosted.org/packages/10/b5/5bba24ff9d325181508501ed7f0c3de8ed3dd2edca0784d48b144b6c5252/torchvision-0.24.1-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:f035f0cacd1f44a8ff6cb7ca3627d84c54d685055961d73a1a9fb9827a5414c8", size = 8049661, upload-time = "2025-11-12T15:25:22.558Z" },
-    { url = "https://files.pythonhosted.org/packages/5c/ec/54a96ae9ab6a0dd66d4bba27771f892e36478a9c3489fa56e51c70abcc4d/torchvision-0.24.1-cp313-cp313-win_amd64.whl", hash = "sha256:16274823b93048e0a29d83415166a2e9e0bf4e1b432668357b657612a4802864", size = 4319808, upload-time = "2025-11-12T15:25:17.318Z" },
-    { url = "https://files.pythonhosted.org/packages/d5/f3/a90a389a7e547f3eb8821b13f96ea7c0563cdefbbbb60a10e08dda9720ff/torchvision-0.24.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:e3f96208b4bef54cd60e415545f5200346a65024e04f29a26cd0006dbf9e8e66", size = 2005342, upload-time = "2025-11-12T15:25:11.871Z" },
-    { url = "https://files.pythonhosted.org/packages/a9/fe/ff27d2ed1b524078164bea1062f23d2618a5fc3208e247d6153c18c91a76/torchvision-0.24.1-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:f231f6a4f2aa6522713326d0d2563538fa72d613741ae364f9913027fa52ea35", size = 2341708, upload-time = "2025-11-12T15:25:25.08Z" },
-    { url = "https://files.pythonhosted.org/packages/b1/b9/d6c903495cbdfd2533b3ef6f7b5643ff589ea062f8feb5c206ee79b9d9e5/torchvision-0.24.1-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:1540a9e7f8cf55fe17554482f5a125a7e426347b71de07327d5de6bfd8d17caa", size = 8177239, upload-time = "2025-11-12T15:25:18.554Z" },
-    { url = "https://files.pythonhosted.org/packages/4f/2b/ba02e4261369c3798310483028495cf507e6cb3f394f42e4796981ecf3a7/torchvision-0.24.1-cp313-cp313t-win_amd64.whl", hash = "sha256:d83e16d70ea85d2f196d678bfb702c36be7a655b003abed84e465988b6128938", size = 4251604, upload-time = "2025-11-12T15:25:34.069Z" },
-    { url = "https://files.pythonhosted.org/packages/42/84/577b2cef8f32094add5f52887867da4c2a3e6b4261538447e9b48eb25812/torchvision-0.24.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:cccf4b4fec7fdfcd3431b9ea75d1588c0a8596d0333245dafebee0462abe3388", size = 2005319, upload-time = "2025-11-12T15:25:23.827Z" },
-    { url = "https://files.pythonhosted.org/packages/5f/34/ecb786bffe0159a3b49941a61caaae089853132f3cd1e8f555e3621f7e6f/torchvision-0.24.1-cp314-cp314-manylinux_2_28_aarch64.whl", hash = "sha256:1b495edd3a8f9911292424117544f0b4ab780452e998649425d1f4b2bed6695f", size = 2338844, upload-time = "2025-11-12T15:25:32.625Z" },
-    { url = "https://files.pythonhosted.org/packages/51/99/a84623786a6969504c87f2dc3892200f586ee13503f519d282faab0bb4f0/torchvision-0.24.1-cp314-cp314-manylinux_2_28_x86_64.whl", hash = "sha256:ab211e1807dc3e53acf8f6638df9a7444c80c0ad050466e8d652b3e83776987b", size = 8175144, upload-time = "2025-11-12T15:25:31.355Z" },
-    { url = "https://files.pythonhosted.org/packages/6d/ba/8fae3525b233e109317ce6a9c1de922ab2881737b029a7e88021f81e068f/torchvision-0.24.1-cp314-cp314-win_amd64.whl", hash = "sha256:18f9cb60e64b37b551cd605a3d62c15730c086362b40682d23e24b616a697d41", size = 4234459, upload-time = "2025-11-12T15:25:19.859Z" },
-    { url = "https://files.pythonhosted.org/packages/50/33/481602c1c72d0485d4b3a6b48c9534b71c2957c9d83bf860eb837bf5a620/torchvision-0.24.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:ec9d7379c519428395e4ffda4dbb99ec56be64b0a75b95989e00f9ec7ae0b2d7", size = 2005336, upload-time = "2025-11-12T15:25:27.225Z" },
-    { url = "https://files.pythonhosted.org/packages/d0/7f/372de60bf3dd8f5593bd0d03f4aecf0d1fd58f5bc6943618d9d913f5e6d5/torchvision-0.24.1-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:af9201184c2712d808bd4eb656899011afdfce1e83721c7cb08000034df353fe", size = 2341704, upload-time = "2025-11-12T15:25:29.857Z" },
-    { url = "https://files.pythonhosted.org/packages/36/9b/0f3b9ff3d0225ee2324ec663de0e7fb3eb855615ca958ac1875f22f1f8e5/torchvision-0.24.1-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:9ef95d819fd6df81bc7cc97b8f21a15d2c0d3ac5dbfaab5cbc2d2ce57114b19e", size = 8177422, upload-time = "2025-11-12T15:25:37.357Z" },
-    { url = "https://files.pythonhosted.org/packages/d6/ab/e2bcc7c2f13d882a58f8b30ff86f794210b075736587ea50f8c545834f8a/torchvision-0.24.1-cp314-cp314t-win_amd64.whl", hash = "sha256:480b271d6edff83ac2e8d69bbb4cf2073f93366516a50d48f140ccfceedb002e", size = 4335190, upload-time = "2025-11-12T15:25:35.745Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/e7/56b47cc3b132aea90ccce22bcb8975dec688b002150012acc842846039d0/torchvision-0.26.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:c409e1c3fdebec7a3834465086dbda8bf7680eff79abf7fd2f10c6b59520a7a4", size = 1863502, upload-time = "2026-03-23T18:12:57.326Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/ec/5c31c92c08b65662fe9604a4067ae8232582805949f11ddc042cebe818ed/torchvision-0.26.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:406557718e62fdf10f5706e88d8a5ec000f872da913bf629aab9297622585547", size = 7767944, upload-time = "2026-03-23T18:12:42.805Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/d8/cb6ccda1a1f35a6597645818641701207b3e8e13553e75fce5d86bac74b2/torchvision-0.26.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:d61a5abb6b42a0c0c311996c2ac4b83a94418a97182c83b055a2a4ae985e05aa", size = 7522205, upload-time = "2026-03-23T18:12:54.654Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/a9/c272623a0f735c35f0f6cd6dc74784d4f970e800cf063bb76687895a2ab9/torchvision-0.26.0-cp312-cp312-win_amd64.whl", hash = "sha256:7993c01648e7c61d191b018e84d38fe0825c8fcb2720cd0f37caf7ba14404aa1", size = 4255155, upload-time = "2026-03-23T18:12:32.652Z" },
+    { url = "https://files.pythonhosted.org/packages/da/80/0762f77f53605d10c9477be39bb47722cc8e383bbbc2531471ce0e396c07/torchvision-0.26.0-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:5d63dd43162691258b1b3529b9041bac7d54caa37eae0925f997108268cbf7c4", size = 1860809, upload-time = "2026-03-23T18:12:47.629Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/81/0b3e58d1478c660a5af4268713486b2df7203f35abd9195fea87348a5178/torchvision-0.26.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:a39c7a26538c41fda453f9a9692b5ff9b35a5437db1d94f3027f6f509c160eac", size = 7727494, upload-time = "2026-03-23T18:12:46.062Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/dc/d9ab5d29115aa05e12e30f1397a3eeae1d88a511241dc3bce48dc4342675/torchvision-0.26.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:b7e6213620bbf97742e5f79832f9e9d769e6cf0f744c5b53dad80b76db633691", size = 7521747, upload-time = "2026-03-23T18:12:36.815Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/1b/f1bc86a918c5f6feab1eeff11982e2060f4704332e96185463d27855bdf5/torchvision-0.26.0-cp313-cp313-win_amd64.whl", hash = "sha256:4280c35ec8cba1fcc8294fb87e136924708726864c379e4c54494797d86bc474", size = 4319880, upload-time = "2026-03-23T18:12:38.168Z" },
+    { url = "https://files.pythonhosted.org/packages/66/28/b4ad0a723ed95b003454caffcc41894b34bd8379df340848cae2c33871de/torchvision-0.26.0-cp313-cp313t-macosx_12_0_arm64.whl", hash = "sha256:358fc4726d0c08615b6d83b3149854f11efb2a564ed1acb6fce882e151412d23", size = 1951973, upload-time = "2026-03-23T18:12:48.781Z" },
+    { url = "https://files.pythonhosted.org/packages/71/e2/7a89096e6cf2f3336353b5338ba925e0addf9d8601920340e6bdf47e8eb3/torchvision-0.26.0-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:3daf9cc149cf3cdcbd4df9c59dae69ffca86c6823250442c3bbfd63fc2e26c61", size = 7728679, upload-time = "2026-03-23T18:12:26.196Z" },
+    { url = "https://files.pythonhosted.org/packages/69/1d/4e1eebc17d18ce080a11dcf3df3f8f717f0efdfa00983f06e8ba79259f61/torchvision-0.26.0-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:82c3965eca27e86a316e31e4c3e5a16d353e0bcbe0ef8efa2e66502c54493c4b", size = 7609138, upload-time = "2026-03-23T18:12:35.327Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/a4/f1155e943ae5b32400d7000adc81c79bb0392b16ceb33bcf13e02e48cced/torchvision-0.26.0-cp313-cp313t-win_amd64.whl", hash = "sha256:ebc043cc5a4f0bf22e7680806dbba37ffb19e70f6953bbb44ed1a90aeb5c9bea", size = 4248202, upload-time = "2026-03-23T18:12:41.423Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/c8/9bffa9c7f7bdf95b2a0a2dc535c290b9f1cc580c3fb3033ab1246ffffdeb/torchvision-0.26.0-cp314-cp314-macosx_12_0_arm64.whl", hash = "sha256:eb61804eb9dbe88c5a2a6c4da8dec1d80d2d0a6f18c999c524e32266cb1ebcd3", size = 1860813, upload-time = "2026-03-23T18:12:39.636Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/ac/48f28ffd227991f2e14f4392dde7e8dc14352bb9428c1ef4a4bbf5f7ed85/torchvision-0.26.0-cp314-cp314-manylinux_2_28_aarch64.whl", hash = "sha256:9a904f2131cbfadab4df828088a9f66291ad33f49ff853872aed1f86848ef776", size = 7727777, upload-time = "2026-03-23T18:12:22.549Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/21/a2266f7f1b0e58e624ff15fd6f01041f59182c49551ece0db9a183071329/torchvision-0.26.0-cp314-cp314-manylinux_2_28_x86_64.whl", hash = "sha256:0f3e572efe62ad645017ea847e0b5e4f2f638d4e39f05bc011d1eb9ac68d4806", size = 7522174, upload-time = "2026-03-23T18:12:29.565Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/ba/1666f90bc0bdd77aaa11dcc42bb9f621a9c3668819c32430452e3d404730/torchvision-0.26.0-cp314-cp314-win_amd64.whl", hash = "sha256:114bec0c0e98aa4ba446f63e2fe7a2cbca37b39ac933987ee4804f65de121800", size = 4348469, upload-time = "2026-03-23T18:12:24.44Z" },
+    { url = "https://files.pythonhosted.org/packages/45/8f/1f0402ac55c2ae15651ff831957d083fe70b2d12282e72612a30ba601512/torchvision-0.26.0-cp314-cp314t-macosx_12_0_arm64.whl", hash = "sha256:b7d3e295624a28b3b1769228ce1345d94cf4d390dd31136766f76f2d20f718da", size = 1860826, upload-time = "2026-03-23T18:12:34.1Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/6a/18a582fe3c5ee26f49b5c9fb21ad8016b4d1c06d10178894a58653946fda/torchvision-0.26.0-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:7058c5878262937e876f20c25867b33724586aa4499e2853b2d52b99a5e51953", size = 7729089, upload-time = "2026-03-23T18:12:31.394Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/9b/f7e119b59499edc00c55c03adc9ec3bd96144d9b81c46852c431f9c64a9a/torchvision-0.26.0-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:8008474855623c6ba52876589dc52df0aa66e518c25eca841445348e5f79844c", size = 7522704, upload-time = "2026-03-23T18:12:20.301Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/6a/09f3844c10643f6c0de5d95abc863420cfaf194c88c7dffd0ac523e2015f/torchvision-0.26.0-cp314-cp314t-win_amd64.whl", hash = "sha256:e9d0e022c19a78552fb055d0414d47fecb4a649309b9968573daea160ba6869c", size = 4454275, upload-time = "2026-03-23T18:12:27.487Z" },
 ]
 
 [[package]]
@@ -7013,7 +7496,8 @@ source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "filelock" },
     { name = "huggingface-hub" },
-    { name = "numpy" },
+    { name = "numpy", version = "2.3.5", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.13'" },
+    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.13'" },
     { name = "packaging" },
     { name = "pyyaml" },
     { name = "regex" },
@@ -7031,12 +7515,41 @@ wheels = [
 name = "triton"
 version = "3.5.1"
 source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version >= '3.14' and sys_platform == 'win32'",
+    "python_full_version >= '3.14' and sys_platform == 'emscripten'",
+    "python_full_version >= '3.14' and sys_platform == 'darwin'",
+    "python_full_version == '3.13.*' and sys_platform == 'win32'",
+    "python_full_version < '3.13' and sys_platform == 'win32'",
+    "python_full_version == '3.13.*' and sys_platform == 'emscripten'",
+    "python_full_version < '3.13' and sys_platform == 'emscripten'",
+    "python_full_version == '3.13.*' and sys_platform == 'darwin'",
+    "python_full_version < '3.13' and sys_platform == 'darwin'",
+]
+
+[[package]]
+name = "triton"
+version = "3.6.0"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version >= '3.14' and platform_machine == 'aarch64' and sys_platform == 'linux'",
+    "(python_full_version >= '3.14' and platform_machine != 'aarch64' and sys_platform == 'linux') or (python_full_version >= '3.14' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'linux' and sys_platform != 'win32')",
+    "python_full_version == '3.13.*' and platform_machine == 'aarch64' and sys_platform == 'linux'",
+    "(python_full_version == '3.13.*' and platform_machine != 'aarch64' and sys_platform == 'linux') or (python_full_version == '3.13.*' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'linux' and sys_platform != 'win32')",
+    "python_full_version < '3.13' and platform_machine == 'aarch64' and sys_platform == 'linux'",
+    "(python_full_version < '3.13' and platform_machine != 'aarch64' and sys_platform == 'linux') or (python_full_version < '3.13' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'linux' and sys_platform != 'win32')",
+]
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/f2/50/9a8358d3ef58162c0a415d173cfb45b67de60176e1024f71fbc4d24c0b6d/triton-3.5.1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d2c6b915a03888ab931a9fd3e55ba36785e1fe70cbea0b40c6ef93b20fc85232", size = 170470207, upload-time = "2025-11-11T17:41:00.253Z" },
-    { url = "https://files.pythonhosted.org/packages/27/46/8c3bbb5b0a19313f50edcaa363b599e5a1a5ac9683ead82b9b80fe497c8d/triton-3.5.1-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f3f4346b6ebbd4fad18773f5ba839114f4826037c9f2f34e0148894cd5dd3dba", size = 170470410, upload-time = "2025-11-11T17:41:06.319Z" },
-    { url = "https://files.pythonhosted.org/packages/37/92/e97fcc6b2c27cdb87ce5ee063d77f8f26f19f06916aa680464c8104ef0f6/triton-3.5.1-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0b4d2c70127fca6a23e247f9348b8adde979d2e7a20391bfbabaac6aebc7e6a8", size = 170579924, upload-time = "2025-11-11T17:41:12.455Z" },
-    { url = "https://files.pythonhosted.org/packages/a4/e6/c595c35e5c50c4bc56a7bac96493dad321e9e29b953b526bbbe20f9911d0/triton-3.5.1-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d0637b1efb1db599a8e9dc960d53ab6e4637db7d4ab6630a0974705d77b14b60", size = 170480488, upload-time = "2025-11-11T17:41:18.222Z" },
-    { url = "https://files.pythonhosted.org/packages/16/b5/b0d3d8b901b6a04ca38df5e24c27e53afb15b93624d7fd7d658c7cd9352a/triton-3.5.1-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bac7f7d959ad0f48c0e97d6643a1cc0fd5786fe61cb1f83b537c6b2d54776478", size = 170582192, upload-time = "2025-11-11T17:41:23.963Z" },
+    { url = "https://files.pythonhosted.org/packages/17/5d/08201db32823bdf77a0e2b9039540080b2e5c23a20706ddba942924ebcd6/triton-3.6.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:374f52c11a711fd062b4bfbb201fd9ac0a5febd28a96fb41b4a0f51dde3157f4", size = 176128243, upload-time = "2026-01-20T16:16:07.857Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/a8/cdf8b3e4c98132f965f88c2313a4b493266832ad47fb52f23d14d4f86bb5/triton-3.6.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:74caf5e34b66d9f3a429af689c1c7128daba1d8208df60e81106b115c00d6fca", size = 188266850, upload-time = "2026-01-20T16:00:43.041Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/12/34d71b350e89a204c2c7777a9bba0dcf2f19a5bfdd70b57c4dbc5ffd7154/triton-3.6.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:448e02fe6dc898e9e5aa89cf0ee5c371e99df5aa5e8ad976a80b93334f3494fd", size = 176133521, upload-time = "2026-01-20T16:16:13.321Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/0b/37d991d8c130ce81a8728ae3c25b6e60935838e9be1b58791f5997b24a54/triton-3.6.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:10c7f76c6e72d2ef08df639e3d0d30729112f47a56b0c81672edc05ee5116ac9", size = 188289450, upload-time = "2026-01-20T16:00:49.136Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/4e/41b0c8033b503fd3cfcd12392cdd256945026a91ff02452bef40ec34bee7/triton-3.6.0-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1722e172d34e32abc3eb7711d0025bb69d7959ebea84e3b7f7a341cd7ed694d6", size = 176276087, upload-time = "2026-01-20T16:16:18.989Z" },
+    { url = "https://files.pythonhosted.org/packages/35/f8/9c66bfc55361ec6d0e4040a0337fb5924ceb23de4648b8a81ae9d33b2b38/triton-3.6.0-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d002e07d7180fd65e622134fbd980c9a3d4211fb85224b56a0a0efbd422ab72f", size = 188400296, upload-time = "2026-01-20T16:00:56.042Z" },
+    { url = "https://files.pythonhosted.org/packages/49/55/5ecf0dcaa0f2fbbd4420f7ef227ee3cb172e91e5fede9d0ecaddc43363b4/triton-3.6.0-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ef5523241e7d1abca00f1d240949eebdd7c673b005edbbce0aca95b8191f1d43", size = 176138577, upload-time = "2026-01-20T16:16:25.426Z" },
+    { url = "https://files.pythonhosted.org/packages/df/3d/9e7eee57b37c80cec63322c0231bb6da3cfe535a91d7a4d64896fcb89357/triton-3.6.0-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a17a5d5985f0ac494ed8a8e54568f092f7057ef60e1b0fa09d3fd1512064e803", size = 188273063, upload-time = "2026-01-20T16:01:07.278Z" },
+    { url = "https://files.pythonhosted.org/packages/48/db/56ee649cab5eaff4757541325aca81f52d02d4a7cd3506776cad2451e060/triton-3.6.0-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0b3a97e8ed304dfa9bd23bb41ca04cdf6b2e617d5e782a8653d616037a5d537d", size = 176274804, upload-time = "2026-01-20T16:16:31.528Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/56/6113c23ff46c00aae423333eb58b3e60bdfe9179d542781955a5e1514cb3/triton-3.6.0-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:46bd1c1af4b6704e554cad2eeb3b0a6513a980d470ccfa63189737340c7746a7", size = 188397994, upload-time = "2026-01-20T16:01:14.236Z" },
 ]
 
 [[package]]
@@ -7095,37 +7608,37 @@ wheels = [
 
 [[package]]
 name = "urllib3"
-version = "2.6.3"
+version = "2.7.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/c7/24/5f1b3bdffd70275f6661c76461e25f024d5a38a46f04aaca912426a2b1d3/urllib3-2.6.3.tar.gz", hash = "sha256:1b62b6884944a57dbe321509ab94fd4d3b307075e0c2eae991ac71ee15ad38ed", size = 435556, upload-time = "2026-01-07T16:24:43.925Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/53/0c/06f8b233b8fd13b9e5ee11424ef85419ba0d8ba0b3138bf360be2ff56953/urllib3-2.7.0.tar.gz", hash = "sha256:231e0ec3b63ceb14667c67be60f2f2c40a518cb38b03af60abc813da26505f4c", size = 433602, upload-time = "2026-05-07T16:13:18.596Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/39/08/aaaad47bc4e9dc8c725e68f9d04865dbcb2052843ff09c97b08904852d84/urllib3-2.6.3-py3-none-any.whl", hash = "sha256:bf272323e553dfb2e87d9bfd225ca7b0f467b919d7bbd355436d3fd37cb0acd4", size = 131584, upload-time = "2026-01-07T16:24:42.685Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/3e/5db95bcf282c52709639744ca2a8b149baccf648e39c8cc87553df9eae0c/urllib3-2.7.0-py3-none-any.whl", hash = "sha256:9fb4c81ebbb1ce9531cce37674bbc6f1360472bc18ca9a553ede278ef7276897", size = 131087, upload-time = "2026-05-07T16:13:17.151Z" },
 ]
 
 [[package]]
 name = "uv"
-version = "0.11.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/2b/e9/691eb77e5e767cdec695db3f91ec259bbb66f9af7c86a8dbe462ef72a120/uv-0.11.1.tar.gz", hash = "sha256:8aa7e4983fabb06d0ba58e8b8c969d568ce495ad5f2f0426af97b55720f0dee1", size = 4007244, upload-time = "2026-03-24T23:14:18.269Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/16/f9/a95c44fba785c27a966087154a8f6825774d49a38b3c5cd35f80e07ca5ca/uv-0.11.1-py3-none-linux_armv6l.whl", hash = "sha256:424b5b412d37838ea6dc11962f037be98b92e83c6ec755509e2af8a4ca3fbf2a", size = 23320598, upload-time = "2026-03-24T23:13:44.998Z" },
-    { url = "https://files.pythonhosted.org/packages/5d/de/b7e24956a2508debf2addefcad93c72165069370f914d90db6264e0cf96a/uv-0.11.1-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:c2133b0532af0217bf252d981bded8bff0c770f174f91f20655f88705f28c03f", size = 22832732, upload-time = "2026-03-24T23:13:33.677Z" },
-    { url = "https://files.pythonhosted.org/packages/93/bd/1ac91bc704c22a427a44262f09e208ae897817a856d0e8dc0d60e4032e92/uv-0.11.1-py3-none-macosx_11_0_arm64.whl", hash = "sha256:1a7b74e5a15b9bc6e61ce807adeca5a2807f557d3f06a5586de1da309d844c1d", size = 21406409, upload-time = "2026-03-24T23:14:32.231Z" },
-    { url = "https://files.pythonhosted.org/packages/34/1d/f767701e1160538d25ee6c1d49ce1e72442970b6658365afdd57339d10e0/uv-0.11.1-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.musllinux_1_1_aarch64.whl", hash = "sha256:fb1f32ec6c7dffb7ae71afaf6bf1defca0bd20a73a25e61226210c0a3e8bb13d", size = 23154066, upload-time = "2026-03-24T23:14:07.334Z" },
-    { url = "https://files.pythonhosted.org/packages/55/21/d2cfa3571557ba68ffd530656b1d7159fe59a6b01be94595351b1eec1c29/uv-0.11.1-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.musllinux_1_1_armv7l.whl", hash = "sha256:0d5cf3c1c96f8afd67072d80479a58c2d69471916bac4ac36cc55f2aa025dc8e", size = 22922490, upload-time = "2026-03-24T23:13:25.83Z" },
-    { url = "https://files.pythonhosted.org/packages/59/3c/68119f555b2ec152235951cc9aa0f40006c5f03d17c98adaab6a3d36d42b/uv-0.11.1-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:5829a254c64b19420b9e48186182d162b01f8da0130e770cbb8851fd138bb820", size = 22923054, upload-time = "2026-03-24T23:14:03.595Z" },
-    { url = "https://files.pythonhosted.org/packages/70/ce/0df944835519372b1d698acaa388baa874cf69a6183b5f0980cb8855b81a/uv-0.11.1-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d4259027e80f4dcc9ae3dceddcd5407173d334484737166fc212e96bb760d6ea", size = 24576177, upload-time = "2026-03-24T23:14:25.263Z" },
-    { url = "https://files.pythonhosted.org/packages/db/04/0076335413c618fe086e5a4762103634552e638a841e12a4bb8f5137d710/uv-0.11.1-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b6169eb49d1d2b5df7a7079162e1242e49ad46c6590c55f05b182fa526963763", size = 25207026, upload-time = "2026-03-24T23:14:11.579Z" },
-    { url = "https://files.pythonhosted.org/packages/bb/57/79c0479e12c2291ad9777be53d813957fa38283975b708eead8e855ba725/uv-0.11.1-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c96a7310a051b1013efffe082f31d718bce0538d4abc20a716d529bf226b7c44", size = 24393748, upload-time = "2026-03-24T23:13:48.553Z" },
-    { url = "https://files.pythonhosted.org/packages/c3/25/9ef73c8b6ef04b0cead7d8f1547034568e3e58f3397b55b83167e587f84a/uv-0.11.1-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:41ccc438dbb905240a3630265feb25be1bda61656ec7c32682a83648a686f4aa", size = 24518525, upload-time = "2026-03-24T23:13:41.129Z" },
-    { url = "https://files.pythonhosted.org/packages/a0/a3/035c7c2feb2139efb5d70f2e9f68912c34f7d92ee2429bacd708824483bb/uv-0.11.1-py3-none-manylinux_2_28_aarch64.whl", hash = "sha256:44f528ba3d66321cea829770982cccb14af142203e4e19d00ff0c23b28e3cd33", size = 23270167, upload-time = "2026-03-24T23:13:51.937Z" },
-    { url = "https://files.pythonhosted.org/packages/25/59/2dd782b537bfd1e41cb06de4f4a529fe2f9bd10034fb3fcce225ec86c1a5/uv-0.11.1-py3-none-manylinux_2_31_riscv64.musllinux_1_1_riscv64.whl", hash = "sha256:4fcc3d5fdea24181d77e7765bf9d16cdd9803fd524820c62c66f91b2e2644d5b", size = 24011976, upload-time = "2026-03-24T23:13:37.402Z" },
-    { url = "https://files.pythonhosted.org/packages/7b/f0/9983e6f31d495cc548f1e211cab5b89a3716f406a2d9d8134b8245ec103c/uv-0.11.1-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:5de9e43a32079b8d57093542b0cd8415adba5ed9944fa49076c0927f3ff927e1", size = 24029605, upload-time = "2026-03-24T23:14:28.819Z" },
-    { url = "https://files.pythonhosted.org/packages/19/dc/9c59e803bfc1b9d6c4c4b7374689c688e9dc0a1ecc2375399d3a59fd4a58/uv-0.11.1-py3-none-musllinux_1_1_i686.whl", hash = "sha256:f13ae98a938effae5deb587a63e7e42f05d6ba9c1661903ef538e4e87b204f8c", size = 23702811, upload-time = "2026-03-24T23:14:21.207Z" },
-    { url = "https://files.pythonhosted.org/packages/7d/77/b1cbfdac0b2dd3e7aa420e9dad1abe8badb47eabd8741a9993586b14f8dc/uv-0.11.1-py3-none-musllinux_1_1_x86_64.whl", hash = "sha256:57d38e8b6f6937e1521da568adf846bb89439c73e146e89a8ab2cfe7bb15657a", size = 24714239, upload-time = "2026-03-24T23:13:29.814Z" },
-    { url = "https://files.pythonhosted.org/packages/e4/d3/94917751acbbb5e053cb366004ae8be3c9664f82aef7de54f55e38ec15cb/uv-0.11.1-py3-none-win32.whl", hash = "sha256:36f4552b24acaa4699b02baeb1bb928202bb98d426dcc5041ab7ebae082a6430", size = 22404606, upload-time = "2026-03-24T23:13:55.614Z" },
-    { url = "https://files.pythonhosted.org/packages/aa/87/8dadfe03944a4a493cd58b6f4f13e5181069a0048aeb2fae7da2c587a542/uv-0.11.1-py3-none-win_amd64.whl", hash = "sha256:d6a1c4cdb1064e9ceaa59e89a7489dd196222a0b90cfb77ca37a909b5e024ea0", size = 24850092, upload-time = "2026-03-24T23:14:15.186Z" },
-    { url = "https://files.pythonhosted.org/packages/38/1b/dad559273df0c8263533afa4a28570cf6804272f379df9830b528a9cf8bc/uv-0.11.1-py3-none-win_arm64.whl", hash = "sha256:3bc9632033c7a280342f9b304bd12eccb47d6965d50ea9ee57ecfaf4f1f393c4", size = 23376127, upload-time = "2026-03-24T23:13:59.59Z" },
+version = "0.11.21"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f3/f9/f45bb1c251962ee614afd58ccd3dc06ada7869d04987efc2858a81cc4e0f/uv-0.11.21.tar.gz", hash = "sha256:083882c73373a16de4c136d54e3386a52388dead5048a07505e25578b157182f", size = 4259001, upload-time = "2026-06-11T18:18:26.468Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/6f/a5/1c863b931f3aba6e07547929b8cb45875038de00678bfd2fbabcd76faeef/uv-0.11.21-py3-none-linux_armv6l.whl", hash = "sha256:48c36eb170a5e7a668c1d13d2c8edeb017a3e6484c224f1521b540a6bda9e50b", size = 23747368, upload-time = "2026-06-11T18:19:21.724Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/8c/66d22f9152a014fbb17b1308394efe274e860b8beb4933f051396f96dd9f/uv-0.11.21-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:88d8283f6ea9f0cdbb7717e6e08e916c32a8b8b7e11c72fcc6426a4c4eeb89e0", size = 22992460, upload-time = "2026-06-11T18:18:33.543Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/f7/31d62c17837c9ae79cc6d5351fc5d54e8926e78b0315b4b6c187e0d1d50d/uv-0.11.21-py3-none-macosx_11_0_arm64.whl", hash = "sha256:9c11169a049ec8bf9ddc6a9f55fba9a240942ec8005faaaf4393f00ff7a4c16e", size = 21762931, upload-time = "2026-06-11T18:18:41.155Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/04/c5503fc1015095db71c280526f45537f3bb06855ce281ff1761b85d149bf/uv-0.11.21-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.musllinux_1_1_aarch64.whl", hash = "sha256:00193e4e077c27ee3d66da356744dbf0b3aa59356dfbd9a9efb1dc8469af8ad7", size = 23716032, upload-time = "2026-06-11T18:19:17.03Z" },
+    { url = "https://files.pythonhosted.org/packages/13/ac/46132335772fcdc38e5b5ec76701a8df8e3707605909b5fed46783689501/uv-0.11.21-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.musllinux_1_1_armv7l.whl", hash = "sha256:870f48082df673016f465b068f40ad5aa7d2d3cfbcfb4e73724630684003a2ab", size = 23330010, upload-time = "2026-06-11T18:19:00.825Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/d4/cfa1ea36706c32006dea9bf0a819b56c22af8270ea3a2b57562ce96c2d45/uv-0.11.21-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:af08e0d8f43da43bc68930aee56ca5f38ccfbc79d45b6e8a7d5051f1e975684f", size = 23339731, upload-time = "2026-06-11T18:18:52.395Z" },
+    { url = "https://files.pythonhosted.org/packages/96/c5/b34d3cdf05a069c583ef368e6db90242f842d7eb26b246981b3ca8799c27/uv-0.11.21-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4530761c565f3a519a68f36628ee51f2b467b66573e2023e9073641219b60d23", size = 24657820, upload-time = "2026-06-11T18:19:25.62Z" },
+    { url = "https://files.pythonhosted.org/packages/be/b9/89b4e3909111c14311d4a1551afb37f0669587dc1f4ae7e26ec5baea6c09/uv-0.11.21-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:66906cfa7c29c2cf4ea5117cf5614b0b83078ff669e664e2187071fcb24c85c1", size = 25744586, upload-time = "2026-06-11T18:19:09.311Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/7b/51d53d9fb1aaf38a613c2d20b40583ee2aa47fc000724a00aecbd5e61431/uv-0.11.21-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:525ef0eb56ff982357a321eca953307d824ab6f58473630c69521e8085f12b0a", size = 24990030, upload-time = "2026-06-11T18:18:29.618Z" },
+    { url = "https://files.pythonhosted.org/packages/de/70/3347f736911b73df1f31c0823d6502891f3c49fdeb157fe8060b18c08d1c/uv-0.11.21-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b9ecdefa81db7e966d1655988cad6f840316228381dd69131ebc4ae9362bbccd", size = 25110133, upload-time = "2026-06-11T18:19:13.307Z" },
+    { url = "https://files.pythonhosted.org/packages/61/b5/b92538042d78550626ec7ac98b525bcb81ded8605c7ca9d6e35a1454ba71/uv-0.11.21-py3-none-manylinux_2_28_aarch64.whl", hash = "sha256:4ed98ff3165bf7b339692d0df918b87e6d36eb0bed5183466330d27d5730d57b", size = 23755172, upload-time = "2026-06-11T18:18:19.189Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/1a/5c8993f95d4384baeaf00b96df0111af3c941a34e4466cde0d52b0b6ad99/uv-0.11.21-py3-none-manylinux_2_31_riscv64.musllinux_1_1_riscv64.whl", hash = "sha256:0e7916874f125a6f6af4cddd95f892ef19a4bb65c146afea7e544b0f98c63d02", size = 24468447, upload-time = "2026-06-11T18:19:04.572Z" },
+    { url = "https://files.pythonhosted.org/packages/66/2c/d4db24f9aeab8fce106633cd0388df4c0cf9f0991a2b5d9f58d061a031f7/uv-0.11.21-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:05e2f2e0fbf7c423f8287011ba0d2d69464f26a5f13b33df05cd491fbe5a910a", size = 24564716, upload-time = "2026-06-11T18:19:29.559Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/53/c61711e81f9f8d34dd020340ace968499b2539d3bb4ac09d39339df54a9d/uv-0.11.21-py3-none-musllinux_1_1_i686.whl", hash = "sha256:b756dd2b368d7cc4aeb48249d06e1250bfcf81f0313ff7d7ec2ccafcd3ee4c93", size = 23917742, upload-time = "2026-06-11T18:18:57.187Z" },
+    { url = "https://files.pythonhosted.org/packages/84/21/210a5562a6a0eddfbe4890eb48e67f167be0307e75f029ca46b8f6386e5d/uv-0.11.21-py3-none-musllinux_1_1_x86_64.whl", hash = "sha256:88668a27959df9188ff72b0314f6b14f6acf6090964bb0748974239183ecb51c", size = 25330418, upload-time = "2026-06-11T18:18:37.383Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/3c/81979463de0278facaa59ed3940b9c62f25a68d737d1a6f11cc3f922fba3/uv-0.11.21-py3-none-win32.whl", hash = "sha256:a00c78f3eea6db7967d98a505b01b7d80354517c7ff34f51701949f39c7b53e6", size = 22633520, upload-time = "2026-06-11T18:18:44.992Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/51/e682e060813424467f14ae964dd7022f8fc537fea5803b5aab0ba1eca9cc/uv-0.11.21-py3-none-win_amd64.whl", hash = "sha256:d956ba9470d5267cc0ea3d7572cac3bf045bc78adad5b031b5558c6df13d2e19", size = 25291878, upload-time = "2026-06-11T18:18:23.832Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/ef/8b1d92f9501963ef8694bb17ad80ba9926d049240d2da0a4f879aa37f3e2/uv-0.11.21-py3-none-win_arm64.whl", hash = "sha256:f64a851e429e6afb96f3a0b688995757ed3697bf1078509e2da8220ffc9805cd", size = 23715885, upload-time = "2026-06-11T18:18:48.596Z" },
 ]
 
 [[package]]
@@ -7200,11 +7713,12 @@ wheels = [
 
 [[package]]
 name = "vllm"
-version = "0.14.0"
+version = "0.22.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "aiohttp" },
     { name = "anthropic" },
+    { name = "apache-tvm-ffi" },
     { name = "blake3" },
     { name = "cachetools" },
     { name = "cbor2" },
@@ -7214,14 +7728,15 @@ dependencies = [
     { name = "diskcache" },
     { name = "einops" },
     { name = "fastapi", extra = ["standard"] },
+    { name = "fastsafetensors" },
     { name = "filelock" },
+    { name = "flashinfer-cubin" },
     { name = "flashinfer-python" },
     { name = "gguf" },
-    { name = "grpcio" },
-    { name = "grpcio-reflection" },
+    { name = "humming-kernels", extra = ["cu13"] },
     { name = "ijson" },
     { name = "lark" },
-    { name = "llguidance", marker = "platform_machine == 'aarch64' or platform_machine == 'arm64' or platform_machine == 'ppc64le' or platform_machine == 's390x' or platform_machine == 'x86_64'" },
+    { name = "llguidance", marker = "platform_machine == 'aarch64' or platform_machine == 'arm64' or platform_machine == 'ppc64le' or platform_machine == 'x86_64'" },
     { name = "lm-format-enforcer" },
     { name = "mcp" },
     { name = "mistral-common", extra = ["image"] },
@@ -7229,10 +7744,17 @@ dependencies = [
     { name = "msgspec" },
     { name = "ninja" },
     { name = "numba" },
-    { name = "numpy" },
+    { name = "numpy", version = "2.3.5", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.13'" },
+    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.13'" },
+    { name = "nvidia-cudnn-frontend" },
+    { name = "nvidia-cutlass-dsl", extra = ["cu13"] },
     { name = "openai" },
     { name = "openai-harmony" },
     { name = "opencv-python-headless" },
+    { name = "opentelemetry-api" },
+    { name = "opentelemetry-exporter-otlp" },
+    { name = "opentelemetry-sdk" },
+    { name = "opentelemetry-semantic-conventions-ai" },
     { name = "outlines-core" },
     { name = "partial-json-parser" },
     { name = "pillow" },
@@ -7246,15 +7768,18 @@ dependencies = [
     { name = "python-json-logger" },
     { name = "pyyaml" },
     { name = "pyzmq" },
-    { name = "ray", extra = ["cgraph"] },
+    { name = "quack-kernels" },
     { name = "regex" },
     { name = "requests" },
+    { name = "safetensors" },
     { name = "sentencepiece" },
     { name = "setproctitle" },
     { name = "setuptools" },
     { name = "six" },
     { name = "tiktoken" },
+    { name = "tilelang" },
     { name = "tokenizers" },
+    { name = "tokenspeed-mla" },
     { name = "torch" },
     { name = "torchaudio" },
     { name = "torchvision" },
@@ -7264,10 +7789,10 @@ dependencies = [
     { name = "watchfiles" },
     { name = "xgrammar", marker = "platform_machine == 'aarch64' or platform_machine == 'arm64' or platform_machine == 'ppc64le' or platform_machine == 's390x' or platform_machine == 'x86_64'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/01/fd/abb7391e8cb5cb729ae770946b4f61b9e9b56bac8805e7baeaed651378d5/vllm-0.14.0.tar.gz", hash = "sha256:ed86c6a9d22fbfd059648794493cad88444c71688f3ff6efcb26c5ca353f0e5d", size = 19690728, upload-time = "2026-01-20T10:55:03.658Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/84/7c/6c745e218eaffc0fe77480d0fcbbf6835ba655da3691606eba3b8b48cc81/vllm-0.22.1.tar.gz", hash = "sha256:cd34902729f3767e3dfbb391956b2986bc638a54be9893e78bda9cc55669f15c", size = 36246058, upload-time = "2026-06-05T10:12:16.046Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/e6/8a/bfaac90c55be0f3144bc870c39e36c5c2571f68788e7bbf8a83c6cc70bbf/vllm-0.14.0-cp38-abi3-manylinux_2_31_aarch64.whl", hash = "sha256:f4684881e3677b69d731494c68ad0525588b02cad556c5d5aef4f7eba9368c86", size = 448040411, upload-time = "2026-01-20T10:50:00.177Z" },
-    { url = "https://files.pythonhosted.org/packages/f6/06/36d927bf262d5a180739218e69a4122325dc63c9baf33297e5f0322df9fc/vllm-0.14.0-cp38-abi3-manylinux_2_31_x86_64.whl", hash = "sha256:9362cadde2cd1329a0c4a0ea9eace233d79576b3d6f5648b854922b2a2554a01", size = 495377847, upload-time = "2026-01-20T10:50:29.898Z" },
+    { url = "https://files.pythonhosted.org/packages/86/90/bfdbaa7762a977932f509e48e18db8543b0b07936ee0e06db02e760e7790/vllm-0.22.1-cp38-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:2d8e51693683e4d7c7e9ed311a2996200428fa3a28e154ddbff809aeb7c5382a", size = 252950342, upload-time = "2026-06-05T10:13:00.428Z" },
+    { url = "https://files.pythonhosted.org/packages/08/cd/c863370930b2043b7b7f67ff900c9e27c2265f3b3edd080d62c148d4bcb4/vllm-0.22.1-cp38-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:cc50536c93827a577b2bc45f038b8b866c31ed220631008521a337c9b2558f4d", size = 261042548, upload-time = "2026-06-05T10:13:34.853Z" },
 ]
 
 [[package]]
@@ -7514,27 +8039,39 @@ wheels = [
 
 [[package]]
 name = "xgrammar"
-version = "0.1.29"
+version = "0.2.2"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "mlx-lm", marker = "platform_machine == 'arm64' and sys_platform == 'darwin'" },
-    { name = "numpy" },
+    { name = "apache-tvm-ffi" },
+    { name = "numpy", version = "2.3.5", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.13'" },
+    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.13'" },
     { name = "pydantic" },
     { name = "torch" },
     { name = "transformers" },
-    { name = "triton", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
+    { name = "triton", version = "3.6.0", source = { registry = "https://pypi.org/simple" }, marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/02/a3/70dbe3ffd331a1e7e1ad5a95690a4086e6c7cdb8089f5c7eda712219ccec/xgrammar-0.1.29.tar.gz", hash = "sha256:cf195afa81b489eebf35d4c6f37f27136d05420739ab4a6f7f065c938d7e4baa", size = 2321317, upload-time = "2025-12-19T08:23:54.53Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/c1/d8/fb282fc78be6e9bbefb5cb389f66b22e4efd6ae14f06234f599651620da5/xgrammar-0.1.29-cp312-cp312-macosx_10_14_x86_64.whl", hash = "sha256:d992a3cee7594bbdaa64ae59f90da5ce21c5fe654719df3816014289ada6f04d", size = 16007376, upload-time = "2025-12-19T08:23:23.634Z" },
-    { url = "https://files.pythonhosted.org/packages/82/a7/2c9767620ee50f2f40f1eb95e55a3a29e1a0670f087ee6dc1bc1c887b906/xgrammar-0.1.29-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:1bbdf02e45cfa8614218ba01ca7952d375f8bc1c13884e3d04daa4b54180cbc2", size = 17913535, upload-time = "2025-12-19T08:23:26.02Z" },
-    { url = "https://files.pythonhosted.org/packages/57/94/18793c64bf0368075a34c06e196bf002f1e6ab0aee332268f44e8d356d5a/xgrammar-0.1.29-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6eb370a16b27a683e5f2b9e429ab41440c69977d4a504849ed61831b94cc704c", size = 34705239, upload-time = "2025-12-19T08:23:28.369Z" },
-    { url = "https://files.pythonhosted.org/packages/3e/da/4c14e3e00be698009b52700f15326a23272b4b00475939b6acc86b151188/xgrammar-0.1.29-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:79e6e4f5cd33be77418cf91efc482f2b3d773d309891224383bc8a4948ad7b07", size = 34906135, upload-time = "2025-12-19T08:23:30.838Z" },
-    { url = "https://files.pythonhosted.org/packages/22/d8/34423997f48627cef3b74cc894d9dfcaacae02941c06237ac5f3196406a7/xgrammar-0.1.29-cp312-cp312-win_amd64.whl", hash = "sha256:39bdfadedbce34599835486164fa80ba00248c6c75ad91f3843db90ef37e037f", size = 5928381, upload-time = "2025-12-19T08:23:33.428Z" },
-    { url = "https://files.pythonhosted.org/packages/2c/ef/8a4b4cb10fc996c0a25c9bf5613aaf5a86114291a9a4003e43605cab42bf/xgrammar-0.1.29-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:fedf21e447ef646f23a6e2d11877c0812d55965dcf8c0aa9b0f32590c9b6e22a", size = 17913609, upload-time = "2025-12-19T08:23:36.06Z" },
-    { url = "https://files.pythonhosted.org/packages/e9/c5/e4965c9921e7bb6061f246ae7f8c7b9b1dfc21262248100c2f9b398b361e/xgrammar-0.1.29-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eb22aea775971f7d8c4d0e193257ebeb71b68acd9d36af3331ca5fd4d9a46991", size = 34904126, upload-time = "2025-12-19T08:23:38.335Z" },
-    { url = "https://files.pythonhosted.org/packages/09/26/641d7ee1a59e526aa94be980c485f899088d09dd1af517a2e1d0e85853bc/xgrammar-0.1.29-cp313-cp313-win_amd64.whl", hash = "sha256:12e6d63e892e9da8d088569dd629af58a5eafd909dc58788d499c4fd74bcd2a1", size = 5928450, upload-time = "2025-12-19T08:23:40.667Z" },
+sdist = { url = "https://files.pythonhosted.org/packages/fe/b7/86178b241be0b29ce9ee991a44d4b7eddb0f0c98310c0067fe83afc897d1/xgrammar-0.2.2.tar.gz", hash = "sha256:42bcc5c4187ff9cb6edc44ff5f56030d8b69d62c7576f674a5a074f71b68b1fa", size = 2430492, upload-time = "2026-06-11T19:02:49.624Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/31/48/c50e00cb390702153a740d6eb163efb6771c2c18087401160132b1be1bdb/xgrammar-0.2.2-cp312-cp312-macosx_10_14_x86_64.whl", hash = "sha256:f457e20099768203f313dfc4bdfcb80ebdd98040b8df7a4f25adf5b0ddaa2cd4", size = 23292820, upload-time = "2026-06-11T19:01:40.152Z" },
+    { url = "https://files.pythonhosted.org/packages/93/b9/d6004ab97588bf680fc5524a7a07b9e6c58caecd5de303c9e74d6b70267d/xgrammar-0.2.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:c4e46e6c62c534c8e539447008fc1f77b592d92d304a92961852e9540aa8f0cc", size = 23236355, upload-time = "2026-06-11T19:01:42.817Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/20/84f3d71964cf2142c3470025731c0ccb3fb8c54b192c1435f10b79d72d31/xgrammar-0.2.2-cp312-cp312-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5432dee479702807e0af956b3804d4c5b7ddafb61b1d97d437574be6837a4e15", size = 44091972, upload-time = "2026-06-11T19:01:45.96Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/40/eb28b7343b019350a83cde47fe876a79f3ee19e412c1af451200b6351fe8/xgrammar-0.2.2-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d3f0195ffc978bc2b44e4d5b682ff3a5ee86c378e8934b0f8582ddd0b00c24f0", size = 44588349, upload-time = "2026-06-11T19:01:49.062Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/c6/01182ac2d0cf3943f8c990824027cb13b914867c32990c5e648a09f2d8fa/xgrammar-0.2.2-cp312-cp312-win_amd64.whl", hash = "sha256:2560d07b6b194334dd612a937c5a27b04e34f5b73aba8aea5d6860f758bcdff8", size = 7436669, upload-time = "2026-06-11T19:01:51.674Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/8f/369583b77da66c69a3ebb895d1f8fd7a65b7dae7fcc9415215353cc80f3d/xgrammar-0.2.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:345e036b0db12bd18c91b42b9e1f0d2ddfb26c5d5b3a40514c3655e5672817b6", size = 23236335, upload-time = "2026-06-11T19:01:53.784Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/f1/9d96b373e900f441aa6f3ec53ef21b02c25cf5c9428e33713199c1621532/xgrammar-0.2.2-cp313-cp313-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:73044ce2cc9fd3c0a6c32435df88970a7f1ae7a94bcf866f7d5961b49c89210b", size = 44091957, upload-time = "2026-06-11T19:01:56.874Z" },
+    { url = "https://files.pythonhosted.org/packages/de/83/f92bc01fb60417353cf6d1b92206800a20962757e6a7457b64cab7b7c386/xgrammar-0.2.2-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:055f46d96c5e92b64807eb17ae9ec1cce3b39e9fd843fa8191b3fd7443d80dd9", size = 44588429, upload-time = "2026-06-11T19:01:59.995Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/fc/5cda0eaa1f741b0708d375b2dedda52525d0768a2c0c2ebf7dadbe4f4675/xgrammar-0.2.2-cp313-cp313-win_amd64.whl", hash = "sha256:6de5da025cdbc8150181b19ca9ee5db9e4b4acac96484aa5e8af0cf810e9bb91", size = 7436668, upload-time = "2026-06-11T19:02:02.887Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/3d/430ef2b6390063045ed6ad553fcd607daf72d63657e0c08adcce4cf11b19/xgrammar-0.2.2-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:cfeef076e2c83b2ec062107a7dfd79dd99c38df29687332838494e1bd7ead84e", size = 23292967, upload-time = "2026-06-11T19:02:05.221Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/71/16e1d8d80717f0d845821b401f25dc1754c248fc724b6be3a3963ec111b3/xgrammar-0.2.2-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:a3f81e0660003bcd7f7372f99fff6e7bf4269de7527843606ebda4068ae4c391", size = 23236347, upload-time = "2026-06-11T19:02:07.978Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/c1/bca659a26df996a444122ed162037512ec877b124d82377cd8d36d65a000/xgrammar-0.2.2-cp314-cp314-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f87b5df772dd6ec15de285322272008317e93490a769af4b77d452557984fa83", size = 44091965, upload-time = "2026-06-11T19:02:11.261Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/bd/a2c5d59eae268d6c76fe4469ba2dcf45f4f9580d958667164d9a4ad3005e/xgrammar-0.2.2-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ba3aba228174cf62e0297f328c4c0a1066328a6cb810ec61623924c7adde6968", size = 44588347, upload-time = "2026-06-11T19:02:14.874Z" },
+    { url = "https://files.pythonhosted.org/packages/79/e8/0378c36d09cc32437d5ebe6327e1e239f1a5f472fe06ce07881d8ffe2039/xgrammar-0.2.2-cp314-cp314-win_amd64.whl", hash = "sha256:367b2ad388bdefd067e90cbb294af9bc0bb52116c7cfe455be9410284654dc4f", size = 7532501, upload-time = "2026-06-11T19:02:17.542Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/51/0f49c9615974d05b4eda9f602f7b9347a531c2d1d07016b3855c0eb81826/xgrammar-0.2.2-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:602ac4acfb06c3172f26e29d934d267bc4e25083167ae65b7d053e435ab679b4", size = 23292952, upload-time = "2026-06-11T19:02:19.704Z" },
+    { url = "https://files.pythonhosted.org/packages/13/db/482e6caed1d108f9a9bd0b98e28201131bd07058c512951b5b72a179a86a/xgrammar-0.2.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:f10153e5cbc35b2852af18e59a43cf2c2dc4b6f03a958ee1b82f4fb16f871c1f", size = 23236316, upload-time = "2026-06-11T19:02:25.767Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/91/1d8bc9e291a320ccbbd7f5d91ed801f9c8e801cfbfb7d2a295defdaaca2a/xgrammar-0.2.2-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:13373f6344dad4501cd16b78e838387e9b870b88d41fce2b0c3fcfa5a52d7092", size = 44092018, upload-time = "2026-06-11T19:02:28.504Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/c4/8e0c76bec53e9309b54c9e9919a0c8329cf9f28892a8130615642c0e937c/xgrammar-0.2.2-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e0f7ba39591ec47501f46170a327fba8337afbcfdc09afb19270875db8984e5e", size = 44588391, upload-time = "2026-06-11T19:02:31.428Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/25/0c713d31c1581ef1a068832e286791cb612c1b034c1e4e87117e545498ec/xgrammar-0.2.2-cp314-cp314t-win_amd64.whl", hash = "sha256:64a96df4bbc14c8ed70bdef64f79d03c036183902cda129aca5137804910d0c4", size = 7532500, upload-time = "2026-06-11T19:02:34.082Z" },
 ]
 
 [[package]]
@@ -7724,6 +8261,20 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/69/68/c8739671f5699c7dc470580a4f821ef37c32c4cb0b047ce223a7f115757f/yarl-1.23.0-py3-none-any.whl", hash = "sha256:a2df6afe50dea8ae15fa34c9f824a3ee958d785fd5d089063d960bae1daa0a3f", size = 48288, upload-time = "2026-03-01T22:07:51.388Z" },
 ]
 
+[[package]]
+name = "z3-solver"
+version = "4.15.4.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/8a/8e/0c8f17309549d2e5cde9a3ccefa6365437f1e7bafe71878eaf9478e47b18/z3_solver-4.15.4.0.tar.gz", hash = "sha256:928c29b58c4eb62106da51c1914f6a4a55d0441f8f48a81b9da07950434a8946", size = 5018600, upload-time = "2025-10-29T18:12:03.062Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/63/33/a3d5d2eaeb0f7b3174d57d405437eabb2075d4d50bd9ea0957696c435c7b/z3_solver-4.15.4.0-py3-none-macosx_13_0_arm64.whl", hash = "sha256:407e825cc9211f95ef46bdc8d151bf630e7ab2d62a21d24cd74c09cc5b73f3aa", size = 37052538, upload-time = "2025-10-29T18:11:46.233Z" },
+    { url = "https://files.pythonhosted.org/packages/47/84/fd7ffac1551cd9f8d44fe41358f738be670fc4c24dfd514fab503f2cf3e7/z3_solver-4.15.4.0-py3-none-macosx_13_0_x86_64.whl", hash = "sha256:00bd10c5a6a5f6112d3a9a810d0799227e52f76caa860dafa5e00966bb47eb13", size = 39807925, upload-time = "2025-10-29T18:11:49.81Z" },
+    { url = "https://files.pythonhosted.org/packages/21/c9/bb51a96af0091324c81b803f16c49f719f9f6ea0b0bb52200f5c97ec4892/z3_solver-4.15.4.0-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7e103a6f203f505b8b8b8e5c931cc407c95b61556512d4921c1ddc0b3f41b08e", size = 29268352, upload-time = "2025-10-29T18:11:53.032Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/2e/0b49f7e4e53817cfb09a0f6585012b782dfe0b666e8abefcb4fac0570606/z3_solver-4.15.4.0-py3-none-manylinux_2_34_aarch64.whl", hash = "sha256:62c7e9cbdd711932301f29919ad9158de9b2f58b4d281dd259bbcd0a2f408ba1", size = 27226534, upload-time = "2025-10-29T18:11:55.59Z" },
+    { url = "https://files.pythonhosted.org/packages/26/91/33de49538444d4aafbe47415c450c2f9abab1733e1226f276b496672f46c/z3_solver-4.15.4.0-py3-none-win32.whl", hash = "sha256:be3bc916545c96ffbf89e00d07104ff14f78336e55db069177a1bfbcc01b269d", size = 13191672, upload-time = "2025-10-29T18:11:58.424Z" },
+    { url = "https://files.pythonhosted.org/packages/03/d6/a0b135e4419df475177ae78fc93c422430b0fd8875649486f9a5989772e6/z3_solver-4.15.4.0-py3-none-win_amd64.whl", hash = "sha256:00e35b02632ed085ea8199fb230f6015e6fc40554a6680c097bd5f060e827431", size = 16259597, upload-time = "2025-10-29T18:12:01.14Z" },
+]
+
 [[package]]
 name = "zipp"
 version = "3.23.0"

From b6c741044698c3655bf7ae51484913f59b44c55e Mon Sep 17 00:00:00 2001
From: Aravind N <aravindn1308@outlook.com>
Date: Thu, 11 Jun 2026 17:25:40 -0400
Subject: [PATCH 13/15] fix(ci): lazy-import crewai in VisionAgent.run() to fix
 test collection

Top-level `from crewai import Agent, Crew, Task` caused ModuleNotFoundError
during pytest collection for test_legend_grounding.py because the
agentic-xai-eval dependency group is not installed in CI (uv sync
--all-extras --dev only installs extras, not named groups).

Mirrors the same fix applied to openai_compat.build_crewai_llm().
---
 src/agentfinvqa/agents/vision_agent.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/agentfinvqa/agents/vision_agent.py b/src/agentfinvqa/agents/vision_agent.py
index cbb07fb..f3c0c99 100644
--- a/src/agentfinvqa/agents/vision_agent.py
+++ b/src/agentfinvqa/agents/vision_agent.py
@@ -8,8 +8,6 @@
 from pathlib import Path
 from typing import Any, List, Optional, Tuple
 
-from crewai import Agent, Crew, Task
-
 from ..datasets.perceived_sample import PerceivedSample
 from ..langfuse_integration.tracing import close_span, open_llm_span
 from ..mep.schema import MEPColorArea
@@ -366,6 +364,8 @@ def run(
         tool_traces : list of dict
             A log of tool interactions during the run.
         """
+        from crewai import Agent, Crew, Task  # noqa: PLC0415
+
         tool = self._build_tool(lf_trace=lf_trace)
         llm = build_crewai_llm(self.agent_backend, self.agent_model, self.agent_api_key, self.agent_api_base)
         task_description = build_vision_task_description(

From 47879ed6478255abf97acf673f528f1b5650decc Mon Sep 17 00:00:00 2001
From: Aravind N <aravindn1308@outlook.com>
Date: Thu, 11 Jun 2026 20:13:01 -0400
Subject: [PATCH 14/15] fix(ci): lazy-import crewai in VisionAgent.run() to fix
 test collection

Top-level `from crewai import Agent, Crew, Task` in vision_agent.py and
`from crewai.tools import BaseTool` in all four tool files caused
ModuleNotFoundError during pytest collection because the agentic-xai-eval
dependency group is not installed in CI (uv sync --all-extras --dev only
installs extras, not named groups).

- vision_agent.py: moved Agent/Crew/Task import inside VisionAgent.run()
  with # noqa: PLC0415
- vision_qa_tool.py, legend_grounder_tool.py, ocr_reader_tool.py,
  verifier_tool.py: wrapped BaseTool import in try/except ImportError,
  falling back to pydantic.BaseModel so the class definition succeeds
  without crewai installed
---
 src/agentfinvqa/tools/legend_grounder_tool.py | 6 +++++-
 src/agentfinvqa/tools/ocr_reader_tool.py      | 6 +++++-
 src/agentfinvqa/tools/verifier_tool.py        | 6 +++++-
 src/agentfinvqa/tools/vision_qa_tool.py       | 6 +++++-
 4 files changed, 20 insertions(+), 4 deletions(-)

diff --git a/src/agentfinvqa/tools/legend_grounder_tool.py b/src/agentfinvqa/tools/legend_grounder_tool.py
index 5d812e5..c8c3ae9 100644
--- a/src/agentfinvqa/tools/legend_grounder_tool.py
+++ b/src/agentfinvqa/tools/legend_grounder_tool.py
@@ -13,7 +13,11 @@
 from datetime import datetime, timezone
 from typing import Any, List, Optional, Type
 
-from crewai.tools import BaseTool
+
+try:
+    from crewai.tools import BaseTool
+except ImportError:
+    from pydantic import BaseModel as BaseTool  # type: ignore[assignment]
 from google import genai
 from openai import OpenAI  # noqa: F401 — re-exported for backwards-compat / type hints
 from pydantic import BaseModel, Field, PrivateAttr
diff --git a/src/agentfinvqa/tools/ocr_reader_tool.py b/src/agentfinvqa/tools/ocr_reader_tool.py
index 8a64a24..2cb3f53 100644
--- a/src/agentfinvqa/tools/ocr_reader_tool.py
+++ b/src/agentfinvqa/tools/ocr_reader_tool.py
@@ -13,7 +13,11 @@
 from datetime import datetime, timezone
 from typing import Any, Optional, Type
 
-from crewai.tools import BaseTool
+
+try:
+    from crewai.tools import BaseTool
+except ImportError:
+    from pydantic import BaseModel as BaseTool  # type: ignore[assignment]
 from google import genai
 from openai import OpenAI  # noqa: F401 — re-exported for backwards-compat / type hints
 from pydantic import BaseModel, Field, PrivateAttr
diff --git a/src/agentfinvqa/tools/verifier_tool.py b/src/agentfinvqa/tools/verifier_tool.py
index 788dbde..ba141af 100644
--- a/src/agentfinvqa/tools/verifier_tool.py
+++ b/src/agentfinvqa/tools/verifier_tool.py
@@ -13,7 +13,11 @@
 from pathlib import Path
 from typing import Any, List, Optional, Type
 
-from crewai.tools import BaseTool
+
+try:
+    from crewai.tools import BaseTool
+except ImportError:
+    from pydantic import BaseModel as BaseTool  # type: ignore[assignment]
 from google import genai
 from openai import OpenAI  # noqa: F401 — re-exported for backwards-compat / type hints
 from pydantic import BaseModel, Field, PrivateAttr
diff --git a/src/agentfinvqa/tools/vision_qa_tool.py b/src/agentfinvqa/tools/vision_qa_tool.py
index 20c9670..ad84fec 100644
--- a/src/agentfinvqa/tools/vision_qa_tool.py
+++ b/src/agentfinvqa/tools/vision_qa_tool.py
@@ -13,7 +13,11 @@
 from pathlib import Path
 from typing import Any, List, Optional, Type
 
-from crewai.tools import BaseTool
+
+try:
+    from crewai.tools import BaseTool
+except ImportError:
+    from pydantic import BaseModel as BaseTool  # type: ignore[assignment]
 from google import genai
 from openai import OpenAI  # noqa: F401 — re-exported for backwards-compat / type hints
 from pydantic import BaseModel, Field, PrivateAttr

From 856c5735252007a4dd7abe97d86cc053761a2cf8 Mon Sep 17 00:00:00 2001
From: Aravind N <aravindn1308@outlook.com>
Date: Thu, 11 Jun 2026 20:22:34 -0400
Subject: [PATCH 15/15] fix(ci): lazy-import crewai in PlannerAgent and
 VerifierAgent to resolve test collection issues

Moved the import of `Agent`, `Crew`, and `Task` from crewai inside the respective classes in planner_agent.py and verifier_agent.py to prevent ModuleNotFoundError during pytest collection, as the agentic-xai-eval dependency group is not installed in CI.
---
 src/agentfinvqa/agents/planner_agent.py  | 4 ++--
 src/agentfinvqa/agents/verifier_agent.py | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/agentfinvqa/agents/planner_agent.py b/src/agentfinvqa/agents/planner_agent.py
index 3f96e88..9194b21 100644
--- a/src/agentfinvqa/agents/planner_agent.py
+++ b/src/agentfinvqa/agents/planner_agent.py
@@ -7,8 +7,6 @@
 from pathlib import Path
 from typing import Any, Optional, Tuple
 
-from crewai import Agent, Crew, Task
-
 from ..datasets.perceived_sample import PerceivedSample
 from ..langfuse_integration.tracing import close_span, open_llm_span
 from ..utils.json_strict import parse_strict
@@ -134,6 +132,8 @@ def run(self, sample: PerceivedSample, lf_trace: Any = None) -> Tuple[str, dict,
         raw_text : str
             The raw response from the LLM.
         """
+        from crewai import Agent, Crew, Task  # noqa: PLC0415
+
         prompt = build_planner_prompt(sample)
 
         span = open_llm_span(
diff --git a/src/agentfinvqa/agents/verifier_agent.py b/src/agentfinvqa/agents/verifier_agent.py
index 13c02e0..1bacafc 100644
--- a/src/agentfinvqa/agents/verifier_agent.py
+++ b/src/agentfinvqa/agents/verifier_agent.py
@@ -11,8 +11,6 @@
 import os
 from typing import Any, Optional, Tuple
 
-from crewai import Agent, Crew, Task
-
 from ..agents.vision_agent import _is_multi_select
 from ..langfuse_integration.tracing import close_span, open_llm_span
 from ..tools.verifier_tool import (
@@ -168,6 +166,8 @@ def run(
             f"Call verifier_tool ONCE with all these details and return its JSON output exactly."
         )
 
+        from crewai import Agent, Crew, Task  # noqa: PLC0415
+
         tool = self._build_tool(lf_trace=lf_trace)
         llm = build_crewai_llm(self.backend, self.model, self.api_key, self.api_base)