feat: run history tab, semantics batching, tag v2 fallback, fixes

- Add Run History admin tab with 10/50/100/All selector + email filter
- Log company/use_case in session meta for run tracking
- Fix Custom vertical: also disable Function dropdown (like Line)
- model_semantic_updater: batch columns in groups of 25, add 60s timeout
- thoughtspot_deployer: fix empty tag log, add v2 tag API fallback for models
- Fix [OK] 0 columns enriched → [WARN] when semantics returns nothing
- Add 5-min hard timeout to MCP liveboard creation (asyncio.wait_for)
- Add pipeline summary (model + liveboard URLs) before pipeline complete
- Existing model path: use create_liveboard_from_model_mcp with real ts_client

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

chat_interface.py

@@ -1744,6 +1744,8 @@ To change settings, use:
             generic_context: Additional context provided by user for generic use cases
         """
         _slog = self._session_logger
+        if _slog:
+            _slog.log("run", "run started", company=company or '', use_case=use_case or '')
         _t = _slog.log_start("research") if _slog else None
 
         print(f"\n\n[CACHE DEBUG] === run_research_streaming called ===")
@@ -3574,8 +3576,9 @@ Tables: Created and populated
             self.log_feedback(f"Using existing model: {existing_model_guid}")
             
             try:
-                from liveboard_creator import create_liveboard_from_model
-                
+                from liveboard_creator import create_liveboard_from_model_mcp
+                from thoughtspot_deployer import ThoughtSpotDeployer
+
                 # Get ThoughtSpot settings
                 ts_url = get_admin_setting('THOUGHTSPOT_URL')
                 ts_user = self._get_effective_user_email()
@@ -3583,12 +3586,10 @@ Tables: Created and populated
                 if not ts_secret:
                     raise ValueError("ThoughtSpot trusted auth key not set. Select a TS environment from the dropdown.")
 
-                liveboard_method = 'HYBRID'  # Only HYBRID method is supported
-                
                 # Clean company name for display (strip .com, .org, etc)
                 clean_company = company.split('.')[0].title() if '.' in company else company
                 liveboard_name = self.settings.get('liveboard_name', '') or f"{clean_company} - {use_case}"
-                
+
                 # Get company data for liveboard
                 company_data = {
                     'name': clean_company,
@@ -3597,18 +3598,27 @@ Tables: Created and populated
                     'primary_color': getattr(self.demo_builder, 'primary_color', '#3498db'),
                     'secondary_color': getattr(self.demo_builder, 'secondary_color', '#2c3e50')
                 }
-                
-                yield f"**Creating Liveboard from Existing Model**\n\nMethod: {liveboard_method}\nModel: `{existing_model_guid}`\n\n"
-                
-                # Create liveboard
-                liveboard_result = create_liveboard_from_model(
+
+                yield f"**Creating Liveboard from Existing Model**\n\nModel: `{existing_model_guid}`\n\n"
+
+                # Auth a deployer so we can pass ts_client to MCP
+                ts_client = ThoughtSpotDeployer(ts_url, ts_user, ts_secret)
+                if not ts_client.authenticate():
+                    raise ValueError("ThoughtSpot authentication failed.")
+
+                llm_model = self.settings.get('model', DEFAULT_LLM_MODEL)
+
+                # Create liveboard via HYBRID (MCP) path
+                liveboard_result = create_liveboard_from_model_mcp(
+                    ts_client=ts_client,
                     model_id=existing_model_guid,
-                    model_name="Existing Model",  # We don't have the name
-                    use_case=use_case,
+                    model_name="Existing Model",
                     company_data=company_data,
+                    use_case=use_case,
+                    num_visualizations=8,
                     liveboard_name=liveboard_name,
-                    method=liveboard_method,
-                    num_visualizations=8
+                    llm_model=llm_model,
+                    prompt_logger=self._prompt_logger,
                 )
                 
                 if liveboard_result.get('success'):
@@ -4775,6 +4785,129 @@ def create_chat_interface():
                     with gr.Tab("🧩 Matrix"):
                         matrix_components = create_matrix_tab(interface)
 
+                    with gr.Tab("📊 Run History"):
+                        gr.Markdown("### Pipeline Run History")
+                        gr.Markdown("*Every pipeline run — who ran it, whether it succeeded, and where it failed.*")
+                        with gr.Row():
+                            run_history_refresh_btn = gr.Button("🔄 Refresh", size="sm")
+                            run_history_email_filter = gr.Textbox(label="Filter by email", placeholder="user@company.com", scale=2)
+                            run_history_limit = gr.Dropdown(
+                                label="Show",
+                                choices=["10", "50", "100", "All"],
+                                value="10",
+                                scale=1,
+                            )
+                        run_history_display = gr.Dataframe(
+                            headers=["Time (UTC)", "User", "Company", "Use Case", "Status", "Failed At", "Duration"],
+                            datatype=["str", "str", "str", "str", "str", "str", "str"],
+                            column_widths=["130px", "210px", "140px", "160px", "100px", "220px", "80px"],
+                            interactive=False,
+                            label="Runs",
+                            wrap=True,
+                        )
+
+                        def load_run_history(email_filter="", limit_choice="10"):
+                            try:
+                                from supabase_client import SupabaseSettings
+                                from datetime import datetime as _dt
+                                ss = SupabaseSettings()
+                                if not ss.is_enabled():
+                                    return [["Supabase not configured", "", "", "", "", "", ""]]
+
+                                display_limit = None if limit_choice == "All" else int(limit_choice)
+                                # Fetch enough raw rows to aggregate into desired number of sessions
+                                fetch_limit = 2000 if limit_choice == "All" else max(500, (display_limit or 10) * 20)
+
+                                query = ss.client.table("session_logs") \
+                                    .select("session_id,user_email,ts,stage,event,duration_ms,error,meta") \
+                                    .order("ts", desc=True) \
+                                    .limit(fetch_limit)
+                                if email_filter and email_filter.strip():
+                                    query = query.eq("user_email", email_filter.strip())
+                                result = query.execute()
+                                rows = result.data or []
+
+                                # Group by session_id
+                                sessions = {}
+                                for row in rows:
+                                    sid = row.get('session_id', '')
+                                    if not sid:
+                                        continue
+                                    if sid not in sessions:
+                                        sessions[sid] = {
+                                            'user': row.get('user_email', ''),
+                                            'events': [],
+                                            'start_ts': row.get('ts', ''),
+                                            'end_ts': row.get('ts', ''),
+                                            'errors': [],
+                                            'stages': [],
+                                            'meta': {},
+                                        }
+                                    s = sessions[sid]
+                                    s['events'].append(row.get('event', ''))
+                                    ts = row.get('ts', '')
+                                    if ts and ts < s['start_ts']:
+                                        s['start_ts'] = ts
+                                    if ts and ts > s['end_ts']:
+                                        s['end_ts'] = ts
+                                    if row.get('error'):
+                                        s['errors'].append(f"{row.get('stage','?')}: {row.get('error','')[:100]}")
+                                    stage = row.get('stage')
+                                    if stage and stage not in s['stages']:
+                                        s['stages'].append(stage)
+                                    if row.get('meta'):
+                                        s['meta'].update(row.get('meta') or {})
+
+                                sorted_sessions = sorted(sessions.items(), key=lambda x: x[1]['start_ts'], reverse=True)
+                                if display_limit:
+                                    sorted_sessions = sorted_sessions[:display_limit]
+
+                                display_rows = []
+                                for sid, s in sorted_sessions:
+                                    has_failed = any('failed' in e for e in s['events'])
+                                    has_completed = any('completed' in e for e in s['events'])
+                                    if has_failed:
+                                        status = '❌ Failed'
+                                        failed_at = s['errors'][0][:80] if s['errors'] else 'unknown'
+                                    elif has_completed:
+                                        status = '✅ Success'
+                                        failed_at = ''
+                                    else:
+                                        status = '⏳ In Progress'
+                                        failed_at = ''
+
+                                    company = s['meta'].get('company', '') or s['meta'].get('company_name', '')
+                                    use_case = s['meta'].get('use_case', '')
+
+                                    try:
+                                        start = _dt.fromisoformat(s['start_ts'].replace('Z', '+00:00'))
+                                        end = _dt.fromisoformat(s['end_ts'].replace('Z', '+00:00'))
+                                        dur_s = int((end - start).total_seconds())
+                                        dur_str = f"{dur_s//60}m {dur_s%60}s" if dur_s >= 60 else f"{dur_s}s"
+                                    except Exception:
+                                        dur_str = ''
+
+                                    display_rows.append([
+                                        s['start_ts'][:16].replace('T', ' '),
+                                        s['user'],
+                                        company,
+                                        use_case,
+                                        status,
+                                        failed_at,
+                                        dur_str,
+                                    ])
+
+                                return display_rows if display_rows else [["No runs found", "", "", "", "", "", ""]]
+                            except Exception as e:
+                                return [[f"Error: {e}", "", "", "", "", "", ""]]
+
+                        run_history_refresh_btn.click(
+                            fn=load_run_history,
+                            inputs=[run_history_email_filter, run_history_limit],
+                            outputs=[run_history_display]
+                        )
+                        interface.load(fn=load_run_history, inputs=[], outputs=[run_history_display])
+
                 # Check admin status and toggle admin-only settings visibility
         def check_admin_visibility(request: gr.Request):
             """Check if logged-in user is admin and toggle settings visibility."""
@@ -5168,23 +5301,25 @@ def create_chat_tab(chat_controller_state, settings, current_stage, current_mode
         msg.submit(fn=send_message, inputs=_send_inputs, outputs=_send_outputs)
         send_btn.click(fn=send_message, inputs=_send_inputs, outputs=_send_outputs)
         
-        # App tab: vertical → line cascade
+        # App tab: vertical → line + function cascade
         def update_line_on_vertical(vertical):
             lines = VERTICAL_LINES.get(vertical, [])
             if vertical == "Custom" or not lines:
                 return (
                     gr.Dropdown(choices=[], value=None, interactive=False),
-                    gr.Textbox(label="Context *", placeholder="Describe your use case...", interactive=True),
+                    gr.Dropdown(choices=[], value=None, interactive=False),
+                    gr.Textbox(label="Context *", placeholder="Describe your use case, industry, and key metrics...", interactive=True),
                 )
             return (
                 gr.Dropdown(choices=lines, value=lines[0], interactive=True),
+                gr.Dropdown(choices=DEMO_FUNCTIONS, value=DEMO_FUNCTIONS[0], interactive=True),
                 gr.Textbox(label="Context", placeholder="Any extra context for the demo...", interactive=True),
             )
 
         vertical_dd.change(
             fn=update_line_on_vertical,
             inputs=[vertical_dd],
-            outputs=[line_dd, additional_info_input]
+            outputs=[line_dd, function_dd, additional_info_input]
         )
 
         # Defined tab: GO button handler

model_semantic_updater.py

@@ -29,7 +29,7 @@ class ModelSemanticUpdater:
         # json_object response_format which requires OpenAI.
         resolved = resolve_model_name(llm_model)
         self.llm_model = resolved if is_openai_model_name(resolved) else resolve_model_name(DEFAULT_LLM_MODEL)
-        self.openai_client = create_openai_client()
+        self.openai_client = create_openai_client(timeout=60, max_retries=2)
 
     # ------------------------------------------------------------------
     # TML export / import helpers
@@ -166,14 +166,20 @@ Write only the description, nothing else."""
         use_case_line = f"\nUse case: {use_case}" if use_case else ""
         company_line = f"\nCompany: {company_name}" if company_name else ""
 
-        prompt = f"""You are a data analyst enriching a ThoughtSpot analytics model with semantic metadata.
+        # Batch columns into groups of 25 — 107 columns at 4000 tokens = truncated JSON.
+        # Each batch gets its own LLM call so we never hit the output token ceiling.
+        BATCH_SIZE = 25
+        results: Dict[str, Dict] = {}
+        for batch_start in range(0, len(column_info), BATCH_SIZE):
+            batch = column_info[batch_start:batch_start + BATCH_SIZE]
+            batch_prompt = f"""You are a data analyst enriching a ThoughtSpot analytics model with semantic metadata.
 {company_line}{use_case_line}
 
 Company/Industry Context:
 {research_snippet}
 
-Columns in this model:
-{json.dumps(column_info, indent=2)}
+Columns in this batch:
+{json.dumps(batch, indent=2)}
 
 For EVERY column listed, generate three fields:
 
@@ -199,20 +205,23 @@ Return a JSON object keyed by the exact column name:
     "ai_context": "..."
   }}
 }}"""
-
-        try:
-            token_kwargs = build_openai_chat_token_kwargs(self.llm_model, 4000)
-            response = self.openai_client.chat.completions.create(
-                model=self.llm_model,
-                messages=[{"role": "user", "content": prompt}],
-                response_format={"type": "json_object"},
-                temperature=0.3,
-                **token_kwargs,
-            )
-            return json.loads(response.choices[0].message.content)
-        except Exception as e:
-            print(f"Error generating column semantics: {e}")
-            return {}
+            try:
+                # ~200 tokens per column is comfortable for desc + synonyms + ai_context
+                batch_max_tokens = max(2000, len(batch) * 200)
+                token_kwargs = build_openai_chat_token_kwargs(self.llm_model, batch_max_tokens)
+                response = self.openai_client.chat.completions.create(
+                    model=self.llm_model,
+                    messages=[{"role": "user", "content": batch_prompt}],
+                    response_format={"type": "json_object"},
+                    temperature=0.3,
+                    **token_kwargs,
+                )
+                batch_result = json.loads(response.choices[0].message.content)
+                results.update(batch_result)
+                print(f"  [Semantics] Batch {batch_start//BATCH_SIZE + 1}: enriched {len(batch_result)} columns")
+            except Exception as e:
+                print(f"  [Semantics] Batch {batch_start//BATCH_SIZE + 1} failed: {e}")
+        return results
 
     # ------------------------------------------------------------------
     # TML mutation

thoughtspot_deployer.py

@@ -1737,11 +1737,25 @@ class ThoughtSpotDeployer:
                 print(f"[ThoughtSpot]    ✅ Tagged {len(object_guids)} {object_type} objects with '{tag_name}'", flush=True)
                 return True
             else:
-                print(f"[ThoughtSpot]    ⚠️  Tag assignment failed: {assign_response.status_code}", flush=True)
-                print(f"[ThoughtSpot]    DEBUG: Response text: {assign_response.text[:500]}", flush=True)
-                print(f"[ThoughtSpot]    DEBUG: Object GUIDs: {object_guids}", flush=True)
-                print(f"[ThoughtSpot]    DEBUG: Object type: {object_type}", flush=True)
-                return False
+                print(f"[ThoughtSpot]    ⚠️  v1 tag assignment failed ({assign_response.status_code}), trying v2 API...", flush=True)
+                # v1 API returns 404 for models — fall back to v2
+                try:
+                    v2_response = self.session.post(
+                        f"{self.base_url}/api/rest/2.0/tags/assign",
+                        json={
+                            "tag_identifiers": [tag_name],
+                            "metadata": [{"identifier": guid, "type": object_type} for guid in object_guids]
+                        }
+                    )
+                    if v2_response.status_code in [200, 204]:
+                        print(f"[ThoughtSpot]    ✅ Tagged {len(object_guids)} {object_type} objects with '{tag_name}' (v2)", flush=True)
+                        return True
+                    else:
+                        print(f"[ThoughtSpot]    ⚠️  v2 tag assignment also failed: {v2_response.status_code} — {v2_response.text[:300]}", flush=True)
+                        return False
+                except Exception as v2_err:
+                    print(f"[ThoughtSpot]    ⚠️  v2 tag assignment error: {v2_err}", flush=True)
+                    return False
                 
         except Exception as e:
             print(f"[ThoughtSpot]    ⚠️  Tag assignment error: {str(e)}", flush=True)
@@ -2225,9 +2239,9 @@ class ThoughtSpotDeployer:
                         results['model_guid'] = model_guid
                         
                         # Assign tag to model
-                        print(f"🔍 DEBUG BEFORE TAG CALL: tag_name='{tag_name}', model_guid='{model_guid}'")
-                        log_progress(f"Assigning tag '{tag_name}' to model...")
-                        self.assign_tags_to_objects([model_guid], 'LOGICAL_TABLE', tag_name)
+                        if tag_name and model_guid:
+                            log_progress(f"Assigning tag '{tag_name}' to model...")
+                            self.assign_tags_to_objects([model_guid], 'LOGICAL_TABLE', tag_name)
 
                         # Share model
                         _effective_share = share_with or get_admin_setting('SHARE_WITH', required=False)
@@ -2281,7 +2295,10 @@ class ThoughtSpotDeployer:
                                             # Parse back so we can still dump consistently below
                                             model_tml_dict = yaml.safe_load(enriched_yaml)
                                             sem_time = time.time() - sem_start
-                                            log_progress(f"[OK] Semantics generated: {len(column_semantics)} columns enriched ({sem_time:.1f}s)")
+                                            if column_semantics:
+                                                log_progress(f"[OK] Semantics generated: {len(column_semantics)} columns enriched ({sem_time:.1f}s)")
+                                            else:
+                                                log_progress(f"[WARN] Semantics generation returned 0 columns — LLM call may have failed ({sem_time:.1f}s)")
                                         except Exception as sem_err:
                                             log_progress(f"[WARN] Semantic enrichment failed (non-fatal): {sem_err}")
 
@@ -2557,7 +2574,27 @@ class ThoughtSpotDeployer:
 
             # Mark as successful if we got this far
             results['success'] = len(results['errors']) == 0
-            
+
+            # Log summary with clickable links before returning
+            ts_base = self.base_url.rstrip('/')
+            model_guid = results.get('model_guid', '')
+            liveboard_guid = results.get('liveboard_guid', '')
+            lb_url = results.get('liveboard_url', '')
+            if not lb_url and liveboard_guid:
+                lb_url = f"{ts_base}/#/pinboard/{liveboard_guid}"
+            model_url = f"{ts_base}/#/data/tables/{model_guid}" if model_guid else ''
+
+            log_progress("─" * 40)
+            if results['success']:
+                log_progress("✅ Pipeline complete")
+            else:
+                log_progress(f"⚠️ Pipeline finished with {len(results['errors'])} error(s)")
+            if model_url:
+                log_progress(f"Model: {model_url}")
+            if lb_url:
+                log_progress(f"Liveboard: {lb_url}")
+            log_progress("─" * 40)
+
         except Exception as e:
             import traceback
             error_msg = str(e)