Update app.py

app.py

@@ -12,6 +12,7 @@ import time # For profiling if needed
 from datetime import datetime, timedelta # Added timedelta
 import numpy as np
 from collections import OrderedDict # To maintain section order
+import asyncio # For async operations with the new agent
 
 # --- Module Imports ---
 from gradio_utils import get_url_user_token
@@ -32,10 +33,34 @@ from ui_generators import (
 from analytics_plot_generator import update_analytics_plots_figures, create_placeholder_plot
 from formulas import PLOT_FORMULAS
 
-# --- NEW CHATBOT MODULE IMPORTS ---
+# --- EXISTING CHATBOT MODULE IMPORTS ---
 from chatbot_prompts import get_initial_insight_prompt_and_suggestions # MODIFIED IMPORT
 from chatbot_handler import generate_llm_response
-# --- END NEW CHATBOT MODULE IMPORTS ---
+# --- END EXISTING CHATBOT MODULE IMPORTS ---
+
+# --- NEW EMPLOYER BRANDING AGENT MODULE IMPORTS ---
+try:
+    from eb_agent_module import (
+        EmployerBrandingAgent, 
+        GENERATION_CONFIG_PARAMS as EB_AGENT_GEN_CONFIG, # Rename to avoid conflict
+        LLM_MODEL_NAME as EB_AGENT_LLM_MODEL,           # Rename
+        GEMINI_EMBEDDING_MODEL_NAME as EB_AGENT_EMBEDDING_MODEL, # Rename
+        df_rag_documents as eb_agent_default_rag_docs, # Rename
+        DEFAULT_SAFETY_SETTINGS as EB_AGENT_SAFETY_SETTINGS # Import safety settings
+    )
+    EB_AGENT_AVAILABLE = True
+    logging.info("Successfully imported EmployerBrandingAgent module.")
+except ImportError as e:
+    logging.error(f"Failed to import EmployerBrandingAgent module: {e}", exc_info=True)
+    EB_AGENT_AVAILABLE = False
+    # Define dummy classes/variables if import fails, so app can still run
+    class EmployerBrandingAgent:
+        def __init__(self, *args, **kwargs): logging.error("EB Agent Dummy Class Initialized")
+        async def process_query(self, query, **kwargs): return "# Error: Employer Branding Agent module not loaded."
+        def update_dataframes(self, dfs): pass
+        def clear_chat_history(self): pass
+    EB_AGENT_GEN_CONFIG, EB_AGENT_LLM_MODEL, EB_AGENT_EMBEDDING_MODEL, eb_agent_default_rag_docs, EB_AGENT_SAFETY_SETTINGS = {}, None, None, pd.DataFrame(), {}
+
 
 # Configure logging
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(module)s - %(message)s')
@@ -54,10 +79,16 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
         "config_eb_labels_col": "li_eb_label"
     })
 
+    # States for existing analytics tab chatbot
     chat_histories_st = gr.State({})
     current_chat_plot_id_st = gr.State(None)
     plot_data_for_chatbot_st = gr.State({})
 
+    # --- NEW: States for Employer Branding Agent Tab ---
+    eb_agent_chat_history_st = gr.State([]) 
+    # The agent instance itself will be created on-the-fly or managed if complex state is needed.
+    # For now, we'll re-initialize it with fresh data in the handler.
+
     gr.Markdown("# 🚀 LinkedIn Organization Dashboard")
     url_user_token_display = gr.Textbox(label="User Token (Nascosto)", interactive=False, visible=False)
     status_box = gr.Textbox(label="Stato Generale Token LinkedIn", interactive=False, value="Inizializzazione...")
@@ -136,34 +167,30 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
             unique_ordered_sections = list(OrderedDict.fromkeys(pc["section"] for pc in plot_configs))
             num_unique_sections = len(unique_ordered_sections)
 
-            active_panel_action_state = gr.State(None) # Stores {"plot_id": "...", "type": "insights/formula"}
-            explored_plot_id_state = gr.State(None) # Stores plot_id of the currently explored plot
+            active_panel_action_state = gr.State(None) 
+            explored_plot_id_state = gr.State(None) 
 
             plot_ui_objects = {} 
             section_titles_map = {} 
 
             with gr.Row(equal_height=False):
                 with gr.Column(scale=8) as plots_area_col:
-                    # This function is in ui_generators.py and now builds the entire plot area
                     ui_elements_tuple = build_analytics_tab_plot_area(plot_configs)
                     if isinstance(ui_elements_tuple, tuple) and len(ui_elements_tuple) == 2:
                         plot_ui_objects, section_titles_map = ui_elements_tuple
-                        # Validate section_titles_map
                         if not all(sec_name in section_titles_map for sec_name in unique_ordered_sections):
                             logging.error("section_titles_map from build_analytics_tab_plot_area is incomplete.")
-                            # Fallback for missing section titles
                             for sec_name in unique_ordered_sections:
                                 if sec_name not in section_titles_map:
-                                     # This should not happen if build_analytics_tab_plot_area is correct
-                                     section_titles_map[sec_name] = gr.Markdown(f"### {sec_name} (Error Placeholder)") 
+                                    section_titles_map[sec_name] = gr.Markdown(f"### {sec_name} (Error Placeholder)") 
                     else:
                         logging.error("build_analytics_tab_plot_area did not return a tuple of (plot_ui_objects, section_titles_map).")
-                        plot_ui_objects = ui_elements_tuple if isinstance(ui_elements_tuple, dict) else {} # Fallback
-                        for sec_name in unique_ordered_sections: # Fallback for section titles
+                        plot_ui_objects = ui_elements_tuple if isinstance(ui_elements_tuple, dict) else {} 
+                        for sec_name in unique_ordered_sections: 
                             section_titles_map[sec_name] = gr.Markdown(f"### {sec_name} (Error Placeholder)")
 
 
-                with gr.Column(scale=4, visible=False) as global_actions_column_ui: # Right-hand column for chatbot/formula
+                with gr.Column(scale=4, visible=False) as global_actions_column_ui: 
                     gr.Markdown("### 💡 Azioni Contestuali Grafico")
                     insights_chatbot_ui = gr.Chatbot(
                         label="Chat Insights", type="messages", height=450,
@@ -182,13 +209,12 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
                     formula_display_markdown_ui = gr.Markdown(
                         "I dettagli sulla formula/metodologia appariranno qui.", visible=False
                     )
-                    # NEW: Hint for closing the formula panel
-                    formula_close_hint_md = gr.Markdown(
+                    formula_close_hint_md = gr.Markdown( # Component for the hint's visibility
                         "<p style='font-size:0.9em; text-align:center; margin-top:10px;'><em>Click the active ƒ button on the plot again to close this panel.</em></p>", 
                         visible=False
                     )
 
-
+            # --- ASYNC HANDLERS FOR ANALYTICS TAB ---
             async def handle_panel_action(
                 plot_id_clicked: str, action_type: str, current_active_action_from_state: dict,
                 current_chat_histories: dict, current_chat_plot_id: str,
@@ -200,15 +226,8 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
                 if not clicked_plot_config:
                     logging.error(f"Config not found for plot_id {plot_id_clicked}")
                     num_plots = len(plot_configs)
-                    # 15 (base UI + states) + N (panels) + N (bomb_btns) + N (formula_btns) + N (explore_btns) + M (sections) = 15 + 4N + M
                     error_list_len = 15 + (4 * num_plots) + num_unique_sections 
                     error_list = [gr.update()] * error_list_len
-                    # Manually set key states to avoid further issues if possible
-                    # Indices for states in action_panel_outputs_list:
-                    # active_panel_action_state is at index 11
-                    # current_chat_plot_id_st is at index 12
-                    # chat_histories_st is at index 13
-                    # explored_plot_id_state is at index 14
                     error_list[11] = current_active_action_from_state 
                     error_list[12] = current_chat_plot_id 
                     error_list[13] = current_chat_histories 
@@ -220,7 +239,6 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
                 hypothetical_new_active_state = {"plot_id": plot_id_clicked, "type": action_type}
                 is_toggling_off = current_active_action_from_state == hypothetical_new_active_state
 
-                # Initialize UI updates
                 action_col_visible_update = gr.update(visible=False)
                 insights_chatbot_visible_update, insights_chat_input_visible_update, insights_suggestions_row_visible_update = gr.update(visible=False), gr.update(visible=False), gr.update(visible=False)
                 formula_display_visible_update = gr.update(visible=False)
@@ -230,7 +248,6 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
                 new_active_action_state_to_set, new_current_chat_plot_id = None, current_chat_plot_id
                 updated_chat_histories, new_explored_plot_id_to_set = current_chat_histories, current_explored_plot_id
 
-                # Lists for dynamic component updates
                 generated_panel_vis_updates = []
                 generated_bomb_btn_updates = []
                 generated_formula_btn_updates = []
@@ -239,17 +256,15 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
 
 
                 if is_toggling_off:
-                    new_active_action_state_to_set = None # Clear active state
-                    action_col_visible_update = gr.update(visible=False) # Hide the right action column
+                    new_active_action_state_to_set = None 
+                    action_col_visible_update = gr.update(visible=False) 
                     logging.info(f"Toggling OFF panel {action_type} for {plot_id_clicked}.")
 
-                    # Reset bomb and formula buttons to their default icons
                     for _ in plot_configs:
                         generated_bomb_btn_updates.append(gr.update(value=BOMB_ICON))
                         generated_formula_btn_updates.append(gr.update(value=FORMULA_ICON))
 
                     if current_explored_plot_id: 
-                        # If an explore view was active, restore visibility based on that
                         explored_cfg = next((p for p in plot_configs if p["id"] == current_explored_plot_id), None)
                         explored_sec = explored_cfg["section"] if explored_cfg else None
                         for i, sec_name in enumerate(unique_ordered_sections):
@@ -259,28 +274,25 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
                             generated_panel_vis_updates.append(gr.update(visible=is_exp))
                             generated_explore_btn_updates.append(gr.update(value=ACTIVE_ICON if is_exp else EXPLORE_ICON))
                     else: 
-                        # No explore view, so all plots and sections become visible
                         for i in range(num_unique_sections): section_title_vis_updates[i] = gr.update(visible=True)
                         for _ in plot_configs:
                             generated_panel_vis_updates.append(gr.update(visible=True))
-                            generated_explore_btn_updates.append(gr.update(value=EXPLORE_ICON)) # Reset explore buttons
+                            generated_explore_btn_updates.append(gr.update(value=EXPLORE_ICON)) 
                     
-                    if action_type == "insights": new_current_chat_plot_id = None # Clear chat context if insights panel is closed
+                    if action_type == "insights": new_current_chat_plot_id = None
 
                 else: # Toggling ON a new action or switching actions
                     new_active_action_state_to_set = hypothetical_new_active_state
-                    action_col_visible_update = gr.update(visible=True) # Show the right action column
-                    new_explored_plot_id_to_set = None # Cancel any active explore view
+                    action_col_visible_update = gr.update(visible=True) 
+                    new_explored_plot_id_to_set = None 
                     logging.info(f"Toggling ON panel {action_type} for {plot_id_clicked}. Cancelling explore view if any.")
 
-                    # Set visibility for sections and plot panels: only the clicked plot and its section title
                     for i, sec_name in enumerate(unique_ordered_sections): 
                         section_title_vis_updates[i] = gr.update(visible=(sec_name == clicked_plot_section))
                     for cfg in plot_configs: 
                         generated_panel_vis_updates.append(gr.update(visible=(cfg["id"] == plot_id_clicked)))
-                        generated_explore_btn_updates.append(gr.update(value=EXPLORE_ICON)) # Reset all explore buttons
+                        generated_explore_btn_updates.append(gr.update(value=EXPLORE_ICON)) 
 
-                    # Update bomb and formula buttons: set active icon for the clicked one
                     for cfg_btn in plot_configs: 
                         is_act_ins = new_active_action_state_to_set == {"plot_id": cfg_btn["id"], "type": "insights"}
                         is_act_for = new_active_action_state_to_set == {"plot_id": cfg_btn["id"], "type": "formula"}
@@ -292,15 +304,14 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
                         new_current_chat_plot_id = plot_id_clicked
                         history = current_chat_histories.get(plot_id_clicked, [])
                         summary = current_plot_data_for_chatbot.get(plot_id_clicked, f"No summary for '{clicked_plot_label}'.")
-                        if not history: # First time opening chat for this plot
+                        if not history: 
                             prompt, sugg = get_initial_insight_prompt_and_suggestions(plot_id_clicked, clicked_plot_label, summary)
                             llm_hist = [{"role": "user", "content": prompt}]
-                            # Simulate LLM call for Gradio streaming if needed, or direct call
-                            resp = await generate_llm_response(prompt, plot_id_clicked, clicked_plot_label, llm_hist, summary)
-                            history = [{"role": "assistant", "content": resp}] # Start with AI's response
+                            resp = await generate_llm_response(prompt, plot_id_clicked, clicked_plot_label, llm_hist, summary) # This is your existing LLM call
+                            history = [{"role": "assistant", "content": resp}] 
                             updated_chat_histories = {**current_chat_histories, plot_id_clicked: history}
-                        else: # Re-opening chat, just get suggestions
-                            _, sugg = get_initial_insight_prompt_and_suggestions(plot_id_clicked, clicked_plot_label, summary) # Get fresh suggestions
+                        else: 
+                            _, sugg = get_initial_insight_prompt_and_suggestions(plot_id_clicked, clicked_plot_label, summary) 
                         
                         chatbot_content_update = gr.update(value=history)
                         s1_upd,s2_upd,s3_upd = gr.update(value=sugg[0] if sugg else "N/A"),gr.update(value=sugg[1] if len(sugg)>1 else "N/A"),gr.update(value=sugg[2] if len(sugg)>2 else "N/A")
@@ -315,32 +326,31 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
                             f_text += f"### {f_data['title']}\n\n{f_data['description']}\n\n**Calculation:**\n" + "\n".join([f"- {s}" for s in f_data['calculation_steps']])
                         else: f_text += "(No detailed formula information found.)"
                         formula_content_update = gr.update(value=f_text)
-                        new_current_chat_plot_id = None # Clear chat context if formula panel is opened
+                        new_current_chat_plot_id = None 
 
-                # Assemble the full list of updates in the correct order
                 final_updates = [
                     action_col_visible_update, insights_chatbot_visible_update, chatbot_content_update,
                     insights_chat_input_visible_update, insights_suggestions_row_visible_update, 
                     s1_upd, s2_upd, s3_upd, formula_display_visible_update, formula_content_update,
-                    formula_close_hint_md, # This is the component for the hint's visibility
-                    # States
+                    formula_close_hint_md, # This is the component for the hint's visibility, should be formula_close_hint_visible_update
                     new_active_action_state_to_set, new_current_chat_plot_id, updated_chat_histories,
                     new_explored_plot_id_to_set 
                 ]
-                final_updates.extend(generated_panel_vis_updates)    # N panel visibility updates
-                final_updates.extend(generated_bomb_btn_updates)     # N bomb button updates
-                final_updates.extend(generated_formula_btn_updates)  # N formula button updates
-                final_updates.extend(generated_explore_btn_updates)  # N explore button updates
-                final_updates.extend(section_title_vis_updates)      # M section title visibility updates
+                # Correcting the hint update:
+                final_updates[10] = formula_close_hint_visible_update
+
+
+                final_updates.extend(generated_panel_vis_updates)   
+                final_updates.extend(generated_bomb_btn_updates)    
+                final_updates.extend(generated_formula_btn_updates) 
+                final_updates.extend(generated_explore_btn_updates) 
+                final_updates.extend(section_title_vis_updates)     
                 
-                # Expected length: 11 (base UI) + 4 (states) + N (panels) + N (bomb_btns) + N (formula_btns) + N (explore_btns) + M (sections)
-                # = 15 + 4N + M. For N=19, M=6: 15 + 4*19 + 6 = 15 + 76 + 6 = 97.
-                logging.debug(f"handle_panel_action returning {len(final_updates)} updates. Expected 97 for N=19, M=6.")
+                logging.debug(f"handle_panel_action returning {len(final_updates)} updates. Expected {15 + 4*len(plot_configs) + num_unique_sections}.")
                 return final_updates
 
             async def handle_chat_message_submission(user_message: str, current_plot_id: str, chat_histories: dict, current_plot_data_for_chatbot: dict ):
                 if not current_plot_id or not user_message.strip():
-                    # Ensure history is a list for the chatbot component
                     current_history_for_plot = chat_histories.get(current_plot_id, [])
                     if not isinstance(current_history_for_plot, list): current_history_for_plot = []
                     yield current_history_for_plot, gr.update(value=""), chat_histories; return
@@ -349,18 +359,15 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
                 lbl = cfg["label"] if cfg else "Selected Plot"
                 summary = current_plot_data_for_chatbot.get(current_plot_id, f"No summary for '{lbl}'.")
                 
-                # Ensure current history is a list
                 hist_for_plot = chat_histories.get(current_plot_id, [])
-                if not isinstance(hist_for_plot, list): hist_for_plot = [] # Safeguard
+                if not isinstance(hist_for_plot, list): hist_for_plot = [] 
 
                 hist = hist_for_plot.copy() + [{"role": "user", "content": user_message}]
-                yield hist, gr.update(value=""), chat_histories # Show user message immediately
+                yield hist, gr.update(value=""), chat_histories 
 
-                # Call LLM
-                resp = await generate_llm_response(user_message, current_plot_id, lbl, hist, summary)
+                resp = await generate_llm_response(user_message, current_plot_id, lbl, hist, summary) # Existing LLM
                 hist.append({"role": "assistant", "content": resp})
                 
-                # Update chat histories state
                 updated_chat_histories = {**chat_histories, current_plot_id: hist}
                 yield hist, "", updated_chat_histories
 
@@ -371,29 +378,28 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
                     if not isinstance(current_history_for_plot, list): current_history_for_plot = []
                     yield current_history_for_plot, gr.update(value=""), chat_histories; return
                 
-                # Use the generator to stream updates from handle_chat_message_submission
                 async for update_chunk in handle_chat_message_submission(suggestion_text, current_plot_id, chat_histories, current_plot_data_for_chatbot):
                     yield update_chunk
 
 
             def handle_explore_click(plot_id_clicked, current_explored_plot_id_from_state, current_active_panel_action_state):
+                # This function remains synchronous as per original
                 logging.info(f"Explore Click: Plot '{plot_id_clicked}'. Current Explored: {current_explored_plot_id_from_state}. Active Panel: {current_active_panel_action_state}")
                 num_plots = len(plot_configs)
                 if not plot_ui_objects: 
                     logging.error("plot_ui_objects not populated for handle_explore_click.")
-                    # explore_outputs_list: 4 base states/UI + N panels + N explore_btns + N bomb_btns + N formula_btns + M sections
                     error_list_len = 4 + (4 * num_plots) + num_unique_sections 
                     error_list = [gr.update()] * error_list_len
-                    error_list[0] = current_explored_plot_id_from_state # explored_plot_id_state
-                    error_list[2] = current_active_panel_action_state # active_panel_action_state
+                    error_list[0] = current_explored_plot_id_from_state 
+                    error_list[2] = current_active_panel_action_state 
                     return error_list
 
                 new_explored_id_to_set = None
                 is_toggling_off_explore = (plot_id_clicked == current_explored_plot_id_from_state)
 
-                action_col_upd = gr.update() # Default to no change for action column visibility
-                new_active_panel_state_upd = current_active_panel_action_state # Default to no change
-                formula_hint_upd = gr.update(visible=False) # Hide formula hint by default
+                action_col_upd = gr.update() 
+                new_active_panel_state_upd = current_active_panel_action_state 
+                formula_hint_upd = gr.update(visible=False) 
 
                 panel_vis_updates = []
                 explore_btns_updates = []
@@ -405,17 +411,15 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
                 sec_of_clicked = clicked_cfg["section"] if clicked_cfg else None
 
                 if is_toggling_off_explore:
-                    new_explored_id_to_set = None # Clear explored state
+                    new_explored_id_to_set = None 
                     logging.info(f"Stopping explore for {plot_id_clicked}. All plots/sections to be visible.")
                     for i in range(num_unique_sections): section_title_vis_updates[i] = gr.update(visible=True)
                     for _ in plot_configs:
                         panel_vis_updates.append(gr.update(visible=True))
                         explore_btns_updates.append(gr.update(value=EXPLORE_ICON))
-                        # If an action panel was active, its buttons are handled by its own logic if it's closed.
-                        # Here, we just ensure explore buttons are reset. Bomb/Formula buttons remain as they were unless an active panel is closed.
-                        bomb_btns_updates.append(gr.update()) # No change unless active panel is closed
-                        formula_btns_updates.append(gr.update()) # No change
-                else: # Toggling ON explore for a plot
+                        bomb_btns_updates.append(gr.update()) 
+                        formula_btns_updates.append(gr.update()) 
+                else: 
                     new_explored_id_to_set = plot_id_clicked
                     logging.info(f"Exploring {plot_id_clicked}. Hiding other plots/sections.")
                     for i, sec_name in enumerate(unique_ordered_sections): 
@@ -425,24 +429,19 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
                         panel_vis_updates.append(gr.update(visible=is_target))
                         explore_btns_updates.append(gr.update(value=ACTIVE_ICON if is_target else EXPLORE_ICON))
                     
-                    # If an action panel (insights/formula) is currently active, close it
                     if current_active_panel_action_state:
                         logging.info("Closing active insight/formula panel due to explore click.")
-                        action_col_upd = gr.update(visible=False) # Hide the right action column
-                        new_active_panel_state_upd = None # Clear the active panel state
-                        formula_hint_upd = gr.update(visible=False) # Hide formula hint
-                        # Reset all bomb and formula buttons to default icons
+                        action_col_upd = gr.update(visible=False) 
+                        new_active_panel_state_upd = None 
+                        formula_hint_upd = gr.update(visible=False) 
                         for _ in plot_configs:
                             bomb_btns_updates.append(gr.update(value=BOMB_ICON))
                             formula_btns_updates.append(gr.update(value=FORMULA_ICON))
                     else:
-                        # No action panel was active, bomb/formula buttons remain as they are (no update)
                         for _ in plot_configs:
                             bomb_btns_updates.append(gr.update())
                             formula_btns_updates.append(gr.update())
                 
-                # Order: states/UI (4), panels (N), explore_btns (N), bomb_btns (N), formula_btns (N), section_titles (M)
-                # Total: 4 + 4N + M.
                 final_explore_updates = [
                     new_explored_id_to_set, action_col_upd, new_active_panel_state_upd, formula_hint_upd
                 ]
@@ -456,35 +455,29 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
                 return final_explore_updates
 
 
-            # --- Define Output Lists for Event Handlers ---
-            # Base UI for action panel (insights/formula): 11 elements
             _base_action_panel_ui_outputs = [
-                global_actions_column_ui, insights_chatbot_ui, insights_chatbot_ui, # Chatbot vis + value
+                global_actions_column_ui, insights_chatbot_ui, insights_chatbot_ui, 
                 insights_chat_input_ui, insights_suggestions_row_ui, 
                 insights_suggestion_1_btn, insights_suggestion_2_btn, insights_suggestion_3_btn,
-                formula_display_markdown_ui, formula_display_markdown_ui, # Formula MD (vis + value)
-                formula_close_hint_md # Formula hint visibility
+                formula_display_markdown_ui, formula_display_markdown_ui, 
+                formula_close_hint_md 
             ]
-            # States for action panel: 4 elements
             _action_panel_state_outputs = [active_panel_action_state, current_chat_plot_id_st, chat_histories_st, explored_plot_id_state]
             
-            action_panel_outputs_list = _base_action_panel_ui_outputs + _action_panel_state_outputs # 11 + 4 = 15
-            action_panel_outputs_list.extend([plot_ui_objects.get(pc["id"], {}).get("panel_component", gr.update()) for pc in plot_configs]) # +N (panels)
-            action_panel_outputs_list.extend([plot_ui_objects.get(pc["id"], {}).get("bomb_button", gr.update()) for pc in plot_configs])    # +N (bomb_button)
-            action_panel_outputs_list.extend([plot_ui_objects.get(pc["id"], {}).get("formula_button", gr.update()) for pc in plot_configs]) # +N (formula_button)
-            action_panel_outputs_list.extend([plot_ui_objects.get(pc["id"], {}).get("explore_button", gr.update()) for pc in plot_configs]) # +N (explore_button)
-            action_panel_outputs_list.extend([section_titles_map.get(s_name, gr.update()) for s_name in unique_ordered_sections]) # +M (sections)
-            # Total for action_panel_outputs_list = 15 + 4N + M. For N=19, M=6: 15 + 76 + 6 = 97. Correct.
-
-            # Base UI/States for explore click: 4 elements
+            action_panel_outputs_list = _base_action_panel_ui_outputs + _action_panel_state_outputs 
+            action_panel_outputs_list.extend([plot_ui_objects.get(pc["id"], {}).get("panel_component", gr.update()) for pc in plot_configs]) 
+            action_panel_outputs_list.extend([plot_ui_objects.get(pc["id"], {}).get("bomb_button", gr.update()) for pc in plot_configs])   
+            action_panel_outputs_list.extend([plot_ui_objects.get(pc["id"], {}).get("formula_button", gr.update()) for pc in plot_configs]) 
+            action_panel_outputs_list.extend([plot_ui_objects.get(pc["id"], {}).get("explore_button", gr.update()) for pc in plot_configs]) 
+            action_panel_outputs_list.extend([section_titles_map.get(s_name, gr.update()) for s_name in unique_ordered_sections]) 
+
             _explore_base_outputs = [explored_plot_id_state, global_actions_column_ui, active_panel_action_state, formula_close_hint_md] 
-            explore_outputs_list = _explore_base_outputs # 4
-            explore_outputs_list.extend([plot_ui_objects.get(pc["id"], {}).get("panel_component", gr.update()) for pc in plot_configs]) # +N (panels)
-            explore_outputs_list.extend([plot_ui_objects.get(pc["id"], {}).get("explore_button", gr.update()) for pc in plot_configs]) # +N (explore_button)
-            explore_outputs_list.extend([plot_ui_objects.get(pc["id"], {}).get("bomb_button", gr.update()) for pc in plot_configs])    # +N (bomb_button)
-            explore_outputs_list.extend([plot_ui_objects.get(pc["id"], {}).get("formula_button", gr.update()) for pc in plot_configs]) # +N (formula_button)
-            explore_outputs_list.extend([section_titles_map.get(s_name, gr.update()) for s_name in unique_ordered_sections]) # +M (sections)
-            # Total for explore_outputs_list = 4 + 4N + M. For N=19, M=6: 4 + 76 + 6 = 86. Correct.
+            explore_outputs_list = _explore_base_outputs 
+            explore_outputs_list.extend([plot_ui_objects.get(pc["id"], {}).get("panel_component", gr.update()) for pc in plot_configs]) 
+            explore_outputs_list.extend([plot_ui_objects.get(pc["id"], {}).get("explore_button", gr.update()) for pc in plot_configs]) 
+            explore_outputs_list.extend([plot_ui_objects.get(pc["id"], {}).get("bomb_button", gr.update()) for pc in plot_configs])   
+            explore_outputs_list.extend([plot_ui_objects.get(pc["id"], {}).get("formula_button", gr.update()) for pc in plot_configs]) 
+            explore_outputs_list.extend([section_titles_map.get(s_name, gr.update()) for s_name in unique_ordered_sections]) 
 
             action_click_inputs = [active_panel_action_state, chat_histories_st, current_chat_plot_id_st, plot_data_for_chatbot_st, explored_plot_id_state]
             explore_click_inputs = [explored_plot_id_state, active_panel_action_state]
@@ -498,13 +491,18 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
                 plot_id = config_item["id"]
                 if plot_id in plot_ui_objects:
                     ui_obj = plot_ui_objects[plot_id]
-                    # Ensure buttons exist before attaching handlers
                     if ui_obj.get("bomb_button"):
                         ui_obj["bomb_button"].click(fn=create_panel_action_handler(plot_id, "insights"), inputs=action_click_inputs, outputs=action_panel_outputs_list, api_name=f"action_insights_{plot_id}")
                     if ui_obj.get("formula_button"):
                         ui_obj["formula_button"].click(fn=create_panel_action_handler(plot_id, "formula"), inputs=action_click_inputs, outputs=action_panel_outputs_list, api_name=f"action_formula_{plot_id}")
                     if ui_obj.get("explore_button"):
-                        ui_obj["explore_button"].click(fn=lambda current_explored_val, current_active_panel_val, p_id=plot_id: handle_explore_click(p_id, current_explored_val, current_active_panel_val), inputs=explore_click_inputs, outputs=explore_outputs_list, api_name=f"action_explore_{plot_id}")
+                        # Original lambda was not async, ensure it matches handle_explore_click signature and type
+                        ui_obj["explore_button"].click(
+                            fn=lambda current_explored_val, current_active_panel_val, p_id=plot_id: handle_explore_click(p_id, current_explored_val, current_active_panel_val), 
+                            inputs=explore_click_inputs, 
+                            outputs=explore_outputs_list, 
+                            api_name=f"action_explore_{plot_id}"
+                        ) # if handle_explore_click becomes async, this needs 'await' or be wrapped
                 else: logging.warning(f"UI object for plot_id '{plot_id}' not found for click handlers.")
 
 
@@ -518,56 +516,49 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
             insights_suggestion_3_btn.click(fn=handle_suggested_question_click, inputs=[insights_suggestion_3_btn] + suggestion_click_inputs_base, outputs=chat_submission_outputs, api_name="click_suggestion_3")
 
 
-            def refresh_all_analytics_ui_elements(current_token_state, date_filter_val, custom_start_val, custom_end_val, current_chat_histories):
+            def refresh_all_analytics_ui_elements(current_token_state_val, date_filter_val, custom_start_val, custom_end_val, current_chat_histories_val):
+                # This function remains synchronous as per original
                 logging.info("Refreshing all analytics UI elements and resetting actions/chat.")
-                plot_gen_results = update_analytics_plots_figures(current_token_state, date_filter_val, custom_start_val, custom_end_val, plot_configs)
+                plot_gen_results = update_analytics_plots_figures(current_token_state_val, date_filter_val, custom_start_val, custom_end_val, plot_configs)
                 status_msg, gen_figs, new_summaries = plot_gen_results[0], plot_gen_results[1:-1], plot_gen_results[-1]
                 
-                all_updates = [status_msg] # 1. analytics_status_md
-                all_updates.extend(gen_figs if len(gen_figs) == len(plot_configs) else [create_placeholder_plot("Error", f"Fig missing {i}") for i in range(len(plot_configs))]) # +N (plot figures)
+                all_updates = [status_msg] 
+                all_updates.extend(gen_figs if len(gen_figs) == len(plot_configs) else [create_placeholder_plot("Error", f"Fig missing {i}") for i in range(len(plot_configs))]) 
                 
-                # UI Resets for action panel (9 elements)
                 all_updates.extend([ 
-                    gr.update(visible=False), # global_actions_column_ui
-                    gr.update(value=[], visible=False), # insights_chatbot_ui (value + visibility)
-                    gr.update(value="", visible=False), # insights_chat_input_ui
-                    gr.update(visible=False), # insights_suggestions_row_ui
-                    gr.update(value="S1"), gr.update(value="S2"), gr.update(value="S3"), # sugg_btns
-                    gr.update(value="Formula details here.", visible=False), # formula_display_markdown_ui (value + visibility)
-                    gr.update(visible=False) # formula_close_hint_md
+                    gr.update(visible=False), 
+                    gr.update(value=[], visible=False), 
+                    gr.update(value="", visible=False), 
+                    gr.update(visible=False), 
+                    gr.update(value="S1"), gr.update(value="S2"), gr.update(value="S3"), 
+                    gr.update(value="Formula details here.", visible=False), 
+                    gr.update(visible=False) 
                 ]) 
                 
-                # State Resets (4 elements)
                 all_updates.extend([ 
-                    None, # active_panel_action_state
-                    None, # current_chat_plot_id_st
-                    {},   # chat_histories_st (reset all chat histories)
-                    new_summaries # plot_data_for_chatbot_st
+                    None, 
+                    None, 
+                    {},   
+                    new_summaries 
                 ]) 
                 
-                # Plot-specific buttons (3 per plot: bomb, formula, explore) and panel visibility (1 per plot)
                 for _ in plot_configs: 
                     all_updates.extend([
                         gr.update(value=BOMB_ICON), 
                         gr.update(value=FORMULA_ICON), 
                         gr.update(value=EXPLORE_ICON), 
-                        gr.update(visible=True) # panel_component visibility
+                        gr.update(visible=True) 
                     ]) 
                 
-                all_updates.append(None) # Reset explored_plot_id_state (1 element)
-                all_updates.extend([gr.update(visible=True)] * num_unique_sections) # Make all section titles visible (M elements)
+                all_updates.append(None) 
+                all_updates.extend([gr.update(visible=True)] * num_unique_sections) 
                 
-                # Total: 1 (status) + N (figs) + 9 (UI resets) + 4 (state resets) + 4N (plot buttons/panels) + 1 (explored_state) + M (sections)
-                # = 1 + N + 9 + 4 + 4N + 1 + M = 15 + 5N + M.
-                # For N=19, M=6: 15 + 5*19 + 6 = 15 + 95 + 6 = 116. This matches apply_filter_and_sync_outputs_list.
                 logging.info(f"Prepared {len(all_updates)} updates for analytics refresh. Expected {15 + 5*len(plot_configs) + num_unique_sections}.")
                 return all_updates
 
-            # Construction of apply_filter_and_sync_outputs_list
-            apply_filter_and_sync_outputs_list = [analytics_status_md] # 1. Status
-            apply_filter_and_sync_outputs_list.extend([plot_ui_objects.get(pc["id"], {}).get("plot_component", gr.update()) for pc in plot_configs]) # 2. Plot figures (N)
+            apply_filter_and_sync_outputs_list = [analytics_status_md] 
+            apply_filter_and_sync_outputs_list.extend([plot_ui_objects.get(pc["id"], {}).get("plot_component", gr.update()) for pc in plot_configs]) 
             
-            # 3. UI Resets for action panel (9 elements)
             _ui_resets_for_filter = [
                 global_actions_column_ui, insights_chatbot_ui, insights_chat_input_ui,
                 insights_suggestions_row_ui, insights_suggestion_1_btn, insights_suggestion_2_btn, insights_suggestion_3_btn,
@@ -575,26 +566,21 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
             ]
             apply_filter_and_sync_outputs_list.extend(_ui_resets_for_filter)
             
-            # 4. State Resets (4 elements)
             _state_resets_for_filter = [active_panel_action_state, current_chat_plot_id_st, chat_histories_st, plot_data_for_chatbot_st]
             apply_filter_and_sync_outputs_list.extend(_state_resets_for_filter)
 
-            # 5. Plot-specific buttons (3 per plot) and panel visibility (1 per plot) = 4N elements
             for pc in plot_configs: 
                 pid = pc["id"]
                 apply_filter_and_sync_outputs_list.extend([
                     plot_ui_objects.get(pid, {}).get("bomb_button", gr.update()),
                     plot_ui_objects.get(pid, {}).get("formula_button", gr.update()),
                     plot_ui_objects.get(pid, {}).get("explore_button", gr.update()),
-                    plot_ui_objects.get(pid, {}).get("panel_component", gr.update()) # Panel visibility
+                    plot_ui_objects.get(pid, {}).get("panel_component", gr.update()) 
                 ])
             
-            # 6. Explored state reset (1 element)
             apply_filter_and_sync_outputs_list.append(explored_plot_id_state) 
             
-            # 7. Section Titles (M elements)
             apply_filter_and_sync_outputs_list.extend([section_titles_map.get(s_name, gr.update()) for s_name in unique_ordered_sections]) 
-            # Total elements: 1 + N + 9 + 4 + 4N + 1 + M = 15 + 5N + M. Correct.
             
             apply_filter_btn.click(
                 fn=refresh_all_analytics_ui_elements,
@@ -626,17 +612,203 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
                 outputs=[follower_stats_html, fs_plot_monthly_gains, fs_plot_seniority, fs_plot_industry],
                 show_progress="full"
             )
+        
+        # --- NEW: Tab 5 for Employer Branding Agent ---
+        with gr.TabItem("5️⃣ Agente AI Employer Branding", id="tab_eb_agent"):
+            gr.Markdown("## 🤖 Interagisci con l'Agente AI per l'Employer Branding")
             
+            if not EB_AGENT_AVAILABLE:
+                gr.Markdown("<p style='color:red;font-weight:bold;'>Attenzione: Il modulo dell'Agente AI per l'Employer Branding non è stato caricato correttamente. Controllare i log e l'installazione della libreria `google-generativeai` e la variabile d'ambiente `GEMINI_API_KEY`.</p>")
+            elif not os.getenv('GEMINI_API_KEY'):
+                 gr.Markdown("<p style='color:orange;font-weight:bold;'>Attenzione: La variabile d'ambiente `GEMINI_API_KEY` non è impostata. Le funzionalità dell'Agente AI saranno limitate o non funzioneranno.</p>")
+
+
+            gr.Markdown(
+                "Fai domande sui tuoi dati LinkedIn (statistiche follower, post e menzioni) per ottenere insights e codice Pandas per analizzarli. "
+                "L'agente utilizza i dati attualmente disponibili nello stato dell'applicazione."
+            )
+            with gr.Row():
+                with gr.Column(scale=2):
+                    eb_agent_chatbot_ui = gr.Chatbot(
+                        label="Chat con Agente AI EB",
+                        value=[[None, "Ciao! Sono il tuo Agente AI per l'Employer Branding. Come posso aiutarti ad analizzare i tuoi dati LinkedIn oggi? Chiedimi di generare codice Pandas o di fornire insights."]] if EB_AGENT_AVAILABLE else [[None, "Agente AI non disponibile."]],
+                        bubble_full_width=False,
+                        height=500,
+                        placeholder="L'Agente AI è pronto. Chiedi pure..."
+                    )
+                    eb_agent_chat_input_ui = gr.Textbox(
+                        label="La tua domanda:",
+                        placeholder="Es: 'Mostrami le aziende dei miei follower nel settore tecnologico' o 'Qual è il sentiment medio delle mie menzioni?'",
+                        lines=3,
+                        interactive=EB_AGENT_AVAILABLE # Disable if agent not available
+                    )
+                    with gr.Row():
+                        eb_agent_submit_btn = gr.Button("💬 Invia Messaggio", variant="primary", interactive=EB_AGENT_AVAILABLE)
+                        eb_agent_clear_btn = gr.Button("🗑️ Cancella Chat", variant="stop", interactive=EB_AGENT_AVAILABLE)
+                with gr.Column(scale=1):
+                    gr.Markdown("#### Schemi Dati Disponibili per l'Agente:")
+                    eb_agent_schema_display_md = gr.Markdown("Gli schemi dei dati (follower, post, menzioni) verranno mostrati qui quando l'agente viene inizializzato con una query.")
+                    eb_agent_status_md = gr.Markdown("Stato Agente: In attesa di input...")
+            
+            # --- NEW: Handler for Employer Branding Agent Chat ---
+            eb_agent_instance_dict = {"agent": None} # To store agent instance across calls if needed, or re-init
+
+            async def handle_eb_agent_chat(user_message: str, chat_history_list: list, current_token_state: dict):
+                if not EB_AGENT_AVAILABLE or not os.getenv('GEMINI_API_KEY'):
+                    no_key_msg = "L'Agente AI non è disponibile. Assicurati che GEMINI_API_KEY sia configurata."
+                    chat_history_list.append([user_message, no_key_msg])
+                    return chat_history_list, chat_history_list, "", gr.update(value=no_key_msg)
+
+                if not user_message.strip():
+                    return chat_history_list, chat_history_list, "", gr.update(value="Stato Agente: Per favore, inserisci una domanda.")
+
+                status_update_msg = "Stato Agente: Elaborazione della tua richiesta..."
+                yield chat_history_list + [[user_message, None]], chat_history_list + [[user_message, None]], "", gr.update(value=status_update_msg) # Show user message immediately
+
+                # Prepare DataFrames for the agent
+                df_follower_stats = current_token_state.get("bubble_follower_stats_df", pd.DataFrame())
+                df_posts = current_token_state.get("bubble_posts_df", pd.DataFrame()) # Contains post content
+                df_post_stats = current_token_state.get("bubble_post_stats_df", pd.DataFrame()) # Contains post metrics
+                df_mentions = current_token_state.get("bubble_mentions_df", pd.DataFrame())
+
+                # For simplicity, we can merge posts and post_stats if they have a common key (e.g., post_id)
+                # Assuming 'id' in df_posts corresponds to 'post_id' in df_post_stats
+                # This is a guess, adjust based on your actual schemas.
+                # If no common key, pass them separately and instruct LLM.
+                df_posts_combined = df_posts
+                if not df_posts.empty and not df_post_stats.empty:
+                    # Attempt merge, ensure column names are correct for your DFs
+                    # Example: common_col_posts = 'id'; common_col_stats = 'post_id'
+                    # For now, let's assume they might not be easily mergeable or LLM can handle separately
+                    pass # LLM will see df_posts and df_post_stats separately
+
+
+                dataframes_for_agent = {
+                    "follower_stats": df_follower_stats.copy() if not df_follower_stats.empty else pd.DataFrame(columns=['no_data_follower_stats']), # Use copy to avoid modifying state
+                    "posts": df_posts.copy() if not df_posts.empty else pd.DataFrame(columns=['no_data_posts']),
+                    "post_stats": df_post_stats.copy() if not df_post_stats.empty else pd.DataFrame(columns=['no_data_post_stats']),
+                    "mentions": df_mentions.copy() if not df_mentions.empty else pd.DataFrame(columns=['no_data_mentions'])
+                }
+                
+                # Display schemas for user reference
+                schemas_text = "Schemi DataFrames inviati all'Agente:\n\n"
+                from eb_agent_module import get_all_schemas_representation # Re-import for safety if run in different context
+                schemas_text += get_all_schemas_representation(dataframes_for_agent)
+                # Limit schema display length for UI
+                max_schema_display_len = 1500
+                if len(schemas_text) > max_schema_display_len:
+                    schemas_text = schemas_text[:max_schema_display_len] + "\n...(schemi troncati per la visualizzazione)"
+                
+                # Initialize or update agent
+                # For simplicity, re-initialize. If RAG embeddings are slow, consider stateful agent.
+                current_agent = EmployerBrandingAgent(
+                    llm_model_name=EB_AGENT_LLM_MODEL,
+                    generation_config_params=EB_AGENT_GEN_CONFIG,
+                    safety_settings=EB_AGENT_SAFETY_SETTINGS,
+                    all_dataframes=dataframes_for_agent,
+                    rag_documents_df=eb_agent_default_rag_docs.copy(), # Use a copy of default RAG docs
+                    embedding_model_name=EB_AGENT_EMBEDDING_MODEL,
+                    force_sandbox=True # True to get Python code
+                )
+                # Restore chat history to the agent if it were stateful
+                # current_agent.chat_history = [msg for pair in chat_history_list for msg_type, msg_content in (('user', pair[0]), ('assistant', pair[1])) if msg_content is not None]
+                # For stateless re-init, we pass history to process_query if needed by LLM, but agent itself starts fresh or manages its own history via its methods
+
+                # Simplified history for this agent: it manages its own via process_query
+                # We only need to pass the user_message.
+                # The agent's process_query will handle its internal history.
+                
+                # If the agent's internal history needs to match the UI history:
+                # Convert Gradio chat history to agent's expected format
+                agent_internal_history = []
+                for user_q, ai_r in chat_history_list:
+                    if user_q: agent_internal_history.append({"role": "user", "content": user_q})
+                    if ai_r: agent_internal_history.append({"role": "assistant", "content": ai_r}) # or "model"
+                
+                # Update agent's history before processing (if agent supports this way)
+                current_agent.chat_history = agent_internal_history # Agent will append new query and response
+
+                try:
+                    logging.info(f"Sending to EB Agent. User: '{user_message}'. DF Keys: {list(dataframes_for_agent.keys())}")
+                    # The agent's process_query already appends to its internal history
+                    ai_response = await current_agent.process_query(user_query=user_message)
+                    
+                    # The agent's internal history is now updated. We need to reflect this in Gradio's history state.
+                    # The last two entries in agent.chat_history are the current user_message and ai_response
+                    updated_gradio_history = []
+                    temp_hist = current_agent.chat_history
+                    for i in range(0, len(temp_hist), 2):
+                        u_msg = temp_hist[i]['content']
+                        a_msg = temp_hist[i+1]['content'] if i+1 < len(temp_hist) else "Thinking..." # Should have assistant response
+                        updated_gradio_history.append([u_msg, a_msg])
+                    
+                    status_update_msg = "Stato Agente: Risposta ricevuta."
+                    yield updated_gradio_history, updated_gradio_history, "", gr.update(value=status_update_msg), gr.update(value=schemas_text)
+
+                except Exception as e:
+                    logging.error(f"Error during EB Agent processing: {e}", exc_info=True)
+                    error_msg = f"# Errore dell'Agente AI:\n{type(e).__name__}: {str(e)}"
+                    # Use the last known good history before error for UI state
+                    chat_history_list.append([user_message, error_msg]) # Add error to current turn
+                    status_update_msg = f"Stato Agente: Errore - {type(e).__name__}"
+                    yield chat_history_list, chat_history_list, "", gr.update(value=status_update_msg), gr.update(value=schemas_text)
+
+
+            def clear_eb_agent_chat_history():
+                # eb_agent_instance_dict["agent"] might need its history cleared too if stateful
+                # For re-init agent, just clearing UI state is enough.
+                # If agent instance is stored and reused:
+                # agent_to_clear = eb_agent_instance_dict.get("agent")
+                # if agent_to_clear and hasattr(agent_to_clear, 'clear_chat_history'):
+                #    agent_to_clear.clear_chat_history()
+                initial_msg = "Ciao! Sono il tuo Agente AI per l'Employer Branding. Come posso aiutarti?" if EB_AGENT_AVAILABLE else "Agente AI non disponibile."
+                return [[None, initial_msg]], [[None, initial_msg]], "Stato Agente: Chat resettata."
+
+            # Connect UI to Handler for EB Agent
+            eb_agent_submit_btn.click(
+                fn=handle_eb_agent_chat,
+                inputs=[eb_agent_chat_input_ui, eb_agent_chat_history_st, token_state],
+                outputs=[eb_agent_chatbot_ui, eb_agent_chat_history_st, eb_agent_chat_input_ui, eb_agent_status_md, eb_agent_schema_display_md],
+                api_name="eb_agent_chat_submit"
+            )
+            eb_agent_chat_input_ui.submit(
+                fn=handle_eb_agent_chat,
+                inputs=[eb_agent_chat_input_ui, eb_agent_chat_history_st, token_state],
+                outputs=[eb_agent_chatbot_ui, eb_agent_chat_history_st, eb_agent_chat_input_ui, eb_agent_status_md, eb_agent_schema_display_md],
+                api_name="eb_agent_chat_enter"
+            )
+            eb_agent_clear_btn.click(
+                fn=clear_eb_agent_chat_history,
+                inputs=[],
+                outputs=[eb_agent_chatbot_ui, eb_agent_chat_history_st, eb_agent_status_md],
+                api_name="eb_agent_clear_chat"
+            )
+
+
+    # --- Sync Events (at the end of the app's 'with gr.Blocks()' context) ---
     sync_event_part1 = sync_data_btn.click(fn=sync_all_linkedin_data_orchestrator, inputs=[token_state], outputs=[sync_status_html_output, token_state], show_progress="full")
     sync_event_part2 = sync_event_part1.then(fn=process_and_store_bubble_token, inputs=[url_user_token_display, org_urn_display, token_state], outputs=[status_box, token_state, sync_data_btn], show_progress=False)
     sync_event_part3 = sync_event_part2.then(fn=display_main_dashboard, inputs=[token_state], outputs=[dashboard_display_html], show_progress=False)
-    sync_event_final = sync_event_part3.then(fn=refresh_all_analytics_ui_elements, inputs=[token_state, date_filter_selector, custom_start_date_picker, custom_end_date_picker, chat_histories_st], outputs=apply_filter_and_sync_outputs_list, show_progress="full")
+    sync_event_final = sync_event_part3.then(
+        fn=refresh_all_analytics_ui_elements, # This is synchronous
+        inputs=[token_state, date_filter_selector, custom_start_date_picker, custom_end_date_picker, chat_histories_st], 
+        outputs=apply_filter_and_sync_outputs_list, 
+        show_progress="full"
+    )
 
 
 if __name__ == "__main__":
     if not os.environ.get(LINKEDIN_CLIENT_ID_ENV_VAR): logging.warning(f"ATTENZIONE: '{LINKEDIN_CLIENT_ID_ENV_VAR}' non impostata.")
     if not all(os.environ.get(var) for var in [BUBBLE_APP_NAME_ENV_VAR, BUBBLE_API_KEY_PRIVATE_ENV_VAR, BUBBLE_API_ENDPOINT_ENV_VAR]):
         logging.warning("ATTENZIONE: Variabili Bubble non impostate.")
+    
+    if not EB_AGENT_AVAILABLE:
+        logging.error("L'Agente AI per l'Employer Branding non è disponibile a causa di errori di importazione.")
+    elif not os.getenv('GEMINI_API_KEY'):
+        logging.warning("ATTENZIONE: GEMINI_API_KEY non è impostata. L'Agente AI per l'Employer Branding potrebbe non funzionare.")
+
     try: logging.info(f"Matplotlib: {matplotlib.__version__}, Backend: {matplotlib.get_backend()}")
     except ImportError: logging.warning("Matplotlib non trovato.")
-    app.launch(server_name="0.0.0.0", server_port=7860, debug=True)
+    
+    app.launch(server_name="0.0.0.0", server_port=7860, debug=True)
+