Upload 6 files

pages/1_Property_Probe.py

@@ -11,14 +11,23 @@ from src.lookup import (
     get_polyinfo,
 )
 from src.predictor_router import RouterPredictor
-from src.ui_style import apply_global_style
+from src.ui_style import apply_global_style, render_page_header
 
 st.set_page_config(page_title="Property Probe", layout="wide")
 apply_global_style()
-st.title("Quick Polymer Property Check")
+render_page_header(
+    title="Quick Polymer Property Check",
+    subtitle="Check one polymer at a time using source lookups plus ensemble ML prediction.",
+    badge="Property Probe",
+)
+
+
+@st.cache_resource(show_spinner=False)
+def get_router_predictor() -> RouterPredictor:
+    return RouterPredictor(device="cpu")
 
-db = load_all_sources()
-predictor = RouterPredictor(device="cpu")
+
+predictor = get_router_predictor()
 
 
 def resolve_smiles_from_polymer_name(db_obj, polymer_name_query: str) -> tuple[str | None, str | None]:
@@ -72,6 +81,8 @@ selected_label = st.selectbox("Select property", options)
 prop = label_to_key[selected_label]
 
 if st.button("Search", type="primary"):
+    db = load_all_sources()
+
     if input_mode == "SMILES":
         s_canon = canonicalize_smiles(query_value)
         if s_canon is None:
@@ -137,4 +148,5 @@ if st.button("Search", type="primary"):
         })
 
     out = pd.DataFrame(rows)
+    out.index = range(1, len(out) + 1)
     st.table(out)

pages/2_Batch_Prediction.py

@@ -2,17 +2,41 @@ import io
 import pandas as pd
 import streamlit as st
 
-from src.lookup import PROPERTY_META, canonicalize_smiles
+from src.lookup import (
+    PROPERTY_META,
+    SOURCES,
+    SOURCE_LABELS,
+    canonicalize_smiles,
+    get_value,
+    load_all_sources,
+)
 from src.predictor_router import RouterPredictor
-from src.ui_style import apply_global_style
+from src.ui_style import apply_global_style, render_page_header
 
 st.set_page_config(page_title="Batch Prediction", layout="wide")
 apply_global_style()
-st.title("Bulk Polymer Property Prediction")
+render_page_header(
+    title="Bulk Polymer Property Prediction",
+    subtitle="Predict multiple target properties for large candidate sets with downloadable results.",
+    badge="Batch Prediction",
+)
+
+
+@st.cache_resource(show_spinner=False)
+def get_router_predictor() -> RouterPredictor:
+    return RouterPredictor(device="cpu")
+
+
+predictor = get_router_predictor()
 
-predictor = RouterPredictor(device="cpu")
+
+@st.cache_resource(show_spinner=False)
+def get_lookup_db():
+    return load_all_sources()
 
 MAX_RENDER_ROWS = 5000  # above this -> download only (no dataframe render)
+MAX_BATCH_SMILES = 3000
+MAX_BATCH_PREDICTIONS = 25000
 
 
 # -----------------------------
@@ -82,7 +106,17 @@ for k in prop_keys:
     label_to_key[label] = k
 
 selected_labels = st.multiselect("Select properties to predict", options=prop_options)
-include_std = st.checkbox("Include model std (ensemble spread)", value=False)
+opt_col1, opt_col2 = st.columns([1, 2])
+with opt_col1:
+    include_std = st.checkbox("Include model std (ensemble spread)", value=False)
+with opt_col2:
+    selected_source_labels = st.multiselect(
+        "Include source database values",
+        options=[SOURCE_LABELS.get(src, src) for src in SOURCES],
+        placeholder="Select Experiment, MD, DFT, and/or GC",
+    )
+source_label_to_key = {SOURCE_LABELS.get(src, src): src for src in SOURCES}
+selected_sources = [source_label_to_key[label] for label in selected_source_labels]
 
 st.divider()
 
@@ -129,14 +163,15 @@ else:
     )
     dataset_path = dataset[1]
 
-    # For PI1M, force an N limit for the live web MVP
-    st.caption("Note: large selections will switch to download-only to avoid crashing the page.")
+    # Website-safe cap: render mode is not enough, inference itself must stay bounded.
+    st.caption("Website-safe limits apply. Large jobs should be run offline rather than in the live app.")
 
     pick_mode = st.radio("Row selection", options=["First N", "Random sample N"], horizontal=True)
     mode = "first" if pick_mode == "First N" else "random"
 
-    default_n = 13000 if dataset_path.endswith("PI.csv") else 2000
-    max_n = 13000 if dataset_path.endswith("PI.csv") else 50000  # sensible web limit for MVP
+    is_virtual_pi1m = dataset_path.endswith("PI1M.csv")
+    default_n = 1000 if is_virtual_pi1m else 2000
+    max_n = MAX_BATCH_SMILES
 
     n = st.number_input(
         "How many SMILES to use",
@@ -169,6 +204,23 @@ if run:
         st.stop()
 
     props = [label_to_key[lbl] for lbl in selected_labels]
+    lookup_db = get_lookup_db() if selected_sources else None
+    requested_smiles = len(smiles_list)
+    prediction_cells = requested_smiles * len(props)
+
+    if requested_smiles > MAX_BATCH_SMILES:
+        st.error(
+            f"This website currently limits Batch Prediction to {MAX_BATCH_SMILES:,} SMILES per run. "
+            "Use a smaller subset or run larger jobs offline."
+        )
+        st.stop()
+
+    if prediction_cells > MAX_BATCH_PREDICTIONS:
+        st.error(
+            f"This request would run {prediction_cells:,} model predictions, which exceeds the website-safe limit "
+            f"of {MAX_BATCH_PREDICTIONS:,}. Reduce the number of SMILES or selected properties."
+        )
+        st.stop()
 
     # Decide whether to render table
     render_table = len(smiles_list) <= MAX_RENDER_ROWS
@@ -204,6 +256,13 @@ if run:
                 if include_std:
                     row[col_name + " [std]"] = std
 
+            if lookup_db is not None:
+                for src in selected_sources:
+                    src_label = SOURCE_LABELS.get(src, src)
+                    src_col = f"{col_name} [{src_label}]"
+                    val = get_value(lookup_db, src, s_canon, prop)
+                    row[src_col] = float("nan") if val is None else val
+
         rows.append(row)
         if total > 0:
             progress.progress(int(100 * i / total))
@@ -224,7 +283,9 @@ if run:
     # Render table only if safe
     if render_table:
         st.subheader("Predictions")
-        st.dataframe(out_df, width="stretch")
+        display_df = out_df.copy()
+        display_df.index = range(1, len(display_df) + 1)
+        st.dataframe(display_df, width="stretch")
 
     # Download
     csv_bytes = out_df.to_csv(index=False).encode("utf-8")

pages/3_Molecular_View.py

@@ -10,13 +10,17 @@ from streamlit.components.v1 import html
 from rdkit.Chem import Lipinski, Crippen
 from rdkit.Chem.rdMolDescriptors import CalcTPSA, CalcExactMolWt, CalcFractionCSP3, CalcNumRings, CalcNumAromaticRings
 
-from src.ui_style import apply_global_style
+from src.ui_style import apply_global_style, render_page_header
 
 RDLogger.DisableLog("rdApp.*")
 
 st.set_page_config(page_title="Molecular View", layout="wide")
 apply_global_style()
-st.title("Molecular Structure View")
+render_page_header(
+    title="Molecular Structure View",
+    subtitle="Inspect 2D and 3D polymer structures and review repeat-unit descriptors.",
+    badge="Molecular View",
+)
 
 # -------------------------
 # Polymer-safe helpers
@@ -313,7 +317,7 @@ with top_left:
 
 with top_right:
     st.markdown("Molecule Information ")
-    st.table(
+    info_df = pd.DataFrame(
         {
             "Property": ["Formula", "Molar Weight", "Atoms"],
             "Value": [
@@ -323,6 +327,8 @@ with top_right:
             ],
         }
     )
+    info_df.index = range(1, len(info_df) + 1)
+    st.table(info_df)
 
     # MOL download *below the table*
     if mol_block_3d is not None:
@@ -366,4 +372,4 @@ with bottom_right:
 
     # Legend: include hydrogens + colored dots
     # Use capped mol (no '*') for clean element counting
-    render_element_legend_with_colors(mol_cap, include_hydrogens=True)
+    render_element_legend_with_colors(mol_cap, include_hydrogens=True)

pages/4_Discovery_(Manual).py

@@ -13,11 +13,15 @@ import streamlit as st
 
 from src.discovery import run_discovery, spec_from_dict
 from src.lookup import PROPERTY_META
-from src.ui_style import apply_global_style
+from src.ui_style import apply_global_style, render_page_header
 
 st.set_page_config(page_title="Discovery (Manual)", layout="wide")
 apply_global_style()
-st.title("Manual Multi-Objective Discovery")
+render_page_header(
+    title="Manual Multi-Objective Discovery",
+    subtitle="Tune objectives and constraints directly to explore Pareto-optimal polymer candidates.",
+    badge="Discovery (Manual)",
+)
 
 # ----------------------------
 # Files
@@ -699,7 +703,9 @@ if st.session_state.get("discovery_done"):
                 meta = PROPERTY_META[prop_key]
                 rename_map[c] = f"{meta['name']} ({meta['unit']})"
         preview_df = preview_df.rename(columns=rename_map)
-        st.dataframe(preview_df.head(50), width="stretch")
+        preview_display = preview_df.head(50).copy()
+        preview_display.index = range(1, len(preview_display) + 1)
+        st.dataframe(preview_display, width="stretch")
 
         st.subheader("📥 Download")
         buf = io.StringIO()

pages/5_Discovery_(AI).py

@@ -8,6 +8,7 @@ import threading
 import time
 import urllib.request
 import urllib.error
+import urllib.parse
 import zipfile
 from pathlib import Path
 
@@ -17,11 +18,15 @@ import streamlit as st
 from streamlit.components.v1 import html
 
 from src.discover_llm import PROPERTY_META, run_discovery, spec_from_dict
-from src.ui_style import apply_global_style
+from src.ui_style import apply_global_style, render_page_header
 
 st.set_page_config(page_title="DISCOVERY (AI)", layout="wide")
 apply_global_style()
-st.title("AI-Driven Multi-Objective Discovery")
+render_page_header(
+    title="AI-Driven Multi-Objective Discovery",
+    subtitle="Describe target behavior in plain language and run auto-configured multi-objective search.",
+    badge="Discovery (AI)",
+)
 
 # ----------------------------
 # Files
@@ -307,7 +312,236 @@ def get_webui_base_url() -> str:
     ).rstrip("/")
 
 
-def validate_api_access(api_key: str, base_url: str) -> str | None:
+PROVIDER_LABELS = {
+    "auto": "Auto detect",
+    "openwebui": "OpenWebUI",
+    "openai_compatible": "OpenAI-compatible",
+    "anthropic": "Anthropic",
+    "gemini": "Gemini",
+}
+
+PROVIDER_OPTIONS = list(PROVIDER_LABELS.keys())
+
+
+def _provider_label(provider: str) -> str:
+    return PROVIDER_LABELS.get(provider, provider)
+
+
+def default_model_for_provider(provider: str) -> str:
+    p = _normalize_provider(provider)
+    if p == "openwebui":
+        return (
+            get_config_value("CRC_OPENWEBUI_MODEL", "")
+            or get_config_value("OPENWEBUI_MODEL", "")
+            or get_config_value("OPENAI_MODEL", "")
+            or "gpt-oss:latest"
+        )
+    if p == "openai_compatible":
+        return (
+            get_config_value("OPENAI_MODEL", "")
+            or get_config_value("OPENWEBUI_MODEL", "")
+            or get_config_value("CRC_OPENWEBUI_MODEL", "")
+            or "gpt-4o-mini"
+        )
+    if p == "anthropic":
+        return get_config_value("ANTHROPIC_MODEL", "") or "claude-3-5-sonnet-latest"
+    if p == "gemini":
+        return get_config_value("GEMINI_MODEL", "") or "gemini-2.0-flash"
+    return get_config_value("OPENAI_MODEL", "") or "gpt-4o-mini"
+
+
+def _normalize_provider(provider: str | None) -> str:
+    s = str(provider or "").strip().lower().replace("-", "_").replace(" ", "_")
+    if s in PROVIDER_LABELS:
+        return s
+    return "auto"
+
+
+def detect_api_provider(base_url: str) -> str:
+    u = str(base_url or "").strip().lower()
+    if "openwebui" in u:
+        return "openwebui"
+    if "anthropic.com" in u:
+        return "anthropic"
+    if "generativelanguage.googleapis.com" in u or "googleapis.com" in u:
+        return "gemini"
+    if "api.openai.com" in u or "/v1" in u or "openrouter.ai" in u:
+        return "openai_compatible"
+    return "openai_compatible"
+
+
+def resolve_api_provider(base_url: str, provider: str | None = None) -> str:
+    p = _normalize_provider(provider)
+    if p == "auto":
+        return detect_api_provider(base_url)
+    return p
+
+
+def _provider_root(base_url: str, provider: str) -> str:
+    u = str(base_url or "").strip().rstrip("/")
+    if provider == "openwebui":
+        return u
+    if provider == "openai_compatible":
+        return u if u.endswith("/v1") else f"{u}/v1"
+    if provider == "anthropic":
+        return u if u.endswith("/v1") else f"{u}/v1"
+    if provider == "gemini":
+        if u.endswith("/v1") or u.endswith("/v1beta"):
+            return u
+        return f"{u}/v1beta"
+    return u
+
+
+def _join_url(base_url: str, path: str) -> str:
+    return f"{base_url.rstrip('/')}{path}"
+
+
+def _http_json_request(
+    url: str,
+    headers: dict[str, str] | None = None,
+    payload: dict | None = None,
+    method: str | None = None,
+    timeout: int = 60,
+) -> dict:
+    req = urllib.request.Request(
+        url=url,
+        data=(json.dumps(payload).encode("utf-8") if payload is not None else None),
+        headers=(headers or {}),
+        method=(method or ("POST" if payload is not None else "GET")),
+    )
+    try:
+        with urllib.request.urlopen(req, timeout=timeout) as resp:
+            return json.loads(resp.read().decode("utf-8"))
+    except urllib.error.HTTPError as e:
+        detail = e.read().decode("utf-8", errors="ignore")
+        raise RuntimeError(f"HTTP {e.code}: {detail}") from e
+    except Exception as e:
+        raise RuntimeError(str(e)) from e
+
+
+def _flatten_text_content(content) -> str:
+    if isinstance(content, str):
+        return content.strip()
+    if isinstance(content, list):
+        parts = []
+        for item in content:
+            if isinstance(item, str):
+                parts.append(item)
+            elif isinstance(item, dict):
+                txt = str(item.get("text", "")).strip()
+                if txt:
+                    parts.append(txt)
+        return "\n".join(p for p in parts if p).strip()
+    return str(content or "").strip()
+
+
+def provider_request(
+    base_url: str,
+    api_key: str,
+    provider: str,
+    path: str,
+    payload: dict | None = None,
+) -> dict:
+    root = _provider_root(base_url, provider)
+    headers = {"Content-Type": "application/json"}
+    url = _join_url(root, path)
+
+    if provider in {"openwebui", "openai_compatible"}:
+        headers["Authorization"] = f"Bearer {api_key}"
+    elif provider == "anthropic":
+        headers["x-api-key"] = api_key
+        headers["anthropic-version"] = "2023-06-01"
+    elif provider == "gemini":
+        sep = "&" if "?" in url else "?"
+        url = f"{url}{sep}key={urllib.parse.quote(api_key, safe='')}"
+
+    try:
+        return _http_json_request(url, headers=headers, payload=payload)
+    except Exception as e:
+        raise RuntimeError(f"{_provider_label(provider)} API call failed: {e}") from e
+
+
+def chat_text_request(
+    base_url: str,
+    api_key: str,
+    provider: str,
+    model: str,
+    system_prompt: str,
+    user_prompt: str,
+    max_tokens: int = 1024,
+) -> str:
+    provider = resolve_api_provider(base_url, provider)
+    if provider in {"openwebui", "openai_compatible"}:
+        raw = provider_request(
+            base_url,
+            api_key,
+            provider,
+            "/chat/completions" if provider == "openai_compatible" else "/api/chat/completions",
+            payload={
+                "model": model,
+                "messages": [
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": user_prompt},
+                ],
+            },
+        )
+        try:
+            return _flatten_text_content(raw["choices"][0]["message"]["content"])
+        except Exception as e:
+            raise RuntimeError("Unexpected chat-completions response format.") from e
+
+    if provider == "anthropic":
+        raw = provider_request(
+            base_url,
+            api_key,
+            provider,
+            "/messages",
+            payload={
+                "model": model,
+                "system": system_prompt,
+                "max_tokens": int(max_tokens),
+                "messages": [{"role": "user", "content": user_prompt}],
+            },
+        )
+        try:
+            return "\n".join(
+                str(part.get("text", "")).strip()
+                for part in raw.get("content", [])
+                if isinstance(part, dict) and str(part.get("type", "")) == "text"
+            ).strip()
+        except Exception as e:
+            raise RuntimeError("Unexpected Anthropic response format.") from e
+
+    if provider == "gemini":
+        model_name = str(model or "").strip()
+        if model_name.startswith("models/"):
+            model_name = model_name.split("/", 1)[1]
+        raw = provider_request(
+            base_url,
+            api_key,
+            provider,
+            f"/models/{urllib.parse.quote(model_name, safe='')}:generateContent",
+            payload={
+                "system_instruction": {"parts": [{"text": system_prompt}]},
+                "contents": [{"role": "user", "parts": [{"text": user_prompt}]}],
+                "generationConfig": {"temperature": 0.0, "maxOutputTokens": int(max_tokens)},
+            },
+        )
+        try:
+            candidates = raw.get("candidates", [])
+            parts = candidates[0]["content"]["parts"] if candidates else []
+            return "\n".join(
+                str(part.get("text", "")).strip()
+                for part in parts
+                if isinstance(part, dict) and str(part.get("text", "")).strip()
+            ).strip()
+        except Exception as e:
+            raise RuntimeError("Unexpected Gemini response format.") from e
+
+    raise RuntimeError(f"Unsupported provider: {provider}")
+
+
+def validate_api_access(api_key: str, base_url: str, provider: str | None = None, model: str | None = None) -> str | None:
     """Return None when credentials are usable, else an error message."""
     k = str(api_key or "").strip()
     u = str(base_url or "").strip().rstrip("/")
@@ -315,8 +549,23 @@ def validate_api_access(api_key: str, base_url: str) -> str | None:
         return "API key is required."
     if not u.startswith("https://"):
         return "API base URL must start with `https://`."
+
+    resolved_provider = resolve_api_provider(u, provider)
     try:
-        _ = webui_request(u, k, "/api/models", payload=None)
+        if resolved_provider in {"openwebui", "openai_compatible"}:
+            _ = list_available_models(k, u, resolved_provider)
+        elif resolved_provider in {"anthropic", "gemini"}:
+            if not str(model or "").strip():
+                return f"{_provider_label(resolved_provider)} validation requires a model name."
+            _ = chat_text_request(
+                u,
+                k,
+                resolved_provider,
+                str(model).strip(),
+                "Reply with OK.",
+                "ping",
+                max_tokens=8,
+            )
     except Exception as e:
         return f"API key validation failed: {e}"
     return None
@@ -326,40 +575,37 @@ def clear_byok_key() -> None:
     st.session_state["discover_llm_byok_key"] = ""
 
 
-def webui_request(base_url: str, api_key: str, path: str, payload: dict | None = None) -> dict:
-    url = f"{base_url}{path}"
-    req = urllib.request.Request(
-        url=url,
-        data=(json.dumps(payload).encode("utf-8") if payload is not None else None),
-        headers={
-            "Authorization": f"Bearer {api_key}",
-            "Content-Type": "application/json",
-        },
-        method=("POST" if payload is not None else "GET"),
-    )
-    try:
-        with urllib.request.urlopen(req, timeout=60) as resp:
-            return json.loads(resp.read().decode("utf-8"))
-    except urllib.error.HTTPError as e:
-        detail = e.read().decode("utf-8", errors="ignore")
-        raise RuntimeError(f"WebUI API HTTP {e.code}: {detail}") from e
-    except Exception as e:
-        raise RuntimeError(f"WebUI API call failed: {e}") from e
-
-
-def list_available_models(api_key: str | None = None, base_url: str | None = None) -> list[str]:
+def list_available_models(
+    api_key: str | None = None,
+    base_url: str | None = None,
+    provider: str | None = None,
+) -> list[str]:
     api_key = (api_key or get_webui_api_key()).strip()
     if not api_key:
         return []
     base_url = (base_url or get_webui_base_url()).rstrip("/")
-    raw = webui_request(base_url, api_key, "/api/models", payload=None)
-    items = raw.get("data", raw) if isinstance(raw, dict) else raw
+    resolved_provider = resolve_api_provider(base_url, provider)
+
+    if resolved_provider == "openwebui":
+        raw = provider_request(base_url, api_key, resolved_provider, "/api/models", payload=None)
+        items = raw.get("data", raw) if isinstance(raw, dict) else raw
+    elif resolved_provider == "openai_compatible":
+        raw = provider_request(base_url, api_key, resolved_provider, "/models", payload=None)
+        items = raw.get("data", raw) if isinstance(raw, dict) else raw
+    elif resolved_provider == "gemini":
+        raw = provider_request(base_url, api_key, resolved_provider, "/models", payload=None)
+        items = raw.get("models", raw.get("data", raw)) if isinstance(raw, dict) else raw
+    else:
+        return []
+
     if not isinstance(items, list):
         return []
     out = []
     for m in items:
         if isinstance(m, dict):
             mid = str(m.get("id", m.get("name", ""))).strip()
+            if resolved_provider == "gemini" and mid.startswith("models/"):
+                mid = mid.split("/", 1)[1]
         else:
             mid = str(m).strip()
         if mid:
@@ -368,7 +614,11 @@ def list_available_models(api_key: str | None = None, base_url: str | None = Non
 
 
 def generate_spec_from_llm(
-    user_query: str, model: str, api_key: str | None = None, base_url: str | None = None
+    user_query: str,
+    model: str,
+    api_key: str | None = None,
+    base_url: str | None = None,
+    provider: str | None = None,
 ) -> dict:
     api_key = (api_key or get_webui_api_key()).strip()
     if not api_key:
@@ -401,20 +651,15 @@ def generate_spec_from_llm(
     user_prompt = (
         "User request:\n" + user_query.strip()
     )
-
-    payload = {
-        "model": model,
-        "messages": [
-            {"role": "system", "content": system_prompt},
-            {"role": "user", "content": user_prompt},
-        ],
-    }
-    raw = webui_request(base_url, api_key, "/api/chat/completions", payload=payload)
-
-    try:
-        content = raw["choices"][0]["message"]["content"]
-    except Exception:
-        raise RuntimeError("Unexpected LLM response format.")
+    content = chat_text_request(
+        base_url,
+        api_key,
+        resolve_api_provider(base_url, provider),
+        model,
+        system_prompt,
+        user_prompt,
+        max_tokens=1024,
+    )
 
     try:
         parsed = extract_first_json_object(content)
@@ -506,11 +751,6 @@ def render_copyable_prompt(prompt_text: str, box_height: int = 220) -> None:
     html(snippet, height=box_height + 54)
 
 
-@st.cache_data(ttl=300, show_spinner=False)
-def list_available_models_cached() -> list[str]:
-    return list_available_models()
-
-
 def _local_reasoning_fallback(spec_obj: dict, stats: dict) -> str:
     objectives = spec_obj.get("objectives", []) if isinstance(spec_obj, dict) else []
     constraints = spec_obj.get("hard_constraints", {}) if isinstance(spec_obj, dict) else {}
@@ -599,6 +839,7 @@ def generate_selection_reasoning(
     model: str,
     api_key: str | None = None,
     base_url: str | None = None,
+    provider: str | None = None,
 ) -> str:
     api_key = (api_key or get_webui_api_key()).strip()
     if not api_key:
@@ -674,19 +915,15 @@ def generate_selection_reasoning(
         "You can add brief clarifying bullets if helpful, but keep it concise and focused.\n\n"
         f"INPUT:\n{json.dumps(user_payload, indent=2)}"
     )
-    payload = {
-        "model": model,
-        "messages": [
-            {"role": "system", "content": system_prompt},
-            {"role": "user", "content": user_prompt},
-        ],
-    }
-    raw = webui_request(base_url, api_key, "/api/chat/completions", payload=payload)
-    try:
-        content = raw["choices"][0]["message"]["content"]
-        return str(content).strip()
-    except Exception:
-        raise RuntimeError("Unexpected LLM response format for reasoning.")
+    return chat_text_request(
+        base_url,
+        api_key,
+        resolve_api_provider(base_url, provider),
+        model,
+        system_prompt,
+        user_prompt,
+        max_tokens=900,
+    )
 
 
 def pareto_publication_plot(plot_df: pd.DataFrame, obj_props: list[str]):
@@ -1011,13 +1248,17 @@ if "discover_llm_query_text" not in st.session_state:
 if "discover_llm_last_example_choice" not in st.session_state:
     st.session_state["discover_llm_last_example_choice"] = "Select an example prompt…"
 if "discover_llm_mode" not in st.session_state:
-    st.session_state["discover_llm_mode"] = "Built-in API"
+    st.session_state["discover_llm_mode"] = "Bring Your Own Key"
 if "discover_llm_external_response" not in st.session_state:
     st.session_state["discover_llm_external_response"] = ""
 if "discover_llm_byok_key" not in st.session_state:
     st.session_state["discover_llm_byok_key"] = ""
 if "discover_llm_byok_base_url" not in st.session_state:
-    st.session_state["discover_llm_byok_base_url"] = get_webui_base_url()
+    st.session_state["discover_llm_byok_base_url"] = ""
+if "discover_llm_byok_provider" not in st.session_state:
+    st.session_state["discover_llm_byok_provider"] = "auto"
+if st.session_state.get("discover_llm_mode") not in {"Bring Your Own Key", "External LLM (manual copy–paste)"}:
+    st.session_state["discover_llm_mode"] = "Bring Your Own Key"
 
 # Apply deferred JSON updates before any JSON editor widget is instantiated.
 pending_spec_text = st.session_state.get("discover_llm_spec_text_next")
@@ -1049,7 +1290,7 @@ with st.container(border=True):
     )
 mode = st.radio(
     "LLM setup",
-    options=["Built-in API", "Bring Your Own Key", "External LLM (manual copy–paste)"],
+    options=["Bring Your Own Key", "External LLM (manual copy–paste)"],
     key="discover_llm_mode",
     horizontal=True,
 )
@@ -1058,75 +1299,73 @@ external_response_text = st.session_state.get("discover_llm_external_response",
 selected_model = "external-copy-paste"
 active_api_key = ""
 active_base_url = get_webui_base_url()
+active_provider = "openwebui"
 api_config_invalid = False
-default_model = (
-    get_config_value("CRC_OPENWEBUI_MODEL", "")
-    or get_config_value("OPENWEBUI_MODEL", "")
-    or get_config_value("OPENAI_MODEL", "")
-    or "gpt-oss:latest"
-)
 
-if mode in {"Built-in API", "Bring Your Own Key"}:
-    if mode == "Built-in API":
-        active_api_key = get_webui_api_key()
-        active_base_url = get_webui_base_url()
-        if not active_api_key:
-            st.warning(
-                "No API key found. Set `CRC_OPENWEBUI_API_KEY` in `.streamlit/secrets.toml` "
-                "or an environment variable."
-            )
-    else:
-        with st.container(border=True):
-            st.caption(
-                "Bring Your Own Key mode: key is used only for this session and never written to files."
-            )
-            st.text_input(
-                "Your API key",
-                key="discover_llm_byok_key",
-                type="password",
-                placeholder="Paste your API key",
-            )
-            st.text_input(
-                "API base URL",
-                key="discover_llm_byok_base_url",
-                placeholder="https://openwebui.crc.nd.edu",
-            )
-            st.button("Clear API key", key="clear_byok_key", on_click=clear_byok_key)
-        active_api_key = str(st.session_state.get("discover_llm_byok_key", "")).strip()
-        active_base_url = str(st.session_state.get("discover_llm_byok_base_url", "")).strip().rstrip("/")
-        if active_base_url and not active_base_url.startswith("https://"):
-            st.error("API base URL must start with `https://`.")
-            api_config_invalid = True
-        if not active_api_key:
-            st.warning("Enter your API key to enable in-app LLM generation.")
+if mode == "Bring Your Own Key":
+    with st.container(border=True):
+        st.caption(
+            "Bring Your Own Key mode: key is used only for this session and never written to files."
+        )
+        st.caption(
+            "Enter the service root URL, not a full endpoint path. Examples: "
+            "`https://api.openai.com`, `https://api.anthropic.com`, "
+            "`https://generativelanguage.googleapis.com`, or your OpenWebUI base URL."
+        )
+        st.text_input(
+            "Your API key",
+            key="discover_llm_byok_key",
+            type="password",
+            placeholder="Paste your API key",
+        )
+        st.text_input(
+            "API base URL",
+            key="discover_llm_byok_base_url",
+            placeholder="Enter service root URL",
+        )
+        st.selectbox(
+            "API provider",
+            options=PROVIDER_OPTIONS,
+            key="discover_llm_byok_provider",
+            format_func=_provider_label,
+            help=(
+                "Use Auto detect for most endpoints. "
+                "Choose a provider explicitly if the base URL is a direct Anthropic or Gemini endpoint, "
+                "or if your gateway does not identify itself clearly."
+            ),
+        )
+        st.button("Clear API key", key="clear_byok_key", on_click=clear_byok_key)
+    active_api_key = str(st.session_state.get("discover_llm_byok_key", "")).strip()
+    user_base_url = str(st.session_state.get("discover_llm_byok_base_url", "")).strip().rstrip("/")
+    active_base_url = user_base_url or get_webui_base_url()
+    configured_provider = str(st.session_state.get("discover_llm_byok_provider", "auto")).strip()
+    active_provider = resolve_api_provider(active_base_url, configured_provider) if active_base_url else "auto"
+    fallback_model = default_model_for_provider(active_provider)
+    if user_base_url and not user_base_url.startswith("https://"):
+        st.error("API base URL must start with `https://`.")
+        api_config_invalid = True
+    elif user_base_url:
+        st.caption(f"Detected provider: `{_provider_label(active_provider)}`")
+    if not active_api_key:
+        st.warning("Enter your API key to enable in-app LLM generation.")
 
     available_models: list[str] = []
     models_error = ""
     if active_api_key and not api_config_invalid:
         try:
-            if mode == "Built-in API":
-                available_models = list_available_models_cached()
-            else:
-                available_models = list_available_models(active_api_key, active_base_url)
+            available_models = list_available_models(active_api_key, active_base_url, active_provider)
         except Exception as e:
             models_error = str(e)
 
     if available_models:
-        model_index = available_models.index(default_model) if default_model in available_models else 0
-        selected_model = st.selectbox(
-            "LLM model",
-            options=available_models,
-            index=model_index,
-            help="Model used only to translate your natural language request into JSON.",
-        )
+        model_index = available_models.index(fallback_model) if fallback_model in available_models else 0
+        selected_model = available_models[model_index]
+        st.caption(f"Using model: `{selected_model}`")
     else:
         if models_error:
-            st.warning(f"Could not load model list from API. Enter model name manually. Error: {models_error}")
-        selected_model = st.text_input(
-            "LLM model",
-            value=default_model,
-            help="Use a valid model id from your CRC Open WebUI instance (for example `gpt-oss:latest`).",
-        )
+            st.warning(f"Could not load model list from API. Using fallback model `{fallback_model}`. Error: {models_error}")
+        selected_model = fallback_model
+        st.caption(f"Using fallback model: `{selected_model}`")
 else:
     with st.container(border=True):
         st.caption(
@@ -1148,7 +1387,7 @@ generate_json_btn = False
 if show_json_editor:
     generate_json_btn = st.button(
         "Generate JSON from LLM"
-        if mode in {"Built-in API", "Bring Your Own Key"}
+        if mode == "Bring Your Own Key"
         else "Generate JSON from pasted response"
     )
 
@@ -1554,7 +1793,11 @@ def _build_runnable_spec(raw_obj: dict) -> tuple[dict, list[str], list[str]]:
 
 
 def _raw_spec_from_prompt(
-    user_query: str, model_name: str, api_key: str | None = None, base_url: str | None = None
+    user_query: str,
+    model_name: str,
+    api_key: str | None = None,
+    base_url: str | None = None,
+    provider: str | None = None,
 ) -> tuple[dict, list[str], str | None]:
     notes: list[str] = []
     extracted = {}
@@ -1562,7 +1805,13 @@ def _raw_spec_from_prompt(
         return {}, notes, "Please provide a prompt before generating or running discovery."
     with st.spinner("Interpreting prompt and preparing discovery config..."):
         try:
-            extracted = generate_spec_from_llm(user_query, model_name, api_key=api_key, base_url=base_url)
+            extracted = generate_spec_from_llm(
+                user_query,
+                model_name,
+                api_key=api_key,
+                base_url=base_url,
+                provider=provider,
+            )
         except Exception as e:
             return {}, notes, f"LLM generation failed: {e}"
 
@@ -1629,17 +1878,21 @@ def _raw_spec_from_external_response(user_query: str, response_text: str) -> tup
 
 
 if show_json_editor and generate_json_btn:
-    if mode in {"Built-in API", "Bring Your Own Key"} and not llm_query.strip():
+    if mode == "Bring Your Own Key" and not llm_query.strip():
         st.error("Please provide a prompt before generating JSON.")
         st.stop()
     if mode == "Bring Your Own Key":
-        byok_err = validate_api_access(active_api_key, active_base_url)
+        byok_err = validate_api_access(active_api_key, active_base_url, active_provider, selected_model)
         if byok_err:
             st.error(f"BYOK validation failed: {byok_err}")
             st.stop()
-    if mode in {"Built-in API", "Bring Your Own Key"}:
+    if mode == "Bring Your Own Key":
         raw_spec_obj, prep_notes, parse_error = _raw_spec_from_prompt(
-            llm_query, selected_model, api_key=active_api_key, base_url=active_base_url
+            llm_query,
+            selected_model,
+            api_key=active_api_key,
+            base_url=active_base_url,
+            provider=active_provider,
         )
         if parse_error:
             for msg in prep_notes:
@@ -1665,11 +1918,11 @@ if show_json_editor and generate_json_btn:
 run_btn = st.button("Run discovery", type="primary")
 
 if run_btn:
-    if mode in {"Built-in API", "Bring Your Own Key"} and not llm_query.strip():
+    if mode == "Bring Your Own Key" and not llm_query.strip():
         st.error("Please provide a prompt before running discovery.")
         st.stop()
     if mode == "Bring Your Own Key":
-        byok_err = validate_api_access(active_api_key, active_base_url)
+        byok_err = validate_api_access(active_api_key, active_base_url, active_provider, selected_model)
         if byok_err:
             st.error(f"BYOK validation failed: {byok_err}")
             st.stop()
@@ -1686,9 +1939,13 @@ if run_btn:
             raw_spec_obj = {}
             prep_notes.append("Invalid JSON detected. Using fixed template defaults.")
     else:
-        if mode in {"Built-in API", "Bring Your Own Key"}:
+        if mode == "Bring Your Own Key":
             raw_spec_obj, llm_notes, parse_error = _raw_spec_from_prompt(
-                llm_query, selected_model, api_key=active_api_key, base_url=active_base_url
+                llm_query,
+                selected_model,
+                api_key=active_api_key,
+                base_url=active_base_url,
+                provider=active_provider,
             )
             if parse_error:
                 for msg in llm_notes:
@@ -1728,6 +1985,7 @@ if run_btn:
     st.session_state["discovery_mode_used"] = mode
     st.session_state["discovery_api_key"] = active_api_key if mode == "Bring Your Own Key" else ""
     st.session_state["discovery_api_base_url"] = active_base_url if mode == "Bring Your Own Key" else ""
+    st.session_state["discovery_api_provider"] = active_provider if mode == "Bring Your Own Key" else ""
     st.session_state["discovery_reasoning_text"] = None
     st.session_state["discovery_reasoning_key"] = None
     st.session_state["discovery_reasoning_note"] = None
@@ -1799,13 +2057,15 @@ if st.session_state.get("discovery_done"):
     c3.metric("Pareto pool", int(stats.get("n_pareto_pool", 0)))
     c4.metric("Selected", int(stats.get("n_selected", 0)))
 
-    if mode_used in {"Built-in API", "Bring Your Own Key"}:
+    if mode_used == "Bring Your Own Key":
         reasoning_api_key = st.session_state.get("discovery_api_key", "")
         reasoning_api_base_url = st.session_state.get("discovery_api_base_url", "")
+        reasoning_api_provider = st.session_state.get("discovery_api_provider", "openwebui")
         reasoning_key_obj = {
             "spec": resolved_spec,
             "model": model_used,
             "mode": mode_used,
+            "provider": reasoning_api_provider,
             "selected_smiles_head": (
                 out_df["SMILES"].astype(str).head(20).tolist()
                 if isinstance(out_df, pd.DataFrame) and "SMILES" in out_df.columns
@@ -1826,6 +2086,7 @@ if st.session_state.get("discovery_done"):
                         model_used,
                         api_key=(str(reasoning_api_key).strip() or None),
                         base_url=(str(reasoning_api_base_url).strip() or None),
+                        provider=(str(reasoning_api_provider).strip() or None),
                     )
                 st.session_state["discovery_reasoning_note"] = None
             except Exception as e:
@@ -1869,7 +2130,9 @@ if st.session_state.get("discovery_done"):
                 meta = PROPERTY_META[prop_key]
                 rename_map[c] = f"{meta['name']} ({meta['unit']})"
         preview_df = preview_df.rename(columns=rename_map)
-        st.dataframe(preview_df.head(50), width="stretch")
+        preview_display = preview_df.head(50).copy()
+        preview_display.index = range(1, len(preview_display) + 1)
+        st.dataframe(preview_display, width="stretch")
 
         st.subheader("📥  Download")
         buf = io.StringIO()

pages/6_Novel_SMILES_Generation.py

@@ -11,59 +11,95 @@ from src.rnn_smiles.generator import (
     load_existing_smiles_set,
     load_rnn_model,
 )
-from src.ui_style import apply_global_style
+from src.ui_style import apply_global_style, render_page_header
 
 st.set_page_config(page_title="Novel SMILES Generation", layout="wide")
 apply_global_style()
-st.title("Novel SMILES Generation")
-st.caption("Generate candidate polymers with an RNN and keep only molecules not seen in local datasets.")
+render_page_header(
+    title="Novel SMILES Generation",
+    subtitle="Generate candidate polymers with an RNN and filter against local datasets for novelty.",
+    badge="Novel SMILES Generation",
+)
 
 APP_ROOT = Path(__file__).resolve().parents[1]
 MODEL_DIR = APP_ROOT / "models" / "rnn" / "pretrained_model"
 
 DEFAULT_CKPT = MODEL_DIR / "Prior.ckpt"
 DEFAULT_VOC = MODEL_DIR / "voc"
+ckpt_path = str(DEFAULT_CKPT)
+voc_path = str(DEFAULT_VOC)
 
-NOVELTY_DATASETS = [
+FAST_NOVELTY_DATASETS = [
     APP_ROOT / "data" / "EXP.csv",
     APP_ROOT / "data" / "MD.csv",
     APP_ROOT / "data" / "DFT.csv",
     APP_ROOT / "data" / "GC.csv",
     APP_ROOT / "data" / "POLYINFO.csv",
+]
+SLOW_NOVELTY_DATASETS = [
     APP_ROOT / "data" / "PI1M.csv",
 ]
 
-with st.sidebar:
-    st.subheader("Model Assets")
-    ckpt_path = st.text_input("Checkpoint path", value=str(DEFAULT_CKPT))
-    voc_path = st.text_input("Vocabulary path", value=str(DEFAULT_VOC))
 
+def _has_smiles_column(path: Path) -> bool:
+    try:
+        header = pd.read_csv(path, nrows=0)
+    except Exception:
+        return False
+    cols = [str(c).strip().lower() for c in header.columns]
+    return any(c in {"smiles", "canonical_smiles", "canonical smiles", "smile", "smi"} or "smiles" in c for c in cols)
+
+
+with st.sidebar:
     st.subheader("Generation Parameters")
     target_count = st.number_input("Novel SMILES to return", min_value=1, max_value=5000, value=200, step=25)
     max_length = st.number_input("Max token length", min_value=20, max_value=300, value=140, step=10)
     temperature = st.slider("Temperature", min_value=0.2, max_value=2.0, value=1.0, step=0.1)
     max_attempts = st.number_input("Sampling attempts", min_value=1, max_value=50, value=10, step=1)
+    include_virtual_novelty = st.checkbox(
+        "Include PI1M in novelty filter (slower)",
+        value=False,
+        help="Off by default for website responsiveness. Enable only if you need novelty checked against the virtual library too.",
+    )
+
+novelty_datasets = list(FAST_NOVELTY_DATASETS)
+if include_virtual_novelty:
+    novelty_datasets.extend(SLOW_NOVELTY_DATASETS)
 
 if not Path(ckpt_path).expanduser().exists() or not Path(voc_path).expanduser().exists():
     st.error("Model files were not found.")
-    st.write("Expected default location:")
-    st.code(str(MODEL_DIR))
     st.stop()
 
-available_datasets = [p for p in NOVELTY_DATASETS if p.exists()]
-missing_datasets = [p for p in NOVELTY_DATASETS if not p.exists()]
+available_datasets = [p for p in novelty_datasets if p.exists() and _has_smiles_column(p)]
+missing_datasets = [p for p in novelty_datasets if not p.exists()]
+invalid_datasets = [p for p in novelty_datasets if p.exists() and not _has_smiles_column(p)]
+
+if include_virtual_novelty:
+    st.caption("Full novelty mode includes PI1M and may take significantly longer on the first run.")
+else:
+    st.caption("Fast novelty mode checks EXP, MD, DFT, GC, and POLYINFO. PI1M is excluded by default for website responsiveness.")
 
 if missing_datasets:
     st.warning("Some novelty datasets are missing and were skipped.")
     for path in missing_datasets:
         st.write(f"- {path.name}")
 
+if invalid_datasets:
+    st.warning("Some novelty datasets are malformed or missing a SMILES column and were skipped.")
+    for path in invalid_datasets:
+        st.write(f"- {path.name}")
+
 if not available_datasets:
     st.warning("No novelty datasets found. Results will only be de-duplicated within this run.")
 
 if st.button("Generate", type="primary"):
-    with st.spinner("Loading RNN model (cached after first load)..."):
-        model, voc = load_rnn_model(ckpt_path, voc_path)
+    try:
+        with st.spinner("Loading RNN model (cached after first load)..."):
+            model, voc = load_rnn_model(ckpt_path, voc_path)
+    except Exception as exc:
+        st.error(f"Failed to load the RNN checkpoint: {exc}")
+        st.info("If you see a Git LFS pointer error, replace `models/rnn/pretrained_model/Prior.ckpt` with the real model file.")
+        st.stop()
 
     with st.spinner("Building novelty index (cached after first load)..."):
         existing_smiles = load_existing_smiles_set(tuple(str(p) for p in available_datasets)) if available_datasets else set()
@@ -121,7 +157,9 @@ if st.button("Generate", type="primary"):
         st.stop()
 
     result_df = pd.DataFrame({"SMILES": novel})
-    st.dataframe(result_df, width="stretch")
+    display_df = result_df.copy()
+    display_df.index = range(1, len(display_df) + 1)
+    st.dataframe(display_df, width="stretch")
     st.download_button(
         "Download CSV",
         data=result_df.to_csv(index=False).encode("utf-8"),