Upload 7 files

Dockerfile

@@ -0,0 +1,16 @@
+FROM python:3.12-slim
+
+WORKDIR /app
+
+ENV PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONUNBUFFERED=1 \
+    PIP_NO_CACHE_DIR=1
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+EXPOSE 7860
+
+CMD ["streamlit", "run", "app.py", "--server.port=7860", "--server.address=0.0.0.0", "--server.headless=true"]

README.md

@@ -1,12 +1,43 @@
 ---
-title: Llm Arithmetic Explorer
-emoji: 🌍
-colorFrom: yellow
-colorTo: red
+title: LLM & Arithmetic
+emoji: 🔢
+colorFrom: blue
+colorTo: green
 sdk: docker
 pinned: false
-license: apache-2.0
-short_description: Exploration of LLM and arithmetic datasets
+short_description: Explore LLM arithmetic and next-prime datasets.
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# LLM & Arithmetic
+
+Explore LLM arithmetic and next-prime experiments across raw, prompted, and tool modes.
+
+Streamlit explorer for two public Hugging Face datasets:
+
+- [`hoololi/llm-calculations`](https://huggingface.co/datasets/hoololi/llm-calculations)
+- [`hoololi/llm-next-prime`](https://huggingface.co/datasets/hoololi/llm-next-prime)
+
+The app compares how LLMs behave on arithmetic-like tasks across three modes:
+
+- **raw**: direct answer;
+- **prompted**: task-oriented system prompt;
+- **tool**: external deterministic tool available to the model.
+
+## Features
+
+- top-level tabs for **Calculations** and **Next Prime**;
+- nested **Statistics** and **Detailed results** views for each dataset;
+- model comparison across raw, prompted, and tool modes;
+- charts for accuracy, latency, cost, tokens, and category/magnitude breakdowns;
+- tool-pipeline summaries where relevant;
+- side-by-side inspection of two model × mode results for the same task;
+- quick filters for wrong answers, run failures, tool issues, long answers, slowest answers, fastest answers, and high-cost rows;
+- OpenRouter model metadata snapshot display when available.
+
+The app loads the datasets directly from Hugging Face and is containerized with Docker.
+
+To refresh OpenRouter metadata, update `model_families.json` if needed and run:
+
+```bash
+python fetch_openrouter_model_info.py
+```

app.py

@@ -0,0 +1,701 @@
+import json
+import re
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+import pandas as pd
+import plotly.express as px
+import plotly.graph_objects as go
+import streamlit as st
+from datasets import load_dataset
+
+CALCULATIONS_DATASET_ID = "hoololi/llm-calculations"
+NEXT_PRIME_DATASET_ID = "hoololi/llm-next-prime"
+MODEL_INFO_PATH = Path("model_info_snapshot.json")
+
+MODE_ORDER = ["raw", "prompted", "tool"]
+MODE_COLORS = {"raw": "#6EA8FE", "prompted": "#FFB86B", "tool": "#69DB7C"}
+
+st.set_page_config(page_title="LLM & Arithmetic", page_icon="🔢", layout="wide")
+
+
+@dataclass(frozen=True)
+class DatasetConfig:
+    key: str
+    title: str
+    dataset_id: str
+    description: str
+    default_stat_view: str
+    category_label: str
+    category_col: str
+    task_label: str = "Task"
+
+
+DATASETS = {
+    "calculations": DatasetConfig(
+        key="calculations",
+        title="Calculations",
+        dataset_id=CALCULATIONS_DATASET_ID,
+        description=(
+            "This experiment asks LLMs to solve arithmetic operations such as `45 × 23` "
+            "under raw, prompted, and calculator-tool modes. Each row is one operation, "
+            "one model, and one mode."
+        ),
+        default_stat_view="Accuracy by category",
+        category_label="Operation categories",
+        category_col="operation_category",
+        task_label="Operation",
+    ),
+    "next_prime": DatasetConfig(
+        key="next_prime",
+        title="Next Prime",
+        dataset_id=NEXT_PRIME_DATASET_ID,
+        description=(
+            "This experiment asks LLMs to answer questions of the form: "
+            "`What is the smallest prime number that is strictly greater than n?` "
+            "Inputs are sampled across magnitude ranges and tested in raw, prompted, "
+            "and next-prime-tool modes."
+        ),
+        default_stat_view="Accuracy by magnitude",
+        category_label="Magnitude groups",
+        category_col="magnitude_group",
+        task_label="Input number",
+    ),
+}
+
+
+@st.cache_data(show_spinner=False)
+def load_hf_dataset(dataset_id: str) -> pd.DataFrame:
+    ds = load_dataset(dataset_id, split="train")
+    df = ds.to_pandas()
+    return normalize_frame(df)
+
+
+@st.cache_data(show_spinner=False)
+def load_model_info() -> Dict[str, Any]:
+    if not MODEL_INFO_PATH.exists():
+        return {}
+    return json.loads(MODEL_INFO_PATH.read_text(encoding="utf-8"))
+
+
+def normalize_frame(df: pd.DataFrame) -> pd.DataFrame:
+    df = df.copy()
+    if "operation" not in df.columns and "question" in df.columns:
+        df["operation"] = df["question"]
+    if "operation_id" not in df.columns and "case_id" in df.columns:
+        df["operation_id"] = df["case_id"]
+    if "operation_category" not in df.columns and "category" in df.columns:
+        df["operation_category"] = df["category"]
+    if "correct_result_str" not in df.columns and "correct_result" in df.columns:
+        df["correct_result_str"] = df["correct_result"].astype("string")
+    if "extracted_answer_str" not in df.columns and "extracted_answer" in df.columns:
+        df["extracted_answer_str"] = df["extracted_answer"].astype("string")
+
+    for col in ["cost", "latency_seconds", "total_tokens", "input_tokens", "output_tokens"]:
+        if col in df.columns:
+            df[col] = pd.to_numeric(df[col], errors="coerce")
+    if "mode" in df.columns:
+        df["mode"] = pd.Categorical(df["mode"].astype(str), categories=MODE_ORDER, ordered=True)
+    return df
+
+
+def sanitize_text(value: Any) -> str:
+    if value is None or pd.isna(value):
+        return ""
+    text = str(value)
+    text = re.sub(r"'user_id':\s*'[^']+'", "'user_id': '<redacted>'", text)
+    text = re.sub(r'"user_id"\s*:\s*"[^"]+"', '"user_id": "<redacted>"', text)
+    text = re.sub(r"user_[A-Za-z0-9]+", "user_<redacted>", text)
+    return text
+
+
+def bool_mean_pct(s: pd.Series) -> float:
+    return float(s.eq(True).mean() * 100)
+
+
+def selected_models(model_a: str, model_b: str) -> List[str]:
+    models = [model_a]
+    if model_b and model_b != model_a:
+        models.append(model_b)
+    return models
+
+
+def sort_magnitude(values: List[Any]) -> List[str]:
+    def key(v: Any) -> int:
+        match = re.search(r"10\^(\d+)", str(v))
+        return int(match.group(1)) if match else 999
+
+    return sorted([str(v) for v in values if pd.notna(v)], key=key)
+
+
+def summarize(df: pd.DataFrame, model_order: Optional[List[str]] = None) -> pd.DataFrame:
+    if df.empty:
+        return pd.DataFrame()
+    summary = (
+        df.groupby(["model", "mode"], observed=True)
+        .agg(
+            rows=("mode", "size"),
+            accuracy_pct=("final_result_correct", bool_mean_pct),
+            run_success_pct=("run_success", bool_mean_pct),
+            avg_total_tokens=("total_tokens", "mean"),
+            avg_cost=("cost", "mean"),
+            total_cost=("cost", "sum"),
+            avg_latency_seconds=("latency_seconds", "mean"),
+            median_latency_seconds=("latency_seconds", "median"),
+        )
+        .reset_index()
+    )
+    summary["mode"] = pd.Categorical(summary["mode"].astype(str), categories=MODE_ORDER, ordered=True)
+    if model_order:
+        summary["model"] = pd.Categorical(summary["model"], categories=model_order, ordered=True)
+    summary = summary.sort_values(["model", "mode"])
+    summary["model"] = summary["model"].astype(str)
+    summary["mode"] = summary["mode"].astype(str)
+    return summary.round(4)
+
+
+def metric_chart(summary: pd.DataFrame, metric: str, yaxis_title: str, percent: bool = False) -> go.Figure:
+    fig = go.Figure()
+    if summary.empty or metric not in summary.columns:
+        return fig
+    model_order = summary["model"].drop_duplicates().tolist()
+    for mode in MODE_ORDER:
+        part = summary[summary["mode"] == mode]
+        fig.add_bar(
+            x=part["model"],
+            y=part[metric],
+            name=mode,
+            marker_color=MODE_COLORS[mode],
+            hovertemplate=f"{yaxis_title}: %{{y:.4g}}<extra>{mode}</extra>",
+        )
+    fig.update_layout(
+        template="plotly_dark",
+        barmode="group",
+        height=300,
+        margin=dict(l=35, r=10, t=20, b=45),
+        legend=dict(orientation="h", yanchor="top", y=0.99, xanchor="right", x=0.99),
+        paper_bgcolor="rgba(0,0,0,0)",
+        plot_bgcolor="rgba(255,255,255,0.035)",
+        yaxis_title=yaxis_title,
+        xaxis_title=None,
+    )
+    fig.update_xaxes(categoryorder="array", categoryarray=model_order, tickangle=0)
+    fig.update_yaxes(gridcolor="rgba(255,255,255,0.12)")
+    if percent:
+        fig.update_yaxes(range=[0, 100], tickvals=[0, 20, 40, 60, 80, 100])
+    return fig
+
+
+def grouped_accuracy_chart(df: pd.DataFrame, group_col: str, title: str, group_order: Optional[List[str]] = None) -> go.Figure:
+    if df.empty or group_col not in df.columns:
+        return go.Figure()
+    grouped = (
+        df.groupby(["model", group_col, "mode"], observed=True)
+        .agg(rows=("mode", "size"), accuracy_pct=("final_result_correct", bool_mean_pct))
+        .reset_index()
+    )
+    grouped[group_col] = grouped[group_col].astype(str)
+    model_count = grouped["model"].nunique()
+    if group_order is None:
+        group_order = sorted(grouped[group_col].dropna().astype(str).unique().tolist())
+
+    fig = px.bar(
+        grouped,
+        x=group_col,
+        y="accuracy_pct",
+        color="mode",
+        facet_col="model" if model_count > 1 else None,
+        barmode="group",
+        category_orders={group_col: group_order, "mode": MODE_ORDER},
+        color_discrete_map=MODE_COLORS,
+        hover_data={"rows": True, "accuracy_pct": ":.2f"},
+        labels={"accuracy_pct": "Accuracy (%)", group_col: ""},
+        title=title,
+    )
+    fig.update_layout(
+        template="plotly_dark",
+        height=420 if model_count > 1 else 380,
+        margin=dict(l=35, r=10, t=45, b=55),
+        legend=dict(orientation="h", yanchor="top", y=0.98, xanchor="right", x=0.99),
+        paper_bgcolor="rgba(0,0,0,0)",
+        plot_bgcolor="rgba(255,255,255,0.035)",
+        yaxis_title="Accuracy (%)",
+    )
+    fig.update_xaxes(categoryorder="array", categoryarray=group_order)
+    fig.update_yaxes(range=[0, 100], gridcolor="rgba(255,255,255,0.12)")
+    fig.for_each_annotation(lambda a: a.update(text=a.text.replace("model=", "")))
+    return fig
+
+
+def tool_pipeline_summary(df: pd.DataFrame) -> pd.DataFrame:
+    tool = df[df["mode"].astype(str) == "tool"].copy()
+    if tool.empty:
+        return pd.DataFrame()
+    tool["final_correct_bool"] = tool["final_result_correct"].eq(True)
+    tool["tool_correct_bool"] = tool.get("tool_result_correct", pd.Series(False, index=tool.index)).eq(True)
+    tool["final_or_tool_correct"] = tool["final_correct_bool"] | tool["tool_correct_bool"]
+    return (
+        tool.groupby(["model_family", "model"], observed=True)
+        .agg(
+            rows=("mode", "size"),
+            final_answer_accuracy_pct=("final_correct_bool", lambda s: s.mean() * 100),
+            tool_output_accuracy_pct=("tool_correct_bool", lambda s: s.mean() * 100),
+            final_or_tool_accuracy_pct=("final_or_tool_correct", lambda s: s.mean() * 100),
+            run_success_pct=("run_success", bool_mean_pct),
+        )
+        .reset_index()
+        .sort_values(["final_or_tool_accuracy_pct", "final_answer_accuracy_pct"], ascending=False)
+        .round(3)
+    )
+
+
+def tradeoff_chart(df: pd.DataFrame) -> go.Figure:
+    if df.empty:
+        return go.Figure()
+    tradeoff = (
+        df.groupby(["model_family", "model", "mode"], observed=True)
+        .agg(
+            accuracy_pct=("final_result_correct", bool_mean_pct),
+            success_rate_pct=("run_success", bool_mean_pct),
+            median_latency=("latency_seconds", "median"),
+            avg_cost=("cost", "mean"),
+        )
+        .reset_index()
+        .dropna(subset=["avg_cost", "median_latency", "accuracy_pct"])
+    )
+    if tradeoff.empty:
+        return go.Figure()
+    tradeoff["viable"] = (tradeoff["accuracy_pct"] >= 95) & (tradeoff["success_rate_pct"] >= 95)
+    tradeoff["label"] = tradeoff["model"].str.split("/").str[-1] + " (" + tradeoff["mode"].astype(str) + ")"
+    min_positive_cost = tradeoff.loc[tradeoff["avg_cost"] > 0, "avg_cost"].min()
+    zero_cost_display = (min_positive_cost / 10) if pd.notna(min_positive_cost) else 1e-9
+    tradeoff["avg_cost_display"] = tradeoff["avg_cost"].where(tradeoff["avg_cost"] > 0, zero_cost_display)
+    fig = px.scatter(
+        tradeoff,
+        x="avg_cost_display",
+        y="median_latency",
+        color="accuracy_pct",
+        symbol="mode",
+        size="success_rate_pct",
+        hover_name="label",
+        hover_data={"model_family": True, "avg_cost": ":.6f", "avg_cost_display": False, "median_latency": ":.3f", "accuracy_pct": ":.2f", "success_rate_pct": ":.2f"},
+        color_continuous_scale=[[0, "#D73027"], [0.5, "#FEE08B"], [1, "#1A9850"]],
+        range_color=[50, 100],
+        symbol_map={"raw": "circle", "prompted": "x", "tool": "square"},
+    )
+    viable = tradeoff[tradeoff["viable"]]
+    fig.add_trace(
+        go.Scatter(
+            x=viable["avg_cost_display"],
+            y=viable["median_latency"],
+            mode="markers",
+            marker=dict(symbol="circle-open", size=18, color="white", line=dict(color="black", width=2)),
+            name="viable ≥95% accuracy/success",
+            hoverinfo="skip",
+        )
+    )
+    fig.update_xaxes(type="log", title="Average cost per call, USD (zero-cost points shown near axis minimum)", gridcolor="rgba(255,255,255,0.12)")
+    fig.update_yaxes(type="log", title="Median latency, seconds", gridcolor="rgba(255,255,255,0.12)")
+    fig.update_layout(
+        template="plotly_dark",
+        height=520,
+        margin=dict(l=35, r=10, t=35, b=45),
+        title="Cost / latency trade-off, colored by accuracy",
+        paper_bgcolor="rgba(0,0,0,0)",
+        plot_bgcolor="rgba(255,255,255,0.035)",
+        legend=dict(orientation="h", yanchor="bottom", y=-0.28, xanchor="center", x=0.5),
+    )
+    return fig
+
+
+def price_per_million(value: Any) -> str:
+    if value in (None, ""):
+        return "n/a"
+    try:
+        return f"${float(value) * 1_000_000:.2f}/1M tokens"
+    except (TypeError, ValueError):
+        return str(value)
+
+
+def model_card(model: str, model_info: Dict[str, Any]) -> None:
+    info = model_info.get(model, {})
+    if not info:
+        st.caption(f"No OpenRouter snapshot information available for `{model}`.")
+        return
+    pricing = info.get("pricing", {}) if isinstance(info.get("pricing", {}), dict) else {}
+    architecture = info.get("architecture", {}) if isinstance(info.get("architecture", {}), dict) else {}
+    provider = info.get("top_provider", {}) if isinstance(info.get("top_provider", {}), dict) else {}
+    supported = info.get("supported_parameters", []) or []
+    description = (info.get("description") or "").strip().replace("\n", " ")
+    if len(description) > 260:
+        description = description[:260].rstrip() + "…"
+    st.markdown(f"#### {info.get('name') or model}")
+    st.code(model, language=None)
+    st.markdown(
+        f"""
+- **Context length:** {info.get('context_length') or provider.get('context_length') or 'n/a'}
+- **Max completion tokens:** {provider.get('max_completion_tokens') or 'n/a'}
+- **Input price:** {price_per_million(pricing.get('prompt') or pricing.get('input'))}
+- **Output price:** {price_per_million(pricing.get('completion') or pricing.get('output'))}
+- **Tokenizer:** {architecture.get('tokenizer') or 'n/a'}
+- **Supported parameters:** {', '.join(supported[:7]) if supported else 'n/a'}{'…' if len(supported) > 7 else ''}
+"""
+    )
+    if description:
+        st.caption(description)
+
+
+def apply_global_filters(df: pd.DataFrame, config: DatasetConfig, key_prefix: str) -> tuple[pd.DataFrame, List[str]]:
+    models = sorted(df["model"].dropna().unique().tolist())
+    categories = sorted(df[config.category_col].dropna().astype(str).unique().tolist()) if config.category_col in df.columns else []
+    if config.category_col == "magnitude_group":
+        categories = sort_magnitude(categories)
+
+    with st.container(border=True):
+        c1, c2, c3, c4 = st.columns([1.15, 1.15, 1.45, 1])
+        with c1:
+            model_a = st.selectbox("Model A / primary", models, index=0, key=f"{key_prefix}_model_a")
+        with c2:
+            model_b = st.selectbox("Model B / compare optional", [""] + models, index=0, key=f"{key_prefix}_model_b")
+        with c3:
+            selected_categories = st.multiselect(
+                config.category_label,
+                categories,
+                default=categories,
+                key=f"{key_prefix}_categories",
+            )
+        with c4:
+            run_error_policy = st.selectbox(
+                "Run errors in metrics",
+                ["Count as failures", "Exclude from metrics"],
+                index=0,
+                key=f"{key_prefix}_run_errors",
+            )
+
+    st.caption("Charts use the selected model names directly. If two models are selected, category/magnitude charts are split by model.")
+
+    chosen = selected_models(model_a, model_b)
+    view = df[df["model"].isin(chosen)].copy()
+    if selected_categories and config.category_col in view.columns:
+        view = view[view[config.category_col].astype(str).isin(selected_categories)]
+    if run_error_policy == "Exclude from metrics" and "run_success" in view.columns:
+        view = view[view["run_success"].eq(True)]
+    return view, chosen
+
+
+def render_dataset_intro(df: pd.DataFrame, config: DatasetConfig) -> None:
+    st.markdown(f"### {config.title}")
+    st.markdown(config.description)
+    st.markdown(f"Dataset: [`{config.dataset_id}`](https://huggingface.co/datasets/{config.dataset_id})")
+    c1, c2, c3, c4 = st.columns(4)
+    c1.metric("Rows", f"{len(df):,}")
+    c2.metric("Tasks", f"{df['operation_id'].nunique():,}" if "operation_id" in df.columns else "n/a")
+    c3.metric("Models", f"{df['model'].nunique():,}" if "model" in df.columns else "n/a")
+    c4.metric("Modes", f"{df['mode'].nunique():,}" if "mode" in df.columns else "n/a")
+
+
+def render_statistics(df: pd.DataFrame, config: DatasetConfig, model_info: Dict[str, Any], key_prefix: str) -> None:
+    st.caption("Explore aggregate statistics and compare models across raw, prompted, and tool modes.")
+    view, chosen = apply_global_filters(df, config, key_prefix + "_stats")
+    summary = summarize(view, chosen)
+
+    stat_views = ["Accuracy by category", "Accuracy", "Latency", "Cost", "Tokens", "Tool pipeline", "Cost/latency trade-off"]
+    if config.key == "next_prime":
+        stat_views[0] = "Accuracy by magnitude"
+    default_index = stat_views.index(config.default_stat_view) if config.default_stat_view in stat_views else 0
+    stat_view = st.selectbox("Statistic view", stat_views, index=default_index, key=f"{key_prefix}_stat_view")
+
+    if stat_view in ["Accuracy by category", "Accuracy by magnitude"]:
+        order = None
+        if config.category_col == "magnitude_group" and config.category_col in view.columns:
+            order = sort_magnitude(view[config.category_col].dropna().unique().tolist())
+        st.plotly_chart(
+            grouped_accuracy_chart(view, config.category_col, stat_view, order),
+            width="stretch",
+        )
+    elif stat_view == "Accuracy":
+        st.plotly_chart(metric_chart(summary, "accuracy_pct", "Accuracy (%)", True), width="stretch")
+    elif stat_view == "Latency":
+        st.plotly_chart(metric_chart(summary, "avg_latency_seconds", "Average latency, seconds"), width="stretch")
+    elif stat_view == "Cost":
+        st.plotly_chart(metric_chart(summary, "avg_cost", "Average cost, USD"), width="stretch")
+    elif stat_view == "Tokens":
+        st.plotly_chart(metric_chart(summary, "avg_total_tokens", "Average total tokens"), width="stretch")
+    elif stat_view == "Tool pipeline":
+        st.dataframe(tool_pipeline_summary(view), width="stretch", hide_index=True)
+    elif stat_view == "Cost/latency trade-off":
+        st.plotly_chart(tradeoff_chart(view), width="stretch")
+
+    st.markdown("#### Summary table")
+    st.dataframe(summary, width="stretch", hide_index=True)
+
+    with st.expander("Selected model details from OpenRouter snapshot", expanded=False):
+        info_cols = st.columns(max(1, len(chosen)))
+        for col, model in zip(info_cols, chosen):
+            with col:
+                model_card(model, model_info)
+
+
+def quick_filter(df: pd.DataFrame, filter_name: str, config: DatasetConfig) -> pd.DataFrame:
+    out = df.copy()
+    if filter_name == "Wrong answers":
+        out = out[out["final_result_correct"].ne(True)]
+    elif filter_name == "Correct answers":
+        out = out[out["final_result_correct"].eq(True)]
+    elif filter_name == "Run failures":
+        out = out[out["run_success"].ne(True)]
+    elif filter_name == "Tool issues":
+        out = out[
+            (out["mode"].astype(str) == "tool")
+            & (
+                out.get("tool_called", pd.Series(False, index=out.index)).ne(True)
+                | out.get("tool_result_correct", pd.Series(True, index=out.index)).ne(True)
+                | out.get("tool_error_type", pd.Series("none", index=out.index)).fillna("none").ne("none")
+            )
+        ]
+    elif filter_name == "Tool correct, final failed":
+        out = out[(out["mode"].astype(str) == "tool") & out.get("tool_result_correct", pd.Series(False, index=out.index)).eq(True) & out["final_result_correct"].ne(True)]
+    elif filter_name == "Long answers":
+        lengths = out["answer_text"].fillna("").astype(str).str.len()
+        out = out[lengths >= lengths.quantile(0.90)]
+    elif filter_name == "Slowest answers":
+        out = out[out["latency_seconds"] >= out["latency_seconds"].quantile(0.90)]
+    elif filter_name == "Fastest answers":
+        out = out[out["latency_seconds"] <= out["latency_seconds"].quantile(0.10)]
+    elif filter_name == "Highest cost":
+        if out["cost"].notna().any():
+            out = out[out["cost"] >= out["cost"].quantile(0.90)]
+    elif filter_name == "High magnitude" and config.key == "next_prime":
+        out = out[out.get("magnitude_group", pd.Series("", index=out.index)).astype(str).isin(["10^4", "10^5"])]
+    elif filter_name == "Large prime gap" and config.key == "next_prime":
+        out = out[out.get("distance_to_next_prime", pd.Series(0, index=out.index)) >= out.get("distance_to_next_prime", pd.Series(0, index=out.index)).quantile(0.90)]
+    return out
+
+
+def record_label(row: pd.Series) -> str:
+    status = "✅" if row.get("final_result_correct") == True else "❌"
+    return f"{status} {row.get('model')} | {row.get('mode')}"
+
+
+def display_result_panel(row: Optional[pd.Series], title: str) -> None:
+    st.markdown(f"#### {title}")
+    if row is None:
+        st.info("No matching result.")
+        return
+    status = "✅ correct" if row.get("final_result_correct") == True else "❌ not correct"
+    st.markdown(f"**{row.get('model')}** · `{row.get('mode')}` · {status}")
+    m1, m2, m3 = st.columns(3)
+    m1.metric("Extracted", str(row.get("extracted_answer_str", row.get("extracted_answer"))))
+    m2.metric("Latency", f"{row.get('latency_seconds'):.3g}s" if pd.notna(row.get("latency_seconds")) else "n/a")
+    m3.metric("Cost", f"${row.get('cost'):.6f}" if pd.notna(row.get("cost")) else "n/a")
+    with st.expander("Diagnostics", expanded=False):
+        st.json(
+            {
+                "run_success": bool(row.get("run_success")) if pd.notna(row.get("run_success")) else None,
+                "run_error": sanitize_text(row.get("run_error")),
+                "extraction_error_type": row.get("extraction_error_type"),
+                "tool_called": row.get("tool_called"),
+                "tool_result": row.get("tool_result_str", row.get("tool_result")),
+                "tool_result_correct": row.get("tool_result_correct"),
+                "tool_error_type": row.get("tool_error_type"),
+            }
+        )
+    st.markdown("**Model answer**")
+    st.code(sanitize_text(row.get("answer_text")), language=None)
+    if str(row.get("mode")) == "tool":
+        with st.expander("Tool details", expanded=False):
+            st.json(
+                {
+                    "tool_expression": row.get("tool_expression"),
+                    "tool_result": row.get("tool_result_str", row.get("tool_result")),
+                    "tool_error": sanitize_text(row.get("tool_error")),
+                    "tool_calls": row.get("tool_calls"),
+                }
+            )
+
+
+def render_task_details(case_rows: pd.DataFrame, config: DatasetConfig, key_prefix: str) -> None:
+    if case_rows.empty:
+        st.info("No rows for this task.")
+        return
+    first = case_rows.iloc[0]
+    with st.container(border=True):
+        st.markdown(f"#### {config.task_label}")
+        st.write(first.get("operation"))
+        meta = {
+            "operation_id": first.get("operation_id"),
+            "category": first.get("operation_category"),
+            "correct_result": first.get("correct_result_str", first.get("correct_result")),
+        }
+        for col in ["input_number", "magnitude_group", "distance_to_next_prime", "input_is_prime"]:
+            if col in case_rows.columns:
+                meta[col] = first.get(col)
+        st.json(meta)
+
+    available = case_rows.sort_values(["model", "mode"]).reset_index(drop=True)
+    labels = available.apply(record_label, axis=1).tolist()
+    task_id_for_key = str(first.get("operation_id"))
+    c1, c2 = st.columns(2)
+    with c1:
+        left_label = st.selectbox("Left result", labels, index=0, key=f"{key_prefix}_{task_id_for_key}_left_result")
+    with c2:
+        right_index = min(1, len(labels) - 1)
+        right_label = st.selectbox("Right result", labels, index=right_index, key=f"{key_prefix}_{task_id_for_key}_right_result")
+    left_row = available.iloc[labels.index(left_label)] if labels else None
+    right_row = available.iloc[labels.index(right_label)] if labels else None
+
+    r1, r2 = st.columns(2)
+    with r1:
+        display_result_panel(left_row, "Result A")
+    with r2:
+        display_result_panel(right_row, "Result B")
+
+
+def render_details(df: pd.DataFrame, config: DatasetConfig, key_prefix: str) -> None:
+    st.caption("Pick a task, then compare two model × mode results side by side.")
+    filters = [
+        "All",
+        "Wrong answers",
+        "Correct answers",
+        "Run failures",
+        "Tool issues",
+        "Tool correct, final failed",
+        "Long answers",
+        "Slowest answers",
+        "Fastest answers",
+        "Highest cost",
+    ]
+    if config.key == "next_prime":
+        filters += ["High magnitude", "Large prime gap"]
+
+    c1, c2, c3 = st.columns([1.1, 1.1, 1.8])
+    previous_filter = st.session_state.get(f"{key_prefix}_active_filter")
+    with c1:
+        filter_name = st.selectbox("Quick filter", filters, index=0, key=f"{key_prefix}_quick_filter")
+    selected_task_key = f"{key_prefix}_selected_task_id"
+    if previous_filter != filter_name:
+        st.session_state[f"{key_prefix}_active_filter"] = filter_name
+        st.session_state.pop(selected_task_key, None)
+    with c2:
+        modes = st.multiselect("Modes included", MODE_ORDER, default=MODE_ORDER, key=f"{key_prefix}_detail_modes")
+    with c3:
+        search_text = st.text_input("Search task or answer", value="", key=f"{key_prefix}_search")
+
+    filtered = quick_filter(df, filter_name, config)
+    if modes:
+        filtered = filtered[filtered["mode"].astype(str).isin(modes)]
+    if search_text.strip():
+        needle = search_text.strip().lower()
+        filtered = filtered[
+            filtered["operation"].fillna("").str.lower().str.contains(needle, regex=False)
+            | filtered["answer_text"].fillna("").str.lower().str.contains(needle, regex=False)
+            | filtered["model"].fillna("").str.lower().str.contains(needle, regex=False)
+        ]
+
+    st.caption(
+        f"Quick filter matches {len(filtered):,} rows across "
+        f"{filtered['operation_id'].nunique() if 'operation_id' in filtered.columns else 0:,} tasks. "
+        "The comparison area below uses only rows matching the current filter/mode/search selection."
+    )
+
+    if filter_name == "Long answers":
+        filtered = filtered.assign(_answer_length=filtered["answer_text"].fillna("").astype(str).str.len())
+        task_ids = (
+            filtered.groupby("operation_id", observed=True)["_answer_length"]
+            .max()
+            .sort_values(ascending=False)
+            .index.astype(str)
+            .tolist()
+        )
+    elif filter_name == "Slowest answers":
+        task_ids = (
+            filtered.groupby("operation_id", observed=True)["latency_seconds"]
+            .max()
+            .sort_values(ascending=False)
+            .index.astype(str)
+            .tolist()
+        )
+    elif filter_name == "Fastest answers":
+        task_ids = (
+            filtered.groupby("operation_id", observed=True)["latency_seconds"]
+            .min()
+            .sort_values(ascending=True)
+            .index.astype(str)
+            .tolist()
+        )
+    else:
+        task_ids = filtered["operation_id"].dropna().astype(str).drop_duplicates().sort_values().tolist()
+    if not task_ids:
+        st.info("No tasks match the current filters.")
+        return
+
+    if st.session_state.get(selected_task_key) not in task_ids:
+        st.session_state[selected_task_key] = task_ids[0]
+
+    current_index = task_ids.index(st.session_state[selected_task_key])
+    n1, n2, n3 = st.columns([0.7, 2.6, 0.7])
+    with n1:
+        if st.button("◀ Previous", key=f"{key_prefix}_prev", disabled=current_index == 0):
+            st.session_state[selected_task_key] = task_ids[current_index - 1]
+    with n3:
+        if st.button("Next ▶", key=f"{key_prefix}_next", disabled=current_index == len(task_ids) - 1):
+            st.session_state[selected_task_key] = task_ids[current_index + 1]
+
+    current_index = task_ids.index(st.session_state[selected_task_key])
+    with n2:
+        selected_id = st.selectbox(
+            "Task",
+            task_ids,
+            index=current_index,
+            key=selected_task_key,
+        )
+
+    case_rows = filtered[filtered["operation_id"].astype(str) == selected_id].copy()
+    render_task_details(case_rows, config, key_prefix)
+
+    with st.expander("Rows matching current quick filter", expanded=False):
+        display_cols = [
+            "operation_id",
+            "operation_category",
+            "model",
+            "mode",
+            "operation",
+            "correct_result_str",
+            "extracted_answer_str",
+            "final_result_correct",
+            "run_success",
+            "latency_seconds",
+            "cost",
+            "tool_error_type",
+        ]
+        display_cols = [c for c in display_cols if c in filtered.columns]
+        st.dataframe(filtered[display_cols].head(500), width="stretch", hide_index=True, height=260)
+
+
+def render_dataset_tab(df: pd.DataFrame, config: DatasetConfig, model_info: Dict[str, Any]) -> None:
+    render_dataset_intro(df, config)
+    st.divider()
+    stats_tab, details_tab = st.tabs(["Statistics", "Detailed results"])
+    with stats_tab:
+        render_statistics(df, config, model_info, config.key)
+    with details_tab:
+        render_details(df, config, config.key)
+
+
+st.title("🔢 LLM & Arithmetic")
+st.markdown(
+    "Explore two small, public Hugging Face datasets about LLM behavior on arithmetic-like tasks: "
+    "standard calculations and next-prime search."
+)
+
+with st.spinner("Loading Hugging Face datasets..."):
+    calculations_df = load_hf_dataset(CALCULATIONS_DATASET_ID)
+    next_prime_df = load_hf_dataset(NEXT_PRIME_DATASET_ID)
+model_info_snapshot = load_model_info()
+
+calc_tab, prime_tab = st.tabs(["Calculations", "Next Prime"])
+with calc_tab:
+    render_dataset_tab(calculations_df, DATASETS["calculations"], model_info_snapshot)
+with prime_tab:
+    render_dataset_tab(next_prime_df, DATASETS["next_prime"], model_info_snapshot)

fetch_openrouter_model_info.py

@@ -0,0 +1,50 @@
+"""Fetch an OpenRouter model metadata snapshot for the Space.
+
+Run when you want to refresh model_info_snapshot.json:
+
+    python fetch_openrouter_model_info.py
+
+No API key is required for the public /models endpoint at the time of writing.
+"""
+
+import json
+from pathlib import Path
+
+import requests
+
+MODEL_FAMILIES_PATH = Path("model_families.json")
+OUTPUT = Path("model_info_snapshot.json")
+OPENROUTER_MODELS_URL = "https://openrouter.ai/api/v1/models"
+
+
+def load_model_families() -> dict:
+    return json.loads(MODEL_FAMILIES_PATH.read_text(encoding="utf-8"))
+
+
+def main() -> None:
+    model_families = load_model_families()
+    wanted = {model for models in model_families.values() for model in models}
+    response = requests.get(OPENROUTER_MODELS_URL, timeout=30)
+    response.raise_for_status()
+    data = response.json().get("data", [])
+    by_id = {item.get("id"): item for item in data}
+
+    snapshot = {}
+    for family, models in model_families.items():
+        for model in models:
+            item = by_id.get(model, {"id": model, "name": model})
+            item = dict(item)
+            item["model_family"] = family
+            snapshot[model] = item
+
+    missing = sorted(wanted - set(by_id))
+    OUTPUT.write_text(json.dumps(snapshot, ensure_ascii=False, indent=2), encoding="utf-8")
+    print(f"Wrote {len(snapshot)} models to {OUTPUT}")
+    if missing:
+        print("Missing from OpenRouter response:")
+        for model in missing:
+            print(f"- {model}")
+
+
+if __name__ == "__main__":
+    main()

model_families.json

@@ -0,0 +1,34 @@
+{
+  "openai": [
+    "openai/gpt-3.5-turbo",
+    "openai/gpt-4",
+    "openai/gpt-4o-mini",
+    "openai/gpt-oss-120b",
+    "openai/gpt-5.5"
+  ],
+  "qwen": [
+    "qwen/qwen-2.5-72b-instruct",
+    "qwen/qwen3-30b-a3b-thinking-2507",
+    "qwen/qwen3.5-flash-02-23",
+    "qwen/qwen3.7-plus"
+  ],
+  "deepseek": [
+    "deepseek/deepseek-v3.2",
+    "deepseek/deepseek-v4-flash",
+    "deepseek/deepseek-v4-pro"
+  ],
+  "google": [
+    "google/gemini-3-flash-preview",
+    "google/gemini-2.5-flash-lite",
+    "google/gemma-4-31b-it",
+    "google/gemini-3.5-flash"
+  ],
+  "others": [
+    "cohere/north-mini-code:free",
+    "mistralai/mistral-nemo",
+    "poolside/laguna-m.1",
+    "xiaomi/mimo-v2.5",
+    "minimax/minimax-m3",
+    "z-ai/glm-5.2"
+  ]
+}

model_info_snapshot.json

@@ -0,0 +1,2399 @@
+{
+  "openai/gpt-3.5-turbo": {
+    "id": "openai/gpt-3.5-turbo",
+    "canonical_slug": "openai/gpt-3.5-turbo",
+    "hugging_face_id": null,
+    "name": "OpenAI: GPT-3.5 Turbo",
+    "created": 1685232000,
+    "description": "GPT-3.5 Turbo is OpenAI's fastest model. It can understand and generate natural language or code, and is optimized for chat and traditional completion tasks.\n\nTraining data up to Sep 2021.",
+    "context_length": 16385,
+    "architecture": {
+      "modality": "text->text",
+      "input_modalities": [
+        "text"
+      ],
+      "output_modalities": [
+        "text"
+      ],
+      "tokenizer": "GPT",
+      "instruct_type": null
+    },
+    "pricing": {
+      "prompt": "0.0000005",
+      "completion": "0.0000015"
+    },
+    "top_provider": {
+      "context_length": 16385,
+      "max_completion_tokens": 4096,
+      "is_moderated": true
+    },
+    "per_request_limits": null,
+    "supported_parameters": [
+      "frequency_penalty",
+      "logit_bias",
+      "logprobs",
+      "max_tokens",
+      "presence_penalty",
+      "response_format",
+      "seed",
+      "stop",
+      "structured_outputs",
+      "temperature",
+      "tool_choice",
+      "tools",
+      "top_logprobs",
+      "top_p"
+    ],
+    "default_parameters": {},
+    "supported_voices": null,
+    "knowledge_cutoff": "2021-09-30",
+    "expiration_date": null,
+    "links": {
+      "details": "/api/v1/models/openai/gpt-3.5-turbo/endpoints"
+    },
+    "benchmarks": {
+      "design_arena": [],
+      "artificial_analysis": {
+        "intelligence_index": null,
+        "coding_index": 10.7,
+        "agentic_index": null
+      }
+    },
+    "model_family": "openai"
+  },
+  "openai/gpt-4": {
+    "id": "openai/gpt-4",
+    "canonical_slug": "openai/gpt-4",
+    "hugging_face_id": null,
+    "name": "OpenAI: GPT-4",
+    "created": 1685232000,
+    "description": "OpenAI's flagship model, GPT-4 is a large-scale multimodal language model capable of solving difficult problems with greater accuracy than previous models due to its broader general knowledge and advanced reasoning...",
+    "context_length": 8191,
+    "architecture": {
+      "modality": "text->text",
+      "input_modalities": [
+        "text"
+      ],
+      "output_modalities": [
+        "text"
+      ],
+      "tokenizer": "GPT",
+      "instruct_type": null
+    },
+    "pricing": {
+      "prompt": "0.00003",
+      "completion": "0.00006"
+    },
+    "top_provider": {
+      "context_length": 8191,
+      "max_completion_tokens": 4096,
+      "is_moderated": true
+    },
+    "per_request_limits": null,
+    "supported_parameters": [
+      "frequency_penalty",
+      "logit_bias",
+      "logprobs",
+      "max_completion_tokens",
+      "max_tokens",
+      "presence_penalty",
+      "response_format",
+      "seed",
+      "stop",
+      "structured_outputs",
+      "temperature",
+      "tool_choice",
+      "tools",
+      "top_logprobs",
+      "top_p"
+    ],
+    "default_parameters": {},
+    "supported_voices": null,
+    "knowledge_cutoff": "2021-09-30",
+    "expiration_date": null,
+    "links": {
+      "details": "/api/v1/models/openai/gpt-4/endpoints"
+    },
+    "benchmarks": {
+      "design_arena": [],
+      "artificial_analysis": {
+        "intelligence_index": null,
+        "coding_index": 13.1,
+        "agentic_index": null
+      }
+    },
+    "model_family": "openai"
+  },
+  "openai/gpt-4o-mini": {
+    "id": "openai/gpt-4o-mini",
+    "canonical_slug": "openai/gpt-4o-mini",
+    "hugging_face_id": null,
+    "name": "OpenAI: GPT-4o-mini",
+    "created": 1721260800,
+    "description": "GPT-4o mini is OpenAI's newest model after [GPT-4 Omni](/models/openai/gpt-4o), supporting both text and image inputs with text outputs. As their most advanced small model, it is many multiples more affordable...",
+    "context_length": 128000,
+    "architecture": {
+      "modality": "text+image+file->text",
+      "input_modalities": [
+        "text",
+        "image",
+        "file"
+      ],
+      "output_modalities": [
+        "text"
+      ],
+      "tokenizer": "GPT",
+      "instruct_type": null
+    },
+    "pricing": {
+      "prompt": "0.00000015",
+      "completion": "0.0000006",
+      "input_cache_read": "0.000000075"
+    },
+    "top_provider": {
+      "context_length": 128000,
+      "max_completion_tokens": 16384,
+      "is_moderated": false
+    },
+    "per_request_limits": null,
+    "supported_parameters": [
+      "frequency_penalty",
+      "logit_bias",
+      "logprobs",
+      "max_completion_tokens",
+      "max_tokens",
+      "presence_penalty",
+      "response_format",
+      "seed",
+      "stop",
+      "structured_outputs",
+      "temperature",
+      "tool_choice",
+      "tools",
+      "top_logprobs",
+      "top_p",
+      "web_search_options"
+    ],
+    "default_parameters": {},
+    "supported_voices": null,
+    "knowledge_cutoff": "2023-10-31",
+    "expiration_date": null,
+    "links": {
+      "details": "/api/v1/models/openai/gpt-4o-mini/endpoints"
+    },
+    "benchmarks": {
+      "design_arena": [],
+      "artificial_analysis": {
+        "intelligence_index": null,
+        "coding_index": 11.4,
+        "agentic_index": 1
+      }
+    },
+    "model_family": "openai"
+  },
+  "openai/gpt-oss-120b": {
+    "id": "openai/gpt-oss-120b",
+    "canonical_slug": "openai/gpt-oss-120b",
+    "hugging_face_id": "openai/gpt-oss-120b",
+    "name": "OpenAI: gpt-oss-120b",
+    "created": 1754414231,
+    "description": "gpt-oss-120b is an open-weight, 117B-parameter Mixture-of-Experts (MoE) language model from OpenAI designed for high-reasoning, agentic, and general-purpose production use cases. It activates 5.1B parameters per forward pass and is optimized...",
+    "context_length": 131072,
+    "architecture": {
+      "modality": "text->text",
+      "input_modalities": [
+        "text"
+      ],
+      "output_modalities": [
+        "text"
+      ],
+      "tokenizer": "GPT",
+      "instruct_type": null
+    },
+    "pricing": {
+      "prompt": "0.00000003",
+      "completion": "0.00000015"
+    },
+    "top_provider": {
+      "context_length": 131072,
+      "max_completion_tokens": 131072,
+      "is_moderated": false
+    },
+    "per_request_limits": null,
+    "supported_parameters": [
+      "frequency_penalty",
+      "include_reasoning",
+      "logit_bias",
+      "logprobs",
+      "max_tokens",
+      "min_p",
+      "presence_penalty",
+      "reasoning",
+      "repetition_penalty",
+      "response_format",
+      "seed",
+      "stop",
+      "structured_outputs",
+      "temperature",
+      "tool_choice",
+      "tools",
+      "top_a",
+      "top_k",
+      "top_logprobs",
+      "top_p"
+    ],
+    "default_parameters": {
+      "temperature": null,
+      "top_p": null,
+      "frequency_penalty": null
+    },
+    "supported_voices": null,
+    "knowledge_cutoff": "2024-06-30",
+    "expiration_date": null,
+    "links": {
+      "details": "/api/v1/models/openai/gpt-oss-120b/endpoints"
+    },
+    "benchmarks": {
+      "design_arena": [
+        {
+          "arena": "models",
+          "category": "3d",
+          "elo": 978,
+          "win_rate": 29.4,
+          "rank": 91
+        },
+        {
+          "arena": "models",
+          "category": "codecategories",
+          "elo": 1012,
+          "win_rate": 33.4,
+          "rank": 98
+        },
+        {
+          "arena": "models",
+          "category": "dataviz",
+          "elo": 1043,
+          "win_rate": 45.1,
+          "rank": 87
+        },
+        {
+          "arena": "models",
+          "category": "gamedev",
+          "elo": 1059,
+          "win_rate": 40.6,
+          "rank": 85
+        },
+        {
+          "arena": "models",
+          "category": "uicomponent",
+          "elo": 978,
+          "win_rate": 35.5,
+          "rank": 92
+        },
+        {
+          "arena": "models",
+          "category": "website",
+          "elo": 1010,
+          "win_rate": 32.5,
+          "rank": 100
+        }
+      ],
+      "artificial_analysis": {
+        "intelligence_index": 23.8,
+        "coding_index": 30.4,
+        "agentic_index": 13.2
+      }
+    },
+    "reasoning": {
+      "mandatory": true,
+      "supported_efforts": [
+        "high",
+        "medium",
+        "low"
+      ],
+      "default_effort": "medium"
+    },
+    "model_family": "openai"
+  },
+  "openai/gpt-5.5": {
+    "id": "openai/gpt-5.5",
+    "canonical_slug": "openai/gpt-5.5-20260423",
+    "hugging_face_id": "",
+    "name": "OpenAI: GPT-5.5",
+    "created": 1777051893,
+    "description": "GPT-5.5 is OpenAI’s frontier model designed for complex professional workloads, building on GPT-5.4 with stronger reasoning, higher reliability, and improved token efficiency on hard tasks. It features a 1M+ token...",
+    "context_length": 1050000,
+    "architecture": {
+      "modality": "text+image+file->text",
+      "input_modalities": [
+        "file",
+        "image",
+        "text"
+      ],
+      "output_modalities": [
+        "text"
+      ],
+      "tokenizer": "GPT",
+      "instruct_type": null
+    },
+    "pricing": {
+      "prompt": "0.000005",
+      "completion": "0.00003",
+      "web_search": "0.01",
+      "input_cache_read": "0.0000005"
+    },
+    "top_provider": {
+      "context_length": 1050000,
+      "max_completion_tokens": 128000,
+      "is_moderated": true
+    },
+    "per_request_limits": null,
+    "supported_parameters": [
+      "include_reasoning",
+      "max_completion_tokens",
+      "max_tokens",
+      "reasoning",
+      "response_format",
+      "seed",
+      "structured_outputs",
+      "tool_choice",
+      "tools"
+    ],
+    "default_parameters": {
+      "temperature": null,
+      "top_p": null,
+      "top_k": null,
+      "frequency_penalty": null,
+      "presence_penalty": null,
+      "repetition_penalty": null
+    },
+    "supported_voices": null,
+    "knowledge_cutoff": "2025-12-01",
+    "expiration_date": null,
+    "links": {
+      "details": "/api/v1/models/openai/gpt-5.5-20260423/endpoints"
+    },
+    "benchmarks": {
+      "design_arena": [
+        {
+          "arena": "agents",
+          "category": "agenticgamedev",
+          "elo": 1207,
+          "win_rate": 53,
+          "rank": 5
+        },
+        {
+          "arena": "agents",
+          "category": "agentichtmlslides",
+          "elo": 1084,
+          "win_rate": 34.2,
+          "rank": 9
+        },
+        {
+          "arena": "agents",
+          "category": "agenticslides",
+          "elo": 1150,
+          "win_rate": 43.5,
+          "rank": 7
+        },
+        {
+          "arena": "agents",
+          "category": "agenticslides(html)",
+          "elo": 1077,
+          "win_rate": 33.2,
+          "rank": 9
+        },
+        {
+          "arena": "agents",
+          "category": "agenticslides(python-pptx)",
+          "elo": 1155,
+          "win_rate": 45.2,
+          "rank": 7
+        },
+        {
+          "arena": "agents",
+          "category": "androidnative",
+          "elo": 1260,
+          "win_rate": 55.4,
+          "rank": 4
+        },
+        {
+          "arena": "agents",
+          "category": "fullstack",
+          "elo": 1151,
+          "win_rate": 44.5,
+          "rank": 15
+        },
+        {
+          "arena": "agents",
+          "category": "godotgamedev",
+          "elo": 1217,
+          "win_rate": 53,
+          "rank": 9
+        },
+        {
+          "arena": "agents",
+          "category": "htmlslides",
+          "elo": 1082,
+          "win_rate": 34.3,
+          "rank": 11
+        },
+        {
+          "arena": "agents",
+          "category": "mobileapps",
+          "elo": 1220,
+          "win_rate": 51,
+          "rank": 9
+        },
+        {
+          "arena": "agents",
+          "category": "pptxslides",
+          "elo": 1157,
+          "win_rate": 45.3,
+          "rank": 7
+        },
+        {
+          "arena": "agents",
+          "category": "python-pptxslides",
+          "elo": 1152,
+          "win_rate": 43.3,
+          "rank": 8
+        },
+        {
+          "arena": "agents",
+          "category": "webapps",
+          "elo": 1182,
+          "win_rate": 45.2,
+          "rank": 18
+        },
+        {
+          "arena": "models",
+          "category": "3d",
+          "elo": 1264,
+          "win_rate": 53.2,
+          "rank": 29
+        },
+        {
+          "arena": "models",
+          "category": "asciiart",
+          "elo": 1316,
+          "win_rate": 63.2,
+          "rank": 3
+        },
+        {
+          "arena": "models",
+          "category": "codecategories",
+          "elo": 1296,
+          "win_rate": 56.7,
+          "rank": 17
+        },
+        {
+          "arena": "models",
+          "category": "dataviz",
+          "elo": 1300,
+          "win_rate": 58.3,
+          "rank": 9
+        },
+        {
+          "arena": "models",
+          "category": "gamedev",
+          "elo": 1348,
+          "win_rate": 62.8,
+          "rank": 3
+        },
+        {
+          "arena": "models",
+          "category": "svg",
+          "elo": 1283,
+          "win_rate": 59.9,
+          "rank": 6
+        },
+        {
+          "arena": "models",
+          "category": "uicomponent",
+          "elo": 1298,
+          "win_rate": 57,
+          "rank": 16
+        },
+        {
+          "arena": "models",
+          "category": "website",
+          "elo": 1290,
+          "win_rate": 56,
+          "rank": 19
+        }
+      ],
+      "artificial_analysis": {
+        "intelligence_index": 54.8,
+        "coding_index": 74.9,
+        "agentic_index": 44.9
+      }
+    },
+    "reasoning": {
+      "mandatory": false,
+      "default_enabled": true,
+      "supported_efforts": [
+        "xhigh",
+        "high",
+        "medium",
+        "low",
+        "none"
+      ],
+      "default_effort": "medium"
+    },
+    "model_family": "openai"
+  },
+  "qwen/qwen-2.5-72b-instruct": {
+    "id": "qwen/qwen-2.5-72b-instruct",
+    "canonical_slug": "qwen/qwen-2.5-72b-instruct",
+    "hugging_face_id": "Qwen/Qwen2.5-72B-Instruct",
+    "name": "Qwen2.5 72B Instruct",
+    "created": 1726704000,
+    "description": "Qwen2.5 72B is the latest series of Qwen large language models. Qwen2.5 brings the following improvements upon Qwen2: - Significantly more knowledge and has greatly improved capabilities in coding and...",
+    "context_length": 131072,
+    "architecture": {
+      "modality": "text->text",
+      "input_modalities": [
+        "text"
+      ],
+      "output_modalities": [
+        "text"
+      ],
+      "tokenizer": "Qwen",
+      "instruct_type": "chatml"
+    },
+    "pricing": {
+      "prompt": "0.00000036",
+      "completion": "0.0000004"
+    },
+    "top_provider": {
+      "context_length": 32768,
+      "max_completion_tokens": 16384,
+      "is_moderated": false
+    },
+    "per_request_limits": null,
+    "supported_parameters": [
+      "frequency_penalty",
+      "logit_bias",
+      "max_tokens",
+      "min_p",
+      "presence_penalty",
+      "repetition_penalty",
+      "response_format",
+      "seed",
+      "stop",
+      "structured_outputs",
+      "temperature",
+      "tool_choice",
+      "tools",
+      "top_k",
+      "top_p"
+    ],
+    "default_parameters": {},
+    "supported_voices": null,
+    "knowledge_cutoff": "2024-06-30",
+    "expiration_date": null,
+    "links": {
+      "details": "/api/v1/models/qwen/qwen-2.5-72b-instruct/endpoints"
+    },
+    "model_family": "qwen"
+  },
+  "qwen/qwen3-30b-a3b-thinking-2507": {
+    "id": "qwen/qwen3-30b-a3b-thinking-2507",
+    "canonical_slug": "qwen/qwen3-30b-a3b-thinking-2507",
+    "hugging_face_id": "Qwen/Qwen3-30B-A3B-Thinking-2507",
+    "name": "Qwen: Qwen3 30B A3B Thinking 2507",
+    "created": 1756399192,
+    "description": "Qwen3-30B-A3B-Thinking-2507 is a 30B parameter Mixture-of-Experts reasoning model optimized for complex tasks requiring extended multi-step thinking. The model is designed specifically for “thinking mode,” where internal reasoning traces are separated...",
+    "context_length": 131072,
+    "architecture": {
+      "modality": "text->text",
+      "input_modalities": [
+        "text"
+      ],
+      "output_modalities": [
+        "text"
+      ],
+      "tokenizer": "Qwen3",
+      "instruct_type": null
+    },
+    "pricing": {
+      "prompt": "0.00000013",
+      "completion": "0.00000156"
+    },
+    "top_provider": {
+      "context_length": 81920,
+      "max_completion_tokens": 32768,
+      "is_moderated": false
+    },
+    "per_request_limits": null,
+    "supported_parameters": [
+      "include_reasoning",
+      "max_tokens",
+      "presence_penalty",
+      "reasoning",
+      "response_format",
+      "seed",
+      "temperature",
+      "tool_choice",
+      "tools",
+      "top_p"
+    ],
+    "default_parameters": {},
+    "supported_voices": null,
+    "knowledge_cutoff": "2025-06-30",
+    "expiration_date": null,
+    "links": {
+      "details": "/api/v1/models/qwen/qwen3-30b-a3b-thinking-2507/endpoints"
+    },
+    "benchmarks": {
+      "design_arena": [
+        {
+          "arena": "models",
+          "category": "dataviz",
+          "elo": 969,
+          "win_rate": 33.3,
+          "rank": 95
+        },
+        {
+          "arena": "models",
+          "category": "website",
+          "elo": 973,
+          "win_rate": 35.5,
+          "rank": 103
+        }
+      ],
+      "artificial_analysis": {
+        "intelligence_index": 14.4,
+        "coding_index": 12.1,
+        "agentic_index": 1.8
+      }
+    },
+    "reasoning": {
+      "mandatory": true
+    },
+    "model_family": "qwen"
+  },
+  "qwen/qwen3.5-flash-02-23": {
+    "id": "qwen/qwen3.5-flash-02-23",
+    "canonical_slug": "qwen/qwen3.5-flash-20260224",
+    "hugging_face_id": null,
+    "name": "Qwen: Qwen3.5-Flash",
+    "created": 1772053776,
+    "description": "The Qwen3.5 native vision-language Flash models are built on a hybrid architecture that integrates a linear attention mechanism with a sparse mixture-of-experts model, achieving higher inference efficiency. Compared to the...",
+    "context_length": 1000000,
+    "architecture": {
+      "modality": "text+image+video->text",
+      "input_modalities": [
+        "text",
+        "image",
+        "video"
+      ],
+      "output_modalities": [
+        "text"
+      ],
+      "tokenizer": "Qwen3",
+      "instruct_type": null
+    },
+    "pricing": {
+      "prompt": "0.000000065",
+      "completion": "0.00000026"
+    },
+    "top_provider": {
+      "context_length": 1000000,
+      "max_completion_tokens": 65536,
+      "is_moderated": false
+    },
+    "per_request_limits": null,
+    "supported_parameters": [
+      "include_reasoning",
+      "max_tokens",
+      "presence_penalty",
+      "reasoning",
+      "response_format",
+      "seed",
+      "structured_outputs",
+      "temperature",
+      "tool_choice",
+      "tools",
+      "top_p"
+    ],
+    "default_parameters": {
+      "temperature": null,
+      "top_p": null,
+      "frequency_penalty": null
+    },
+    "supported_voices": null,
+    "knowledge_cutoff": null,
+    "expiration_date": null,
+    "links": {
+      "details": "/api/v1/models/qwen/qwen3.5-flash-20260224/endpoints"
+    },
+    "reasoning": {
+      "mandatory": false
+    },
+    "model_family": "qwen"
+  },
+  "qwen/qwen3.7-plus": {
+    "id": "qwen/qwen3.7-plus",
+    "canonical_slug": "qwen/qwen3.7-plus-20260602",
+    "hugging_face_id": null,
+    "name": "Qwen: Qwen3.7 Plus",
+    "created": 1780491783,
+    "description": "Qwen3.7-Plus is a cost-effective model in Alibaba's Qwen3.7 series. It supports text and image input with text output, building on the series' text capabilities with a comprehensive upgrade to its...",
+    "context_length": 1000000,
+    "architecture": {
+      "modality": "text+image->text",
+      "input_modalities": [
+        "text",
+        "image"
+      ],
+      "output_modalities": [
+        "text"
+      ],
+      "tokenizer": "Qwen",
+      "instruct_type": null
+    },
+    "pricing": {
+      "prompt": "0.00000032",
+      "completion": "0.00000128",
+      "input_cache_read": "0.000000064",
+      "input_cache_write": "0.0000004"
+    },
+    "top_provider": {
+      "context_length": 1000000,
+      "max_completion_tokens": 65536,
+      "is_moderated": false
+    },
+    "per_request_limits": null,
+    "supported_parameters": [
+      "include_reasoning",
+      "logprobs",
+      "max_tokens",
+      "presence_penalty",
+      "reasoning",
+      "response_format",
+      "seed",
+      "structured_outputs",
+      "temperature",
+      "tool_choice",
+      "tools",
+      "top_logprobs",
+      "top_p"
+    ],
+    "default_parameters": {},
+    "supported_voices": null,
+    "knowledge_cutoff": null,
+    "expiration_date": null,
+    "links": {
+      "details": "/api/v1/models/qwen/qwen3.7-plus-20260602/endpoints"
+    },
+    "benchmarks": {
+      "design_arena": [],
+      "artificial_analysis": {
+        "intelligence_index": 39,
+        "coding_index": 55.9,
+        "agentic_index": 20.8
+      }
+    },
+    "reasoning": {
+      "mandatory": false,
+      "default_enabled": true
+    },
+    "model_family": "qwen"
+  },
+  "deepseek/deepseek-v3.2": {
+    "id": "deepseek/deepseek-v3.2",
+    "canonical_slug": "deepseek/deepseek-v3.2-20251201",
+    "hugging_face_id": "deepseek-ai/DeepSeek-V3.2",
+    "name": "DeepSeek: DeepSeek V3.2",
+    "created": 1764594642,
+    "description": "DeepSeek-V3.2 is a large language model designed to harmonize high computational efficiency with strong reasoning and agentic tool-use performance. It introduces DeepSeek Sparse Attention (DSA), a fine-grained sparse attention mechanism...",
+    "context_length": 131072,
+    "architecture": {
+      "modality": "text->text",
+      "input_modalities": [
+        "text"
+      ],
+      "output_modalities": [
+        "text"
+      ],
+      "tokenizer": "DeepSeek",
+      "instruct_type": null
+    },
+    "pricing": {
+      "prompt": "0.0000002288",
+      "completion": "0.0000003432",
+      "input_cache_read": "0.00000002288"
+    },
+    "top_provider": {
+      "context_length": 128000,
+      "max_completion_tokens": 64000,
+      "is_moderated": false
+    },
+    "per_request_limits": null,
+    "supported_parameters": [
+      "frequency_penalty",
+      "include_reasoning",
+      "logit_bias",
+      "logprobs",
+      "max_tokens",
+      "min_p",
+      "presence_penalty",
+      "reasoning",
+      "repetition_penalty",
+      "response_format",
+      "seed",
+      "stop",
+      "structured_outputs",
+      "temperature",
+      "tool_choice",
+      "tools",
+      "top_k",
+      "top_logprobs",
+      "top_p"
+    ],
+    "default_parameters": {
+      "temperature": 1,
+      "top_p": 0.95,
+      "top_k": null,
+      "frequency_penalty": null,
+      "presence_penalty": null,
+      "repetition_penalty": null
+    },
+    "supported_voices": null,
+    "knowledge_cutoff": null,
+    "expiration_date": null,
+    "links": {
+      "details": "/api/v1/models/deepseek/deepseek-v3.2-20251201/endpoints"
+    },
+    "benchmarks": {
+      "design_arena": [
+        {
+          "arena": "models",
+          "category": "3d",
+          "elo": 1212,
+          "win_rate": 49.9,
+          "rank": 42
+        },
+        {
+          "arena": "models",
+          "category": "asciiart",
+          "elo": 1130,
+          "win_rate": 40.9,
+          "rank": 43
+        },
+        {
+          "arena": "models",
+          "category": "codecategories",
+          "elo": 1213,
+          "win_rate": 49.6,
+          "rank": 49
+        },
+        {
+          "arena": "models",
+          "category": "dataviz",
+          "elo": 1202,
+          "win_rate": 48.6,
+          "rank": 49
+        },
+        {
+          "arena": "models",
+          "category": "gamedev",
+          "elo": 1198,
+          "win_rate": 46.7,
+          "rank": 51
+        },
+        {
+          "arena": "models",
+          "category": "svg",
+          "elo": 1089,
+          "win_rate": 40.9,
+          "rank": 55
+        },
+        {
+          "arena": "models",
+          "category": "uicomponent",
+          "elo": 1202,
+          "win_rate": 46.9,
+          "rank": 48
+        },
+        {
+          "arena": "models",
+          "category": "website",
+          "elo": 1216,
+          "win_rate": 50.5,
+          "rank": 48
+        }
+      ]
+    },
+    "reasoning": {
+      "mandatory": false,
+      "default_enabled": false
+    },
+    "model_family": "deepseek"
+  },
+  "deepseek/deepseek-v4-flash": {
+    "id": "deepseek/deepseek-v4-flash",
+    "canonical_slug": "deepseek/deepseek-v4-flash-20260423",
+    "hugging_face_id": "deepseek-ai/DeepSeek-V4-Flash",
+    "name": "DeepSeek: DeepSeek V4 Flash",
+    "created": 1777000666,
+    "description": "DeepSeek V4 Flash is an efficiency-optimized Mixture-of-Experts model from DeepSeek with 284B total parameters and 13B activated parameters, supporting a 1M-token context window. It is designed for fast inference and...",
+    "context_length": 1048576,
+    "architecture": {
+      "modality": "text->text",
+      "input_modalities": [
+        "text"
+      ],
+      "output_modalities": [
+        "text"
+      ],
+      "tokenizer": "DeepSeek",
+      "instruct_type": null
+    },
+    "pricing": {
+      "prompt": "0.00000009",
+      "completion": "0.00000018",
+      "input_cache_read": "0.000000018"
+    },
+    "top_provider": {
+      "context_length": 1048576,
+      "max_completion_tokens": 16384,
+      "is_moderated": false
+    },
+    "per_request_limits": null,
+    "supported_parameters": [
+      "frequency_penalty",
+      "include_reasoning",
+      "logit_bias",
+      "logprobs",
+      "max_tokens",
+      "min_p",
+      "presence_penalty",
+      "reasoning",
+      "repetition_penalty",
+      "response_format",
+      "seed",
+      "stop",
+      "structured_outputs",
+      "temperature",
+      "tool_choice",
+      "tools",
+      "top_k",
+      "top_logprobs",
+      "top_p"
+    ],
+    "default_parameters": {
+      "temperature": null,
+      "top_p": null,
+      "top_k": null,
+      "frequency_penalty": null,
+      "presence_penalty": null,
+      "repetition_penalty": null
+    },
+    "supported_voices": null,
+    "knowledge_cutoff": null,
+    "expiration_date": null,
+    "links": {
+      "details": "/api/v1/models/deepseek/deepseek-v4-flash-20260423/endpoints"
+    },
+    "benchmarks": {
+      "design_arena": [
+        {
+          "arena": "models",
+          "category": "3d",
+          "elo": 1268,
+          "win_rate": 50,
+          "rank": 27
+        },
+        {
+          "arena": "models",
+          "category": "asciiart",
+          "elo": 1165,
+          "win_rate": 44.4,
+          "rank": 36
+        },
+        {
+          "arena": "models",
+          "category": "codecategories",
+          "elo": 1256,
+          "win_rate": 50.1,
+          "rank": 31
+        },
+        {
+          "arena": "models",
+          "category": "dataviz",
+          "elo": 1166,
+          "win_rate": 41.5,
+          "rank": 63
+        },
+        {
+          "arena": "models",
+          "category": "gamedev",
+          "elo": 1263,
+          "win_rate": 50.7,
+          "rank": 28
+        },
+        {
+          "arena": "models",
+          "category": "svg",
+          "elo": 1215,
+          "win_rate": 49.3,
+          "rank": 24
+        },
+        {
+          "arena": "models",
+          "category": "uicomponent",
+          "elo": 1218,
+          "win_rate": 46.2,
+          "rank": 41
+        },
+        {
+          "arena": "models",
+          "category": "website",
+          "elo": 1251,
+          "win_rate": 50.8,
+          "rank": 31
+        }
+      ],
+      "artificial_analysis": {
+        "intelligence_index": 40.3,
+        "coding_index": 56.2,
+        "agentic_index": 31.1
+      }
+    },
+    "reasoning": {
+      "mandatory": false,
+      "supported_efforts": [
+        "xhigh",
+        "high"
+      ],
+      "default_effort": "high"
+    },
+    "model_family": "deepseek"
+  },
+  "deepseek/deepseek-v4-pro": {
+    "id": "deepseek/deepseek-v4-pro",
+    "canonical_slug": "deepseek/deepseek-v4-pro-20260423",
+    "hugging_face_id": "deepseek-ai/DeepSeek-V4-Pro",
+    "name": "DeepSeek: DeepSeek V4 Pro",
+    "created": 1777000679,
+    "description": "DeepSeek V4 Pro is a large-scale Mixture-of-Experts model from DeepSeek with 1.6T total parameters and 49B activated parameters, supporting a 1M-token context window. It is designed for advanced reasoning, coding,...",
+    "context_length": 1048576,
+    "architecture": {
+      "modality": "text->text",
+      "input_modalities": [
+        "text"
+      ],
+      "output_modalities": [
+        "text"
+      ],
+      "tokenizer": "DeepSeek",
+      "instruct_type": null
+    },
+    "pricing": {
+      "prompt": "0.000000435",
+      "completion": "0.00000087",
+      "input_cache_read": "0.000000003625"
+    },
+    "top_provider": {
+      "context_length": 1048576,
+      "max_completion_tokens": 384000,
+      "is_moderated": false
+    },
+    "per_request_limits": null,
+    "supported_parameters": [
+      "frequency_penalty",
+      "include_reasoning",
+      "logit_bias",
+      "logprobs",
+      "max_tokens",
+      "min_p",
+      "presence_penalty",
+      "reasoning",
+      "repetition_penalty",
+      "response_format",
+      "seed",
+      "stop",
+      "structured_outputs",
+      "temperature",
+      "tool_choice",
+      "tools",
+      "top_k",
+      "top_logprobs",
+      "top_p"
+    ],
+    "default_parameters": {
+      "temperature": 1,
+      "top_p": 1,
+      "top_k": null,
+      "frequency_penalty": null,
+      "presence_penalty": null,
+      "repetition_penalty": null
+    },
+    "supported_voices": null,
+    "knowledge_cutoff": null,
+    "expiration_date": null,
+    "links": {
+      "details": "/api/v1/models/deepseek/deepseek-v4-pro-20260423/endpoints"
+    },
+    "benchmarks": {
+      "design_arena": [
+        {
+          "arena": "agents",
+          "category": "fullstack",
+          "elo": 948,
+          "win_rate": 22.1,
+          "rank": 29
+        },
+        {
+          "arena": "agents",
+          "category": "godotgamedev",
+          "elo": 1097,
+          "win_rate": 34,
+          "rank": 20
+        },
+        {
+          "arena": "agents",
+          "category": "webapps",
+          "elo": 1018,
+          "win_rate": 26.6,
+          "rank": 25
+        },
+        {
+          "arena": "models",
+          "category": "3d",
+          "elo": 1325,
+          "win_rate": 60.5,
+          "rank": 7
+        },
+        {
+          "arena": "models",
+          "category": "asciiart",
+          "elo": 1202,
+          "win_rate": 47.6,
+          "rank": 22
+        },
+        {
+          "arena": "models",
+          "category": "codecategories",
+          "elo": 1287,
+          "win_rate": 54.9,
+          "rank": 20
+        },
+        {
+          "arena": "models",
+          "category": "dataviz",
+          "elo": 1221,
+          "win_rate": 48.6,
+          "rank": 38
+        },
+        {
+          "arena": "models",
+          "category": "gamedev",
+          "elo": 1296,
+          "win_rate": 56.1,
+          "rank": 18
+        },
+        {
+          "arena": "models",
+          "category": "svg",
+          "elo": 1193,
+          "win_rate": 46.9,
+          "rank": 34
+        },
+        {
+          "arena": "models",
+          "category": "uicomponent",
+          "elo": 1271,
+          "win_rate": 52,
+          "rank": 25
+        },
+        {
+          "arena": "models",
+          "category": "website",
+          "elo": 1278,
+          "win_rate": 53.7,
+          "rank": 23
+        }
+      ],
+      "artificial_analysis": {
+        "intelligence_index": 44.3,
+        "coding_index": 59.4,
+        "agentic_index": 36.4
+      }
+    },
+    "reasoning": {
+      "mandatory": false,
+      "supported_efforts": [
+        "xhigh",
+        "high"
+      ],
+      "default_effort": "high"
+    },
+    "model_family": "deepseek"
+  },
+  "google/gemini-3-flash-preview": {
+    "id": "google/gemini-3-flash-preview",
+    "canonical_slug": "google/gemini-3-flash-preview-20251217",
+    "hugging_face_id": "",
+    "name": "Google: Gemini 3 Flash Preview",
+    "created": 1765987078,
+    "description": "Gemini 3 Flash Preview is a high speed, high value thinking model designed for agentic workflows, multi turn chat, and coding assistance. It delivers near Pro level reasoning and tool...",
+    "context_length": 1048576,
+    "architecture": {
+      "modality": "text+image+file+audio+video->text",
+      "input_modalities": [
+        "text",
+        "image",
+        "file",
+        "audio",
+        "video"
+      ],
+      "output_modalities": [
+        "text"
+      ],
+      "tokenizer": "Gemini",
+      "instruct_type": null
+    },
+    "pricing": {
+      "prompt": "0.0000005",
+      "completion": "0.000003",
+      "image": "0.0000005",
+      "audio": "0.000001",
+      "web_search": "0.014",
+      "internal_reasoning": "0.000003",
+      "input_cache_read": "0.00000005",
+      "input_cache_write": "0.00000008333333333333334"
+    },
+    "top_provider": {
+      "context_length": 1048576,
+      "max_completion_tokens": 65535,
+      "is_moderated": false
+    },
+    "per_request_limits": null,
+    "supported_parameters": [
+      "include_reasoning",
+      "max_tokens",
+      "reasoning",
+      "response_format",
+      "seed",
+      "stop",
+      "structured_outputs",
+      "temperature",
+      "tool_choice",
+      "tools",
+      "top_p"
+    ],
+    "default_parameters": {
+      "temperature": null,
+      "top_p": null,
+      "top_k": null,
+      "frequency_penalty": null,
+      "presence_penalty": null,
+      "repetition_penalty": null
+    },
+    "supported_voices": null,
+    "knowledge_cutoff": null,
+    "expiration_date": null,
+    "links": {
+      "details": "/api/v1/models/google/gemini-3-flash-preview-20251217/endpoints"
+    },
+    "benchmarks": {
+      "design_arena": [
+        {
+          "arena": "agents",
+          "category": "agenticslides",
+          "elo": 1073,
+          "win_rate": 39.3,
+          "rank": 9
+        },
+        {
+          "arena": "agents",
+          "category": "agenticslides(python-pptx)",
+          "elo": 1075,
+          "win_rate": 39.3,
+          "rank": 9
+        },
+        {
+          "arena": "agents",
+          "category": "androidnative",
+          "elo": 1059,
+          "win_rate": 48,
+          "rank": 24
+        },
+        {
+          "arena": "agents",
+          "category": "fullstack",
+          "elo": 1128,
+          "win_rate": 47.1,
+          "rank": 17
+        },
+        {
+          "arena": "agents",
+          "category": "godotgamedev",
+          "elo": 1218,
+          "win_rate": 52.3,
+          "rank": 8
+        },
+        {
+          "arena": "agents",
+          "category": "mobileapps",
+          "elo": 1183,
+          "win_rate": 49.8,
+          "rank": 17
+        },
+        {
+          "arena": "agents",
+          "category": "webapps",
+          "elo": 1186,
+          "win_rate": 49.5,
+          "rank": 17
+        },
+        {
+          "arena": "models",
+          "category": "3d",
+          "elo": 1261,
+          "win_rate": 62.7,
+          "rank": 30
+        },
+        {
+          "arena": "models",
+          "category": "codecategories",
+          "elo": 1238,
+          "win_rate": 57.6,
+          "rank": 34
+        },
+        {
+          "arena": "models",
+          "category": "gamedev",
+          "elo": 1232,
+          "win_rate": 58.3,
+          "rank": 39
+        },
+        {
+          "arena": "models",
+          "category": "website",
+          "elo": 1238,
+          "win_rate": 57,
+          "rank": 34
+        }
+      ]
+    },
+    "reasoning": {
+      "mandatory": false,
+      "supported_efforts": [
+        "high",
+        "medium",
+        "low",
+        "minimal"
+      ],
+      "default_effort": "medium"
+    },
+    "model_family": "google"
+  },
+  "google/gemini-2.5-flash-lite": {
+    "id": "google/gemini-2.5-flash-lite",
+    "canonical_slug": "google/gemini-2.5-flash-lite",
+    "hugging_face_id": "",
+    "name": "Google: Gemini 2.5 Flash Lite",
+    "created": 1753200276,
+    "description": "Gemini 2.5 Flash-Lite is a lightweight reasoning model in the Gemini 2.5 family, optimized for ultra-low latency and cost efficiency. It offers improved throughput, faster token generation, and better performance...",
+    "context_length": 1048576,
+    "architecture": {
+      "modality": "text+image+file+audio+video->text",
+      "input_modalities": [
+        "text",
+        "image",
+        "file",
+        "audio",
+        "video"
+      ],
+      "output_modalities": [
+        "text"
+      ],
+      "tokenizer": "Gemini",
+      "instruct_type": null
+    },
+    "pricing": {
+      "prompt": "0.0000001",
+      "completion": "0.0000004",
+      "image": "0.0000001",
+      "audio": "0.0000003",
+      "web_search": "0.014",
+      "internal_reasoning": "0.0000004",
+      "input_cache_read": "0.00000001",
+      "input_cache_write": "0.00000008333333333333334"
+    },
+    "top_provider": {
+      "context_length": 1048576,
+      "max_completion_tokens": 65535,
+      "is_moderated": false
+    },
+    "per_request_limits": null,
+    "supported_parameters": [
+      "include_reasoning",
+      "max_tokens",
+      "reasoning",
+      "response_format",
+      "seed",
+      "stop",
+      "structured_outputs",
+      "temperature",
+      "tool_choice",
+      "tools",
+      "top_p"
+    ],
+    "default_parameters": {
+      "temperature": null,
+      "top_p": null,
+      "frequency_penalty": null
+    },
+    "supported_voices": null,
+    "knowledge_cutoff": "2025-01-31",
+    "expiration_date": null,
+    "links": {
+      "details": "/api/v1/models/google/gemini-2.5-flash-lite/endpoints"
+    },
+    "reasoning": {
+      "mandatory": false
+    },
+    "model_family": "google"
+  },
+  "google/gemma-4-31b-it": {
+    "id": "google/gemma-4-31b-it",
+    "canonical_slug": "google/gemma-4-31b-it-20260402",
+    "hugging_face_id": "google/gemma-4-31B-it",
+    "name": "Google: Gemma 4 31B",
+    "created": 1775148486,
+    "description": "Gemma 4 31B Instruct is Google DeepMind's 30.7B dense multimodal model supporting text and image input with text output. Features a 256K token context window, configurable thinking/reasoning mode, native function...",
+    "context_length": 262144,
+    "architecture": {
+      "modality": "text+image+video->text",
+      "input_modalities": [
+        "image",
+        "text",
+        "video"
+      ],
+      "output_modalities": [
+        "text"
+      ],
+      "tokenizer": "Gemma",
+      "instruct_type": null
+    },
+    "pricing": {
+      "prompt": "0.00000012",
+      "completion": "0.00000035",
+      "input_cache_read": "0.00000009"
+    },
+    "top_provider": {
+      "context_length": 262144,
+      "max_completion_tokens": 262144,
+      "is_moderated": false
+    },
+    "per_request_limits": null,
+    "supported_parameters": [
+      "frequency_penalty",
+      "include_reasoning",
+      "logit_bias",
+      "logprobs",
+      "max_tokens",
+      "min_p",
+      "presence_penalty",
+      "reasoning",
+      "repetition_penalty",
+      "response_format",
+      "seed",
+      "stop",
+      "structured_outputs",
+      "temperature",
+      "tool_choice",
+      "tools",
+      "top_k",
+      "top_logprobs",
+      "top_p"
+    ],
+    "default_parameters": {
+      "temperature": 1,
+      "top_p": 0.95,
+      "top_k": 64,
+      "frequency_penalty": null,
+      "presence_penalty": null,
+      "repetition_penalty": null
+    },
+    "supported_voices": null,
+    "knowledge_cutoff": null,
+    "expiration_date": null,
+    "links": {
+      "details": "/api/v1/models/google/gemma-4-31b-it-20260402/endpoints"
+    },
+    "benchmarks": {
+      "design_arena": [],
+      "artificial_analysis": {
+        "intelligence_index": 29.4,
+        "coding_index": 43.4,
+        "agentic_index": 14.4
+      }
+    },
+    "reasoning": {
+      "mandatory": false,
+      "default_enabled": false
+    },
+    "model_family": "google"
+  },
+  "google/gemini-3.5-flash": {
+    "id": "google/gemini-3.5-flash",
+    "canonical_slug": "google/gemini-3.5-flash-20260519",
+    "hugging_face_id": null,
+    "name": "Google: Gemini 3.5 Flash",
+    "created": 1779193800,
+    "description": "Gemini 3.5 Flash is Google's high-efficiency multimodal model, bringing near-Pro level coding and reasoning at Flash-tier cost and speed. It is highly optimized for coding proficiency and parallel agentic execution...",
+    "context_length": 1048576,
+    "architecture": {
+      "modality": "text+image+file+audio+video->text",
+      "input_modalities": [
+        "text",
+        "image",
+        "video",
+        "file",
+        "audio"
+      ],
+      "output_modalities": [
+        "text"
+      ],
+      "tokenizer": "Gemini",
+      "instruct_type": null
+    },
+    "pricing": {
+      "prompt": "0.0000015",
+      "completion": "0.000009",
+      "image": "0.0000015",
+      "audio": "0.000003",
+      "web_search": "0.014",
+      "internal_reasoning": "0.000009",
+      "input_cache_read": "0.00000015",
+      "input_cache_write": "0.00000008333333333333334"
+    },
+    "top_provider": {
+      "context_length": 1048576,
+      "max_completion_tokens": 65536,
+      "is_moderated": false
+    },
+    "per_request_limits": null,
+    "supported_parameters": [
+      "include_reasoning",
+      "max_tokens",
+      "reasoning",
+      "response_format",
+      "seed",
+      "stop",
+      "structured_outputs",
+      "temperature",
+      "tool_choice",
+      "tools",
+      "top_p"
+    ],
+    "default_parameters": {
+      "temperature": null,
+      "top_p": null,
+      "top_k": null,
+      "frequency_penalty": null,
+      "presence_penalty": null,
+      "repetition_penalty": null
+    },
+    "supported_voices": null,
+    "knowledge_cutoff": "2025-01-01",
+    "expiration_date": null,
+    "links": {
+      "details": "/api/v1/models/google/gemini-3.5-flash-20260519/endpoints"
+    },
+    "benchmarks": {
+      "design_arena": [
+        {
+          "arena": "agents",
+          "category": "agenticgamedev",
+          "elo": 1212,
+          "win_rate": 54.9,
+          "rank": 3
+        },
+        {
+          "arena": "agents",
+          "category": "agentichtmlslides",
+          "elo": 1162,
+          "win_rate": 45.8,
+          "rank": 7
+        },
+        {
+          "arena": "agents",
+          "category": "agenticslides",
+          "elo": 1244,
+          "win_rate": 57.5,
+          "rank": 4
+        },
+        {
+          "arena": "agents",
+          "category": "agenticslides(html)",
+          "elo": 1162,
+          "win_rate": 45.7,
+          "rank": 7
+        },
+        {
+          "arena": "agents",
+          "category": "agenticslides(python-pptx)",
+          "elo": 1242,
+          "win_rate": 57.8,
+          "rank": 3
+        },
+        {
+          "arena": "agents",
+          "category": "androidnative",
+          "elo": 1256,
+          "win_rate": 54.4,
+          "rank": 5
+        },
+        {
+          "arena": "agents",
+          "category": "fullstack",
+          "elo": 1264,
+          "win_rate": 58,
+          "rank": 6
+        },
+        {
+          "arena": "agents",
+          "category": "htmlslides",
+          "elo": 1181,
+          "win_rate": 49,
+          "rank": 9
+        },
+        {
+          "arena": "agents",
+          "category": "mobileapps",
+          "elo": 1257,
+          "win_rate": 56.5,
+          "rank": 3
+        },
+        {
+          "arena": "agents",
+          "category": "pptxslides",
+          "elo": 1244,
+          "win_rate": 57.7,
+          "rank": 3
+        },
+        {
+          "arena": "agents",
+          "category": "python-pptxslides",
+          "elo": 1247,
+          "win_rate": 57.4,
+          "rank": 4
+        },
+        {
+          "arena": "agents",
+          "category": "webapps",
+          "elo": 1264,
+          "win_rate": 54.2,
+          "rank": 6
+        },
+        {
+          "arena": "models",
+          "category": "3d",
+          "elo": 1313,
+          "win_rate": 60.2,
+          "rank": 14
+        },
+        {
+          "arena": "models",
+          "category": "asciiart",
+          "elo": 1310,
+          "win_rate": 62.1,
+          "rank": 5
+        },
+        {
+          "arena": "models",
+          "category": "codecategories",
+          "elo": 1306,
+          "win_rate": 58.4,
+          "rank": 12
+        },
+        {
+          "arena": "models",
+          "category": "dataviz",
+          "elo": 1266,
+          "win_rate": 54.9,
+          "rank": 24
+        },
+        {
+          "arena": "models",
+          "category": "gamedev",
+          "elo": 1330,
+          "win_rate": 59.3,
+          "rank": 9
+        },
+        {
+          "arena": "models",
+          "category": "svg",
+          "elo": 1307,
+          "win_rate": 63,
+          "rank": 3
+        },
+        {
+          "arena": "models",
+          "category": "uicomponent",
+          "elo": 1311,
+          "win_rate": 59.4,
+          "rank": 12
+        },
+        {
+          "arena": "models",
+          "category": "website",
+          "elo": 1299,
+          "win_rate": 57.5,
+          "rank": 15
+        }
+      ],
+      "artificial_analysis": {
+        "intelligence_index": 50.2,
+        "coding_index": 70.1,
+        "agentic_index": 37.4
+      }
+    },
+    "reasoning": {
+      "mandatory": true,
+      "default_enabled": true,
+      "supported_efforts": [
+        "high",
+        "medium",
+        "low",
+        "minimal"
+      ],
+      "default_effort": "medium"
+    },
+    "model_family": "google"
+  },
+  "cohere/north-mini-code:free": {
+    "id": "cohere/north-mini-code:free",
+    "canonical_slug": "cohere/north-mini-code-20260617",
+    "hugging_face_id": "CohereLabs/North-Mini-Code-1.0",
+    "name": "Cohere: North Mini Code (free)",
+    "created": 1781723748,
+    "description": "North Mini Code is Cohere's first agentic coding model and the debut of its North family. A sparse mixture-of-experts model with 30B total parameters and 3B active, it is optimized...",
+    "context_length": 256000,
+    "architecture": {
+      "modality": "text->text",
+      "input_modalities": [
+        "text"
+      ],
+      "output_modalities": [
+        "text"
+      ],
+      "tokenizer": "Cohere",
+      "instruct_type": null
+    },
+    "pricing": {
+      "prompt": "0",
+      "completion": "0"
+    },
+    "top_provider": {
+      "context_length": 256000,
+      "max_completion_tokens": 64000,
+      "is_moderated": true
+    },
+    "per_request_limits": null,
+    "supported_parameters": [
+      "frequency_penalty",
+      "include_reasoning",
+      "max_tokens",
+      "presence_penalty",
+      "reasoning",
+      "seed",
+      "stop",
+      "temperature",
+      "tool_choice",
+      "tools",
+      "top_k",
+      "top_p"
+    ],
+    "default_parameters": {
+      "temperature": null,
+      "top_p": null,
+      "top_k": null,
+      "frequency_penalty": null,
+      "presence_penalty": null,
+      "repetition_penalty": null
+    },
+    "supported_voices": null,
+    "knowledge_cutoff": null,
+    "expiration_date": null,
+    "links": {
+      "details": "/api/v1/models/cohere/north-mini-code-20260617/endpoints"
+    },
+    "reasoning": {
+      "mandatory": false
+    },
+    "model_family": "others"
+  },
+  "mistralai/mistral-nemo": {
+    "id": "mistralai/mistral-nemo",
+    "canonical_slug": "mistralai/mistral-nemo",
+    "hugging_face_id": "mistralai/Mistral-Nemo-Instruct-2407",
+    "name": "Mistral: Mistral Nemo",
+    "created": 1721347200,
+    "description": "A 12B parameter model with a 128k token context length built by Mistral in collaboration with NVIDIA. The model is multilingual, supporting English, French, German, Spanish, Italian, Portuguese, Chinese, Japanese,...",
+    "context_length": 131072,
+    "architecture": {
+      "modality": "text->text",
+      "input_modalities": [
+        "text"
+      ],
+      "output_modalities": [
+        "text"
+      ],
+      "tokenizer": "Mistral",
+      "instruct_type": "mistral"
+    },
+    "pricing": {
+      "prompt": "0.00000002",
+      "completion": "0.00000003"
+    },
+    "top_provider": {
+      "context_length": 131072,
+      "max_completion_tokens": null,
+      "is_moderated": false
+    },
+    "per_request_limits": null,
+    "supported_parameters": [
+      "frequency_penalty",
+      "logit_bias",
+      "logprobs",
+      "max_tokens",
+      "min_p",
+      "presence_penalty",
+      "repetition_penalty",
+      "response_format",
+      "seed",
+      "stop",
+      "structured_outputs",
+      "temperature",
+      "tool_choice",
+      "tools",
+      "top_k",
+      "top_logprobs",
+      "top_p"
+    ],
+    "default_parameters": {
+      "temperature": 0.3
+    },
+    "supported_voices": null,
+    "knowledge_cutoff": "2024-04-30",
+    "expiration_date": null,
+    "links": {
+      "details": "/api/v1/models/mistralai/mistral-nemo/endpoints"
+    },
+    "model_family": "others"
+  },
+  "poolside/laguna-m.1": {
+    "id": "poolside/laguna-m.1",
+    "canonical_slug": "poolside/laguna-m.1-20260312",
+    "hugging_face_id": "poolside/Laguna-M.1",
+    "name": "Poolside: Laguna M.1",
+    "created": 1777388504,
+    "description": "Laguna M.1 is the flagship coding agent model from [Poolside](https://poolside.ai/), optimized for complex software engineering tasks. Designed for agentic coding workflows, it supports tool calling and reasoning, with a 256K...",
+    "context_length": 262144,
+    "architecture": {
+      "modality": "text->text",
+      "input_modalities": [
+        "text"
+      ],
+      "output_modalities": [
+        "text"
+      ],
+      "tokenizer": "Other",
+      "instruct_type": null
+    },
+    "pricing": {
+      "prompt": "0.0000002",
+      "completion": "0.0000004",
+      "input_cache_read": "0.0000001"
+    },
+    "top_provider": {
+      "context_length": 262144,
+      "max_completion_tokens": 32768,
+      "is_moderated": false
+    },
+    "per_request_limits": null,
+    "supported_parameters": [
+      "include_reasoning",
+      "max_tokens",
+      "reasoning",
+      "temperature",
+      "tool_choice",
+      "tools"
+    ],
+    "default_parameters": {
+      "temperature": null,
+      "top_p": null,
+      "top_k": null,
+      "frequency_penalty": null,
+      "presence_penalty": null,
+      "repetition_penalty": null
+    },
+    "supported_voices": null,
+    "knowledge_cutoff": null,
+    "expiration_date": null,
+    "links": {
+      "details": "/api/v1/models/poolside/laguna-m.1-20260312/endpoints"
+    },
+    "reasoning": {
+      "mandatory": false,
+      "default_enabled": true
+    },
+    "model_family": "others"
+  },
+  "xiaomi/mimo-v2.5": {
+    "id": "xiaomi/mimo-v2.5",
+    "canonical_slug": "xiaomi/mimo-v2.5-20260422",
+    "hugging_face_id": "XiaomiMiMo/MiMo-V2.5",
+    "name": "Xiaomi: MiMo-V2.5",
+    "created": 1776874269,
+    "description": "MiMo-V2.5 is a native omnimodal model by Xiaomi. It delivers Pro-level agentic performance at roughly half the inference cost, while surpassing MiMo-V2-Omni in multimodal perception across image and video understanding...",
+    "context_length": 1048576,
+    "architecture": {
+      "modality": "text+image+audio+video->text",
+      "input_modalities": [
+        "text",
+        "audio",
+        "image",
+        "video"
+      ],
+      "output_modalities": [
+        "text"
+      ],
+      "tokenizer": "Other",
+      "instruct_type": null
+    },
+    "pricing": {
+      "prompt": "0.000000105",
+      "completion": "0.00000028"
+    },
+    "top_provider": {
+      "context_length": 32000,
+      "max_completion_tokens": null,
+      "is_moderated": false
+    },
+    "per_request_limits": null,
+    "supported_parameters": [
+      "frequency_penalty",
+      "include_reasoning",
+      "logit_bias",
+      "logprobs",
+      "max_tokens",
+      "min_p",
+      "presence_penalty",
+      "reasoning",
+      "repetition_penalty",
+      "response_format",
+      "seed",
+      "stop",
+      "structured_outputs",
+      "temperature",
+      "tool_choice",
+      "tools",
+      "top_k",
+      "top_logprobs",
+      "top_p"
+    ],
+    "default_parameters": {
+      "temperature": 1,
+      "top_p": 0.95,
+      "top_k": null,
+      "frequency_penalty": null,
+      "presence_penalty": null,
+      "repetition_penalty": null
+    },
+    "supported_voices": null,
+    "knowledge_cutoff": null,
+    "expiration_date": null,
+    "links": {
+      "details": "/api/v1/models/xiaomi/mimo-v2.5-20260422/endpoints"
+    },
+    "benchmarks": {
+      "design_arena": [
+        {
+          "arena": "models",
+          "category": "3d",
+          "elo": 1298,
+          "win_rate": 54.1,
+          "rank": 19
+        },
+        {
+          "arena": "models",
+          "category": "asciiart",
+          "elo": 1189,
+          "win_rate": 47.5,
+          "rank": 28
+        },
+        {
+          "arena": "models",
+          "category": "codecategories",
+          "elo": 1303,
+          "win_rate": 55,
+          "rank": 15
+        },
+        {
+          "arena": "models",
+          "category": "dataviz",
+          "elo": 1282,
+          "win_rate": 54,
+          "rank": 16
+        },
+        {
+          "arena": "models",
+          "category": "gamedev",
+          "elo": 1298,
+          "win_rate": 55.6,
+          "rank": 17
+        },
+        {
+          "arena": "models",
+          "category": "svg",
+          "elo": 1219,
+          "win_rate": 52.3,
+          "rank": 22
+        },
+        {
+          "arena": "models",
+          "category": "uicomponent",
+          "elo": 1311,
+          "win_rate": 56.1,
+          "rank": 13
+        },
+        {
+          "arena": "models",
+          "category": "website",
+          "elo": 1304,
+          "win_rate": 55.2,
+          "rank": 12
+        }
+      ]
+    },
+    "reasoning": {
+      "mandatory": false
+    },
+    "model_family": "others"
+  },
+  "minimax/minimax-m3": {
+    "id": "minimax/minimax-m3",
+    "canonical_slug": "minimax/minimax-m3-20260531",
+    "hugging_face_id": "MiniMaxAI/Minimax-M3",
+    "name": "MiniMax: MiniMax M3",
+    "created": 1780245374,
+    "description": "MiniMax-M3 is a multimodal foundation model from MiniMax. It supports text, image, and video inputs with text output, a 1M-token context window, and is suited for long-horizon agentic work, coding,...",
+    "context_length": 1048576,
+    "architecture": {
+      "modality": "text+image+video->text",
+      "input_modalities": [
+        "text",
+        "image",
+        "video"
+      ],
+      "output_modalities": [
+        "text"
+      ],
+      "tokenizer": "Other",
+      "instruct_type": null
+    },
+    "pricing": {
+      "prompt": "0.0000003",
+      "completion": "0.0000012",
+      "input_cache_read": "0.00000006"
+    },
+    "top_provider": {
+      "context_length": 524288,
+      "max_completion_tokens": 512000,
+      "is_moderated": false
+    },
+    "per_request_limits": null,
+    "supported_parameters": [
+      "frequency_penalty",
+      "include_reasoning",
+      "logit_bias",
+      "logprobs",
+      "max_tokens",
+      "min_p",
+      "presence_penalty",
+      "reasoning",
+      "repetition_penalty",
+      "response_format",
+      "seed",
+      "stop",
+      "structured_outputs",
+      "temperature",
+      "tool_choice",
+      "tools",
+      "top_k",
+      "top_logprobs",
+      "top_p"
+    ],
+    "default_parameters": {
+      "temperature": 1,
+      "top_p": 0.95,
+      "top_k": null,
+      "frequency_penalty": null,
+      "presence_penalty": null,
+      "repetition_penalty": null
+    },
+    "supported_voices": null,
+    "knowledge_cutoff": null,
+    "expiration_date": null,
+    "links": {
+      "details": "/api/v1/models/minimax/minimax-m3-20260531/endpoints"
+    },
+    "benchmarks": {
+      "design_arena": [
+        {
+          "arena": "agents",
+          "category": "androidnative",
+          "elo": 1047,
+          "win_rate": 26,
+          "rank": 26
+        },
+        {
+          "arena": "models",
+          "category": "3d",
+          "elo": 1305,
+          "win_rate": 56.6,
+          "rank": 17
+        },
+        {
+          "arena": "models",
+          "category": "asciiart",
+          "elo": 1221,
+          "win_rate": 49.8,
+          "rank": 15
+        },
+        {
+          "arena": "models",
+          "category": "codecategories",
+          "elo": 1306,
+          "win_rate": 55.6,
+          "rank": 14
+        },
+        {
+          "arena": "models",
+          "category": "dataviz",
+          "elo": 1291,
+          "win_rate": 56.7,
+          "rank": 11
+        },
+        {
+          "arena": "models",
+          "category": "gamedev",
+          "elo": 1288,
+          "win_rate": 51.6,
+          "rank": 20
+        },
+        {
+          "arena": "models",
+          "category": "svg",
+          "elo": 1243,
+          "win_rate": 54.3,
+          "rank": 15
+        },
+        {
+          "arena": "models",
+          "category": "uicomponent",
+          "elo": 1294,
+          "win_rate": 54.1,
+          "rank": 17
+        },
+        {
+          "arena": "models",
+          "category": "website",
+          "elo": 1304,
+          "win_rate": 55.6,
+          "rank": 13
+        }
+      ],
+      "artificial_analysis": {
+        "intelligence_index": 44.4,
+        "coding_index": 58.6,
+        "agentic_index": 35.4
+      }
+    },
+    "reasoning": {
+      "mandatory": false
+    },
+    "model_family": "others"
+  },
+  "z-ai/glm-5.2": {
+    "id": "z-ai/glm-5.2",
+    "canonical_slug": "z-ai/glm-5.2-20260616",
+    "hugging_face_id": "zai-org/GLM-5.2",
+    "name": "Z.ai: GLM 5.2",
+    "created": 1781631930,
+    "description": "GLM 5.2 is a large-scale reasoning model from Z.ai. It supports text input and output with a 1M-token context window, and is suited for long-horizon agent workflows, project-level software engineering,...",
+    "context_length": 1048576,
+    "architecture": {
+      "modality": "text->text",
+      "input_modalities": [
+        "text"
+      ],
+      "output_modalities": [
+        "text"
+      ],
+      "tokenizer": "Other",
+      "instruct_type": null
+    },
+    "pricing": {
+      "prompt": "0.00000056",
+      "completion": "0.00000176",
+      "input_cache_read": "0.000000104"
+    },
+    "top_provider": {
+      "context_length": 1048576,
+      "max_completion_tokens": 131072,
+      "is_moderated": false
+    },
+    "per_request_limits": null,
+    "supported_parameters": [
+      "frequency_penalty",
+      "include_reasoning",
+      "logit_bias",
+      "logprobs",
+      "max_tokens",
+      "min_p",
+      "parallel_tool_calls",
+      "presence_penalty",
+      "reasoning",
+      "reasoning_effort",
+      "repetition_penalty",
+      "response_format",
+      "seed",
+      "stop",
+      "structured_outputs",
+      "temperature",
+      "tool_choice",
+      "tools",
+      "top_k",
+      "top_logprobs",
+      "top_p"
+    ],
+    "default_parameters": {
+      "temperature": 1,
+      "top_p": 0.95,
+      "top_k": null,
+      "frequency_penalty": null,
+      "presence_penalty": null,
+      "repetition_penalty": null
+    },
+    "supported_voices": null,
+    "knowledge_cutoff": null,
+    "expiration_date": null,
+    "links": {
+      "details": "/api/v1/models/z-ai/glm-5.2-20260616/endpoints"
+    },
+    "benchmarks": {
+      "design_arena": [
+        {
+          "arena": "agents",
+          "category": "androidnative",
+          "elo": 1252,
+          "win_rate": 57,
+          "rank": 6
+        },
+        {
+          "arena": "agents",
+          "category": "fullstack",
+          "elo": 1293,
+          "win_rate": 63.6,
+          "rank": 3
+        },
+        {
+          "arena": "agents",
+          "category": "htmlslides",
+          "elo": 1204,
+          "win_rate": 52.5,
+          "rank": 8
+        },
+        {
+          "arena": "agents",
+          "category": "mobileapps",
+          "elo": 1240,
+          "win_rate": 54,
+          "rank": 5
+        },
+        {
+          "arena": "agents",
+          "category": "python-pptxslides",
+          "elo": 1217,
+          "win_rate": 50.3,
+          "rank": 5
+        },
+        {
+          "arena": "agents",
+          "category": "webapps",
+          "elo": 1284,
+          "win_rate": 57.5,
+          "rank": 3
+        },
+        {
+          "arena": "models",
+          "category": "3d",
+          "elo": 1373,
+          "win_rate": 64,
+          "rank": 1
+        },
+        {
+          "arena": "models",
+          "category": "codecategories",
+          "elo": 1360,
+          "win_rate": 62,
+          "rank": 1
+        },
+        {
+          "arena": "models",
+          "category": "dataviz",
+          "elo": 1326,
+          "win_rate": 59.8,
+          "rank": 3
+        },
+        {
+          "arena": "models",
+          "category": "gamedev",
+          "elo": 1357,
+          "win_rate": 61.3,
+          "rank": 2
+        },
+        {
+          "arena": "models",
+          "category": "uicomponent",
+          "elo": 1339,
+          "win_rate": 59.8,
+          "rank": 5
+        },
+        {
+          "arena": "models",
+          "category": "website",
+          "elo": 1356,
+          "win_rate": 61.6,
+          "rank": 1
+        }
+      ],
+      "artificial_analysis": {
+        "intelligence_index": 51.1,
+        "coding_index": 68.8,
+        "agentic_index": 43.1
+      }
+    },
+    "reasoning": {
+      "mandatory": false,
+      "default_enabled": true,
+      "supported_efforts": [
+        "xhigh",
+        "high"
+      ],
+      "default_effort": "high"
+    },
+    "model_family": "others"
+  }
+}

requirements.txt

@@ -0,0 +1,6 @@
+streamlit>=1.40.0
+pandas>=2.0.0
+plotly>=5.20.0
+datasets>=2.19.0
+pyarrow>=15.0.0
+requests>=2.31.0