pull

.gitattributes

@@ -1,2 +1,35 @@
-# Auto detect text files and perform LF normalization
-* text=auto
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

.github/prompts/plan-llmCompare.prompt.md

@@ -1,69 +0,0 @@
-## Plan: LLM Comparison Web App (Gradio)
-
-Build a Gradio Blocks app with two-column side-by-side LLM comparison. Left: user's custom model via OpenAI-compatible API endpoint. Right: selectable provider models (OpenAI, Anthropic, Gemini, Qwen, Yi) with default API keys from HF Spaces secrets. Users enter a nickname, prompt both models, then comment and grade (1-10) each response. All evaluations persist to SQLite. Admin can download all data as Excel (.xlsx). Deploy on HuggingFace Spaces.
-
----
-
-### Phase 1: Project Setup
-1. Create `requirements.txt` with: `gradio`, `openai`, `anthropic`, `google-generativeai`, `openpyxl`
-2. Update `README.md` with project description and setup instructions
-
-### Phase 2: Database Layer — `db.py`
-3. Create SQLite helper with `init_db()` to create the `evaluations` table with columns: `id`, `timestamp`, `nickname`, `prompt`, `left_model_name`, `left_model_endpoint`, `left_response`, `left_comment`, `left_grade`, `right_model_name`, `right_provider`, `right_response`, `right_comment`, `right_grade`
-4. Add `save_evaluation(...)` function to insert a row
-5. Add `export_to_excel(filepath)` function using `openpyxl` to dump all rows to .xlsx
-
-### Phase 3: LLM Provider Abstraction — `providers.py`
-6. Define a model registry dict mapping display name → (provider, model_id, base_url, env_var_name):
-   - **OpenAI** (`gpt-4o`, `gpt-4o-mini`): `openai` SDK, default base
-   - **Anthropic** (`claude-sonnet-4-20250514`): `anthropic` SDK
-   - **Google Gemini** (`gemini-2.0-flash`): `google-generativeai` SDK
-   - **Qwen** (`qwen-plus`): `openai` SDK with DashScope base URL
-   - **Yi** (`yi-large`): `openai` SDK with 01.AI base URL
-7. Implement `call_model(provider, model_name, prompt, api_key)` — dispatches to the correct SDK, falls back to env var key if user key is empty
-8. Implement `call_custom_endpoint(base_url, model_name, prompt, api_key)` — uses `openai` SDK with user-supplied base_url for the left-side custom model
-
-### Phase 4: Gradio UI — `app.py`
-9. Build Gradio Blocks layout:
-   - **Top bar**: Nickname text input (required)
-   - **Prompt area**: Shared textbox + "Send to both" button
-   - **Two-column `gr.Row`**:
-     - **Left** ("Your Model"): API endpoint URL, model name, API key, response display, comment textbox, grade slider (1-10)
-     - **Right** ("Reference Model"): model dropdown (from registry), API key (optional, default provided), response display, comment textbox, grade slider (1-10)
-   - **Submit Evaluation** button → saves to SQLite
-   - **Download Report** button → exports .xlsx file
-10. Wire "Send to both" → calls both models, displays responses
-11. Wire "Submit Evaluation" → validates inputs, saves to DB, shows success notification
-12. Wire "Download Report" → exports SQLite to temp .xlsx, returns as `gr.File`
-
-### Phase 5: Security & Configuration
-13. Default API keys from env vars (`OPENAI_API_KEY`, `ANTHROPIC_API_KEY`, `GOOGLE_API_KEY`, `DASHSCOPE_API_KEY`, `YI_API_KEY`), set as HF Spaces secrets. User-provided keys override per-session only — never stored. All keys processed server-side only.
-14. Input sanitization: validate URL format for left endpoint, sanitize nickname (max 50 chars)
-
-### Phase 6: Deployment
-15. Create HuggingFace Space (Gradio SDK), push code
-16. Set repository secrets for default API keys
-17. End-to-end test on live Space
-
----
-
-**Relevant files**
-- `app.py` — Main Gradio Blocks UI, event wiring, layout (new)
-- `db.py` — SQLite init, save, export functions (new)
-- `providers.py` — Model registry, API call dispatch (new)
-- `requirements.txt` — Python dependencies (new)
-- `README.md` — Update with project info (existing)
-
-**Verification**
-1. Launch locally with `python app.py`, verify two-column layout renders
-2. Test left column with a local OpenAI-compatible endpoint (e.g. Ollama)
-3. Test right column with each provider using default keys
-4. Submit evaluation → verify row in SQLite
-5. Download report → verify .xlsx has all columns populated
-6. Test validation (missing nickname, missing grade → error)
-7. Deploy to HF Spaces, set secrets, run full end-to-end
-
-**Further Considerations**
-1. **SQLite persistence on HF Spaces**: Ephemeral storage resets on restart. Recommend enabling persistent storage and placing DB under `/data`. Alternative: periodic backup to HF Dataset.
-2. **Rate limiting**: Consider adding per-nickname rate limiting to prevent abuse of default API keys.
-3. **Streaming responses**: Initial version uses non-streaming calls; streaming can be added later for better UX.

.gitignore

@@ -1,5 +0,0 @@
-__pycache__/
-*.pyc
-evaluations.db
-*.xlsx
-.DS_Store

README.md

@@ -1,82 +1,13 @@
 ---
-title: LLM Compare
-emoji: 🔍
-colorFrom: blue
+title: Llm Compare
+emoji: 👀
+colorFrom: green
 colorTo: purple
 sdk: gradio
-sdk_version: "6.9.0"
+sdk_version: 6.9.0
 app_file: app.py
 pinned: false
+short_description: compares anti DV agent with other public agents
 ---
 
-# LLM Compare
-
-A Gradio web app for side-by-side LLM comparison. Compare your Dify application against reference models from OpenAI, Anthropic, Google Gemini, Qwen, and Yi.
-
-## Features
-
-- **Two-column layout**: Your Dify app on the left, a selectable reference model on the right
-- **Multiple providers**: OpenAI (GPT-4o), Anthropic (Claude), Google Gemini, Qwen, Yi
-- **Overridable defaults**: Base URL and Model ID auto-fill from env vars but can be edited per-session
-- **Evaluation workflow**: Comment and grade (1–10) each model's response
-- **Nickname tracking**: All evaluations tagged with user nickname
-- **Excel export**: Download all evaluation data as `.xlsx`
-
-## Setup
-
-```bash
-pip install -r requirements.txt
-python app.py
-```
-
-## Environment Variables
-
-Set these as **Hugging Face Spaces secrets** (Settings → Repository secrets) to provide defaults.
-Users can override Base URL / Model ID in the UI at runtime.
-
-### API Keys (required for each provider you use)
-
-| Variable | Provider |
-|---|---|
-| `OPENAI_API_KEY` | OpenAI |
-| `ANTHROPIC_API_KEY` | Anthropic |
-| `GOOGLE_API_KEY` | Google Gemini |
-| `DASHSCOPE_API_KEY` | Qwen (DashScope / Alibaba) |
-| `YI_API_KEY` | Yi (01.AI) |
-
-### Base URL overrides (optional)
-
-Override the default API endpoint for each provider. Useful for proxies or custom deployments.
-
-| Variable | Default |
-|---|---|
-| `OPENAI_BASE_URL` | *(uses OpenAI SDK default)* |
-| `ANTHROPIC_BASE_URL` | *(uses Anthropic SDK default)* |
-| `GOOGLE_BASE_URL` | *(uses Google GenAI SDK default)* |
-| `DASHSCOPE_BASE_URL` | `https://dashscope.aliyuncs.com/compatible-mode/v1` |
-| `YI_BASE_URL` | `https://api.01.ai/v1` |
-
-### Model ID overrides (optional)
-
-Override the default model ID. Useful for switching to newer model versions without code changes.
-
-| Variable | Default |
-|---|---|
-| `OPENAI_MODEL_ID` | `gpt-4o` |
-| `OPENAI_MINI_MODEL_ID` | `gpt-4o-mini` |
-| `ANTHROPIC_MODEL_ID` | `claude-sonnet-4-20250514` |
-| `GOOGLE_MODEL_ID` | `gemini-2.0-flash` |
-| `DASHSCOPE_MODEL_ID` | `qwen-plus` |
-| `YI_MODEL_ID` | `yi-large` |
-
-## How it works
-
-1. Select a reference model from the dropdown — **Base URL** and **Model ID** auto-fill from env vars (or registry defaults)
-2. Edit Base URL / Model ID if needed (changes apply to current session only)
-3. Enter your prompt and click **Send to Both**
-4. Grade and comment on each response, then **Submit Evaluation**
-
-## Deployment
-
-Deploy on HuggingFace Spaces with Gradio SDK. Set the API keys and optional overrides as repository secrets in Settings.
-
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -1,297 +0,0 @@
-import re
-import tempfile
-import gradio as gr
-
-from db import init_db, save_evaluation, export_to_excel
-from providers import (
-    MODEL_NAMES,
-    call_model,
-    call_custom_endpoint,
-    MODEL_REGISTRY,
-    get_model_defaults,
-)
-
-# ---------------------------------------------------------------------------
-# Initialise database on import
-# ---------------------------------------------------------------------------
-init_db()
-
-# ---------------------------------------------------------------------------
-# Helpers
-# ---------------------------------------------------------------------------
-URL_RE = re.compile(r"^https?://\S+$")
-
-
-def _sanitize_nickname(nick: str) -> str:
-    return nick.strip()[:50]
-
-
-def _validate_url(url: str) -> bool:
-    return bool(URL_RE.match(url.strip()))
-
-
-def on_model_select(display_name: str):
-    """When user picks a model from dropdown, populate base_url and model_id."""
-    base_url, model_id = get_model_defaults(display_name)
-    return base_url, model_id
-
-
-# ---------------------------------------------------------------------------
-# Event handlers
-# ---------------------------------------------------------------------------
-
-def send_to_both(
-    prompt: str,
-    left_url: str,
-    left_model: str,
-    left_key: str,
-    right_name: str,
-    right_base_url: str,
-    right_model_id: str,
-    right_key: str,
-):
-    """Call both models and return their responses."""
-    if not prompt or not prompt.strip():
-        raise gr.Error("Please enter a prompt.")
-
-    # Left — Dify endpoint
-    left_response = ""
-    left_err = ""
-    if left_url and left_url.strip():
-        if not _validate_url(left_url):
-            left_err = "⚠️ Invalid URL format. Use http:// or https://."
-        else:
-            try:
-                left_response = call_custom_endpoint(
-                    left_url.strip(), left_model.strip() or "default", prompt, left_key
-                )
-            except Exception as e:
-                left_err = f"⚠️ Left model error: {e}"
-
-    # Right — registry model (with optional user overrides)
-    right_response = ""
-    right_err = ""
-    try:
-        right_response = call_model(
-            right_name, prompt, right_key, right_base_url, right_model_id
-        )
-    except Exception as e:
-        right_err = f"⚠️ Right model error: {e}"
-
-    return (
-        left_response if not left_err else left_err,
-        right_response if not right_err else right_err,
-    )
-
-
-def submit_evaluation(
-    nickname: str,
-    prompt: str,
-    left_url: str,
-    left_model: str,
-    left_response: str,
-    left_comment: str,
-    left_grade: int,
-    right_name: str,
-    right_model_id: str,
-    right_response: str,
-    right_comment: str,
-    right_grade: int,
-):
-    """Validate and persist an evaluation."""
-    nickname = _sanitize_nickname(nickname)
-    if not nickname:
-        raise gr.Error("Nickname is required.")
-    if not prompt or not prompt.strip():
-        raise gr.Error("Prompt is empty — send a prompt first.")
-    if not left_response.strip() and not right_response.strip():
-        raise gr.Error("No responses to evaluate — send a prompt first.")
-    if left_grade < 1 or left_grade > 10:
-        raise gr.Error("Left grade must be between 1 and 10.")
-    if right_grade < 1 or right_grade > 10:
-        raise gr.Error("Right grade must be between 1 and 10.")
-
-    entry = MODEL_REGISTRY.get(right_name, {})
-    right_provider = entry.get("provider", "unknown")
-
-    save_evaluation(
-        nickname=nickname,
-        prompt=prompt,
-        left_model_name=left_model.strip() or "custom",
-        left_model_endpoint=left_url.strip(),
-        left_response=left_response,
-        left_comment=left_comment,
-        left_grade=int(left_grade),
-        right_model_name=right_model_id.strip() or right_name,
-        right_provider=right_provider,
-        right_response=right_response,
-        right_comment=right_comment,
-        right_grade=int(right_grade),
-    )
-    gr.Info("✅ Evaluation saved!")
-
-
-def download_report():
-    """Export all evaluations to a temp .xlsx and return as a downloadable file."""
-    tmp = tempfile.NamedTemporaryFile(suffix=".xlsx", delete=False)
-    export_to_excel(tmp.name)
-    return tmp.name
-
-
-# ---------------------------------------------------------------------------
-# Gradio Blocks UI
-# ---------------------------------------------------------------------------
-
-# Pre-compute initial defaults for first model
-_init_base_url, _init_model_id = get_model_defaults(MODEL_NAMES[0])
-
-with gr.Blocks(title="LLM Compare") as demo:
-    gr.Markdown("# 🔍 LLM Compare\nSide-by-side comparison: your Dify app vs reference models.")
-
-    # ---- Top bar: nickname ---------------------------------------------------
-    with gr.Row():
-        nickname = gr.Textbox(
-            label="Your Nickname",
-            placeholder="Enter a nickname (required)",
-            scale=2,
-        )
-
-    # ---- Prompt area ---------------------------------------------------------
-    with gr.Row():
-        prompt = gr.Textbox(
-            label="Prompt",
-            placeholder="Type your prompt here…",
-            lines=4,
-            scale=4,
-        )
-        send_btn = gr.Button("🚀 Send to Both", variant="primary", scale=1)
-
-    # ---- Two-column layout ---------------------------------------------------
-    with gr.Row(equal_height=True):
-        # ---- LEFT: Dify model ------------------------------------------------
-        with gr.Column():
-            gr.Markdown("### 🧪 Your Model (Dify Endpoint)")
-            left_url = gr.Textbox(
-                label="Dify API Base URL",
-                placeholder="https://api.dify.ai/v1",
-            )
-            left_model = gr.Textbox(
-                label="App Name (for display only)",
-                placeholder="e.g. my-dify-app",
-            )
-            left_key = gr.Textbox(
-                label="Dify Secret Key",
-                placeholder="app-xxxxxxxxxxxx",
-                type="password",
-            )
-            left_response = gr.Textbox(
-                label="Response",
-                lines=12,
-                interactive=False,
-            )
-            left_comment = gr.Textbox(
-                label="Comment",
-                placeholder="Your thoughts on this response…",
-                lines=2,
-            )
-            left_grade = gr.Slider(
-                minimum=1,
-                maximum=10,
-                step=1,
-                value=5,
-                label="Grade (1–10)",
-            )
-
-        # ---- RIGHT: reference model ------------------------------------------
-        with gr.Column():
-            gr.Markdown("### 📚 Reference Model")
-            right_name = gr.Dropdown(
-                choices=MODEL_NAMES,
-                value=MODEL_NAMES[0],
-                label="Select Model",
-            )
-            right_base_url = gr.Textbox(
-                label="Base URL (auto-filled, editable)",
-                value=_init_base_url,
-                placeholder="e.g. https://api.openai.com/v1",
-            )
-            right_model_id = gr.Textbox(
-                label="Model ID (auto-filled, editable)",
-                value=_init_model_id,
-                placeholder="e.g. gpt-4o",
-            )
-            right_key = gr.Textbox(
-                label="API Key (optional — uses env default)",
-                placeholder="Leave blank to use default key",
-                type="password",
-            )
-            right_response = gr.Textbox(
-                label="Response",
-                lines=12,
-                interactive=False,
-            )
-            right_comment = gr.Textbox(
-                label="Comment",
-                placeholder="Your thoughts on this response…",
-                lines=2,
-            )
-            right_grade = gr.Slider(
-                minimum=1,
-                maximum=10,
-                step=1,
-                value=5,
-                label="Grade (1–10)",
-            )
-
-    # ---- Action buttons ------------------------------------------------------
-    with gr.Row():
-        submit_btn = gr.Button("💾 Submit Evaluation", variant="primary")
-        download_btn = gr.Button("📥 Download Report (.xlsx)")
-    report_file = gr.File(label="Report", visible=False)
-
-    # ---- Wiring --------------------------------------------------------------
-
-    # Auto-fill base_url and model_id when dropdown changes
-    right_name.change(
-        fn=on_model_select,
-        inputs=[right_name],
-        outputs=[right_base_url, right_model_id],
-    )
-
-    send_btn.click(
-        fn=send_to_both,
-        inputs=[
-            prompt, left_url, left_model, left_key,
-            right_name, right_base_url, right_model_id, right_key,
-        ],
-        outputs=[left_response, right_response],
-    )
-
-    submit_btn.click(
-        fn=submit_evaluation,
-        inputs=[
-            nickname,
-            prompt,
-            left_url,
-            left_model,
-            left_response,
-            left_comment,
-            left_grade,
-            right_name,
-            right_model_id,
-            right_response,
-            right_comment,
-            right_grade,
-        ],
-        outputs=[],
-    )
-
-    download_btn.click(
-        fn=download_report,
-        inputs=[],
-        outputs=[report_file],
-    ).then(lambda: gr.update(visible=True), outputs=[report_file])
-
-
-if __name__ == "__main__":
-    demo.launch(theme=gr.themes.Soft())

db.py

@@ -1,100 +0,0 @@
-import sqlite3
-import os
-from datetime import datetime
-
-from openpyxl import Workbook
-
-DB_DIR = os.environ.get("DATA_DIR", ".")
-DB_PATH = os.path.join(DB_DIR, "evaluations.db")
-
-
-def _get_conn() -> sqlite3.Connection:
-    conn = sqlite3.connect(DB_PATH)
-    conn.execute("PRAGMA journal_mode=WAL")
-    return conn
-
-
-def init_db() -> None:
-    conn = _get_conn()
-    conn.execute(
-        """
-        CREATE TABLE IF NOT EXISTS evaluations (
-            id              INTEGER PRIMARY KEY AUTOINCREMENT,
-            timestamp       TEXT    NOT NULL,
-            nickname        TEXT    NOT NULL,
-            prompt          TEXT    NOT NULL,
-            left_model_name TEXT    NOT NULL,
-            left_model_endpoint TEXT NOT NULL,
-            left_response   TEXT    NOT NULL,
-            left_comment    TEXT    NOT NULL DEFAULT '',
-            left_grade      INTEGER NOT NULL,
-            right_model_name TEXT   NOT NULL,
-            right_provider  TEXT    NOT NULL,
-            right_response  TEXT    NOT NULL,
-            right_comment   TEXT    NOT NULL DEFAULT '',
-            right_grade     INTEGER NOT NULL
-        )
-        """
-    )
-    conn.commit()
-    conn.close()
-
-
-def save_evaluation(
-    nickname: str,
-    prompt: str,
-    left_model_name: str,
-    left_model_endpoint: str,
-    left_response: str,
-    left_comment: str,
-    left_grade: int,
-    right_model_name: str,
-    right_provider: str,
-    right_response: str,
-    right_comment: str,
-    right_grade: int,
-) -> None:
-    conn = _get_conn()
-    conn.execute(
-        """
-        INSERT INTO evaluations (
-            timestamp, nickname, prompt,
-            left_model_name, left_model_endpoint, left_response, left_comment, left_grade,
-            right_model_name, right_provider, right_response, right_comment, right_grade
-        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-        """,
-        (
-            datetime.utcnow().isoformat(),
-            nickname,
-            prompt,
-            left_model_name,
-            left_model_endpoint,
-            left_response,
-            left_comment,
-            left_grade,
-            right_model_name,
-            right_provider,
-            right_response,
-            right_comment,
-            right_grade,
-        ),
-    )
-    conn.commit()
-    conn.close()
-
-
-def export_to_excel(filepath: str) -> str:
-    conn = _get_conn()
-    cursor = conn.execute("SELECT * FROM evaluations ORDER BY id")
-    columns = [desc[0] for desc in cursor.description]
-    rows = cursor.fetchall()
-    conn.close()
-
-    wb = Workbook()
-    ws = wb.active
-    ws.title = "Evaluations"
-    ws.append(columns)
-    for row in rows:
-        ws.append(list(row))
-    wb.save(filepath)
-    return filepath

llm_compare

@@ -1 +0,0 @@
-Subproject commit 75be778201f3a72ce3af88996ea7e433263a5f41

providers.py

@@ -1,184 +0,0 @@
-import os
-import requests
-from openai import OpenAI
-import anthropic
-from google import genai
-
-# ---------------------------------------------------------------------------
-# Model Registry
-# Each entry: display_name -> {provider, model_id, base_url (None = default), env_var}
-# ---------------------------------------------------------------------------
-MODEL_REGISTRY: dict[str, dict] = {
-    "GPT-4o (OpenAI)": {
-        "provider": "openai",
-        "model_id": "gpt-4o",
-        "base_url": None,
-        "env_var": "OPENAI_API_KEY",
-        "env_base_url": "OPENAI_BASE_URL",
-        "env_model_id": "OPENAI_MODEL_ID",
-    },
-    "GPT-4o-mini (OpenAI)": {
-        "provider": "openai",
-        "model_id": "gpt-4o-mini",
-        "base_url": None,
-        "env_var": "OPENAI_API_KEY",
-        "env_base_url": "OPENAI_BASE_URL",
-        "env_model_id": "OPENAI_MINI_MODEL_ID",
-    },
-    "Claude Sonnet 4 (Anthropic)": {
-        "provider": "anthropic",
-        "model_id": "claude-sonnet-4-6",
-        "base_url": None,
-        "env_var": "ANTHROPIC_API_KEY",
-        "env_base_url": "ANTHROPIC_BASE_URL",
-        "env_model_id": "ANTHROPIC_MODEL_ID",
-    },
-    "Gemini 2.0 Flash (Google)": {
-        "provider": "gemini",
-        "model_id": "gemini-2.0-flash",
-        "base_url": None,
-        "env_var": "GOOGLE_API_KEY",
-        "env_base_url": "GOOGLE_BASE_URL",
-        "env_model_id": "GOOGLE_MODEL_ID",
-    },
-    "Qwen-Plus (Alibaba)": {
-        "provider": "openai_compat",
-        "model_id": "qwen-plus",
-        "base_url": "https://dashscope.aliyuncs.com/compatible-mode/v1",
-        "env_var": "DASHSCOPE_API_KEY",
-        "env_base_url": "DASHSCOPE_BASE_URL",
-        "env_model_id": "DASHSCOPE_MODEL_ID",
-    },
-    "Yi-Large (01.AI)": {
-        "provider": "openai_compat",
-        "model_id": "yi-large",
-        "base_url": "https://api.01.ai/v1",
-        "env_var": "YI_API_KEY",
-        "env_base_url": "YI_BASE_URL",
-        "env_model_id": "YI_MODEL_ID",
-    },
-}
-
-MODEL_NAMES = list(MODEL_REGISTRY.keys())
-
-
-def get_model_defaults(display_name: str) -> tuple[str, str]:
-    """Return (base_url, model_id) for a registry model, considering env overrides.
-
-    Priority: env var > registry hardcoded value.
-    """
-    entry = MODEL_REGISTRY.get(display_name, {})
-    base_url = os.environ.get(entry.get("env_base_url", ""), "") or entry.get("base_url") or ""
-    model_id = os.environ.get(entry.get("env_model_id", ""), "") or entry.get("model_id", "")
-    return base_url, model_id
-
-
-def _resolve_key(env_var: str, user_key: str | None) -> str:
-    """Return user-provided key if non-empty, else fall back to env var."""
-    if user_key and user_key.strip():
-        return user_key.strip()
-    key = os.environ.get(env_var, "")
-    if not key:
-        raise ValueError(
-            f"No API key provided and environment variable {env_var} is not set."
-        )
-    return key
-
-
-# ---------------------------------------------------------------------------
-# Provider dispatch
-# ---------------------------------------------------------------------------
-
-def _call_openai(model_id: str, prompt: str, api_key: str, base_url: str | None) -> str:
-    client = OpenAI(api_key=api_key, base_url=base_url)
-    resp = client.chat.completions.create(
-        model=model_id,
-        messages=[{"role": "user", "content": prompt}],
-    )
-    return resp.choices[0].message.content
-
-
-def _call_anthropic(model_id: str, prompt: str, api_key: str) -> str:
-    client = anthropic.Anthropic(api_key=api_key)
-    resp = client.messages.create(
-        model=model_id,
-        max_tokens=4096,
-        messages=[{"role": "user", "content": prompt}],
-    )
-    return resp.content[0].text
-
-
-def _call_gemini(model_id: str, prompt: str, api_key: str) -> str:
-    client = genai.Client(api_key=api_key)
-    resp = client.models.generate_content(model=model_id, contents=prompt)
-    return resp.text
-
-
-def call_model(
-    display_name: str,
-    prompt: str,
-    user_key: str | None = None,
-    user_base_url: str | None = None,
-    user_model_id: str | None = None,
-) -> str:
-    """Call a reference model from the registry.
-
-    User-supplied base_url / model_id override env-var defaults, which in turn
-    override the hardcoded registry values.
-    """
-    entry = MODEL_REGISTRY.get(display_name)
-    if entry is None:
-        raise ValueError(f"Unknown model: {display_name}")
-
-    api_key = _resolve_key(entry["env_var"], user_key)
-    provider = entry["provider"]
-
-    # Resolve: user input > env var > registry default
-    default_base_url, default_model_id = get_model_defaults(display_name)
-    model_id = (user_model_id.strip() if user_model_id and user_model_id.strip() else "") or default_model_id
-    base_url = (user_base_url.strip() if user_base_url and user_base_url.strip() else "") or default_base_url or None
-
-    if provider in ("openai", "openai_compat"):
-        return _call_openai(model_id, prompt, api_key, base_url)
-    elif provider == "anthropic":
-        return _call_anthropic(model_id, prompt, api_key)
-    elif provider == "gemini":
-        return _call_gemini(model_id, prompt, api_key)
-    else:
-        raise ValueError(f"Unknown provider: {provider}")
-
-
-def call_custom_endpoint(
-    base_url: str, model_name: str, prompt: str, api_key: str
-) -> str:
-    """Call a user-supplied Dify application endpoint (left column).
-
-    Dify API docs: https://docs.dify.ai/en/guides/application-publishing/developing-with-apis
-
-    base_url should be the Dify API base, e.g. https://api.dify.ai/v1
-    The endpoint called is {base_url}/chat-messages (for Chat apps).
-    """
-    if not base_url or not base_url.strip():
-        raise ValueError("API endpoint URL is required for your Dify model.")
-    if not api_key or not api_key.strip():
-        raise ValueError("API Key (Secret Key) is required for Dify.")
-
-    url = base_url.strip().rstrip("/") + "/chat-messages"
-    headers = {
-        "Authorization": f"Bearer {api_key.strip()}",
-        "Content-Type": "application/json",
-    }
-    payload = {
-        "inputs": {},
-        "query": prompt,
-        "response_mode": "blocking",
-        "user": "llm-compare-user",
-    }
-
-    resp = requests.post(url, json=payload, headers=headers, timeout=120)
-    resp.raise_for_status()
-    data = resp.json()
-    answer = data.get("answer", "")
-    if not answer:
-        raise ValueError(f"Dify returned no answer. Full response: {data}")
-    return answer

requirements.txt

@@ -1,5 +0,0 @@
-gradio
-openai
-anthropic
-google-genai
-openpyxl