Update app.py

app.py

@@ -57,6 +57,7 @@ DEFAULT_CONTROLLED_VOCAB_JSON = """{
   "genotoxicity_result_enum": ["positive","negative","equivocal","not_reported"]
 }"""
 
+# (Used only as a fallback / advanced preview)
 DEFAULT_FIELD_SPEC = """# One field per line: Field Name | type | instructions
 # types: str, num, bool, list[str], list[num], enum[a,b,c], list[enum[a,b,c]]
 
@@ -106,7 +107,7 @@ PRESET_CORE = [
     {"field": "Study_type", "type": "enum", "enum_values": "in_vivo,in_vitro,epidemiology,in_silico,review,methodology,other", "instructions": "Choose the best match."},
     {"field": "Exposure_route", "type": "enum", "enum_values": "oral,inhalation,dermal,parenteral,multiple,not_reported", "instructions": "Choose best match."},
     {"field": "Species", "type": "enum", "enum_values": "human,rat,mouse,rabbit,dog,non_human_primate,cell_line,other,not_reported", "instructions": "Choose best match."},
-    {"field": "Dose_metrics", "type": "list[str]", "enum_values": "", "instructions": "Include any reported NOAEL/LOAEL/BMD/BMDL/LD50/LC50 etc with units if available."},
+    {"field": "Dose_metrics", "type": "list[str]", "enum_values": "", "instructions": "Include reported NOAEL/LOAEL/BMD/BMDL/LD50/LC50 etc with units if available."},
     {"field": "Key_findings", "type": "str", "enum_values": "", "instructions": "2-4 bullet-like sentences summarizing the main findings."},
     {"field": "Conclusion", "type": "str", "enum_values": "", "instructions": "What does the paper conclude about safety/risk?"},
 ]
@@ -409,7 +410,7 @@ def openai_synthesize_across_papers(client: OpenAI, model: str, rows: List[Dict[
 
 
 # =============================
-# UI helpers: vertical view + evidence
+# UI helpers: vertical view + evidence + overview
 # =============================
 def _make_vertical(records: List[Dict[str, Any]], file_name: str) -> pd.DataFrame:
     if not records or not file_name:
@@ -437,9 +438,7 @@ def _render_evidence(details: List[Dict[str, Any]], file_name: str, max_items: i
                 quote = quote[:280] + "…"
             lines.append(f"- **{field}** (pages {pages}): “{quote}”")
     header = "### Evidence (grounding)\n"
-    if not lines:
-        lines = ["- (no evidence returned)"]
-    return header + "\n".join(lines)
+    return header + ("\n".join(lines) if lines else "- (no evidence returned)")
 
 
 def _overview_df_from_records(records: List[Dict[str, Any]]) -> pd.DataFrame:
@@ -447,14 +446,13 @@ def _overview_df_from_records(records: List[Dict[str, Any]]) -> pd.DataFrame:
         return pd.DataFrame(columns=["file","paper_title","risk_stance","risk_confidence"])
     df = pd.DataFrame(records)
     cols = ["file","paper_title","risk_stance","risk_confidence"]
-    # Include chemicals if present
-    for c in ["chemicals", "chemical_s", "chemical", "chemical_s_"]:
-        if c in df.columns and c not in cols:
-            cols.append(c)
-            break
     cols = [c for c in cols if c in df.columns]
     return df[cols].copy() if cols else df.head(50)
 
+
+# =============================
+# Controlled vocab guided editor (lists only) + SEARCH FILTER
+# =============================
 def _filter_terms_df(df: pd.DataFrame, query: str) -> pd.DataFrame:
     if df is None or df.empty:
         return pd.DataFrame(columns=["term"])
@@ -462,20 +460,8 @@ def _filter_terms_df(df: pd.DataFrame, query: str) -> pd.DataFrame:
     if not q:
         return df[["term"]].copy()
     mask = df["term"].astype(str).str.lower().str.contains(q, na=False)
-    out = df.loc[mask, ["term"]].copy()
-    return out
-
-# =============================
-# Controlled vocab guided editor (lists only)
-# =============================
-vocab_search = gr.Textbox(label="Search terms", placeholder="Type to filter (e.g., 471, AMES, comet)", lines=1)
+    return df.loc[mask, ["term"]].copy()
 
-vocab_terms_filtered = gr.Dataframe(
-    headers=["term"],
-    label="Filtered preview (read-only)",
-    interactive=False,
-    wrap=True
-)
 
 def vocab_init_state(vocab_json: str):
     try:
@@ -486,8 +472,8 @@ def vocab_init_state(vocab_json: str):
     list_keys = sorted([k for k, v in vocab.items() if isinstance(v, list)])
     default_key = list_keys[0] if list_keys else None
     terms = vocab.get(default_key, []) if default_key else []
-    terms_df = pd.DataFrame({"term": terms})
-    return vocab, list_keys, default_key, terms_df, json.dumps(vocab, indent=2), "✅ Vocab loaded."
+    full_df = pd.DataFrame({"term": terms})
+    return vocab, list_keys, default_key, full_df, json.dumps(vocab, indent=2), "✅ Vocab loaded."
 
 
 def vocab_load_category(vocab_state: Dict[str, Any], category: str, search: str):
@@ -536,13 +522,9 @@ def vocab_apply_df(vocab_state: Dict[str, Any], category: str, terms_df: Any, se
         return json.dumps(vocab_state, indent=2), pd.DataFrame(columns=["term"]), "Pick a list category first."
 
     try:
-        if isinstance(terms_df, pd.DataFrame):
-            df = terms_df
-        else:
-            df = pd.DataFrame(terms_df, columns=["term"])
+        df = terms_df if isinstance(terms_df, pd.DataFrame) else pd.DataFrame(terms_df, columns=["term"])
     except Exception:
-        vjson = json.dumps(vocab_state, indent=2)
-        return vjson, pd.DataFrame(columns=["term"]), "Could not parse terms table."
+        return json.dumps(vocab_state, indent=2), pd.DataFrame(columns=["term"]), "Could not parse terms table."
 
     terms = []
     for t in df.get("term", []).tolist():
@@ -559,6 +541,7 @@ def vocab_apply_df(vocab_state: Dict[str, Any], category: str, terms_df: Any, se
 def vocab_reset_defaults():
     return vocab_init_state(DEFAULT_CONTROLLED_VOCAB_JSON)
 
+
 def vocab_filter_preview(terms_df, search):
     try:
         df = terms_df if isinstance(terms_df, pd.DataFrame) else pd.DataFrame(terms_df, columns=["term"])
@@ -566,26 +549,12 @@ def vocab_filter_preview(terms_df, search):
         df = pd.DataFrame(columns=["term"])
     return _filter_terms_df(df, search)
 
-vocab_search.change(
-    fn=vocab_filter_preview,
-    inputs=[vocab_terms_df, vocab_search],
-    outputs=[vocab_terms_filtered]
-)
-
 
 # =============================
 # Field builder (type dropdown + presets)
 # =============================
 TYPE_CHOICES = ["str", "num", "bool", "list[str]", "list[num]", "enum", "list[enum]"]
 
-def fields_init_state():
-    # start from DEFAULT_FIELD_SPEC by showing a friendly default builder (Core + Genotox + NAMs)
-    fields = []
-    for row in (PRESET_CORE + PRESET_NAMS_INSILICO + PRESET_GENOTOX_OECD):
-        fields.append(dict(row))
-    df = pd.DataFrame(fields, columns=["field","type","enum_values","instructions"])
-    spec = build_spec_from_field_df(df)
-    return fields, df, spec, "✅ Field builder loaded."
 
 def build_spec_from_field_df(df: pd.DataFrame) -> str:
     lines = [
@@ -602,11 +571,6 @@ def build_spec_from_field_df(df: pd.DataFrame) -> str:
         if not field or not ftype:
             continue
 
-        # normalize types
-        if ftype not in TYPE_CHOICES:
-            # keep as-is, but likely invalid; user can fix
-            pass
-
         if ftype == "enum":
             vals = [v.strip() for v in enums.split(",") if v.strip()]
             type_str = f"enum[{','.join(vals)}]" if vals else "str"
@@ -620,6 +584,41 @@ def build_spec_from_field_df(df: pd.DataFrame) -> str:
 
     return "\n".join(lines).strip() + "\n"
 
+
+def fields_init_state():
+    fields = []
+    for row in (PRESET_CORE + PRESET_NAMS_INSILICO + PRESET_GENOTOX_OECD):
+        fields.append(dict(row))
+    df = pd.DataFrame(fields, columns=["field","type","enum_values","instructions"])
+    spec = build_spec_from_field_df(df)
+    return fields, df, spec, "✅ Field builder loaded."
+
+
+def fields_load_preset(preset_name: str, mode: str, field_rows: List[Dict[str, Any]]):
+    preset = PRESET_MAP.get(preset_name)
+    if not preset:
+        df = pd.DataFrame(field_rows, columns=["field","type","enum_values","instructions"])
+        return field_rows, df, build_spec_from_field_df(df), "Unknown preset."
+
+    if mode == "Replace":
+        new_rows = [dict(r) for r in preset]
+    else:
+        new_rows = [dict(r) for r in field_rows]
+        for p in preset:
+            found = False
+            for r in new_rows:
+                if str(r.get("field","")).strip().lower() == str(p.get("field","")).strip().lower():
+                    r.update(p)
+                    found = True
+                    break
+            if not found:
+                new_rows.append(dict(p))
+
+    df = pd.DataFrame(new_rows, columns=["field","type","enum_values","instructions"])
+    spec = build_spec_from_field_df(df)
+    return new_rows, df, spec, f"✅ Loaded preset: {preset_name} ({mode})."
+
+
 def fields_add_or_update(field_name: str, ftype: str, enum_values: str, instructions: str, field_rows: List[Dict[str, Any]]):
     field_name = (field_name or "").strip()
     ftype = (ftype or "").strip()
@@ -630,7 +629,6 @@ def fields_add_or_update(field_name: str, ftype: str, enum_values: str, instruct
         df = pd.DataFrame(field_rows, columns=["field","type","enum_values","instructions"])
         return field_rows, df, build_spec_from_field_df(df), "Field name and type are required."
 
-    # update if exists
     updated = False
     for r in field_rows:
         if str(r.get("field","")).strip().lower() == field_name.lower():
@@ -647,27 +645,14 @@ def fields_add_or_update(field_name: str, ftype: str, enum_values: str, instruct
     spec = build_spec_from_field_df(df)
     return field_rows, df, spec, ("Updated field." if updated else "Added field.")
 
-def fields_remove(field_to_remove: str, field_rows: List[Dict[str, Any]]):
-    key = (field_to_remove or "").strip().lower()
-    if not key:
-        df = pd.DataFrame(field_rows, columns=["field","type","enum_values","instructions"])
-        return field_rows, df, build_spec_from_field_df(df), "Pick a field to remove."
-    field_rows = [r for r in field_rows if str(r.get("field","")).strip().lower() != key]
-    df = pd.DataFrame(field_rows, columns=["field","type","enum_values","instructions"])
-    spec = build_spec_from_field_df(df)
-    return field_rows, df, spec, "Removed."
 
 def fields_apply_df(field_rows: List[Dict[str, Any]], df_in: Any):
     try:
-        if isinstance(df_in, pd.DataFrame):
-            df = df_in
-        else:
-            df = pd.DataFrame(df_in, columns=["field","type","enum_values","instructions"])
+        df = df_in if isinstance(df_in, pd.DataFrame) else pd.DataFrame(df_in, columns=["field","type","enum_values","instructions"])
     except Exception:
         df = pd.DataFrame(field_rows, columns=["field","type","enum_values","instructions"])
         return field_rows, df, build_spec_from_field_df(df), "Could not parse builder table."
 
-    # clean + rebuild list of dicts
     cleaned = []
     seen = set()
     for _, r in df.iterrows():
@@ -687,34 +672,9 @@ def fields_apply_df(field_rows: List[Dict[str, Any]], df_in: Any):
     spec = build_spec_from_field_df(df2)
     return cleaned, df2, spec, f"✅ Applied builder table ({len(cleaned)} fields)."
 
-def fields_load_preset(preset_name: str, mode: str, field_rows: List[Dict[str, Any]]):
-    preset = PRESET_MAP.get(preset_name)
-    if not preset:
-        df = pd.DataFrame(field_rows, columns=["field","type","enum_values","instructions"])
-        return field_rows, df, build_spec_from_field_df(df), "Unknown preset."
-
-    if mode == "Replace":
-        new_rows = [dict(r) for r in preset]
-    else:
-        # Append (update existing fields if same name)
-        new_rows = [dict(r) for r in field_rows]
-        for p in preset:
-            found = False
-            for r in new_rows:
-                if str(r.get("field","")).strip().lower() == str(p.get("field","")).strip().lower():
-                    r.update(p)
-                    found = True
-                    break
-            if not found:
-                new_rows.append(dict(p))
-
-    df = pd.DataFrame(new_rows, columns=["field","type","enum_values","instructions"])
-    spec = build_spec_from_field_df(df)
-    return new_rows, df, spec, f"✅ Loaded preset: {preset_name} ({mode})."
-
 
 # =============================
-# Extraction handler
+# Main extraction handler
 # =============================
 def run_extraction(
     files,
@@ -757,7 +717,7 @@ def run_extraction(
         pages, page_count = extract_pages_from_pdf(pdf_path, max_pages=int(max_pages))
 
         if _text_based_pdf_warning(pages):
-            results.append({
+            ex = {
                 "_file": filename,
                 "_pages_in_pdf": page_count,
                 "paper_title": "",
@@ -766,10 +726,10 @@ def run_extraction(
                 "risk_summary": "No extractable text found. This app supports text-based PDFs only.",
                 "extracted": {k: ([] if field_props[k].get("type") == "array" else "") for k in field_props.keys()},
                 "evidence": []
-            })
+            }
+            results.append(ex)
         else:
             chunks = chunk_pages(pages, target_chars=int(chunk_chars))
-
             queries = ["regulatory acceptability risk hazard concern conclusion adverse effect uncertainty noael loael bmd bmdl"]
             for k, ins in field_instr.items():
                 queries.append(ins if ins else k)
@@ -789,7 +749,6 @@ def run_extraction(
             extracted["_pages_in_pdf"] = page_count
             results.append(extracted)
 
-        # flatten to internal records for vertical view + review/export
         ex = results[-1]
         row = {
             "file": filename,
@@ -819,7 +778,6 @@ def run_extraction(
     default = choices[0] if choices else None
     vertical = _make_vertical(records, default)
     evidence = _render_evidence(results, default)
-
     overview = _overview_df_from_records(records)
 
     status = "Done. Use the vertical view + evidence for review. Export reviewed CSV when ready."
@@ -842,18 +800,17 @@ def run_extraction(
 def on_pick(file_name: str, records: List[Dict[str, Any]], details: List[Dict[str, Any]]):
     return _make_vertical(records, file_name), _render_evidence(details, file_name)
 
+
 def toggle_review_mode(is_on: bool):
     return gr.update(interactive=bool(is_on))
 
+
 def save_review_changes(file_name: str, vertical_df: Any, records: List[Dict[str, Any]]):
     if not file_name or not records:
         return pd.DataFrame(), records, "Nothing to save."
 
     try:
-        if isinstance(vertical_df, pd.DataFrame):
-            dfv = vertical_df
-        else:
-            dfv = pd.DataFrame(vertical_df, columns=["Field", "Value"])
+        dfv = vertical_df if isinstance(vertical_df, pd.DataFrame) else pd.DataFrame(vertical_df, columns=["Field", "Value"])
     except Exception:
         return _overview_df_from_records(records), records, "Could not parse edited vertical table."
 
@@ -875,6 +832,7 @@ def save_review_changes(file_name: str, vertical_df: Any, records: List[Dict[str
     msg = "Saved changes into session data. Export reviewed CSV to download." if updated else "Record not found."
     return _overview_df_from_records(new_records), new_records, msg
 
+
 def export_reviewed_csv(records: List[Dict[str, Any]]):
     if not records:
         return None, "No reviewed data to export."
@@ -885,7 +843,7 @@ def export_reviewed_csv(records: List[Dict[str, Any]]):
 
 
 # =============================
-# Synthesis
+# Synthesis tab handler
 # =============================
 def run_synthesis(api_key, model, extraction_json_file):
     if extraction_json_file is None:
@@ -907,15 +865,14 @@ with gr.Blocks(title="Toxicology PDF → Grounded Extractor") as demo:
     gr.Markdown(
         "# Toxicology PDF → Grounded Extractor (GPT-4o)\n\n"
         "**Important:** Text-based PDFs only (not scanned/image PDFs). If no extractable text is found, the record is marked `insufficient_data`.\n\n"
-        "This UI is optimized for non-JSON users: **Controlled vocab editor** + **Field Builder**.\n"
-        "Raw JSON/spec are available under **Advanced**."
+        "UI includes a guided **Controlled Vocab editor** (lists only, with search) and a **Field Builder** (type dropdown + presets)."
     )
 
-    # State
-    state_records = gr.State([])    # list[dict]
-    state_details = gr.State([])    # list[dict]
-    vocab_state = gr.State({})      # dict
-    field_rows_state = gr.State([]) # list[dict]
+    # States
+    state_records = gr.State([])     # list[dict]
+    state_details = gr.State([])     # list[dict]
+    vocab_state = gr.State({})       # dict
+    field_rows_state = gr.State([])  # list[dict]
 
     with gr.Tab("Extract"):
         files = gr.File(label="Upload toxicology PDFs", file_types=[".pdf"], file_count="multiple")
@@ -933,94 +890,69 @@ with gr.Blocks(title="Toxicology PDF → Grounded Extractor") as demo:
         # Controlled Vocabulary (guided editor)
         # -------------------------
         gr.Markdown("## Controlled Vocabulary (guided editor)")
-        
-        vocab_mode = gr.Radio(
-            choices=["Guided", "Advanced (Raw JSON)"],
-            value="Guided",
-            label="Vocab editor mode"
-        )
-        
+
         vocab_category = gr.Dropdown(label="Category (lists only)", choices=[], value=None)
-        
-        # NEW: Search box
-        vocab_search = gr.Textbox(
-            label="Search terms",
-            placeholder="Type to filter (e.g., 471, AMES, comet)",
-            lines=1
-        )
-        
+        vocab_search = gr.Textbox(label="Search terms", placeholder="Type to filter (e.g., 471, AMES, comet)", lines=1)
+
         with gr.Row():
             vocab_term_add = gr.Textbox(label="Add term", placeholder="type term and click Add")
             vocab_add_btn = gr.Button("Add")
-        
         with gr.Row():
             vocab_term_remove = gr.Textbox(label="Remove term", placeholder="type exact term and click Remove")
             vocab_remove_btn = gr.Button("Remove")
-            vocab_apply_btn = gr.Button("Apply table changes to category")
+            vocab_apply_btn = gr.Button("Apply full list to category")
             vocab_reset_btn = gr.Button("Reset vocab to defaults")
-        
-        # IMPORTANT: define vocab_terms_df BEFORE using it in any event wiring
+
         vocab_terms_df = gr.Dataframe(
             headers=["term"],
             label="Terms (full list; edit directly)",
             interactive=True,
             wrap=True
         )
-        
-        # NEW: filtered preview (read-only)
+
         vocab_terms_filtered = gr.Dataframe(
             headers=["term"],
             label="Filtered preview (read-only)",
             interactive=False,
             wrap=True
         )
-        
+
         vocab_status = gr.Textbox(label="Vocab status", interactive=False)
-        
+
         with gr.Accordion("Advanced: Raw vocab JSON (auto-generated)", open=False):
             vocab_json = gr.Textbox(label="Controlled vocab JSON", lines=12, interactive=False)
-        
-        # -------------------------
-        # Filtering helper + event
-        # -------------------------
-        def vocab_filter_preview(terms_df, search):
-            try:
-                df = terms_df if isinstance(terms_df, pd.DataFrame) else pd.DataFrame(terms_df, columns=["term"])
-            except Exception:
-                df = pd.DataFrame(columns=["term"])
-            return _filter_terms_df(df, search)
-        
-        # Wire events AFTER components exist
-        vocab_category.change(
-            fn=vocab_load_category,
-            inputs=[vocab_state, vocab_category, vocab_search],
-            outputs=[vocab_terms_df, vocab_terms_filtered, vocab_status]
-        )
-        
+
+        # Filter preview wiring (must be AFTER vocab_terms_df exists)
         vocab_search.change(
             fn=vocab_filter_preview,
             inputs=[vocab_terms_df, vocab_search],
             outputs=[vocab_terms_filtered]
         )
-        
+
+        vocab_category.change(
+            fn=vocab_load_category,
+            inputs=[vocab_state, vocab_category, vocab_search],
+            outputs=[vocab_terms_df, vocab_terms_filtered, vocab_status]
+        )
+
         vocab_add_btn.click(
             fn=vocab_add_term,
             inputs=[vocab_state, vocab_category, vocab_term_add, vocab_search],
             outputs=[vocab_terms_df, vocab_terms_filtered, vocab_term_add, vocab_status]
         )
-        
+
         vocab_remove_btn.click(
             fn=vocab_remove_term,
             inputs=[vocab_state, vocab_category, vocab_term_remove, vocab_search],
             outputs=[vocab_terms_df, vocab_terms_filtered, vocab_term_remove, vocab_status]
         )
-        
+
         vocab_apply_btn.click(
             fn=vocab_apply_df,
             inputs=[vocab_state, vocab_category, vocab_terms_df, vocab_search],
             outputs=[vocab_json, vocab_terms_filtered, vocab_status]
         )
-        
+
         vocab_reset_btn.click(
             fn=vocab_reset_defaults,
             inputs=None,
@@ -1031,8 +963,11 @@ with gr.Blocks(title="Toxicology PDF → Grounded Extractor") as demo:
             outputs=[vocab_terms_df, vocab_terms_filtered, vocab_status]
         )
 
-
+        # -------------------------
+        # Field Builder
+        # -------------------------
         gr.Markdown("## Extraction Spec (Field Builder)")
+
         with gr.Row():
             preset_name = gr.Dropdown(label="Preset", choices=list(PRESET_MAP.keys()), value="Core (recommended)")
             preset_mode = gr.Radio(label="Preset mode", choices=["Replace", "Append"], value="Append")
@@ -1041,30 +976,48 @@ with gr.Blocks(title="Toxicology PDF → Grounded Extractor") as demo:
         with gr.Row():
             field_name_in = gr.Textbox(label="Field name", placeholder="e.g., Genotoxicity_result")
             field_type_in = gr.Dropdown(label="Type", choices=TYPE_CHOICES, value="str")
-        enum_values_in = gr.Textbox(label="Enum values (comma-separated; used for enum/list[enum])", placeholder="a,b,c", lines=2)
+        enum_values_in = gr.Textbox(label="Enum values (comma-separated; for enum/list[enum])", placeholder="a,b,c", lines=2)
         instructions_in = gr.Textbox(label="Instructions", placeholder="Tell the extractor exactly what to pull.", lines=2)
 
-        with gr.Row():
-            add_update_field_btn = gr.Button("Add/Update field")
-            remove_field_name = gr.Dropdown(label="Remove field", choices=[], value=None)
-            remove_field_btn = gr.Button("Remove")
+        add_update_field_btn = gr.Button("Add/Update field")
 
         fields_df = gr.Dataframe(
-            label="Fields (edit if needed, then click Apply)",
+            label="Fields (edit and click Apply)",
             headers=["field","type","enum_values","instructions"],
             interactive=True,
             wrap=True
         )
+
         fields_apply_btn = gr.Button("Apply builder table")
         fields_status = gr.Textbox(label="Field builder status", interactive=False)
 
         with gr.Accordion("Advanced: Raw extraction spec (auto-generated)", open=False):
             field_spec = gr.Textbox(label="Extraction spec", lines=12, interactive=False)
 
+        preset_btn.click(
+            fn=fields_load_preset,
+            inputs=[preset_name, preset_mode, field_rows_state],
+            outputs=[field_rows_state, fields_df, field_spec, fields_status]
+        )
+
+        add_update_field_btn.click(
+            fn=fields_add_or_update,
+            inputs=[field_name_in, field_type_in, enum_values_in, instructions_in, field_rows_state],
+            outputs=[field_rows_state, fields_df, field_spec, fields_status]
+        )
+
+        fields_apply_btn.click(
+            fn=fields_apply_df,
+            inputs=[field_rows_state, fields_df],
+            outputs=[field_rows_state, fields_df, field_spec, fields_status]
+        )
+
+        # -------------------------
+        # Run extraction
+        # -------------------------
         extract_btn = gr.Button("Run Extraction (Grounded)")
         status = gr.Textbox(label="Status", interactive=False)
 
-        # Replace wide table with a compact overview (not duplicate)
         overview_df = gr.Dataframe(
             label="Batch Overview (compact)",
             interactive=False,
@@ -1097,111 +1050,18 @@ with gr.Blocks(title="Toxicology PDF → Grounded Extractor") as demo:
         evidence_md = gr.Markdown()
         reviewed_csv = gr.File(label="Download: reviewed_extraction_table.csv")
 
-        # -------------------------
-        # INIT vocab + fields on load (via a button-less trick: use .load)
-        # -------------------------
-        def _init_all():
-            v, keys, k0, df_terms, vjson, vmsg = vocab_init_state(DEFAULT_CONTROLLED_VOCAB_JSON)
-            frows, fdf, fspec, fmsg = fields_init_state()
-            remove_choices = [r["field"] for r in frows]
-            return (
-                v, gr.update(choices=keys, value=k0), df_terms, vjson, vmsg,
-                frows, fdf, fspec, fmsg, gr.update(choices=remove_choices, value=(remove_choices[0] if remove_choices else None))
-            )
-
-        demo.load(
-            _init_all,
-            inputs=None,
-            outputs=[vocab_state, vocab_category, vocab_terms_df, vocab_json, vocab_status,
-                     field_rows_state, fields_df, field_spec, fields_status, remove_field_name]
-        )
-
-        # Vocab events
-        vocab_category.change(
-            fn=vocab_load_category,
-            inputs=[vocab_state, vocab_category, vocab_search],
-            outputs=[vocab_terms_df, vocab_terms_filtered, vocab_status]
-        )
-        vocab_add_btn.click(
-            fn=vocab_add_term,
-            inputs=[vocab_state, vocab_category, vocab_term_add, vocab_search],
-            outputs=[vocab_terms_df, vocab_terms_filtered, vocab_term_add, vocab_status]
-        )
-
-        vocab_remove_btn.click(
-            fn=vocab_remove_term,
-            inputs=[vocab_state, vocab_category, vocab_term_remove, vocab_search],
-            outputs=[vocab_terms_df, vocab_terms_filtered, vocab_term_remove, vocab_status]
-        )
-
-        vocab_apply_btn.click(
-            fn=vocab_apply_df,
-            inputs=[vocab_state, vocab_category, vocab_terms_df, vocab_search],
-            outputs=[vocab_json, vocab_terms_filtered, vocab_status]
-        )
-
-        vocab_reset_btn.click(
-            fn=vocab_reset_defaults,
-            inputs=None,
-            outputs=[vocab_state, vocab_category, vocab_terms_df, vocab_json, vocab_status]
-        )
-
-        # Field builder events
-        preset_btn.click(
-            fn=fields_load_preset,
-            inputs=[preset_name, preset_mode, field_rows_state],
-            outputs=[field_rows_state, fields_df, field_spec, fields_status]
-        ).then(
-            fn=lambda rows: gr.update(choices=[r["field"] for r in rows], value=None),
-            inputs=[field_rows_state],
-            outputs=[remove_field_name]
-        )
-
-        add_update_field_btn.click(
-            fn=fields_add_or_update,
-            inputs=[field_name_in, field_type_in, enum_values_in, instructions_in, field_rows_state],
-            outputs=[field_rows_state, fields_df, field_spec, fields_status]
-        ).then(
-            fn=lambda rows: gr.update(choices=[r["field"] for r in rows], value=None),
-            inputs=[field_rows_state],
-            outputs=[remove_field_name]
-        )
-
-        remove_field_btn.click(
-            fn=fields_remove,
-            inputs=[remove_field_name, field_rows_state],
-            outputs=[field_rows_state, fields_df, field_spec, fields_status]
-        ).then(
-            fn=lambda rows: gr.update(choices=[r["field"] for r in rows], value=None),
-            inputs=[field_rows_state],
-            outputs=[remove_field_name]
-        )
-
-        fields_apply_btn.click(
-            fn=fields_apply_df,
-            inputs=[field_rows_state, fields_df],
-            outputs=[field_rows_state, fields_df, field_spec, fields_status]
-        ).then(
-            fn=lambda rows: gr.update(choices=[r["field"] for r in rows], value=None),
-            inputs=[field_rows_state],
-            outputs=[remove_field_name]
-        )
-
-        # Extraction
         extract_btn.click(
             fn=run_extraction,
             inputs=[files, api_key, model, field_spec, vocab_json, max_pages, chunk_chars, max_context_chars],
             outputs=[overview_df, out_csv, out_json, status, record_pick, state_records, state_details, vertical_view, evidence_md]
         )
 
-        # Vertical view selection
         record_pick.change(
             fn=on_pick,
             inputs=[record_pick, state_records, state_details],
             outputs=[vertical_view, evidence_md]
         )
 
-        # Review mode
         review_mode.change(fn=toggle_review_mode, inputs=[review_mode], outputs=[vertical_view])
 
         save_btn.click(
@@ -1216,6 +1076,43 @@ with gr.Blocks(title="Toxicology PDF → Grounded Extractor") as demo:
             outputs=[reviewed_csv, review_status]
         )
 
+        # -------------------------
+        # Initialize vocab + fields on load
+        # -------------------------
+        def _init_all():
+            v, keys, k0, full_df, vjson, vmsg = vocab_init_state(DEFAULT_CONTROLLED_VOCAB_JSON)
+            filtered_df = _filter_terms_df(full_df, "")
+            frows, fdf, fspec, fmsg = fields_init_state()
+            return (
+                v,
+                gr.update(choices=keys, value=k0),
+                full_df,
+                filtered_df,
+                vjson,
+                vmsg,
+                frows,
+                fdf,
+                fspec,
+                fmsg
+            )
+
+        demo.load(
+            _init_all,
+            inputs=None,
+            outputs=[
+                vocab_state,
+                vocab_category,
+                vocab_terms_df,
+                vocab_terms_filtered,
+                vocab_json,
+                vocab_status,
+                field_rows_state,
+                fields_df,
+                field_spec,
+                fields_status
+            ]
+        )
+
     with gr.Tab("Cross-paper Synthesis"):
         gr.Markdown("Upload `extraction_details.json` from Extract. Synthesis is based strictly on grounded extractions.")
         api_key2 = gr.Textbox(label="OpenAI API key (optional if set as OPENAI_API_KEY secret)", type="password")