Update app.py

app.py

@@ -4,55 +4,63 @@ import pandas as pd
 import os
 import logging
 import matplotlib
-matplotlib.use('Agg') # Set backend for Matplotlib to avoid GUI conflicts with Gradio
-# import matplotlib.pyplot as plt # Not directly used in app.py anymore
-import time # For profiling if needed
-# from datetime import datetime, timedelta # Not directly used in app.py
-# import numpy as np # Not directly used in app.py
-# from collections import OrderedDict, defaultdict # Not directly used in app.py
-import asyncio # For async operations
+matplotlib.use('Agg') # Set backend for Matplotlib
+import matplotlib.pyplot as plt
+import time
+from datetime import datetime, timedelta
+import numpy as np
+from collections import OrderedDict, defaultdict # Added defaultdict
+import asyncio
 
 # --- Module Imports ---
 from utils.gradio_utils import get_url_user_token
 
-# Configuration (assuming these exist and are correctly defined)
+# Functions from newly created/refactored modules
 from config import (
     LINKEDIN_CLIENT_ID_ENV_VAR, BUBBLE_APP_NAME_ENV_VAR,
     BUBBLE_API_KEY_PRIVATE_ENV_VAR, BUBBLE_API_ENDPOINT_ENV_VAR,
-    # PLOT_ID_TO_FORMULA_KEY_MAP # Used in analytics_handlers
+    PLOT_ID_TO_FORMULA_KEY_MAP # Keep this if used by AnalyticsTab
 )
-# from formulas import PLOT_FORMULAS # Used in analytics_handlers
-
-# Services (assuming these exist and are correctly defined)
 from services.state_manager import process_and_store_bubble_token
 from services.sync_logic import sync_all_linkedin_data_orchestrator
+from ui.ui_generators import (
+    display_main_dashboard,
+    build_analytics_tab_plot_area, # This will be passed to AnalyticsTab
+    BOMB_ICON, EXPLORE_ICON, FORMULA_ICON, ACTIVE_ICON # These will be passed
+)
+from ui.analytics_plot_generator import update_analytics_plots_figures, create_placeholder_plot # Pass these
+from formulas import PLOT_FORMULAS # Keep this if used by AnalyticsTab
 
-# UI Generators (assuming these exist and are correctly defined)
-from ui.ui_generators import display_main_dashboard #, build_analytics_tab_plot_area, BOMB_ICON, EXPLORE_ICON, FORMULA_ICON, ACTIVE_ICON
+# --- EXISTING CHATBOT MODULE IMPORTS ---
+from features.chatbot.chatbot_prompts import get_initial_insight_prompt_and_suggestions # Pass this
+from features.chatbot.chatbot_handler import generate_llm_response # Pass this
 
-# Tab Setup UI functions
-from ui.dashboard_sync_tab import setup_dashboard_sync_tab
-from ui.analytics_tab_setup import setup_analytics_tab
-from ui.agentic_report_tab import setup_agentic_report_tab
-from ui.agentic_okrs_tab import setup_agentic_okrs_tab
+# --- NEW AGENTIC PIPELINE IMPORTS ---
+try:
+    from run_agentic_pipeline import run_full_analytics_orchestration
+    from ui.insights_ui_generator import (
+        format_report_to_markdown,
+        extract_key_results_for_selection,
+        format_single_okr_for_display
+    )
+    AGENTIC_MODULES_LOADED = True
+except ImportError as e:
+    logging.error(f"Could not import agentic pipeline modules: {e}. Tabs 3 and 4 will be disabled.")
+    AGENTIC_MODULES_LOADED = False
+    async def run_full_analytics_orchestration(*args, **kwargs): return None # Placeholder
+    def format_report_to_markdown(report_string): return "Agentic modules not loaded. Report unavailable." # Placeholder
+    def extract_key_results_for_selection(okrs_dict): return [] # Placeholder
+    def format_single_okr_for_display(okr_data, **kwargs): return "Agentic modules not loaded. OKR display unavailable." # Placeholder
 
-# Handler Classes
-from services.dashboard_sync_handlers import DashboardSyncHandlers
-from services.analytics_handlers import AnalyticsHandlers
-from services.agentic_handlers import AgenticHandlers, AGENTIC_MODULES_LOADED as AGENTIC_HANDLERS_MODULES_LOADED
 
-# Check consistency of AGENTIC_MODULES_LOADED
-# This flag is crucial for conditional UI rendering and functionality.
-# The one from AgenticHandlers is based on its own try-except for its specific imports.
-# We might need a global one if app.py itself tries to import agentic modules directly.
-# For now, using the one from AgenticHandlers as it's most relevant to agentic functionality.
-APP_AGENTIC_MODULES_LOADED = AGENTIC_HANDLERS_MODULES_LOADED
+# --- IMPORT THE NEW ANALYTICS TAB MODULE ---
+from services.analytics_tab_module import AnalyticsTab # Assuming analytics_tab_module.py is in the services directory
 
 # Configure logging
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(module)s - %(message)s')
 
 # API Key Setup
-os.environ["GOOGLE_GENAI_USE_VERTEXAI"] = "False" 
+os.environ["GOOGLE_GENAI_USE_VERTEXAI"] = "False"
 user_provided_api_key = os.environ.get("GEMINI_API_KEY")
 if user_provided_api_key:
     os.environ["GOOGLE_API_KEY"] = user_provided_api_key
@@ -60,212 +68,349 @@ if user_provided_api_key:
 else:
     logging.error("CRITICAL ERROR: The API key environment variable 'GEMINI_API_KEY' was not found.")
 
-# --- Main Gradio Application ---
+
 with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
                 title="LinkedIn Organization Dashboard") as app:
-
-    # --- Global States ---
     token_state = gr.State(value={
         "token": None, "client_id": None, "org_urn": None,
         "bubble_posts_df": pd.DataFrame(), "bubble_post_stats_df": pd.DataFrame(),
-        "bubble_mentions_df": pd.DataFrame(), 
+        "bubble_mentions_df": pd.DataFrame(),
         "bubble_follower_stats_df": pd.DataFrame(),
         "fetch_count_for_api": 0, "url_user_token_temp_storage": None,
         "config_date_col_posts": "published_at", "config_date_col_mentions": "date",
         "config_date_col_followers": "date", "config_media_type_col": "media_type",
         "config_eb_labels_col": "li_eb_label"
     })
-    
-    # States for analytics tab chatbot
-    chat_histories_st = gr.State({}) # Stores chat histories for each plot_id {plot_id: [{"role":"user",...}]}
-    current_chat_plot_id_st = gr.State(None) # ID of the plot currently active in chat
-    plot_data_for_chatbot_st = gr.State({}) # Stores summaries for plots {plot_id: "summary text"}
 
-    # States for analytics tab panel management
-    active_panel_action_state = gr.State(None) # Tracks current active panel e.g. {"plot_id": "X", "type": "insights"}
-    explored_plot_id_state = gr.State(None) # Tracks if a plot is being "explored" (others hidden)
+    # States for existing analytics tab chatbot - these are passed to AnalyticsTab
+    chat_histories_st = gr.State({})
+    current_chat_plot_id_st = gr.State(None)
+    plot_data_for_chatbot_st = gr.State({}) # This will be populated by the analytics module's refresh
 
-    # States for Agentic Pipeline
-    orchestration_raw_results_st = gr.State(None) # Stores raw output from run_full_analytics_orchestration
-    key_results_for_selection_st = gr.State([]) # Stores list of dicts for KR checkbox group choices
-    selected_key_result_ids_st = gr.State([]) # Stores list of selected KR unique IDs from checkbox group (though CBG value is source of truth)
+    # --- STATES FOR AGENTIC PIPELINE ---
+    orchestration_raw_results_st = gr.State(None) # Stores the full raw output from the agentic pipeline
+    key_results_for_selection_st = gr.State([]) # Stores the list of dicts for KR selection (label, id, etc.)
+    selected_key_result_ids_st = gr.State([]) # Stores the unique_kr_ids selected in the CheckboxGroup
 
-    # --- Hidden Components for URL Params ---
     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...")
     org_urn_display = gr.Textbox(label="URN Organizzazione (Nascosto)", interactive=False, visible=False)
 
-    # --- Load URL parameters ---
-    # This runs on app load to fetch params from the URL query string
     app.load(fn=get_url_user_token, inputs=None, outputs=[url_user_token_display, org_urn_display], api_name="get_url_params", show_progress=False)
 
-    # --- UI Setup for Tabs ---
+    def initial_load_sequence(url_token, org_urn_val, current_state):
+        status_msg, new_state, btn_update = process_and_store_bubble_token(url_token, org_urn_val, current_state)
+        dashboard_content = display_main_dashboard(new_state)
+        return status_msg, new_state, btn_update, dashboard_content
+
+    # --- Instantiate the AnalyticsTab module ---
+    analytics_icons = {
+        'bomb': BOMB_ICON, 'explore': EXPLORE_ICON,
+        'formula': FORMULA_ICON, 'active': ACTIVE_ICON
+    }
+    analytics_tab_instance = AnalyticsTab(
+        token_state=token_state,
+        chat_histories_st=chat_histories_st,
+        current_chat_plot_id_st=current_chat_plot_id_st,
+        plot_data_for_chatbot_st=plot_data_for_chatbot_st,
+        plot_id_to_formula_map=PLOT_ID_TO_FORMULA_KEY_MAP,
+        plot_formulas_data=PLOT_FORMULAS,
+        icons=analytics_icons,
+        fn_build_plot_area=build_analytics_tab_plot_area,
+        fn_update_plot_figures=update_analytics_plots_figures,
+        fn_create_placeholder_plot=create_placeholder_plot,
+        fn_get_initial_insight=get_initial_insight_prompt_and_suggestions,
+        fn_generate_llm_response=generate_llm_response
+    )
+
     with gr.Tabs() as tabs:
         with gr.TabItem("1️⃣ Dashboard & Sync", id="tab_dashboard_sync"):
-            dashboard_sync_components = setup_dashboard_sync_tab()
+            gr.Markdown("Il sistema controlla i dati esistenti da Bubble. 'Sincronizza' si attiva se sono necessari nuovi dati.")
+            sync_data_btn = gr.Button("🔄 Sincronizza Dati LinkedIn", variant="primary", visible=False, interactive=False)
+            sync_status_html_output = gr.HTML("<p style='text-align:center;'>Stato sincronizzazione...</p>")
+            dashboard_display_html = gr.HTML("<p style='text-align:center;'>Caricamento dashboard...</p>")
 
-        with gr.TabItem("2️⃣ Analisi Grafici", id="tab_analytics"):
-            analytics_components = setup_analytics_tab() # This returns a dict of all components in the tab
+        # --- Use the AnalyticsTab module to create Tab 2 ---
+        analytics_tab_instance.create_tab_ui()
 
-        # Agentic tabs are conditional
-        agentic_report_components = {}
-        agentic_okrs_components = {}
+        # --- Tab 3: Agentic Analysis Report ---
+        with gr.TabItem("3️⃣ Agentic Analysis Report", id="tab_agentic_report", visible=AGENTIC_MODULES_LOADED):
+            gr.Markdown("## 🤖 Comprehensive Analysis Report (AI Generated)")
+            agentic_pipeline_status_md = gr.Markdown("Stato Pipeline AI (filtro 'Sempre'): In attesa...", visible=True)
+            gr.Markdown("Questo report è generato da un agente AI con filtro 'Sempre' sui dati disponibili. Rivedi criticamente.")
+            agentic_report_display_md = gr.Markdown("La pipeline AI si avvierà automaticamente dopo il caricamento iniziale dei dati o dopo una sincronizzazione.")
+            if not AGENTIC_MODULES_LOADED:
+                gr.Markdown("🔴 **Error:** Agentic pipeline modules could not be loaded. This tab is disabled.")
 
-        with gr.TabItem("3️⃣ Agentic Analysis Report", id="tab_agentic_report", visible=APP_AGENTIC_MODULES_LOADED):
-            agentic_report_components = setup_agentic_report_tab(APP_AGENTIC_MODULES_LOADED)
-        
-        with gr.TabItem("4️⃣ Agentic OKRs & Tasks", id="tab_agentic_okrs", visible=APP_AGENTIC_MODULES_LOADED):
-            agentic_okrs_components = setup_agentic_okrs_tab(APP_AGENTIC_MODULES_LOADED)
+        # --- Tab 4: Agentic OKRs & Tasks ---
+        with gr.TabItem("4️⃣ Agentic OKRs & Tasks", id="tab_agentic_okrs", visible=AGENTIC_MODULES_LOADED):
+            gr.Markdown("## 🎯 AI Generated OKRs and Actionable Tasks (filtro 'Sempre')")
+            gr.Markdown("Basato sull'analisi AI (filtro 'Sempre'), l'agente ha proposto i seguenti OKR e task. Seleziona i Key Results per dettagli.")
+            if not AGENTIC_MODULES_LOADED:
+                gr.Markdown("🔴 **Error:** Agentic pipeline modules could not be loaded. This tab is disabled.")
+            with gr.Row():
+                with gr.Column(scale=1):
+                    gr.Markdown("### Suggested Key Results (da analisi 'Sempre')")
+                    key_results_cbg = gr.CheckboxGroup(label="Select Key Results", choices=[], value=[], interactive=True)
+                with gr.Column(scale=3):
+                    gr.Markdown("### Detailed OKRs and Tasks for Selected Key Results")
+                    okr_detail_display_md = gr.Markdown("I dettagli OKR appariranno qui dopo l'esecuzione della pipeline AI.")
 
-    # --- Initialize Handlers ---
-    dashboard_sync_handler = DashboardSyncHandlers(
-        dashboard_sync_components, token_state, url_user_token_display, org_urn_display, status_box
-    )
-    
-    analytics_handler = AnalyticsHandlers(
-        analytics_components, token_state, chat_histories_st, current_chat_plot_id_st, 
-        plot_data_for_chatbot_st, active_panel_action_state, explored_plot_id_state
-    )
-    
-    agentic_handler = None
-    if APP_AGENTIC_MODULES_LOADED:
-        agentic_handler = AgenticHandlers(
-            agentic_report_components, agentic_okrs_components, token_state,
-            orchestration_raw_results_st, key_results_for_selection_st, selected_key_result_ids_st
+            def update_okr_display_on_selection(selected_kr_unique_ids: list, raw_orchestration_results: dict, all_krs_for_selection: list):
+                if not raw_orchestration_results or not AGENTIC_MODULES_LOADED:
+                    return gr.update(value="Nessun dato dalla pipeline AI o moduli non caricati.")
+
+                actionable_okrs_dict = raw_orchestration_results.get("actionable_okrs_and_tasks")
+                if not actionable_okrs_dict or not isinstance(actionable_okrs_dict.get("okrs"), list):
+                    return gr.update(value="Nessun OKR trovato nei risultati della pipeline.")
+
+                okrs_list = actionable_okrs_dict["okrs"]
+                # Ensure all_krs_for_selection is a list of dicts with expected keys
+                if not all_krs_for_selection or not isinstance(all_krs_for_selection, list) or \
+                   not all(isinstance(kr, dict) and 'unique_kr_id' in kr and 'okr_index' in kr and 'kr_index' in kr for kr in all_krs_for_selection):
+                    logging.error("all_krs_for_selection is not in the expected format.")
+                    return gr.update(value="Errore interno: formato dati KR non valido.")
+
+
+                kr_id_to_indices = {kr_info['unique_kr_id']: (kr_info['okr_index'], kr_info['kr_index']) for kr_info in all_krs_for_selection}
+
+                selected_krs_by_okr_idx = defaultdict(list)
+                if selected_kr_unique_ids:
+                    for kr_unique_id in selected_kr_unique_ids:
+                        if kr_unique_id in kr_id_to_indices:
+                            okr_idx, kr_idx = kr_id_to_indices[kr_unique_id]
+                            selected_krs_by_okr_idx[okr_idx].append(kr_idx)
+
+                output_md_parts = []
+                if not okrs_list:
+                    output_md_parts.append("Nessun OKR generato.")
+                else:
+                    for okr_idx, okr_data in enumerate(okrs_list):
+                        accepted_indices_for_this_okr = selected_krs_by_okr_idx.get(okr_idx)
+                        # If specific KRs are selected, only show OKRs that have at least one of the selected KRs
+                        # OR if no KRs are selected at all, show all OKRs.
+                        if selected_kr_unique_ids: # User has made a selection
+                            if accepted_indices_for_this_okr is not None: # This OKR has some of the selected KRs
+                                output_md_parts.append(format_single_okr_for_display(okr_data, accepted_kr_indices=accepted_indices_for_this_okr, okr_main_index=okr_idx))
+                        else: # No KRs selected, show all OKRs with all their KRs
+                            output_md_parts.append(format_single_okr_for_display(okr_data, accepted_kr_indices=None, okr_main_index=okr_idx))
+                
+                if not output_md_parts and selected_kr_unique_ids:
+                    final_md = "Nessun OKR corrisponde alla selezione corrente o i KR selezionati non hanno task dettagliati."
+                elif not output_md_parts and not selected_kr_unique_ids: # Should be covered by "Nessun OKR generato."
+                    final_md = "Nessun OKR generato."
+                else:
+                    final_md = "\n\n---\n\n".join(output_md_parts)
+                return gr.update(value=final_md)
+
+            if AGENTIC_MODULES_LOADED:
+                key_results_cbg.change(
+                    fn=update_okr_display_on_selection,
+                    inputs=[key_results_cbg, orchestration_raw_results_st, key_results_for_selection_st],
+                    outputs=[okr_detail_display_md],
+                    api_name="update_okr_display_on_selection_module"
+                )
+
+    async def run_agentic_pipeline_autonomously(current_token_state_val):
+        logging.info(f"Agentic pipeline check triggered for token_state update. Current token: {'Set' if current_token_state_val.get('token') else 'Not Set'}")
+        # Initial state before pipeline runs or if skipped
+        initial_yield = (
+            gr.update(value="Pipeline AI: In attesa dei dati necessari..."), # agentic_report_display_md
+            gr.update(choices=[], value=[], interactive=False),             # key_results_cbg
+            gr.update(value="Pipeline AI: In attesa dei dati necessari..."), # okr_detail_display_md
+            orchestration_raw_results_st.value, # Preserve current raw results
+            selected_key_result_ids_st.value,   # Preserve current selection
+            key_results_for_selection_st.value, # Preserve current options
+            "Pipeline AI: In attesa dei dati..." # agentic_pipeline_status_md
         )
 
-    # --- Setup Event Handlers from Handler Classes ---
-    # Dashboard/Sync handlers are mostly involved in chained events below
-    analytics_handler.setup_event_handlers() # Sets up internal events for analytics tab
-    
-    if APP_AGENTIC_MODULES_LOADED and agentic_handler:
-        agentic_handler.setup_event_handlers() # Sets up internal events for agentic tabs (e.g., KR selection)
+        if not current_token_state_val or not current_token_state_val.get("token"):
+            logging.info("Agentic pipeline: Token not available in token_state. Skipping.")
+            yield initial_yield
+            return
 
-    # --- Chained Event Logic (Initial Load & Sync) ---
-    
-    # Outputs for the agentic pipeline run
-    # Ensure these components exist even if the tab is not visible, or handle None gracefully.
+        logging.info("Agentic pipeline starting autonomously with 'Sempre' filter.")
+        # Update status to indicate processing
+        yield (
+            gr.update(value="Analisi AI (Sempre) in corso..."),
+            gr.update(choices=[], value=[], interactive=False), # Keep CBG disabled during run
+            gr.update(value="Dettagli OKR (Sempre) in corso di generazione..."),
+            orchestration_raw_results_st.value, # Preserve
+            selected_key_result_ids_st.value,   # Preserve
+            key_results_for_selection_st.value, # Preserve
+            "Esecuzione pipeline AI (Sempre)..."
+        )
+
+        if not AGENTIC_MODULES_LOADED:
+            logging.warning("Agentic modules not loaded. Skipping autonomous pipeline.")
+            yield (
+                gr.update(value="Moduli AI non caricati. Report non disponibile."),
+                gr.update(choices=[], value=[], interactive=False),
+                gr.update(value="Moduli AI non caricati. OKR non disponibili."),
+                None, [], [], "Pipeline AI: Moduli non caricati."
+            )
+            return
+
+        try:
+            # Parameters for 'Sempre' filter for the agentic pipeline
+            date_filter_val_agentic = "Sempre"
+            custom_start_val_agentic = None
+            custom_end_val_agentic = None
+
+            orchestration_output = await run_full_analytics_orchestration(
+                current_token_state_val,
+                date_filter_val_agentic,
+                custom_start_val_agentic,
+                custom_end_val_agentic
+            )
+            agentic_status_text = "Pipeline AI (Sempre) completata."
+            logging.info(f"Autonomous agentic pipeline finished. Output keys: {orchestration_output.keys() if orchestration_output else 'None'}")
+
+            if orchestration_output:
+                orchestration_results_update = orchestration_output # Store full results in state
+                report_str = orchestration_output.get('comprehensive_analysis_report', "Nessun report dettagliato fornito.")
+                agentic_report_md_update = gr.update(value=format_report_to_markdown(report_str))
+
+                actionable_okrs = orchestration_output.get('actionable_okrs_and_tasks') # This is the dict containing 'okrs' list
+                krs_for_ui_selection_list = extract_key_results_for_selection(actionable_okrs) # Expects the dict
+                
+                krs_for_selection_update = krs_for_ui_selection_list # Update state with list of KR dicts
+                
+                # Choices for CheckboxGroup: list of (label, value) tuples
+                kr_choices_for_cbg = [(kr['kr_description'], kr['unique_kr_id']) for kr in krs_for_ui_selection_list]
+                key_results_cbg_update = gr.update(choices=kr_choices_for_cbg, value=[], interactive=True) # Reset selection
+
+                # Display all OKRs by default after pipeline run
+                all_okrs_md_parts = []
+                if actionable_okrs and isinstance(actionable_okrs.get("okrs"), list):
+                    for okr_idx, okr_item in enumerate(actionable_okrs["okrs"]):
+                        all_okrs_md_parts.append(format_single_okr_for_display(okr_item, accepted_kr_indices=None, okr_main_index=okr_idx))
+                
+                if not all_okrs_md_parts:
+                    okr_detail_display_md_update = gr.update(value="Nessun OKR generato o trovato (Sempre).")
+                else:
+                    okr_detail_display_md_update = gr.update(value="\n\n---\n\n".join(all_okrs_md_parts))
+                
+                selected_krs_update = [] # Reset selected KRs state
+            else:
+                agentic_report_md_update = gr.update(value="Nessun report generato dalla pipeline AI (Sempre).")
+                key_results_cbg_update = gr.update(choices=[], value=[], interactive=False)
+                okr_detail_display_md_update = gr.update(value="Nessun OKR generato o errore nella pipeline AI (Sempre).")
+                orchestration_results_update = None
+                selected_krs_update = []
+                krs_for_selection_update = []
+
+            yield (
+                agentic_report_md_update,
+                key_results_cbg_update,
+                okr_detail_display_md_update,
+                orchestration_results_update, # state
+                selected_krs_update,          # state
+                krs_for_selection_update,     # state
+                agentic_status_text
+            )
+        except Exception as e:
+            logging.error(f"Error during autonomous agentic pipeline execution: {e}", exc_info=True)
+            agentic_status_text = f"Errore pipeline AI (Sempre): {str(e)}"
+            yield (
+                gr.update(value=f"Errore generazione report AI (Sempre): {str(e)}"),
+                gr.update(choices=[], value=[], interactive=False),
+                gr.update(value=f"Errore generazione OKR AI (Sempre): {str(e)}"),
+                None, [], [], agentic_status_text # Reset states on error
+            )
+
+    # Define the output list for the agentic pipeline callbacks
+    # Order: Report MD, KR CBG, OKR Detail MD, RawResults State, SelectedKRIDs State, KRList State, Status MD
     agentic_pipeline_outputs_list = [
-        agentic_report_components.get("agentic_report_display_md", gr.update()),
-        agentic_okrs_components.get("key_results_cbg", gr.update()),
-        agentic_okrs_components.get("okr_detail_display_md", gr.update()),
+        agentic_report_display_md,
+        key_results_cbg,
+        okr_detail_display_md,
         orchestration_raw_results_st,
-        selected_key_result_ids_st, # This state is primarily driven by CBG, but pipeline might reset it
+        selected_key_result_ids_st,
         key_results_for_selection_st,
-        agentic_report_components.get("agentic_pipeline_status_md", gr.update())
+        agentic_pipeline_status_md
     ]
-    
-    # Initial Load Sequence:
-    # 1. Get URL token (app.load)
-    # 2. Process token, update dashboard (initial_load_sequence from dashboard_sync_handler)
-    # 3. Refresh analytics graphs (analytics_handler.refresh_analytics_graphs_ui)
-    # 4. Run agentic pipeline (agentic_handler.run_agentic_pipeline_autonomously_on_update)
-
-    initial_load_event = org_urn_display.change( # Triggers after app.load populates org_urn_display
-        fn=dashboard_sync_handler.initial_load_sequence,
+    agentic_pipeline_inputs = [token_state] # Input for the autonomous run
+
+    # --- Event Handling ---
+    initial_load_event = org_urn_display.change(
+        fn=initial_load_sequence,
         inputs=[url_user_token_display, org_urn_display, token_state],
-        outputs=[
-            status_box, 
-            token_state, 
-            dashboard_sync_components['sync_data_btn'], 
-            dashboard_sync_components['dashboard_display_html']
-        ],
-        show_progress="full" # For the initial data processing part
+        outputs=[status_box, token_state, sync_data_btn, dashboard_display_html],
+        show_progress="full"
     )
 
-    # Chain analytics refresh after initial load
     initial_load_event.then(
-        fn=analytics_handler.refresh_analytics_graphs_ui,
+        fn=analytics_tab_instance._refresh_analytics_graphs_ui,
         inputs=[
-            token_state, 
-            analytics_components['date_filter_selector'], 
-            analytics_components['custom_start_date_picker'], 
-            analytics_components['custom_end_date_picker']
-            # chat_histories_st is accessed via self.chat_histories_st in the handler
+            token_state,
+            analytics_tab_instance.date_filter_selector,
+            analytics_tab_instance.custom_start_date_picker,
+            analytics_tab_instance.custom_end_date_picker,
+            chat_histories_st
         ],
-        outputs=analytics_handler._get_graph_refresh_outputs_list(), # Get the list of output components
-        show_progress="full" # For graph generation
+        outputs=analytics_tab_instance.graph_refresh_outputs_list,
+        show_progress="full"
+    ).then(
+        fn=run_agentic_pipeline_autonomously, # Generator function
+        inputs=agentic_pipeline_inputs,
+        outputs=agentic_pipeline_outputs_list,
+        show_progress="minimal" # Use minimal for generators that yield status
     )
-    
-    # Chain agentic pipeline run after initial analytics refresh (if modules loaded)
-    if APP_AGENTIC_MODULES_LOADED and agentic_handler:
-        initial_load_event.then( # Chaining from initial_load_event ensures it uses the updated token_state
-            fn=agentic_handler.run_agentic_pipeline_autonomously_on_update,
-            inputs=[token_state], # Depends on the updated token_state
-            outputs=agentic_pipeline_outputs_list,
-            show_progress="minimal" # For agentic pipeline
-        )
-
-    # Sync Data Sequence:
-    # 1. sync_all_linkedin_data_orchestrator
-    # 2. process_and_store_bubble_token (to update state based on sync results)
-    # 3. display_main_dashboard
-    # 4. refresh_analytics_graphs_ui
-    # 5. run_agentic_pipeline_autonomously_on_update
 
-    sync_event_part1 = dashboard_sync_components['sync_data_btn'].click(
-        fn=sync_all_linkedin_data_orchestrator, # From services.sync_logic
+    sync_event_part1 = sync_data_btn.click(
+        fn=sync_all_linkedin_data_orchestrator,
         inputs=[token_state],
-        outputs=[dashboard_sync_components['sync_status_html_output'], token_state],
-        show_progress="full" # For the main sync operation
+        outputs=[sync_status_html_output, token_state],
+        show_progress="full"
     )
-    
     sync_event_part2 = sync_event_part1.then(
-        fn=process_and_store_bubble_token, # From services.state_manager
-        inputs=[url_user_token_display, org_urn_display, token_state], # Uses the updated token_state from part1
-        outputs=[status_box, token_state, dashboard_sync_components['sync_data_btn']],
-        show_progress=False # Quick state update
+        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
     )
-    
-    # Chain agentic pipeline run after sync and token processing (if modules loaded)
-    if APP_AGENTIC_MODULES_LOADED and agentic_handler:
-        sync_event_part2.then(
-            fn=agentic_handler.run_agentic_pipeline_autonomously_on_update,
-            inputs=[token_state], # Uses the token_state updated by process_and_store_bubble_token
-            outputs=agentic_pipeline_outputs_list,
-            show_progress="minimal"
-        )
-        
-    sync_event_part3 = sync_event_part2.then( # Continues from token processing
-        fn=display_main_dashboard, # From ui.ui_generators
-        inputs=[token_state], # Uses the updated token_state
-        outputs=[dashboard_sync_components['dashboard_display_html']],
-        show_progress=False # Quick UI update
+    sync_event_part2.then(
+        fn=run_agentic_pipeline_autonomously, # Generator function
+        inputs=agentic_pipeline_inputs,
+        outputs=agentic_pipeline_outputs_list,
+        show_progress="minimal"
     )
-    
-    # Chain analytics refresh after dashboard update post-sync
-    sync_event_part3.then(
-        fn=analytics_handler.refresh_analytics_graphs_ui,
+    sync_event_part3 = sync_event_part2.then(
+        fn=display_main_dashboard,
+        inputs=[token_state],
+        outputs=[dashboard_display_html],
+        show_progress=False
+    )
+    sync_event_graphs_after_sync = sync_event_part3.then(
+        fn=analytics_tab_instance._refresh_analytics_graphs_ui,
         inputs=[
-            token_state, 
-            analytics_components['date_filter_selector'], 
-            analytics_components['custom_start_date_picker'], 
-            analytics_components['custom_end_date_picker']
+            token_state,
+            analytics_tab_instance.date_filter_selector,
+            analytics_tab_instance.custom_start_date_picker,
+            analytics_tab_instance.custom_end_date_picker,
+            chat_histories_st
         ],
-        outputs=analytics_handler._get_graph_refresh_outputs_list(),
-        show_progress="full" # For graph generation after sync
+        outputs=analytics_tab_instance.graph_refresh_outputs_list,
+        show_progress="full"
     )
 
-
-# --- Launch ---
 if __name__ == "__main__":
-    # Environment variable checks (optional but good practice)
-    if not os.environ.get(LINKEDIN_CLIENT_ID_ENV_VAR): 
+    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 APP_AGENTIC_MODULES_LOADED: 
-        logging.warning("CRITICAL: Agentic pipeline modules failed to load. Agentic tabs (3 and 4) will be non-functional or hidden.")
-    
-    if not os.environ.get("GEMINI_API_KEY") and APP_AGENTIC_MODULES_LOADED: 
-        logging.warning("ATTENZIONE: 'GEMINI_API_KEY' non impostata. La pipeline AI per le tab 3 e 4 potrebbe non funzionare.")
+        logging.warning("ATTENZIONE: Una o più variabili d'ambiente Bubble (BUBBLE_APP_NAME, BUBBLE_API_KEY_PRIVATE, BUBBLE_API_ENDPOINT) non sono impostate.")
+    if not AGENTIC_MODULES_LOADED:
+        logging.warning("CRITICAL: Agentic pipeline modules failed to load. Tabs 3 and 4 (Agentic Report & OKRs) will be non-functional.")
+    if not os.environ.get("GEMINI_API_KEY"): # Check GEMINI_API_KEY directly as GOOGLE_API_KEY is derived
+        logging.warning("ATTENZIONE: 'GEMINI_API_KEY' non impostata. Questo è necessario per le funzionalità AI, incluse le tab agentiche e il chatbot dei grafici.")
     
-    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)
+    try:
+        logging.info(f"Gradio version: {gr.__version__}")
+        logging.info(f"Pandas version: {pd.__version__}")
+        logging.info(f"Matplotlib version: {matplotlib.__version__}, Backend: {matplotlib.get_backend()}")
+    except Exception as e:
+        logging.warning(f"Could not log library versions: {e}")
 
+    app.launch(server_name="0.0.0.0", server_port=int(os.environ.get("PORT", 7860)), debug=True)