Update app.py

app.py

@@ -1,256 +1,230 @@
-# app.py
-
 import gradio as gr
 import os
+from llama_index.core import Settings
+from llama_index.llms.anthropic import Anthropic
+from llama_index.core.llms import ChatMessage, MessageRole
 import traceback
 import asyncio
-from dotenv import load_dotenv
-from models.task_prompt import TaskPrompt # Ensure this path is correct
-import time
-from llama_index.core import Settings as LlamaSettings
-from llama_index.llms.anthropic import Anthropic
-from manager_agent import ManagerAgent # Ensure this path is correct
-import concurrent.futures
+from dotenv import load_dotenv  # Make sure to use this
+import uuid
+from models.task_prompt import TaskPrompt  # Import from models directory
 
 # Load environment variables from .env file
 load_dotenv()
 
+# Import your ManagerAgent and related classes
+from manager_agent2 import ManagerAgent  # Using the existing manager_agent.py file
+
 # --- Configuration ---
-LLM_MODEL = "claude-sonnet-4-20250514" # Ensure this model is available to your Anthropic key
+LLM_MODEL = "claude-sonnet-4-20250514"  # Modèle Claude Opus 4
 
-# --- Global variables ---
+# --- Global variables for update handling ---
+status_update_queue = asyncio.Queue()
 current_status = "Ready"
-llm_global = None
-manager_agent_global = None
-
-# Thread pool executor for running blocking agent tasks
-# Use a smaller number of workers on resource-constrained environments like HF Spaces free tier
-MAX_WORKERS = min(4, (os.cpu_count() or 1) + 4) # Based on concurrent.futures recommendation
-thread_pool_executor = concurrent.futures.ThreadPoolExecutor(max_workers=MAX_WORKERS)
-
 
 # --- LlamaIndex LLM Initialization ---
-def initialize_components():
-    global llm_global, manager_agent_global
-
+def initialize_llm_and_agent():
+    """Initialize LLM and Manager Agent with proper error handling"""
+    
+    # Check if API key is available
     api_key = os.environ.get("ANTHROPIC_API_KEY")
     if not api_key:
         print("\n" + "="*60)
         print("⚠️ ERROR: ANTHROPIC_API_KEY not found in environment variables!")
-        print("Please set your ANTHROPIC_API_KEY as a Secret in your Hugging Face Space.")
+        print("Please set your API key using one of these methods:")
+        print("1. Create a .env file with: ANTHROPIC_API_KEY=your-api-key-here")
+        print("2. Set as environment variable: export ANTHROPIC_API_KEY='your-api-key-here'")
         print("="*60 + "\n")
-        # The app will still load, but the agent won't work.
-        # UI should ideally show a persistent error if this happens.
-        return
-
+        return None, None
+    
     try:
-        llm_global = Anthropic(
+        # Initialize LLM with lower temperature for more deterministic responses
+        llm = Anthropic(
             model=LLM_MODEL,
-            temperature=0.2,
-            max_tokens=4096 # Consider if this is too high for some models/responses
+            temperature=0.2,  # Lower temperature for more focused responses
+            max_tokens=4096
         )
-        LlamaSettings.llm = llm_global
-        print(f"Successfully initialized LlamaIndex with Anthropic model: {LLM_MODEL}")
-
-        manager_agent_global = ManagerAgent(
-            llm_global,
-            max_iterations=15, # Reduced for HF Spaces to avoid timeouts on complex tasks
-            update_callback=update_status_callback
+        Settings.llm = llm
+        print(f"Successfully initialized LlamaIndex with Anthropic model: {LLM_MODEL} (temperature=0.2)")
+        
+        # Initialize the ManagerAgent with update callback
+        agent = ManagerAgent(
+            llm, 
+            max_iterations=30,  # Increase max_iterations to avoid "Reached max iterations" error
+            update_callback=update_status  # Pass the update callback function
         )
         print("✅ ManagerAgent initialized successfully")
-
+        
+        return llm, agent
+        
     except Exception as e:
         print(f"Error initializing Anthropic LLM or ManagerAgent: {e}")
         traceback.print_exc()
-        # llm_global or manager_agent_global might be None, handled in generate_bot_reply
+        return None, None
 
-# --- Update callback function (called by ManagerAgent) ---
-def update_status_callback(message):
+# --- Update callback function ---
+def update_status(message):
+    """Callback function for the ManagerAgent to update status"""
     global current_status
     current_status = message
-    print(f"✅ UI_STATUS_UPDATE (via callback): {message}")
+    
+    # Add to queue for the status monitor
+    try:
+        status_update_queue.put_nowait(message)
+    except Exception as e:
+        print(f"Error adding status update to queue: {e}")
 
-# --- Status retrieval function for Gradio polling ---
-def get_current_status_for_ui():
+# --- Status monitor function ---
+async def status_monitor():
+    """Monitor for status updates and update the Gradio component"""
     global current_status
-    timestamp = time.time()
-    return f"{current_status}<span style='display:none;'>{timestamp}</span>"
+    
+    try:
+        # Set initial status
+        yield current_status
+        
+        # Monitor for updates
+        while True:
+            try:
+                # Check for new updates with a timeout
+                message = await asyncio.wait_for(status_update_queue.get(), timeout=0.5)
+                yield message
+            except asyncio.TimeoutError:
+                # No updates, continue waiting
+                await asyncio.sleep(0.1)
+            except Exception as e:
+                print(f"Error in status monitor: {e}")
+                await asyncio.sleep(1)
+    except Exception as e:
+        print(f"Status monitor error: {e}")
+        yield f"Status monitor error: {str(e)}"
+
+# --- Gradio Chat Function ---
+async def respond(message, history):
+    """Fonction de réponse pour Gradio ChatInterface utilisant ManagerAgent"""
+    
+    # Vérifier si le ManagerAgent est initialisé
+    if manager_agent is None or Settings.llm is None:
+        yield "❌ ManagerAgent not initialized. Please check your ANTHROPIC_API_KEY environment variable and ensure all components are properly loaded."
+        return
+    
+    try:
+        print(f"\n🤖 ManagerAgent: Processing user message: '{message[:100]}{'...' if len(message) > 100 else ''}'")
+        
+        # Update status
+        update_status(f"Processing your request: '{message[:50]}{'...' if len(message) > 50 else ''}'")
+        
+        # Créer un TaskPrompt à partir du message utilisateur
+        # Le ManagerAgent va analyser le prompt et décider du workflow approprié
+        task_prompt = TaskPrompt(text=message)
+        
+        print("🔄 ManagerAgent: Starting task execution workflow...")
+        
+        # Get complete response
+        response = manager_agent.run_task(task_prompt)
+        
+        # Simuler un streaming progressif de la réponse pour une meilleure UX
+        words = response.split()
+        partial_response = ""
+        
+        for i, word in enumerate(words):
+            partial_response += word + " "
+            
+            # Yield la réponse progressive toutes les quelques mots pour un effet de streaming
+            if i % 3 == 0 or i == len(words) - 1:  # Toutes les 3 mots ou le dernier mot
+                yield partial_response.strip()
+                # Add a small delay for realistic streaming
+                await asyncio.sleep(0.01)
+        
+        print("✅ ManagerAgent: Task completed successfully")
+        update_status("Ready for your next request")
+            
+    except Exception as e:
+        error_message = f"❌ ManagerAgent Error: {str(e)}"
+        print(f"\n🚨 ManagerAgent Error: {e}")
+        traceback.print_exc()
+        update_status(f"Error: {str(e)}")
+        yield error_message
 
 # --- Gradio Interface Setup ---
-def create_gradio_interface():
-    # Check for API key early for user feedback if possible, though init happens later
+def create_interface():
+    """Crée l'interface Gradio"""
+    
+    # Vérifier la clé API
     if "ANTHROPIC_API_KEY" not in os.environ:
-        # This warning will appear at build time if .env is not used on Spaces
-        # For runtime, secrets are preferred.
-        print("Warning: ANTHROPIC_API_KEY not found in os.environ during UI creation.")
-
-
-    with gr.Blocks(theme="soft") as demo:
-        gr.Markdown("# ALITA")
-        gr.Markdown(f"ALITA is a self-learning AI agent. (Gradio Version: {gr.__version__})")
-
-        chatbot_component = gr.Chatbot(
-            label="Chat",
+        print("\n" + "="*60)
+        print("⚠️ WARNING: ANTHROPIC_API_KEY not found in environment variables!")
+        print("Please set your API key:")
+        print("export ANTHROPIC_API_KEY='your-api-key-here'")
+        print("="*60 + "\n")
+    
+    # Create the chat interface
+    interface = gr.ChatInterface(
+        fn=respond,
+        chatbot=gr.Chatbot(
             height=500,
             show_label=False,
-            type='tuples' # Explicitly set for Gradio 3.x to align with history format
-        )
-
+            container=True,
+            type="messages"
+        ),
+        textbox=gr.Textbox(
+            placeholder="Tapez votre message ici...",
+            container=False,
+            scale=7
+        ),
+        title="ALITA",
+        description=f"ALITA is a self-learning AI agent that can search for information, analyze data, create tools, and orchestrate complex tasks.",
+        examples=[
+            "🔍 Recherche des informations sur l'intelligence artificielle",
+            "📊 Analyse les tendances du marché technologique",
+            "⚡ Crée un script pour automatiser une tâche répétitive",
+            "🌐 Trouve des ressources open source pour machine learning",
+        ],
+        theme="soft"
+    )
+    
+    # Add the status box
+    with interface:
         with gr.Row():
-            message_textbox = gr.Textbox(
-                placeholder="Tapez votre message ici...",
-                scale=7,
-                show_label=False,
-                container=False
-            )
-
-        gr.Examples(
-            examples=[
-                "Hello",
-                "What is the temperature in Paris now?",
-                "🔍 Recherche des informations sur l'intelligence artificielle",
-                "📊 Analyse les tendances du marché technologique",
-            ],
-            inputs=message_textbox,
-        )
-
-        status_box_component = gr.Textbox(
-            label="Agent Status",
-            value=get_current_status_for_ui(), # Initial value
-            interactive=False,
-        )
-
-        def add_user_msg(user_input_text, chat_history_list):
-            if chat_history_list is None: # Robustness for first message
-                chat_history_list = []
-            if not user_input_text.strip():
-                return gr.update(value=user_input_text), chat_history_list # Return original textbox value if empty
-            chat_history_list.append((user_input_text, None)) # Using tuple format
-            return gr.update(value=""), chat_history_list
-
-        async def generate_bot_reply(chat_history_list):
-            if chat_history_list is None or not chat_history_list or chat_history_list[-1][0] is None:
-                yield [] # Return empty history or handle as error
-                return
-
-            user_message = chat_history_list[-1][0]
-
-            if manager_agent_global is None or LlamaSettings.llm is None:
-                update_status_callback("⚠️ Error: Agent or LLM not initialized. Check API key and logs.")
-                # Ensure history is not None before trying to update
-                current_user_msg_tuple = chat_history_list[-1] if chat_history_list else (user_message, None)
-                chat_history_list[-1] = (current_user_msg_tuple[0], "❌ Critical Error: ALITA is not properly initialized. Please check server logs and API key.")
-                yield chat_history_list
-                return
-
-            try:
-                print(f"\n🤖 GRADIOLOG: Processing user message: '{user_message[:100]}'")
-                update_status_callback(f"💬 Processing: '{user_message[:50]}{'...' if len(user_message) > 50 else ''}'")
-                await asyncio.sleep(0.01)
-
-                task_prompt = TaskPrompt(text=user_message)
-
-                update_status_callback("🔄 Analyzing request...")
-                await asyncio.sleep(0.01)
-
-                loop = asyncio.get_event_loop()
-                response_text_from_agent = await loop.run_in_executor(
-                    thread_pool_executor,
-                    manager_agent_global.run_task,
-                    task_prompt
+            with gr.Column():
+                status_box = gr.Textbox(
+                    label="Agent Status",
+                    value="Ready",
+                    interactive=False
                 )
-
-                update_status_callback("✨ Generating final response stream...")
-                await asyncio.sleep(0.01)
-                final_bot_response = response_text_from_agent
-
-                words = final_bot_response.split()
-                accumulated_response_stream = ""
                 
-                current_user_msg_tuple = chat_history_list[-1]
-                chat_history_list[-1] = (current_user_msg_tuple[0], "") # Initialize bot response in tuple
-
-                if not words:
-                    chat_history_list[-1] = (current_user_msg_tuple[0], final_bot_response.strip())
-                    yield chat_history_list
-                else:
-                    for i, word in enumerate(words):
-                        accumulated_response_stream += word + " "
-                        if len(words) > 0:
-                            if i == len(words) // 4: update_status_callback("🔄 Streaming response (25%)...")
-                            elif i == len(words) // 2: update_status_callback("🔄 Streaming response (50%)...")
-                            elif i == (len(words) * 3) // 4: update_status_callback("🔄 Streaming response (75%)...")
-
-                        if i % 3 == 0 or i == len(words) - 1:
-                            chat_history_list[-1] = (current_user_msg_tuple[0], accumulated_response_stream.strip())
-                            yield chat_history_list
-                            await asyncio.sleep(0.01)
-
-                if chat_history_list[-1][1] != final_bot_response.strip():
-                    chat_history_list[-1] = (current_user_msg_tuple[0], final_bot_response.strip())
-                    yield chat_history_list
-                
-                print("✅ GRADIOLOG: Task processing and streaming completed.")
-                update_status_callback("✅ Ready for your next request")
-
-            except Exception as e:
-                error_message_for_ui = f"❌ Gradio/Agent Error: {str(e)}"
-                print(f"\n🚨 GRADIOLOG: Error in generate_bot_reply: {e}")
-                traceback.print_exc()
-                update_status_callback(f"❌ Error: {str(e)[:100]}...")
-                current_user_msg_tuple = chat_history_list[-1] if chat_history_list else (user_message, None)
-                chat_history_list[-1] = (current_user_msg_tuple[0], error_message_for_ui)
-                yield chat_history_list
-        
-        message_textbox.submit(
-            add_user_msg,
-            inputs=[message_textbox, chatbot_component],
-            outputs=[message_textbox, chatbot_component],
-        ).then(
-            generate_bot_reply,
-            inputs=[chatbot_component],
-            outputs=[chatbot_component],
-            api_name=False,
-        )
-
-        async def continuous_status_updater(update_interval_seconds=0.3):
-            print("GRADIOLOG: Starting continuous_status_updater loop.")
-            while True:
-                yield get_current_status_for_ui()
-                await asyncio.sleep(update_interval_seconds)
-
-        # demo.load is the correct way to start a background task on Blocks load
-        demo.load(continuous_status_updater, inputs=None, outputs=status_box_component)
-        print("GRADIOLOG: Continuous status updater loaded.")
-    return demo
+                # Use the Interface for status monitoring
+                gr.Interface(
+                    fn=status_monitor,
+                    inputs=None,
+                    outputs=status_box,
+                    live=True,
+                    show_progress=False
+                )
+    
+    return interface
 
-# Initialize LLM and Agent components
-# This should be called AFTER defining functions it might use if there are complex dependencies,
-# but for global setup, it's fine here.
-initialize_components()
+# Initialize the components
+llm, manager_agent = initialize_llm_and_agent()
 
 # --- Launch the Application ---
 if __name__ == "__main__":
-    print(f"Gradio version being used: {gr.__version__}")
-
     print("🚀 Starting Gradio ALITA Chat Application...")
-    alita_interface = create_gradio_interface()
-
+    
+    # Créer et lancer l'interface
+    app = create_interface()
+    
     try:
-        alita_interface.launch(
-            # share=False, # Share=True can sometimes trigger /api_info more aggressively
-            server_name="0.0.0.0", # For HF Spaces, 0.0.0.0 is often needed
-            server_port=int(os.environ.get('PORT', 7860)), # HF Spaces sets PORT env var
-            show_error=True,
+        app.launch(
+            share=False,
+            server_name="127.0.0.1",
+            server_port=7825,
+            show_error=True
         )
     except KeyboardInterrupt:
         print("\n👋 Application stopped by user")
     except Exception as e:
         print(f"\n❌ Error launching application: {e}")
         traceback.print_exc()
-    finally:
-        print("Shutting down thread pool executor...")
-        if thread_pool_executor: # Check if it was initialized
-            thread_pool_executor.shutdown(wait=False) # HF Spaces might kill it anyway
-
+    
     print("✅ Gradio application stopped.")