Update app.py

app.py

@@ -5,9 +5,9 @@
 # - Generates 8–12 randomized SQL questions with varied phrasings.
 # - Validates answers by executing canonical SQL and comparing result sets.
 # - Provides tailored feedback (SQLite dialect, cartesian products, aggregates, aliases).
-# - Shows data results at the bottom pane for every run (SELECT or preview for VIEW/CTAS).
+# - Always shows data results at the bottom pane.
 #
-# Hugging Face Spaces: set OPENAI_API_KEY as a secret to enable LLM randomization.
+# Hugging Face Spaces: set OPENAI_API_KEY in secrets to enable randomization.
 
 import os
 import re
@@ -16,7 +16,7 @@ import time
 import random
 import sqlite3
 import threading
-from dataclasses import dataclass, asdict
+from dataclasses import dataclass
 from datetime import datetime, timezone
 from typing import List, Dict, Any, Tuple, Optional
 
@@ -24,17 +24,10 @@ import gradio as gr
 import pandas as pd
 import numpy as np
 
-# Matplotlib for ERD drawing (headless)
-import matplotlib
-matplotlib.use("Agg")
-import matplotlib.pyplot as plt
-from io import BytesIO
-from PIL import Image
-
 # -------------------- OpenAI (optional) --------------------
 USE_RESPONSES_API = True
 OPENAI_AVAILABLE = True
-MODEL_ID = os.getenv("OPENAI_MODEL", "gpt-4.1-mini")
+DEFAULT_MODEL = os.getenv("OPENAI_MODEL")  # optional override
 try:
     from openai import OpenAI
     _client = OpenAI()  # requires OPENAI_API_KEY
@@ -42,6 +35,17 @@ except Exception:
     OPENAI_AVAILABLE = False
     _client = None
 
+def _candidate_models():
+    base = [
+        DEFAULT_MODEL,
+        "gpt-4o-mini",
+        "gpt-4o",
+        "gpt-4.1-mini",
+        "o3-mini",
+    ]
+    seen = set()
+    return [m for m in base if m and (m not in seen and not seen.add(m))]
+
 # -------------------- Global settings --------------------
 DB_DIR = "/data" if os.path.exists("/data") else "."
 DB_PATH = os.path.join(DB_DIR, "sql_trainer_dynamic.db")
@@ -51,76 +55,14 @@ RANDOM_SEED = int(os.getenv("RANDOM_SEED", "7"))
 random.seed(RANDOM_SEED)
 SYS_RAND = random.SystemRandom()
 
-PLOT_FIGSIZE = (6.8, 3.4)
-PLOT_DPI = 110
-PLOT_HEIGHT = 300
-
-# -------------------- ERD helpers --------------------
-def _to_pil(fig) -> Image.Image:
-    buf = BytesIO()
-    fig.tight_layout()
-    fig.savefig(buf, format="png", dpi=PLOT_DPI, bbox_inches="tight")
-    plt.close(fig)
-    buf.seek(0)
-    return Image.open(buf)
-
-def draw_dynamic_erd(schema: Dict[str, Any]) -> Image.Image:
-    """
-    Draw a simple ERD for the current randomized schema.
-    schema = {
-      "domain": "bookstore",
-      "tables": [
-          {"name":"authors","columns":[{"name":"author_id","type":"INTEGER"}, ...],
-           "pk":["author_id"], "fks":[{"columns":["author_id"],"ref_table":"...","ref_columns":["..."]}],
-           "rows":[{...}, {...}]}
-      ]
-    }
-    """
-    fig, ax = plt.subplots(figsize=PLOT_FIGSIZE)
-    ax.axis("off")
-    tables = schema.get("tables", [])
-    n = max(1, len(tables))
-    # Lay out boxes horizontally
-    margin = 0.03
-    width = (1 - margin*(n+1)) / n
-    height = 0.65
-    y = 0.25
-    boxes = {}
-    for i, t in enumerate(tables):
-        x = margin + i*(width + margin)
-        boxes[t["name"]] = (x, y, width, height)
-        ax.add_patch(plt.Rectangle((x, y), width, height, fill=False))
-        ax.text(x + 0.01, y + height - 0.05, f"**{t['name']}**", fontsize=10, ha="left", va="top")
-        yy = y + height - 0.10
-        pk = set(t.get("pk", []))
-        cols = t.get("columns", [])
-        for col in cols:
-            nm = col["name"]
-            mark = " (PK)" if nm in pk else ""
-            ax.text(x + 0.02, yy, f"{nm}{mark}", fontsize=9, ha="left", va="top")
-            yy -= 0.06
-
-    # Draw FK arrows
-    for t in tables:
-        for fk in t.get("fks", []):
-            src_tbl = t["name"]
-            dst_tbl = fk.get("ref_table")
-            if src_tbl in boxes and dst_tbl in boxes:
-                (x1, y1, w1, h1) = boxes[src_tbl]
-                (x2, y2, w2, h2) = boxes[dst_tbl]
-                ax.annotate("", xy=(x2 + w2/2, y2 + h2), xytext=(x1 + w1/2, y1),
-                            arrowprops=dict(arrowstyle="->", lw=1.1))
-    ax.text(0.5, 0.06, f"Domain: {schema.get('domain','unknown')}", fontsize=9, ha="center")
-    return _to_pil(fig)
-
 # -------------------- SQLite connection + locking --------------------
 DB_LOCK = threading.RLock()
 
 def connect_db():
     """
-    Single shared connection that is allowed to be used across threads.
+    Single shared connection that can be used across threads.
     All operations (reads + writes) are serialized via DB_LOCK.
-    WAL mode improves read concurrency.
+    WAL mode enables concurrent reads.
     """
     con = sqlite3.connect(DB_PATH, check_same_thread=False)
     con.execute("PRAGMA journal_mode=WAL;")
@@ -242,66 +184,44 @@ FALLBACK_SCHEMA = {
 }
 
 FALLBACK_QUESTIONS = [
-    {
-        "id":"Q01","category":"SELECT *","difficulty":1,
-        "prompt_md":"Select all rows and columns from `authors`.",
-        "answer_sql":["SELECT * FROM authors;"],
-        "requires_aliases":False,"required_aliases":[]
-    },
-    {
-        "id":"Q02","category":"SELECT columns","difficulty":1,
-        "prompt_md":"Show `title` and `price` from `books`.",
-        "answer_sql":["SELECT title, price FROM books;"],
-        "requires_aliases":False,"required_aliases":[]
-    },
-    {
-        "id":"Q03","category":"WHERE","difficulty":1,
-        "prompt_md":"List Sci‑Fi books under $15 (show title, price).",
-        "answer_sql":["SELECT title, price FROM books WHERE category='Sci-Fi' AND price < 15;"],
-        "requires_aliases":False,"required_aliases":[]
-    },
-    {
-        "id":"Q04","category":"Aliases","difficulty":1,
-        "prompt_md":"Using aliases `b` and `a`, join `books` to `authors` and show `b.title` and `a.name` as `author_name`.",
-        "answer_sql":["SELECT b.title, a.name AS author_name FROM books b JOIN authors a ON b.author_id=a.author_id;"],
-        "requires_aliases":True,"required_aliases":["a","b"]
-    },
-    {
-        "id":"Q05","category":"JOIN (INNER)","difficulty":2,
-        "prompt_md":"Inner join `books` and `bookstores`. Return `title`, `name` as `store`.",
-        "answer_sql":[
-            "SELECT b.title, s.name AS store FROM books b INNER JOIN bookstores s ON b.store_id=s.store_id;"
-        ],
-        "requires_aliases":False,"required_aliases":[]
-    },
-    {
-        "id":"Q06","category":"JOIN (LEFT)","difficulty":2,
-        "prompt_md":"List each author and their number of books (include authors with zero): columns `name`, `book_count`.",
-        "answer_sql":[
-            "SELECT a.name, COUNT(b.book_id) AS book_count FROM authors a LEFT JOIN books b ON a.author_id=b.author_id GROUP BY a.name;"
-        ],
-        "requires_aliases":False,"required_aliases":[]
-    },
-    {
-        "id":"Q07","category":"VIEW","difficulty":2,
-        "prompt_md":"Create a view `vw_pricy` with `title`, `price` for books priced > 25.",
-        "answer_sql":[
-            "CREATE VIEW vw_pricy AS SELECT title, price FROM books WHERE price > 25;"
-        ],
-        "requires_aliases":False,"required_aliases":[]
-    },
-    {
-        "id":"Q08","category":"CTAS / SELECT INTO","difficulty":2,
-        "prompt_md":"Create a table `cheap_books` containing books priced < 12. Use CTAS or SELECT INTO.",
-        "answer_sql":[
-            "CREATE TABLE cheap_books AS SELECT * FROM books WHERE price < 12;",
-            "SELECT * INTO cheap_books FROM books WHERE price < 12;"
-        ],
-        "requires_aliases":False,"required_aliases":[]
-    },
+    {"id":"Q01","category":"SELECT *","difficulty":1,
+     "prompt_md":"Select all rows and columns from `authors`.",
+     "answer_sql":["SELECT * FROM authors;"],
+     "requires_aliases":False,"required_aliases":[]},
+    {"id":"Q02","category":"SELECT columns","difficulty":1,
+     "prompt_md":"Show `title` and `price` from `books`.",
+     "answer_sql":["SELECT title, price FROM books;"],
+     "requires_aliases":False,"required_aliases":[]},
+    {"id":"Q03","category":"WHERE","difficulty":1,
+     "prompt_md":"List Sci‑Fi books under $15 (show title, price).",
+     "answer_sql":["SELECT title, price FROM books WHERE category='Sci-Fi' AND price < 15;"],
+     "requires_aliases":False,"required_aliases":[]},
+    {"id":"Q04","category":"Aliases","difficulty":1,
+     "prompt_md":"Using aliases `b` and `a`, join `books` to `authors` and show `b.title` and `a.name` as `author_name`.",
+     "answer_sql":["SELECT b.title, a.name AS author_name FROM books b JOIN authors a ON b.author_id=a.author_id;"],
+     "requires_aliases":True,"required_aliases":["a","b"]},
+    {"id":"Q05","category":"JOIN (INNER)","difficulty":2,
+     "prompt_md":"Inner join `books` and `bookstores`. Return `title`, `name` as `store`.",
+     "answer_sql":["SELECT b.title, s.name AS store FROM books b INNER JOIN bookstores s ON b.store_id=s.store_id;"],
+     "requires_aliases":False,"required_aliases":[]},
+    {"id":"Q06","category":"JOIN (LEFT)","difficulty":2,
+     "prompt_md":"List each author and their number of books (include authors with zero): columns `name`, `book_count`.",
+     "answer_sql":["SELECT a.name, COUNT(b.book_id) AS book_count FROM authors a LEFT JOIN books b ON a.author_id=b.author_id GROUP BY a.name;"],
+     "requires_aliases":False,"required_aliases":[]},
+    {"id":"Q07","category":"VIEW","difficulty":2,
+     "prompt_md":"Create a view `vw_pricy` with `title`, `price` for books priced > 25.",
+     "answer_sql":["CREATE VIEW vw_pricy AS SELECT title, price FROM books WHERE price > 25;"],
+     "requires_aliases":False,"required_aliases":[]},
+    {"id":"Q08","category":"CTAS / SELECT INTO","difficulty":2,
+     "prompt_md":"Create a table `cheap_books` containing books priced < 12. Use CTAS or SELECT INTO.",
+     "answer_sql":[
+         "CREATE TABLE cheap_books AS SELECT * FROM books WHERE price < 12;",
+         "SELECT * INTO cheap_books FROM books WHERE price < 12;"
+     ],
+     "requires_aliases":False,"required_aliases":[]},
 ]
 
-# -------------------- OpenAI prompts --------------------
+# -------------------- OpenAI JSON schema --------------------
 DOMAIN_AND_QUESTIONS_SCHEMA = {
     "name": "DomainSQLPack",
     "schema": {
@@ -322,10 +242,7 @@ DOMAIN_AND_QUESTIONS_SCHEMA = {
                             "items": {
                                 "type":"object",
                                 "additionalProperties": False,
-                                "properties": {
-                                    "name":{"type":"string"},
-                                    "type":{"type":"string"}
-                                },
+                                "properties": {"name":{"type":"string"}, "type":{"type":"string"}},
                                 "required":["name","type"]
                             }
                         },
@@ -372,15 +289,17 @@ DOMAIN_AND_QUESTIONS_SCHEMA = {
     "strict": True
 }
 
-DOMAIN_AND_QUESTIONS_PROMPT = """
-You are designing a small relational dataset and training questions for SQL basics.
+def _domain_prompt(prev_domain: Optional[str]) -> str:
+    extra = f" Avoid using the previous domain '{prev_domain}' if possible." if prev_domain else ""
+    return f"""
+You are designing a small relational dataset and training questions for SQL basics.{extra}
 
 1) Choose ONE domain at random from:
    - bookstore, retail sales, wholesaler, sales tax, oil and gas wells, marketing.
 
 2) Produce exactly 3–4 tables that fit together (SQLite-friendly):
    - Use snake_case, avoid reserved words.
-   - Types: INTEGER, REAL, TEXT, NUMERIC, DATE (but no advanced features).
+   - Types: INTEGER, REAL, TEXT, NUMERIC, DATE (no advanced features).
    - Primary keys (pk) and foreign keys (fks) must align.
    - Provide 8–15 small, realistic seed rows per table (not huge).
 
@@ -397,29 +316,59 @@ You are designing a small relational dataset and training questions for SQL basi
 Return JSON only.
 """
 
-def llm_generate_domain_and_questions() -> Optional[Dict[str,Any]]:
-    if not OPENAI_AVAILABLE:
-        return None
-    try:
-        if USE_RESPONSES_API:
-            resp = _client.responses.create(
-                model=MODEL_ID,
-                response_format={"type":"json_schema","json_schema":DOMAIN_AND_QUESTIONS_SCHEMA},
-                input=[{"role":"user","content": DOMAIN_AND_QUESTIONS_PROMPT}],
-                temperature=0.6,
-            )
-            data_text = getattr(resp, "output_text", None)
-        else:
-            chat = _client.chat.completions.create(
-                model=MODEL_ID,
-                messages=[{"role":"user","content": DOMAIN_AND_QUESTIONS_PROMPT}],
-                temperature=0.6
-            )
-            data_text = chat.choices[0].message.content
-        obj = json.loads(data_text) if data_text else None
-        return obj
-    except Exception:
-        return None
+def llm_generate_domain_and_questions(prev_domain: Optional[str]) -> Tuple[Optional[Dict[str,Any]], Optional[str], Optional[str]]:
+    """
+    Returns (obj, error_message, model_used).
+    """
+    if not OPENAI_AVAILABLE or not os.getenv("OPENAI_API_KEY"):
+        return None, "OpenAI client not available or OPENAI_API_KEY missing.", None
+
+    errors = []
+    for model in _candidate_models():
+        try:
+            prompt = _domain_prompt(prev_domain)
+            if USE_RESPONSES_API:
+                resp = _client.responses.create(
+                    model=model,
+                    response_format={"type":"json_schema","json_schema":DOMAIN_AND_QUESTIONS_SCHEMA},
+                    input=[{"role":"user","content": prompt}],
+                    temperature=0.6,
+                )
+                data_text = getattr(resp, "output_text", None)
+                if not data_text:
+                    try:
+                        data_text = resp.output[0].content[0].text  # older SDK layout
+                    except Exception:
+                        data_text = None
+            else:
+                chat = _client.chat.completions.create(
+                    model=model,
+                    messages=[{"role":"user","content": prompt}],
+                    temperature=0.6
+                )
+                data_text = chat.choices[0].message.content
+
+            if not data_text:
+                raise RuntimeError("Empty response from model.")
+
+            obj = json.loads(data_text)
+            # Guardrails: strip RIGHT/FULL joins from answers
+            clean_qs = []
+            for q in obj.get("questions", []):
+                answers = [a for a in q.get("answer_sql", []) if " right join " not in a.lower() and " full " not in a.lower()]
+                if not answers:
+                    continue
+                q["answer_sql"] = answers
+                q.setdefault("requires_aliases", False)
+                q.setdefault("required_aliases", [])
+                clean_qs.append(q)
+            obj["questions"] = clean_qs
+            return obj, None, model
+        except Exception as e:
+            errors.append(f"{model}: {e}")
+            continue
+
+    return None, "; ".join(errors) if errors else "Unknown LLM error.", None
 
 # -------------------- Schema install & question handling --------------------
 def drop_existing_domain_tables(con: sqlite3.Connection, keep_internal=True):
@@ -440,7 +389,7 @@ def install_schema(con: sqlite3.Connection, schema: Dict[str,Any]):
     drop_existing_domain_tables(con, keep_internal=True)
     with DB_LOCK:
         cur = con.cursor()
-        # Create tables first
+        # Create tables
         for t in schema.get("tables", []):
             cols_sql = []
             pk = t.get("pk", [])
@@ -494,7 +443,7 @@ def detect_unsupported_joins(sql: str) -> Optional[str]:
     if " full join " in low or " full outer join " in low:
         return "SQLite does not support FULL OUTER JOIN. Use LEFT JOIN plus UNION for the other side."
     if " ilike " in low:
-        return "SQLite has no ILIKE. Use `LOWER(col) LIKE LOWER('%pattern%')`."
+        return "SQLite has no ILIKE. Use LOWER(col) LIKE LOWER('%pattern%')."
     return None
 
 def detect_cartesian(con: sqlite3.Connection, sql: str, df_result: pd.DataFrame) -> Optional[str]:
@@ -544,7 +493,7 @@ def aliases_present(sql: str, required_aliases: List[str]) -> bool:
             return False
     return True
 
-# -------------------- Question model --------------------
+# -------------------- Question model helpers --------------------
 @dataclass
 class SQLQuestion:
     id: str
@@ -562,36 +511,22 @@ def to_question_dict(q) -> Dict[str,Any]:
     return d
 
 def load_questions(obj_list: List[Dict[str,Any]]) -> List[Dict[str,Any]]:
-    out = []
-    for o in obj_list:
-        out.append(to_question_dict(o))
-    return out
+    return [to_question_dict(o) for o in obj_list]
 
 # -------------------- Domain bootstrap --------------------
-def bootstrap_domain_with_llm_or_fallback() -> Tuple[Dict[str,Any], List[Dict[str,Any]]]:
-    obj = llm_generate_domain_and_questions()
+def bootstrap_domain_with_llm_or_fallback(prev_domain: Optional[str]):
+    obj, err, model_used = llm_generate_domain_and_questions(prev_domain)
     if obj is None:
-        return FALLBACK_SCHEMA, FALLBACK_QUESTIONS
-    # Guardrails: strip RIGHT/FULL joins from answers
-    clean_qs = []
-    for q in obj.get("questions", []):
-        answers = [a for a in q.get("answer_sql", []) if " right join " not in a.lower() and " full " not in a.lower()]
-        if not answers:
-            continue
-        q["answer_sql"] = answers
-        q.setdefault("requires_aliases", False)
-        q.setdefault("required_aliases", [])
-        clean_qs.append(q)
-    obj["questions"] = clean_qs
-    return obj, clean_qs
-
-def install_new_domain():
-    schema, questions = bootstrap_domain_with_llm_or_fallback()
+        return FALLBACK_SCHEMA, FALLBACK_QUESTIONS, {"source":"fallback","model":None,"error":err}
+    return obj, obj["questions"], {"source":"openai","model":model_used,"error":None}
+
+def install_new_domain(prev_domain: Optional[str]):
+    schema, questions, info = bootstrap_domain_with_llm_or_fallback(prev_domain)
     install_schema(CONN, schema)
-    return schema, questions
+    return schema, questions, info
 
 # -------------------- Session state --------------------
-CURRENT_SCHEMA, CURRENT_QS = install_new_domain()
+CURRENT_SCHEMA, CURRENT_QS, CURRENT_INFO = install_new_domain(prev_domain=None)
 
 # -------------------- Progress + mastery --------------------
 def upsert_user(con: sqlite3.Connection, user_id: str, name: str):
@@ -681,7 +616,6 @@ def exec_student_sql(sql_text: str) -> Tuple[Optional[pd.DataFrame], Optional[st
                             return None, "Table created but could not be queried.", None, note
             return pd.DataFrame(), None, None, note
     except Exception as e:
-        # Tailored messages
         msg = str(e)
         if "no such table" in msg.lower():
             return None, f"{msg}. Check table names for this randomized domain.", None, note
@@ -704,7 +638,6 @@ def answer_df(answer_sql: List[str]) -> Optional[pd.DataFrame]:
             if low.startswith("select"):
                 return run_df(CONN, sql)
             if low.startswith("create view"):
-                # temp preview
                 m = re.match(r"(?is)^\s*create\s+view\s+(if\s+not\s+exists\s+)?([a-z_]\w*)\s+as\s+select.*$", low)
                 view_name = m.group(2) if m else "vw_tmp"
                 with DB_LOCK:
@@ -730,7 +663,6 @@ def answer_df(answer_sql: List[str]) -> Optional[pd.DataFrame]:
 
 def validate_answer(q: Dict[str,Any], student_sql: str, df_student: Optional[pd.DataFrame]) -> Tuple[bool, str]:
     df_expected = answer_df(q["answer_sql"])
-    # If we can't build a canonical DF (e.g., DDL side effect), accept any successful execution as correct
     if df_expected is None:
         return (df_student is not None), f"**Explanation:** Your statement executed successfully for this task."
     if df_student is None:
@@ -756,7 +688,6 @@ def start_session(name: str, session: dict):
                 gr.update(value="Please enter your name to begin.", visible=True),
                 gr.update(visible=False),
                 gr.update(visible=False),
-                None,
                 gr.update(visible=False),
                 pd.DataFrame(),
                 pd.DataFrame())
@@ -769,23 +700,21 @@ def start_session(name: str, session: dict):
 
     prompt = q["prompt_md"]
     stats = topic_stats(fetch_attempts(CONN, user_id))
-    erd = draw_dynamic_erd(CURRENT_SCHEMA)
     return (session,
             gr.update(value=f"**Question {q['id']}**\n\n{prompt}", visible=True),
             gr.update(visible=True),  # show SQL input
             gr.update(value="", visible=True),  # preview block
-            erd,
             gr.update(visible=False),  # next btn hidden until submit
             stats,
             pd.DataFrame())
 
-def render_preview_and_erd(sql_text: str, session: dict):
+def render_preview(sql_text: str, session: dict):
     if not session or "q" not in session:
-        return gr.update(value="", visible=False), draw_dynamic_erd(CURRENT_SCHEMA)
+        return gr.update(value="", visible=False)
     s = (sql_text or "").strip()
     if not s:
-        return gr.update(value="", visible=False), draw_dynamic_erd(CURRENT_SCHEMA)
-    return gr.update(value=f"**Preview:**\n\n```sql\n{s}\n```", visible=True), draw_dynamic_erd(CURRENT_SCHEMA)
+        return gr.update(value="", visible=False)
+    return gr.update(value=f"**Preview:**\n\n```sql\n{s}\n```", visible=True)
 
 def submit_answer(sql_text: str, session: dict):
     if not session or "user_id" not in session or "q" not in session:
@@ -804,7 +733,6 @@ def submit_answer(sql_text: str, session: dict):
         stats = topic_stats(fetch_attempts(CONN, user_id))
         return gr.update(value=fb, visible=True), pd.DataFrame(), gr.update(visible=True), stats
 
-    # Validate correctness
     alias_msg = None
     if q.get("requires_aliases"):
         if not aliases_present(sql_text, q.get("required_aliases", [])):
@@ -826,30 +754,29 @@ def submit_answer(sql_text: str, session: dict):
 
 def next_question(session: dict):
     if not session or "user_id" not in session:
-        return session, gr.update(value="Start a session first.", visible=True), gr.update(visible=False), draw_dynamic_erd(CURRENT_SCHEMA), gr.update(visible=False)
+        return session, gr.update(value="Start a session first.", visible=True), gr.update(visible=False), gr.update(visible=False)
     user_id = session["user_id"]
     q = pick_next_question(user_id)
     session["qid"] = q["id"]
     session["q"] = q
     session["start_ts"] = time.time()
-    return session, gr.update(value=f"**Question {q['id']}**\n\n{q['prompt_md']}", visible=True), gr.update(value="", visible=True), draw_dynamic_erd(CURRENT_SCHEMA), gr.update(visible=False)
+    return session, gr.update(value=f"**Question {q['id']}**\n\n{q['prompt_md']}", visible=True), gr.update(value="", visible=True), gr.update(visible=False)
 
 def show_hint(session: dict):
     if not session or "q" not in session:
         return gr.update(value="Start a session first.", visible=True)
-    # Lightweight hint policy: category-specific guidance
     cat = session["q"]["category"]
     hint = {
         "SELECT *": "Use `SELECT * FROM table_name`.",
         "SELECT columns": "List columns: `SELECT col1, col2 FROM table_name`.",
         "WHERE": "Filter with `WHERE` and combine conditions using AND/OR.",
-        "Aliases": "Use `table_name t` and qualify: `t.col`.",
+        "Aliases": "Use `table_name t` and qualify as `t.col`.",
         "JOIN (INNER)": "Join with `... INNER JOIN ... ON left.key = right.key`.",
         "JOIN (LEFT)": "LEFT JOIN keeps all rows from the left table.",
-        "Aggregation": "Use aggregate functions and `GROUP BY` non-aggregated columns.",
+        "Aggregation": "Use aggregates and `GROUP BY` non-aggregated columns.",
         "VIEW": "`CREATE VIEW view_name AS SELECT ...`.",
         "CTAS / SELECT INTO": "SQLite uses `CREATE TABLE name AS SELECT ...`."
-    }.get(cat, "Read the ER diagram and identify keys to join on.")
+    }.get(cat, "Identify keys from the schema and join on them.")
     return gr.update(value=f"**Hint:** {hint}", visible=True)
 
 def export_progress(user_name: str):
@@ -863,11 +790,19 @@ def export_progress(user_name: str):
     (pd.DataFrame([{"info":"No attempts yet."}]) if df.empty else df).to_csv(path, index=False)
     return path
 
+def _domain_status_md():
+    if CURRENT_INFO.get("source") == "openai":
+        return f"✅ **Domain regenerated via OpenAI** (`{CURRENT_INFO.get('model','?')}`) → **{CURRENT_SCHEMA.get('domain','?')}**. " \
+               f"Tables: {', '.join(t['name'] for t in CURRENT_SCHEMA.get('tables', []))}."
+    err = CURRENT_INFO.get("error","")
+    err_short = (err[:160] + "…") if len(err) > 160 else err
+    return f"⚠️ **OpenAI randomization unavailable** → using fallback **{CURRENT_SCHEMA.get('domain','?')}**.\n\n> Reason: {err_short}"
+
 def regenerate_domain():
-    global CURRENT_SCHEMA, CURRENT_QS
-    CURRENT_SCHEMA, CURRENT_QS = install_new_domain()
-    erd = draw_dynamic_erd(CURRENT_SCHEMA)
-    return gr.update(value="✅ Domain regenerated.", visible=True), erd
+    global CURRENT_SCHEMA, CURRENT_QS, CURRENT_INFO
+    prev = CURRENT_SCHEMA.get("domain") if CURRENT_SCHEMA else None
+    CURRENT_SCHEMA, CURRENT_QS, CURRENT_INFO = install_new_domain(prev_domain=prev)
+    return gr.update(value=_domain_status_md(), visible=True)
 
 def preview_table(tbl: str):
     try:
@@ -891,7 +826,7 @@ with gr.Blocks(title="Adaptive SQL Trainer — Randomized Domains") as demo:
         - Practice `SELECT`, `WHERE`, `JOIN` (INNER/LEFT), **aliases**, **views**, and **CTAS / SELECT INTO**.
         - The app explains **SQLite quirks** (no RIGHT/FULL JOIN) and flags likely **cartesian products**.
 
-        > Set your `OPENAI_API_KEY` in the Space secrets to enable randomization.
+        > Set your `OPENAI_API_KEY` in Space secrets to enable randomization.
         """
     )
 
@@ -905,7 +840,7 @@ with gr.Blocks(title="Adaptive SQL Trainer — Randomized Domains") as demo:
             gr.Markdown("---")
             gr.Markdown("### Dataset Controls")
             regen_btn = gr.Button("🔀 Randomize Dataset (OpenAI)")
-            regen_fb = gr.Markdown(visible=False)
+            regen_fb = gr.Markdown(_domain_status_md(), visible=True)
 
             gr.Markdown("---")
             gr.Markdown("### Instructor Tools")
@@ -925,7 +860,6 @@ with gr.Blocks(title="Adaptive SQL Trainer — Randomized Domains") as demo:
             sql_input = gr.Textbox(label="Your SQL", placeholder="Type SQL here (end ; optional).", lines=6, visible=False)
 
             preview_md = gr.Markdown(visible=False)
-            er_image = gr.Image(label="Entity Diagram", value=draw_dynamic_erd(CURRENT_SCHEMA), height=PLOT_HEIGHT)
 
             with gr.Row():
                 submit_btn = gr.Button("Run & Submit", variant="primary")
@@ -951,12 +885,12 @@ with gr.Blocks(title="Adaptive SQL Trainer — Randomized Domains") as demo:
     start_btn.click(
         start_session,
         inputs=[name_box, session_state],
-        outputs=[session_state, prompt_md, sql_input, preview_md, er_image, next_btn, mastery_df, result_df],
+        outputs=[session_state, prompt_md, sql_input, preview_md, next_btn, mastery_df, result_df],
     )
     sql_input.change(
-        render_preview_and_erd,
+        render_preview,
         inputs=[sql_input, session_state],
-        outputs=[preview_md, er_image],
+        outputs=[preview_md],
     )
     submit_btn.click(
         submit_answer,
@@ -966,7 +900,7 @@ with gr.Blocks(title="Adaptive SQL Trainer — Randomized Domains") as demo:
     next_btn.click(
         next_question,
         inputs=[session_state],
-        outputs=[session_state, prompt_md, sql_input, er_image, next_btn],
+        outputs=[session_state, prompt_md, sql_input, next_btn],
     )
     hint_btn.click(
         show_hint,
@@ -981,7 +915,7 @@ with gr.Blocks(title="Adaptive SQL Trainer — Randomized Domains") as demo:
     regen_btn.click(
         regenerate_domain,
         inputs=[],
-        outputs=[regen_fb, er_image],
+        outputs=[regen_fb],
     )
     tbl_btn.click(
         lambda name: preview_table(name),