Upload 10 files

.gitignore

@@ -0,0 +1,23 @@
+# System files
+.DS_Store
+.lprof
+
+# Environment files
+.env
+.env.*
+
+# Python cache files
+__pycache__/
+*.py[cod]
+*$py.class
+.pytest_cache/
+
+# Virtual environments
+.venv/
+venv/
+ENV/
+env/
+
+# Project specific
+.alita_envs/
+temp_downloads/

README.md

@@ -1,12 +1,315 @@
----
-title: GALITA2
-emoji: 💬
-colorFrom: yellow
-colorTo: purple
-sdk: gradio
-sdk_version: 5.0.1
-app_file: app.py
-pinned: false
----
-
-An example chatbot using [Gradio](https://gradio.app), [`huggingface_hub`](https://huggingface.co/docs/huggingface_hub/v0.22.2/en/index), and the [Hugging Face Inference API](https://huggingface.co/docs/api-inference/index).
+# Gradio-hackathon : Generalist self-evolving ai agent inspired by Alita 
+This is my team project for the gradio hackathon 2025
+This Project is inspired by research paper : `https://arxiv.org/abs/2505.20286`
+
+# 📁 Structure du projet
+```bash
+alita_agent/
+│
+├── main.py                           # Point d'entrée principal : exécute un TaskPrompt via le ManagerAgent
+├── manager_agent.py                  # Logique de coordination centrale, il orchestre tous les composants
+├── task_prompt.py                    # Définit la classe TaskPrompt, contenant la requête utilisateur initiale
+│
+├── components/                       # Contient tous les composants fonctionnels modulaires
+│   ├── __init__.py                   # Rends le dossier importable comme un package
+│   ├── script_generator.py           # Génère dynamiquement du code Python à partir d'un MCPToolSpec
+│   ├── code_runner.py                # Exécute un script dans un environnement isolé et capture le résultat
+│   ├── mcp_registry.py               # Gère l'enregistrement, la recherche et la réutilisation des outils MCP
+│   ├── web_agent.py                  # Effectue des recherches web ou GitHub pour aider à la génération de code
+│   └── mcp_brainstormer.py           # Génère des MCPToolSpec en analysant la tâche utilisateur
+│
+├── models/                           # Contient les classes de données (dataclasses) utilisées dans tout le système
+│   ├── __init__.py                   # Rends le dossier importable comme un package
+│   ├── mcp_tool_spec.py              # Définition de MCPToolSpec (dataclass) : nom, schémas I/O, description, pseudo-code, etc.
+│   └── mcp_execution_result.py       # Définition de MCPExecutionResult (dataclass) : succès, sortie, logs, erreur
+│
+├── tests/                            # Contient les tests unitaires pour chaque module
+│   ├── __init__.py                   # Rends le dossier importable comme un package
+│   ├── test_script_generator.py      # Tests pour vérifier la génération correcte de code et d'environnements
+│   ├── test_code_runner.py           # Tests pour s'assurer de la bonne exécution des scripts et gestion d'erreurs
+│   ├── test_mcp_registry.py          # Tests de l'enregistrement, recherche et appel d'outils dans le registre MCP
+│   └── test_manager_agent.py         # Tests d'intégration sur le comportement global du ManagerAgent
+│
+└── README.md                         # Documentation du projet, instructions, pipeline, inspirations et lien vers le papier
+```
+
+# Project Pipeline 
+
+#### 🔄 Le flux complet avec vérification de l'existence
+1. L'utilisateur envoie un TaskPrompt
+2. Le Manager Agent demande au MCPBrainstormer : "Quels outils faudrait-il pour résoudre cette tâche ?"
+3. Le Brainstormer propose une ou plusieurs specs (MCPToolSpec)
+4. Le Manager Agent consulte le MCPRegistry : "Ai-je déjà un outil enregistré dont le nom + I/O matchent cette spec ?"
+   - Oui ? ➜ réutilise l'outil existant
+   - Non ? ➜ il appel le web agent pour une recherche d'outils open-source pour implementer. Puis, le Manager prend la recherche et la donne a Brainstormer pour commencer la construction.
+
+#### 🔍 Comment détecter que l'outil existe déjà ?
+Par matching sur la spec MCPToolSpec :
+- Nom exact (ou identifiant unique comme un hash)
+
+- Ou plus intelligemment :
+    - même structure input_schema
+    - même output_schema
+    - mêmes rôles ou description proche (avec embedding / vector search)
+
+```python
+def check_existing_tool(spec: MCPToolSpec, registry: MCPRegistry) -> Optional[str]:
+    for registered_spec in registry.list_tools():
+        if registered_spec.input_schema == spec.input_schema and \
+           registered_spec.output_schema == spec.output_schema:
+            return registry.get_tool_endpoint(registered_spec.name)
+    return None
+```
+
+#### 💬 Que fait l'agent s'il le trouve ?
+Il ne régénère rien :
+- Il ajoute l'appel de l'outil MCP existant dans son plan
+- Il formate l'entrée JSON
+- Il appelle POST /predict directement
+- Il utilise la réponse dans la suite de son raisonnement
+
+#### 💡 Cas pratiques
+Differents cas et Réaction attendue de l'agent 
+
+| Situation réelle                          | Réaction de l'agent                                                      |
+| ----------------------------------------- | ------------------------------------------------------------------------ |
+| L'outil `"SubtitleExtractor"` existe déjà | L'agent appelle directement l'endpoint                                   |
+| Le spec est proche mais pas identique     | L'agent peut quand même le réutiliser (avec adaptation)                  |
+| L'outil existe mais a échoué              | L'agent peut **fallback** vers génération d'un nouvel outil MCP          |
+| L'outil existe mais est obsolète          | Le Registry peut signaler une mise à jour ou déclencher une régénération |
+
+
+#### Fonctions attendues 
+
+| Classe               | Méthode attendue                           | Présente ? | Commentaire |
+| -------------------- | ------------------------------------------ | ---------- | ----------- |
+| `ManagerAgent`       | `run_task(prompt)`                         | ✅          | OK          |
+| `MCPBrainstormer`    | `brainstorm(prompt)`                       | ✅          | OK          |
+| `WebAgent`           | `search_github`, `retrieve_readme`         | ✅          | OK          |
+| `ScriptGenerator`    | `generate_code`, `generate_env_script`     | ✅          | OK          |
+| `CodeRunner`         | `execute`, `setup_environment`             | ✅          | OK          |
+| `MCPRegistry`        | `register_tool`, `list_tools`, `call_tool` | ✅          | OK          |
+| `MCPExecutionResult` | attributs `success`, `output`, `logs`      | ✅          | OK          |
+| `MCPToolSpec`        | `name`, `input_schema`, etc.               | ✅          | OK          |
+
+Ici Le ManagerAgent coordonne tout. Il délègue à :
+- MCPBrainstormer → pour générer des specs d'outils.
+- ScriptGenerator → pour générer du code.
+- CodeRunner → pour tester le code.
+- WebAgent → pour récupérer du contexte externe.
+- MCPRegistry → pour enregistrer et réutiliser les outils.
+
+
+![](alitaDiagram.svg)
+
+
+```sh
+plantuml -tsvg README.md
+```
+
+<div hidden>
+<details>
+<summary>Voir le script PlantUML</summary>
+```plantuml
+@startuml alitaDiagram
+
+skinparam classAttributeIconSize 0
+
+' === Classes de données ===
+class TaskPrompt {
+    - text: str
+}
+
+class MCPToolSpec {
+    - name: str
+    - input_schema: dict
+    - output_schema: dict
+    - description: str
+    - pseudo_code: str
+    - source_hint: str
+}
+
+class MCPExecutionResult {
+    - success: bool
+    - output: dict
+    - logs: str
+    - error_message: str
+}
+
+class ToolCall {
+  - tool_name: str
+  - input_data: dict
+  - result: dict
+}
+
+
+' === Agents principaux ===
+class ManagerAgent {
+    - brainstormer: MCPBrainstormer
+    - web_agent: WebAgent
+    - generator: ScriptGenerator
+    - runner: CodeRunner
+    - registry: MCPRegistry
+    + run_task(prompt: TaskPrompt): dict
+    + check_existing_tool(spec: MCPToolSpec) -> Optional[str]
+}
+
+class MCPBrainstormer {
+    + brainstorm(prompt: TaskPrompt): List<MCPToolSpec>
+}
+
+class WebAgent {
+    + search_github(query: str): str
+    + retrieve_readme(repo_url: str): str
+}
+
+class ScriptGenerator {
+    + generate_code(spec: MCPToolSpec): str
+    + generate_env_script(spec: MCPToolSpec): str
+}
+
+class CodeRunner {
+    + execute(script: str): MCPExecutionResult
+    + setup_environment(env_script: str): bool
+}
+
+class MCPRegistry {
+    + register_tool(spec: MCPToolSpec, endpoint_url: str): void
+    + list_tools(): List<MCPToolSpec>
+    + call_tool(tool: str): object
+}
+
+
+
+' === Relations avec types + cardinalités ===
+
+' Le Manager reçoit une tâche utilisateur
+TaskPrompt --> "1" ManagerAgent : provides query
+
+' Manager appelle le Brainstormer
+ManagerAgent --> "1" MCPBrainstormer : calls
+
+' Manager utilise WebAgent
+ManagerAgent "1" <--> "1" WebAgent : queries/answers
+
+' Brainstormer appelle ScriptGenerator et CodeRunner
+MCPBrainstormer --> "1" ScriptGenerator : plans
+MCPBrainstormer --> "1" CodeRunner : validates
+
+' Manager consulte ou enregistre dans le Registry
+ManagerAgent --> "1" MCPRegistry : checks/updates
+
+' Manager construit un plan d'appel d'outils
+ManagerAgent --> "0..*" ToolCall : creates
+
+' Brainstormer retourne des MCPToolSpec
+MCPBrainstormer --> "1..*" MCPToolSpec : returns
+
+' ScriptGenerator utilise MCPToolSpec pour générer
+ScriptGenerator --> "1" MCPToolSpec : consumes
+
+' Registry enregistre des ToolSpecs
+MCPRegistry --> "0..*" MCPToolSpec : stores
+
+' CodeRunner renvoie un résultat d'exécution
+CodeRunner --> "1" MCPExecutionResult : returns
+
+' CodeRunner peut utiliser des outils enregistrés
+CodeRunner --> "0..*" MCPRegistry : queries
+
+
+@enduml
+```
+</details> 
+</div>
+
+# ALITA Research Functionality
+
+This README explains how to use the comprehensive research capabilities of the ALITA ManagerAgent.
+
+## Overview
+
+ALITA can now perform deep, autonomous web research using the WebAgent's research functionality. This allows ALITA to gather information from multiple sources, analyze it, and synthesize a comprehensive report on any topic.
+
+## Usage Methods
+
+There are two ways to use the research functionality:
+
+### 1. Direct Research Method
+
+Call the `research` method directly on the ManagerAgent instance:
+
+```python
+from manager_agent2 import ManagerAgent
+from llama_index.llms.anthropic import Anthropic
+
+# Initialize the LLM and ManagerAgent
+llm = Anthropic(model="claude-3-5-sonnet-20241022", api_key="your-api-key")
+manager = ManagerAgent(llm=llm)
+
+# Perform research directly
+report = manager.research(
+    query="What are the latest developments in quantum computing?",
+    max_iterations=50,  # Optional: limit the number of research steps
+    verbose=True        # Optional: show detailed progress
+)
+
+# The report variable now contains a comprehensive research report
+print(report)
+```
+
+### 2. Tool-Based Research through ReActAgent
+
+Let the ManagerAgent's internal ReActAgent decide when to use research:
+
+```python
+from manager_agent2 import ManagerAgent
+from models import TaskPrompt
+from llama_index.llms.anthropic import Anthropic
+
+# Initialize the LLM and ManagerAgent
+llm = Anthropic(model="claude-3-5-sonnet-20241022", api_key="your-api-key")
+manager = ManagerAgent(llm=llm)
+
+# Create a task prompt
+task_prompt = TaskPrompt(text="I need a comprehensive report on recent developments in quantum computing.")
+
+# Run the task through the agent
+response = manager.run_task(task_prompt)
+
+# The response will include the research report if the agent determined research was needed
+print(response)
+```
+
+The agent will automatically detect when deep research is required based on keywords like "comprehensive," "thorough," "research," etc.
+
+## Running the Test Script
+
+A test script is provided to demonstrate both usage methods:
+
+```bash
+python test_research.py
+```
+
+Make sure to set your Anthropic API key in the environment or in a `.env` file before running the script.
+
+## System Prompt Configuration
+
+The ManagerAgent's system prompt has been updated to include guidance on when to use the research tool:
+
+- For simple information needs: use 'web_search' for quick answers
+- For complex research topics: use 'perform_web_research' for comprehensive autonomous research
+
+## How Research Works
+
+When ALITA performs research:
+
+1. It first analyzes the research query to understand what information is needed
+2. It uses web search to gather relevant sources
+3. It visits and reads the content of each source
+4. It downloads and analyzes relevant documents if needed
+5. It evaluates the credibility and relevance of each source
+6. It synthesizes the information into a comprehensive report
+7. It includes citations and references to the sources used
+
+This enables ALITA to provide high-quality, well-researched answers to complex questions.

app.py

@@ -1,64 +1,266 @@
-import gradio as gr
-from huggingface_hub import InferenceClient
-
-"""
-For more information on `huggingface_hub` Inference API support, please check the docs: https://huggingface.co/docs/huggingface_hub/v0.22.2/en/guides/inference
-"""
-client = InferenceClient("HuggingFaceH4/zephyr-7b-beta")
-
-
-def respond(
-    message,
-    history: list[tuple[str, str]],
-    system_message,
-    max_tokens,
-    temperature,
-    top_p,
-):
-    messages = [{"role": "system", "content": system_message}]
-
-    for val in history:
-        if val[0]:
-            messages.append({"role": "user", "content": val[0]})
-        if val[1]:
-            messages.append({"role": "assistant", "content": val[1]})
-
-    messages.append({"role": "user", "content": message})
-
-    response = ""
-
-    for message in client.chat_completion(
-        messages,
-        max_tokens=max_tokens,
-        stream=True,
-        temperature=temperature,
-        top_p=top_p,
-    ):
-        token = message.choices[0].delta.content
-
-        response += token
-        yield response
-
-
-"""
-For information on how to customize the ChatInterface, peruse the gradio docs: https://www.gradio.app/docs/chatinterface
-"""
-demo = gr.ChatInterface(
-    respond,
-    additional_inputs=[
-        gr.Textbox(value="You are a friendly Chatbot.", label="System message"),
-        gr.Slider(minimum=1, maximum=2048, value=512, step=1, label="Max new tokens"),
-        gr.Slider(minimum=0.1, maximum=4.0, value=0.7, step=0.1, label="Temperature"),
-        gr.Slider(
-            minimum=0.1,
-            maximum=1.0,
-            value=0.95,
-            step=0.05,
-            label="Top-p (nucleus sampling)",
-        ),
-    ],
-)
-
-
-if __name__ == "__main__":
-    demo.launch()
+# app.py
+
+import gradio as gr
+import os
+import traceback
+import asyncio
+from dotenv import load_dotenv
+from models.task_prompt import TaskPrompt
+import time
+from llama_index.core import Settings as LlamaSettings # Import at top level
+from llama_index.llms.anthropic import Anthropic # Import at top level
+from manager_agent2 import ManagerAgent # Ensure this path is correct
+import concurrent.futures # For running blocking code in a separate thread
+
+# Load environment variables from .env file
+load_dotenv()
+
+# --- Configuration ---
+LLM_MODEL = "claude-sonnet-4-20250514"
+
+# --- Global variables ---
+current_status = "Ready"
+llm_global = None
+manager_agent_global = None
+# Settings_global is not strictly needed as a global if LlamaSettings is imported directly
+
+# Thread pool executor for running blocking agent tasks
+thread_pool_executor = concurrent.futures.ThreadPoolExecutor(max_workers=os.cpu_count() or 1)
+
+
+# --- LlamaIndex LLM Initialization ---
+def initialize_components():
+    global llm_global, manager_agent_global
+
+    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 API key (e.g., in a .env file).")
+        print("="*60 + "\n")
+        return
+
+    try:
+        llm_global = Anthropic(
+            model=LLM_MODEL,
+            temperature=0.2,
+            max_tokens=4096
+        )
+        LlamaSettings.llm = llm_global # Use the imported LlamaSettings directly
+        print(f"Successfully initialized LlamaIndex with Anthropic model: {LLM_MODEL} (temperature=0.2)")
+
+        manager_agent_global = ManagerAgent(
+            llm_global,
+            max_iterations=30, # Keep this reasonable for testing
+            update_callback=update_status_callback
+        )
+        print("✅ ManagerAgent initialized successfully")
+
+    except Exception as e:
+        print(f"Error initializing Anthropic LLM or ManagerAgent: {e}")
+        traceback.print_exc()
+
+# --- Update callback function (called by ManagerAgent) ---
+def update_status_callback(message):
+    global current_status
+    # This function is called from the ManagerAgent's thread (potentially)
+    # or the ReAct agent's execution context.
+    # It needs to update the global variable, which the Gradio polling thread will pick up.
+    current_status = message
+    print(f"✅ UI_STATUS_UPDATE (via callback): {message}") # Differentiate console log
+
+# --- Status retrieval function for Gradio polling ---
+def get_current_status_for_ui():
+    global current_status
+    timestamp = time.time()
+    return f"{current_status}<span style='display:none;'>{timestamp}</span>"
+
+# --- Gradio Interface Setup ---
+def create_gradio_interface():
+    if "ANTHROPIC_API_KEY" not in os.environ:
+        gr.Warning("ANTHROPIC_API_KEY not found in environment variables! ALITA may not function correctly.")
+
+    with gr.Blocks(theme="soft") as demo:
+        gr.Markdown("# GALITA")
+        gr.Markdown("GALITA is a self-learning AI agent that can search for information, analyze data, create tools, and orchestrate complex tasks.")
+
+        chatbot_component = gr.Chatbot(
+            label="Chat",
+            height=500,
+            show_label=False,
+            # type='messages' # For Gradio 4.x+
+        )
+        gr.Markdown("Gradio version: " + gr.__version__ + " (Chatbot type defaults to 'tuples' for older versions. Consider `type='messages'` for newer Gradio if issues persist with chat display).")
+
+
+        with gr.Row():
+            message_textbox = gr.Textbox(
+                placeholder="Tapez votre message ici...",
+                scale=7,
+                show_label=False,
+                container=False
+            )
+
+        gr.Examples(
+            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",
+                "what is the temperature in paris now"
+            ],
+            inputs=message_textbox,
+        )
+
+        status_box_component = gr.Textbox(
+            label="Agent Status",
+            value=get_current_status_for_ui(),
+            interactive=False,
+            # elem_id="status_box_alita" # For potential direct JS manipulation if desperate (avoid)
+        )
+
+        def add_user_msg(user_input_text, chat_history_list):
+            if not user_input_text.strip():
+                return gr.update(), chat_history_list
+            # For older Gradio, history is list of [user_msg, bot_msg] tuples
+            chat_history_list.append((user_input_text, None))
+            return gr.update(value=""), chat_history_list
+
+        async def generate_bot_reply(chat_history_list):
+            if not chat_history_list or chat_history_list[-1][0] is None:
+                # This case should ideally not be reached if add_user_msg works correctly
+                yield chat_history_list
+                return
+
+            user_message = chat_history_list[-1][0]
+
+            if manager_agent_global is None or LlamaSettings.llm is None:
+                # This update_status_callback will set current_status
+                # The polling mechanism (continuous_status_updater) should pick it up.
+                update_status_callback("⚠️ Error: Agent or LLM not initialized. Check API key and logs.")
+                # For older Gradio, update the last tuple's second element
+                chat_history_list[-1] = (chat_history_list[-1][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]}{'...' if len(user_message) > 100 else ''}'")
+                update_status_callback(f"💬 Processing: '{user_message[:50]}{'...' if len(user_message) > 50 else ''}'")
+                await asyncio.sleep(0.01) # Allow UI to briefly update with "Processing..."
+
+                task_prompt = TaskPrompt(text=user_message)
+
+                update_status_callback("🔄 Analyzing request and determining optimal workflow...")
+                await asyncio.sleep(0.01) # Allow UI to briefly update
+
+                # Run the blocking manager_agent_global.run_task in a separate thread
+                loop = asyncio.get_event_loop()
+                response_text_from_agent = await loop.run_in_executor(
+                    thread_pool_executor,
+                    manager_agent_global.run_task, # The function to run
+                    task_prompt                     # Arguments to the function
+                )
+                # By this point, run_task has completed, and all its internal
+                # calls to update_status_callback (via send_update) should have occurred.
+                # The polling mechanism should have picked up these changes.
+
+                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 = ""
+                total_words = len(words)
+                
+                # Initialize bot's part of the message in history for older Gradio
+                current_user_message = chat_history_list[-1][0]
+                chat_history_list[-1] = (current_user_message, "")
+
+
+                if not words:
+                    chat_history_list[-1] = (current_user_message, final_bot_response.strip())
+                    yield chat_history_list
+                else:
+                    for i, word in enumerate(words):
+                        accumulated_response_stream += word + " "
+                        # These status updates are for the streaming part,
+                        # agent's internal updates should have already happened.
+                        if total_words > 0: # Avoid division by zero
+                            if i == total_words // 4: update_status_callback("🔄 Streaming response (25%)...")
+                            elif i == total_words // 2: update_status_callback("🔄 Streaming response (50%)...")
+                            elif i == (total_words * 3) // 4: update_status_callback("🔄 Streaming response (75%)...")
+
+                        if i % 3 == 0 or i == len(words) - 1:
+                            chat_history_list[-1] = (current_user_message, accumulated_response_stream.strip())
+                            yield chat_history_list
+                            await asyncio.sleep(0.01) # For streaming effect
+
+                # Ensure final complete response is set
+                if chat_history_list[-1][1] != final_bot_response.strip():
+                    chat_history_list[-1] = (current_user_message, 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]}...")
+                chat_history_list[-1] = (chat_history_list[-1][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],
+            show_progress="hidden", # Gradio 3.x might not have this, can be ignored
+        ).then(
+            generate_bot_reply,
+            inputs=[chatbot_component],
+            outputs=[chatbot_component],
+            api_name=False, # Good practice
+            # show_progress="hidden", # Gradio 3.x might not have this
+        )
+
+        async def continuous_status_updater(update_interval_seconds=0.3): # Slightly faster poll
+            """Continuously yields status updates for the status_box_component."""
+            print("GRADIOLOG: Starting continuous_status_updater loop.")
+            while True:
+                # print(f"POLL: Fetching status: {current_status}") # DEBUG: very verbose
+                yield get_current_status_for_ui()
+                await asyncio.sleep(update_interval_seconds)
+
+        demo.load(continuous_status_updater, inputs=None, outputs=status_box_component)
+        print("GRADIOLOG: Continuous status updater loaded.")
+    return demo
+
+# Initialize LLM and Agent components
+initialize_components()
+
+# --- Launch the Application ---
+if __name__ == "__main__":
+    print(f"Gradio version: {gr.__version__}")
+
+    print("🚀 Starting Gradio ALITA Chat Application...")
+    alita_interface = create_gradio_interface()
+
+    try:
+        alita_interface.launch(
+            share=False,
+            server_name="127.0.0.1",
+            server_port=5126,
+            show_error=True,
+            # debug=True # Can be helpful
+        )
+    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...")
+        thread_pool_executor.shutdown(wait=True) # Clean up threads
+
+    print("✅ Gradio application stopped.")

app_modal.py

@@ -0,0 +1,195 @@
+import modal
+import os
+
+# Create Modal app
+app = modal.App("alita-chat-app")
+
+# Define the image with all required dependencies
+image = (
+    modal.Image.debian_slim(python_version="3.11")
+    .pip_install([
+        "gradio>=4.0.0",
+        "llama-index-core",
+        "llama-index-llms-anthropic",
+        "python-dotenv",
+        "openai",
+        "llama-index",
+        "anthropic",
+        "requests",
+        "dataclasses",
+        "beautifulsoup4",
+        "duckduckgo-search",
+        "llama-index-tools-duckduckgo"
+    ])
+    # Main script
+    .add_local_file("manager_agent2.py", "/app/manager_agent2.py")
+    
+    # Models
+    .add_local_file("models/__init__.py", "/app/models/__init__.py")
+    .add_local_file("models/mcp_tool_spec.py", "/app/models/mcp_tool_spec.py")
+    .add_local_file("models/mcp_execution_result.py", "/app/models/mcp_execution_result.py")
+    .add_local_file("models/task_prompt.py", "/app/models/task_prompt.py")
+    
+    # Components
+    .add_local_file("components/__init__.py", "/app/components/__init__.py")
+    .add_local_file("components/mcp_brainstormer.py", "/app/components/mcp_brainstormer.py")
+    .add_local_file("components/web_agent.py", "/app/components/web_agent.py")
+    .add_local_file("components/script_generator.py", "/app/components/script_generator.py")
+    .add_local_file("components/code_runner.py", "/app/components/code_runner.py")
+    .add_local_file("components/mcp_registry.py", "/app/components/mcp_registry.py")
+)
+
+# Global variables to store initialized components
+llm = None
+manager_agent = None
+
+@app.function(
+    image=image,
+    secrets=[modal.Secret.from_name("anthropic")],
+    max_containers=10,
+    timeout=300,
+    min_containers=1,
+    cpu=2,
+    memory=2048
+)
+def initialize_components():
+    """Initialize LLM and Manager Agent"""
+    global llm, manager_agent
+    
+    import sys
+    sys.path.append("/app")
+    
+    try:
+        # Import required modules
+        from llama_index.core import Settings
+        from llama_index.llms.anthropic import Anthropic
+        from models import TaskPrompt
+        from manager_agent import ManagerAgent
+        
+        # Get API key from environment
+        api_key = os.environ.get("ANTHROPIC_API_KEY")
+        if not api_key:
+            raise ValueError("ANTHROPIC_API_KEY not found in environment variables")
+        
+        # Initialize LLM
+        llm = Anthropic(model="claude-3-5-sonnet-20241022", api_key=api_key)
+        Settings.llm = llm
+        print("Successfully initialized LlamaIndex with Anthropic model")
+        
+        # Initialize the ManagerAgent
+        manager_agent = ManagerAgent(llm)
+        print("✅ ManagerAgent initialized successfully")
+        
+        return True
+        
+    except Exception as e:
+        print(f"Error initializing components: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+@app.function(
+    image=image,
+    secrets=[modal.Secret.from_name("anthropic-api-key")],
+    max_containers=10,
+    timeout=60,
+    min_containers=1,
+    cpu=2,
+    memory=2048
+)
+def process_message(message: str):
+    """Process a single message through the ManagerAgent"""
+    import sys
+    sys.path.append("/app")
+    
+    try:
+        from models import TaskPrompt
+        from manager_agent import ManagerAgent
+        from llama_index.core import Settings
+        from llama_index.llms.anthropic import Anthropic
+        
+        # Initialize components if needed
+        api_key = os.environ.get("ANTHROPIC_API_KEY")
+        if not api_key:
+            return "❌ ANTHROPIC_API_KEY not found in environment variables"
+        
+        llm = Anthropic(model="claude-3-5-sonnet-20241022", api_key=api_key)
+        Settings.llm = llm
+        manager_agent = ManagerAgent(llm)
+        
+        # Process the message
+        task_prompt = TaskPrompt(text=message)
+        
+        response = manager_agent.run_task(task_prompt)
+        
+        return response
+        
+    except Exception as e:
+        import traceback
+        error_msg = f"❌ Error processing message: {str(e)}\n{traceback.format_exc()}"
+        print(error_msg)
+        return error_msg
+
+# FIXED: Simple web server approach
+@app.function(
+    image=image,
+    secrets=[modal.Secret.from_name("anthropic-api-key")],
+    max_containers=10,
+    timeout=300,
+    min_containers=1,
+    cpu=2,
+    memory=2048
+)
+@modal.web_server(port=7860, startup_timeout=180)
+def gradio_app():
+    """Simple Gradio app without complex initialization"""
+    import gradio as gr
+    import asyncio
+    
+    async def chat_function(message, history):
+        """Simple chat function that calls the Modal function"""
+        try:
+            # Call the Modal function to process the message
+            response = process_message.remote(message)
+            
+            # Stream the response word by word for better UX
+            words = response.split()
+            partial_response = ""
+            
+            for i, word in enumerate(words):
+                partial_response += word + " "
+                if i % 3 == 0 or i == len(words) - 1:
+                    yield partial_response.strip()
+                    await asyncio.sleep(0.01)
+                    
+        except Exception as e:
+            yield f"❌ Error: {str(e)}"
+    
+    # Create simple Gradio interface
+    interface = gr.ChatInterface(
+        fn=chat_function,
+        type="messages",
+        title="ALITA",
+        description="ALITA: the self learning AI",
+        examples=[
+            "🔍 search for information about AI",
+            "🛠️ Analyse this csv file", 
+            "⚡ Generate a script to automate a repetitive task",
+            "🌐 Find open source resources for machine learning",
+        ],
+        theme="soft"
+    )
+    
+    # Launch the interface with Modal-compatible settings
+    interface.launch(
+        server_name="0.0.0.0",  # Must bind to all interfaces for Modal
+        server_port=7840,       # Must match the port in @modal.web_server
+        share=False,            # Don't create public links
+        quiet=True,             # Reduce logging noise
+        show_error=True,
+        prevent_thread_lock=True  # Important: prevents blocking Modal's event loop
+    )
+
+# For local development and testing
+if __name__ == "__main__":
+    app.deploy("alita-chat-app")

manager_agent.py

@@ -0,0 +1,689 @@
+import uuid
+import os
+from dotenv import load_dotenv
+from typing import Optional, Dict, Any, List, Generator, Callable
+from models import TaskPrompt, MCPToolSpec, MCPExecutionResult
+from components import (
+    WebAgent,
+    ScriptGenerator,
+    CodeRunner,
+    Registry,
+    Brainstormer,
+)
+from llama_index.core.llms import LLM
+from llama_index.core.agent import ReActAgent
+from llama_index.core.tools import FunctionTool
+
+
+# Load environment variables from .env file
+load_dotenv()
+
+class ManagerAgent:
+    """
+    The central orchestrator of the Alita agent - Revised for Gradio integration.
+    
+    Workflow:
+    1. Analyze user prompt to understand the request
+    2. Check existing tools in registry first
+    3. If research needed, formulate search queries and use WebAgent
+    4. If tool needed but not found, brainstorm new tool requirements
+    5. Search for open source tools/solutions via WebAgent
+    6. Create implementation plan via Brainstormer
+    7. Return comprehensive response
+    """
+    
+    def __init__(self, llm: LLM, max_iterations: int = 10000000, update_callback: Optional[Callable[[str], None]] = None):
+        
+        
+        self.llm = llm
+        self.registry = Registry()
+        self.web_agent = WebAgent(llm=llm, max_research_iterations=10000000)
+        self.code_runner = CodeRunner()
+        self.brainstormer = Brainstormer(model_name="claude-sonnet-4-0")
+        self.script_generator = ScriptGenerator(llm=self.llm)
+        self.max_iterations = max_iterations
+        self.update_callback = update_callback
+
+        # Define the tools available to the internal LlamaIndex Agent
+        self._agent_tools = self._define_agent_tools()
+
+        # Initialize the internal LlamaIndex ReAct Agent with improved system prompt
+        self.agent = ReActAgent.from_tools(
+            tools=self._agent_tools,
+            llm=self.llm,
+            verbose=True,
+            system_prompt=self._get_system_prompt(),
+            max_iterations=self.max_iterations  # Use the configurable max_iterations parameter
+        )
+        print("🤖 ManagerAgent initialized with ReActAgent and enhanced workflow.")
+
+    def send_update(self, message: str) -> None:
+        """
+        Send an update message to the user about the agent's progress.
+        
+        Args:
+            message: The update message to send
+            
+        Returns:
+            None
+        """
+        print(f"📢 Update: {message}")
+        
+        # If a callback function is provided, use it to send the update to the user
+        if self.update_callback:
+            try:
+                self.update_callback(message)
+            except Exception as e:
+                print(f"Error sending update via callback: {e}")
+
+    def _get_system_prompt(self) -> str:
+        """Enhanced system prompt for better workflow orchestration"""
+        return """You are ALITA, an advanced generalist agent. You are here to help people with their requests. you can do many tasks like research, tool creation, automation, analysis, and much more. What is unique about you is that you can create tools to help people with their requests, even if they are not in your capabilities.
+
+Your primary workflow for ANY user request:
+
+1. **ANALYZE PHASE**: 
+   - Understand the user's request deeply
+   - Identify if it's: information request, tool request, task automation, research, or creative work.
+   - here you decide wether to answer the request or to create a tool to answer the request, or to search the web only. 
+   - if you decide to answer directly, give your answer right away.
+   - if you decide to search the web,  use 'web_search' with specific queries. give a first answer to the user saying you are searching the web, then take the action of 'web_search'. 
+   - if you there is a thing that needs something more than a text generation or search, then look for existing tool here in the next steps.
+   - Use 'send_user_update' to inform the user about what you're doing and your progress, if you didnt answer direclty to the prompt.
+   - Do not apologize quickly for not being able to answer the prompt, until you do the next steps: EXISTING TOOLS CHECK, TOOL ANALYSIS PHASE, RESEARCH PHASE, TOOL CREATION PHASE. if not successful then apologize.
+
+2. **EXISTING TOOLS CHECK**:
+   - ALWAYS first use 'get_available_tools' to list all tools in your registry
+   - If suitable tools exist but are not deployed, use 'deploy_tool' to activate them
+   - Once tools are active, use 'run_registered_mcp' to execute them OR use 'use_registry_tool' for direct invocation
+   - Keep the user informed of your progress with 'send_user_update'
+
+3. **TOOL ANALYSIS PHASE**:
+   - If you need to determine whether existing tools are sufficient or new tools are needed, use 'brainstorm_tools'
+   - This will analyze the user request against available tools and recommend which tools to use or what new tools to create
+   - Follow the recommendations from the brainstorming phase
+   - Send an update to the user with 'send_user_update' about your findings
+
+4. **RESEARCH PHASE** (if needed):
+   - For information requests: use 'web_search' with specific queries
+   - For in-depth research topics: use 'perform_web_research' for comprehensive autonomous research
+   - For technical solutions: use 'github_search' for open source tools
+   - Use 'retrieve_url_content' to get detailed information from promising results
+   - Send updates to the user with 'send_user_update' about your research progress
+
+5. **TOOL CREATION PHASE** (if no existing tool works):
+   - Use 'brainstorm_tools' to identify what kind of tool is needed
+   - Use 'web_search' and 'github_search' to find existing open source solutions
+   - Use 'generate_mcp_script' to create implementation based on research
+   - Use 'execute_and_register_mcp' to validate and register the new tool
+   - Keep the user informed of your progress with 'send_user_update'
+
+6. **EXECUTION PHASE**:
+   - Use appropriate registered tools via 'run_registered_mcp' or 'use_registry_tool'
+   - Provide comprehensive results with explanations
+   - Send a final update to the user with 'send_user_update' about the results
+
+**Key Principles**:
+- Be proactive in tool discovery and creation
+- Always search for existing solutions before creating new ones
+- Provide detailed explanations of your reasoning process
+- Focus on practical, actionable results
+- Leverage open source resources extensively
+- Keep the user informed of your progress with regular updates
+
+**Tool Management Capabilities**:
+- Use 'get_available_tools' to see all tools in your registry
+- Use 'brainstorm_tools' to analyze if existing tools are sufficient or new ones are needed
+- Check tool states to determine if they are active ('activated') or inactive ('deactivated')
+- Use 'deploy_tool' to activate any inactive tools before running them
+- Remember that tools must be deployed before they can be executed
+- Use 'use_registry_tool' for direct tool invocation with automatic deployment
+
+**Tool Usage Options**:
+- 'run_registered_mcp': Traditional method that requires separate deployment and execution steps
+- 'use_registry_tool': Streamlined method that handles deployment automatically and provides direct invocation
+
+**Research Capabilities**:
+- For simple information needs, use 'web_search' for quick answers
+- For complex research topics requiring in-depth analysis, use 'perform_web_research'
+- The 'perform_web_research' tool conducts autonomous research across multiple sources and synthesizes findings
+
+**Response Style**:
+- Structure your responses clearly with headers
+- Explain what you're doing and why
+- Provide context and next steps
+- Be conversational but informative
+- Use 'send_user_update' to keep the user informed throughout the process
+"""
+
+    def _define_agent_tools(self) -> List[FunctionTool]:
+        """Enhanced tool definition with better descriptions"""
+        tools = []
+
+        # User update tool
+        tools.append(
+            FunctionTool.from_defaults(
+                self.send_update,
+                name="send_user_update",
+                description="Send an update message to the user about your current progress or actions. Takes 'message' (string) containing the update information. Use this tool frequently to keep the user informed about what you're doing."
+            )
+        )
+        
+        # Add research tool
+        tools.append(
+            FunctionTool.from_defaults(
+                self.research,
+                name="perform_web_research",
+                description="Performs comprehensive web research on a given topic. Takes 'query' (string) containing the research question or topic to investigate. Returns a detailed research report with findings and sources."
+            )
+        )
+
+        # Get all available tools
+        tools.append(
+            FunctionTool.from_defaults(
+                self.get_available_tools,
+                name="get_available_tools",
+                description="Get a list of all tools currently available in the registry. Returns a list of tool specifications with names, descriptions, and states."
+            )
+        )
+
+        # Use a registered tool
+        tools.append(
+            FunctionTool.from_defaults(
+                self.use_registry_tool,
+                name="use_registry_tool",
+                description="Use a registered tool directly by invoking its endpoint. Takes 'tool_name' (string) and any additional arguments required by the tool. Automatically deploys the tool if needed. Returns the response from the tool."
+            )
+        )
+
+        # Tool brainstorming
+        tools.append(
+            FunctionTool.from_defaults(
+                self.brainstorm_tools,
+                name="brainstorm_tools",
+                description="Analyze the user request against available tools to determine if existing tools are sufficient or new tools are needed. Takes 'user_task' (string) containing the user's request and optionally 'available_tools' (string) with comma-separated tool names. Returns recommendations on which tools to use or what new tools to create."
+            )
+        )
+
+        # Deploy a specific tool
+        tools.append(
+            FunctionTool.from_defaults(
+                self.deploy_tool,
+                name="deploy_tool",
+                description="Deploy and activate a specific tool from the registry. Takes 'tool_name' (string) containing the name of the tool to deploy. Returns the URL of the deployed tool if successful, or an error message if deployment fails."
+            )
+        )
+
+        # # Enhanced execution and registration tool
+        # tools.append(
+        #     FunctionTool.from_defaults(
+        #         self._run_and_register_mcp,
+        #         name="execute_and_register_mcp",
+        #         description="Execute a generated MCP script in an isolated environment and register it if successful. Takes 'spec' (MCPToolSpec as dict), 'python_script' (string), 'env_script' (string), and optional 'input_data' (dict). Returns execution result."
+        #     )
+        # )
+
+        # # Enhanced registered tool execution
+        # tools.append(
+        #     FunctionTool.from_defaults(
+        #         self._run_registered_mcp,
+        #         name="run_registered_mcp",
+        #         description="Execute a previously registered MCP tool. Takes 'tool_name' (string) and optional 'input_data' (dict). Returns execution result with output data."
+        #     )
+        # )
+
+        # Add analysis tool for better decision making
+        tools.append(
+            FunctionTool.from_defaults(
+                self._analyze_user_request,
+                name="analyze_user_request",
+                description="Analyze user request to determine the best approach (research, existing tool, new tool creation). Takes 'user_message' (string). Returns analysis with recommended actions."
+            )
+        )
+
+        return tools
+
+    def _analyze_user_request(self, user_message: str) -> Dict[str, Any]:
+        """Analyze user request to determine optimal workflow path"""
+        analysis = {
+            "request_type": "unknown",
+            "complexity": "medium",
+            "requires_research": False,
+            "requires_tools": False,
+            "suggested_approach": [],
+            "key_concepts": []
+        }
+        
+        message_lower = user_message.lower()
+        
+        # Look for comprehensive research indicators
+        research_terms = ["comprehensive", "thorough", "in-depth", "detailed", "extensive", 
+                        "research", "investigate", "analyze", "report", "study"]
+        
+        # Determine request type
+        if any(word in message_lower for word in research_terms):
+            analysis["request_type"] = "deep_research"
+            analysis["requires_research"] = True
+            analysis["complexity"] = "high"
+            analysis["suggested_approach"].append("research")
+            
+        elif any(word in message_lower for word in ["recherche", "search", "find", "lookup", "information", "what is", "explain"]):
+            analysis["request_type"] = "information_request"
+            analysis["requires_research"] = True
+            analysis["suggested_approach"].append("web_search")
+            
+        elif any(word in message_lower for word in ["outil", "tool", "script", "automatise", "automate", "create", "build"]):
+            analysis["request_type"] = "tool_request"
+            analysis["requires_tools"] = True
+            analysis["suggested_approach"].extend(["find_existing_tools", "brainstorm_if_needed"])
+            
+        elif any(word in message_lower for word in ["analyse", "analyze", "process", "calculate", "compute"]):
+            analysis["request_type"] = "analysis_task"
+            analysis["requires_tools"] = True
+            analysis["suggested_approach"].extend(["find_existing_tools", "research_methods"])
+            
+        elif any(word in message_lower for word in ["tendance", "trend", "market", "news", "current"]):
+            analysis["request_type"] = "research_task"
+            analysis["requires_research"] = True
+            analysis["complexity"] = "high"
+            analysis["suggested_approach"].extend(["web_search", "github_search"])
+
+        # Extract key concepts for better tool matching
+        concepts = []
+        tech_keywords = ["python", "javascript", "api", "database", "csv", "json", "web", "scraping", "ml", "ai"]
+        for keyword in tech_keywords:
+            if keyword in message_lower:
+                concepts.append(keyword)
+        analysis["key_concepts"] = concepts
+        
+        return analysis
+
+    def _run_and_register_mcp(self, spec: Dict[str, Any], python_script: str, env_script: str, input_data: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """Enhanced MCP execution and registration with better error handling"""
+        print(f"🔧 ManagerAgent: Executing and registering MCP: {spec.get('name', 'Unnamed Tool')}")
+        
+        try:
+            mcp_spec_obj = MCPToolSpec.from_dict(spec)
+            env_name_suffix = mcp_spec_obj.name.lower().replace(' ', '-')[:10]
+            env_name = f"alita-{env_name_suffix}-{uuid.uuid4().hex[:8]}"
+
+            print(f"🔄 Setting up environment: {env_name}")
+            env_success = self.code_runner.setup_environment(env_script, env_name)
+            
+            if not env_success:
+                result = MCPExecutionResult(
+                    success=False, 
+                    error_message=f"Environment setup failed for '{env_name}'. Check dependencies in env_script."
+                )
+                return result.to_dict()
+
+            print(f"▶️ Executing script in environment: {env_name}")
+            execution_result = self.code_runner.execute(python_script, env_name, input_data)
+
+            if execution_result.success:
+                print(f"✅ Script execution successful. Registering tool: {mcp_spec_obj.name}")
+                mcp_spec_obj.validated_script = python_script
+                mcp_spec_obj.environment_script = env_script
+                self.registry.register_tool(mcp_spec_obj)
+                print(f"🎯 Tool '{mcp_spec_obj.name}' successfully registered in registry")
+                
+                # Add success message to result
+                execution_result.output_data = execution_result.output_data or {}
+                execution_result.output_data["registration_status"] = "Successfully registered"
+                
+            else:
+                print(f"❌ Script execution failed for '{mcp_spec_obj.name}': {execution_result.error_message}")
+
+            # Always cleanup after validation
+            self.code_runner.cleanup_environment(env_name)
+            return execution_result.to_dict()
+
+        except Exception as e:
+            error_msg = f"Unexpected error in MCP execution: {str(e)}"
+            print(f"🚨 {error_msg}")
+            
+            # Cleanup on error
+            try:
+                if 'env_name' in locals():
+                    self.code_runner.cleanup_environment(env_name)
+            except:
+                pass
+                
+            return MCPExecutionResult(success=False, error_message=error_msg).to_dict()
+
+    def _run_registered_mcp(self, tool_name: str, input_data: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """Enhanced registered tool execution with better logging"""
+        print(f"🎯 ManagerAgent: Running registered tool: {tool_name}")
+        
+        spec = self.registry.get_tool(tool_name)
+        if not spec:
+            error_msg = f"Tool '{tool_name}' not found in registry. Available tools: {list(self.registry.tools.keys())}"
+            print(f"❌ {error_msg}")
+            return MCPExecutionResult(success=False, error_message=error_msg).to_dict()
+
+        if not spec.validated_script or not spec.environment_script:
+            error_msg = f"Tool '{tool_name}' missing validated script or environment configuration"
+            print(f"❌ {error_msg}")
+            return MCPExecutionResult(success=False, error_message=error_msg).to_dict()
+
+        # Create fresh environment for execution
+        env_name_suffix = spec.name.lower().replace(' ', '-')[:10]
+        env_name = f"alita-run-{env_name_suffix}-{uuid.uuid4().hex[:8]}"
+
+        try:
+            print(f"🔄 Setting up execution environment: {env_name}")
+            env_success = self.code_runner.setup_environment(spec.environment_script, env_name)
+            
+            if not env_success:
+                return MCPExecutionResult(
+                    success=False, 
+                    error_message=f"Failed to setup environment for tool '{tool_name}'"
+                ).to_dict()
+
+            print(f"▶️ Executing registered tool: {tool_name}")
+            execution_result = self.code_runner.execute(spec.validated_script, env_name, input_data)
+            
+            print(f"{'✅' if execution_result.success else '❌'} Tool execution completed. Success: {execution_result.success}")
+            
+            return execution_result.to_dict()
+            
+        except Exception as e:
+            error_msg = f"Error executing registered tool '{tool_name}': {str(e)}"
+            print(f"🚨 {error_msg}")
+            return MCPExecutionResult(success=False, error_message=error_msg).to_dict()
+            
+        finally:
+            # Always cleanup
+            try:
+                self.code_runner.cleanup_environment(env_name)
+            except:
+                pass
+
+    def run_task(self, prompt: TaskPrompt) -> str:
+        """
+        Enhanced task execution with detailed logging and structured workflow
+        Optimized for Gradio integration with comprehensive responses
+        """
+        print(f"\n{'='*60}")
+        print(f"🚀 ALITA ManagerAgent: Starting task execution")
+        print(f"📝 User prompt: {prompt.text[:100]}{'...' if len(prompt.text) > 100 else ''}")
+        print(f"{'='*60}")
+
+        # Send initial update to the user
+        self.send_update(f"Starting to process your request: '{prompt.text[:50]}{'...' if len(prompt.text) > 50 else ''}'")
+
+        try:
+            # Use the internal ReAct agent to handle the complete workflow
+            print("🧠 Engaging ReAct Agent for intelligent task orchestration...")
+            
+            # The ReAct agent will use its tools to:
+            # 1. Analyze the request
+            # 2. Search existing tools
+            # 3. Perform web research if needed
+            # 4. Brainstorm solutions
+            # 5. Create/execute tools as necessary
+            # 6. Provide comprehensive response
+            
+            response = self.agent.chat(prompt.text)
+            
+            print("✅ Task execution completed successfully")
+            print(f"{'='*60}\n")
+            
+            # Send final update to the user
+            self.send_update("Task completed successfully! Here's your response.")
+            
+            # Format response for better Gradio presentation
+            formatted_response = self._format_response_for_gradio(response.response)
+            return formatted_response
+            
+        except Exception as e:
+            error_msg = f"🚨 ManagerAgent encountered an error during task execution:\n\n**Error Details:**\n{str(e)}\n\n**Next Steps:**\n- Check your API key and network connection\n- Verify all components are properly initialized\n- Try a simpler request to test basic functionality"
+            
+            print(f"❌ Task execution failed: {e}")
+            print(f"{'='*60}\n")
+            
+            # Send error update to the user
+            self.send_update(f"An error occurred while processing your request: {str(e)}")
+            
+            return error_msg
+
+    def _format_response_for_gradio(self, response: str) -> str:
+        """Format the agent response for better presentation in Gradio"""
+        
+        # Add header if not present
+        if not response.startswith("##") and not response.startswith("#"):
+            response = f"## 🤖 {response}"
+        
+        # Add footer with capabilities reminder (occasionally)
+        if "capabilities" not in response.lower():
+            footer = "\n\n---\n💡 **Tip**: I can help you with research, tool creation, automation, analysis, and much more. Just ask!"
+            response += footer
+            
+        return response
+
+    def get_registry_status(self) -> Dict[str, Any]:
+        """Get current status of the tool registry"""
+        return {
+            "total_tools": len(self.registry.tools),
+            "tool_names": list(self.registry.tools.keys()),
+            "registry_ready": len(self.registry.tools) > 0
+        }
+
+    def reset_registry(self):
+        """Reset the tool registry (useful for testing)"""
+        self.registry = Registry()
+        print("🔄 Tool registry has been reset")
+
+    def __str__(self):
+        return f"ManagerAgent(llm={type(self.llm).__name__}, tools_registered={len(self.registry.tools)})"
+
+    def research(self, query: str, max_iterations: int = None, verbose: bool = None) -> str:
+        """
+        Performs autonomous web research on the given query using the WebAgent's research function.
+        
+        Args:
+            query: The research question or topic
+            max_iterations: Optional override for the maximum number of research iterations
+            verbose: Optional override for verbose mode
+            
+        Returns:
+            A comprehensive textual report based on web research
+        """
+        print(f"\n{'='*60}")
+        print(f"🌐 ALITA ManagerAgent: Starting web research")
+        print(f"📝 Research query: {query[:100]}{'...' if len(query) > 100 else ''}")
+        print(f"{'='*60}")
+        
+        try:
+            # Configure WebAgent for this research session
+            if max_iterations is not None:
+                self.web_agent.max_research_iterations = max_iterations
+            
+            if verbose is not None:
+                self.web_agent.verbose = verbose
+            
+            # Perform the research
+            print("🔍 Initiating autonomous web research. This may take some time... here is the query: ", query)
+            report = self.web_agent.research(query)
+            print("🔍 here is the report: ", report)
+            
+            print("✅ Research completed successfully")
+            print(f"{'='*60}\n")
+            
+            return report
+            
+        except Exception as e:
+            error_msg = f"🚨 Error during web research: {str(e)}"
+            print(f"❌ Research failed: {e}")
+            print(f"{'='*60}\n")
+            
+            import traceback
+            print(traceback.format_exc())
+            
+            return error_msg
+
+    def get_available_tools(self) -> List[Dict[str, Any]]:
+        """
+        Get a list of all tools currently available in the registry.
+        
+        Returns:
+            List of dictionaries containing tool information (name, description, state)
+        """
+        print("📋 ManagerAgent: Retrieving list of all available tools")
+        tools = self.registry.list_tools()
+        
+        # Format the tools for easier consumption by the agent
+        formatted_tools = []
+        for tool in tools:
+            formatted_tools.append({
+                "name": tool.name,
+                "description": tool.description,
+                "state": getattr(tool, "state", "unknown"),
+                "input_schema": tool.input_schema if hasattr(tool, "input_schema") else {},
+                "output_schema": tool.output_schema if hasattr(tool, "output_schema") else {}
+            })
+            
+        print(f"🔍 Found {len(formatted_tools)} tools in registry")
+        return formatted_tools
+    
+    def deploy_tool(self, tool_name: str) -> Dict[str, Any]:
+        """
+        Deploy and activate a specific tool from the registry.
+        
+        Args:
+            tool_name: Name of the tool to deploy
+            
+        Returns:
+            Dictionary with deployment status and URL (if successful)
+        """
+        print(f"🚀 ManagerAgent: Deploying tool '{tool_name}'")
+        
+        # Check if tool exists in registry
+        if not self.registry.get_tool(tool_name):
+            error_msg = f"Tool '{tool_name}' not found in registry"
+            print(f"❌ {error_msg}")
+            return {"success": False, "error": error_msg}
+        
+        # Attempt to deploy the tool
+        try:
+            url = self.registry.deploy_tool(tool_name)
+            
+            if url:
+                print(f"✅ Successfully deployed tool '{tool_name}' at {url}")
+                return {
+                    "success": True,
+                    "tool_name": tool_name,
+                    "url": url,
+                    "message": f"Tool '{tool_name}' successfully deployed"
+                }
+            else:
+                error_msg = f"Failed to deploy tool '{tool_name}'"
+                print(f"❌ {error_msg}")
+                return {"success": False, "error": error_msg}
+                
+        except Exception as e:
+            error_msg = f"Error deploying tool '{tool_name}': {str(e)}"
+            print(f"🚨 {error_msg}")
+            return {"success": False, "error": error_msg}
+
+    def brainstorm_tools(self, user_task: str, available_tools: str = "") -> Dict[str, Any]:
+        """
+        Use the Brainstormer to analyze if existing tools are sufficient or new tools are needed.
+        
+        Args:
+            user_task: The user's request or task
+            available_tools: Optional comma-separated list of available tool names
+            
+        Returns:
+            Dictionary with tool recommendations or specifications for new tools
+        """
+        print(f"🧠 ManagerAgent: Brainstorming tools for task: {user_task[:100]}{'...' if len(user_task) > 100 else ''}")
+        
+        # If available_tools is not provided, get them from the registry
+        if not available_tools:
+            tools = self.get_available_tools()
+            available_tools = ", ".join([tool["name"] for tool in tools])
+        
+        try:
+            # Call the brainstormer to analyze the task and available tools
+            result = self.brainstormer.generate_mcp_specs_to_fulfill_user_task(
+                task=user_task,
+                tools_list=available_tools
+            )
+            
+            if isinstance(result, dict) and "error" in result:
+                print(f"❌ Brainstorming failed: {result['error']}")
+                return {
+                    "success": False,
+                    "error": result["error"],
+                    "recommendations": "Unable to analyze tools for this task."
+                }
+                
+            print(f"✅ Brainstorming complete. Found {len(result)} tool recommendations.")
+            
+            # Format the result for better consumption by the agent
+            return {
+                "success": True,
+                "recommendations": result,
+                "summary": f"Analysis complete. Found {len(result)} tool recommendations."
+            }
+            
+        except Exception as e:
+            error_msg = f"Error during tool brainstorming: {str(e)}"
+            print(f"🚨 {error_msg}")
+            return {
+                "success": False,
+                "error": error_msg,
+                "recommendations": "Unable to analyze tools due to an error."
+            }
+
+    def use_registry_tool(self, tool_name: str, *args, **kwargs) -> Dict[str, Any]:
+        """
+        Use a registered tool directly by invoking its endpoint.
+        
+        This method utilizes the Registry's use_tool method to invoke a registered tool.
+        It handles tool deployment if needed and provides proper error handling and user feedback.
+        
+        Args:
+            tool_name: Name of the tool to use
+            *args: Positional arguments to pass to the tool
+            **kwargs: Keyword arguments to pass to the tool
+            
+        Returns:
+            The response from the tool as a Python object
+        """
+        try:
+            # Send update to user
+            self.send_update(f"Using tool: {tool_name}")
+            
+            # Check if tool exists in registry
+            if not self.registry.get_tool(tool_name):
+                error_msg = f"Tool '{tool_name}' not found in registry"
+                self.send_update(error_msg)
+                return {"error": error_msg, "success": False}
+                
+            # Use the tool via Registry's use_tool method
+            self.send_update(f"Executing tool: {tool_name}")
+            result = self.registry.use_tool(tool_name, *args, **kwargs)
+            
+            # Send success update
+            self.send_update(f"Tool '{tool_name}' executed successfully")
+            
+            # Return result with success flag
+            if isinstance(result, dict):
+                result["success"] = True
+                return result
+            else:
+                return {"result": result, "success": True}
+                
+        except ValueError as e:
+            # Handle expected errors (tool not found, deployment failed)
+            error_msg = str(e)
+            self.send_update(f"Error: {error_msg}")
+            return {"error": error_msg, "success": False}
+            
+        except Exception as e:
+            # Handle unexpected errors
+            error_msg = f"Unexpected error using tool '{tool_name}': {str(e)}"
+            self.send_update(f"Error: {error_msg}")
+            return {"error": error_msg, "success": False}

manager_agent2.py

@@ -0,0 +1,663 @@
+import uuid
+import os
+from dotenv import load_dotenv
+from typing import Optional, Dict, Any, List, Generator, Callable
+from models import TaskPrompt, MCPToolSpec, MCPExecutionResult
+from components import (
+    WebAgent,
+    ScriptGenerator,
+    CodeRunner,
+    Registry,
+    Brainstormer,
+)
+from llama_index.core.llms import LLM
+from llama_index.core.agent import ReActAgent
+from llama_index.core.tools import FunctionTool
+
+
+# Load environment variables from .env file
+load_dotenv()
+
+class ManagerAgent:
+    """
+    The central orchestrator of the Alita agent - Revised for Gradio integration.
+    
+    Workflow:
+    1. Analyze user prompt to understand the request
+    2. Check existing tools in registry first
+    3. If research needed, formulate search queries and use WebAgent
+    4. If tool needed but not found, brainstorm new tool requirements
+    5. Search for open source tools/solutions via WebAgent
+    6. Create implementation plan via Brainstormer
+    7. Return comprehensive response
+    """
+    
+    def __init__(self, llm: LLM, max_iterations: int = 10000000, update_callback: Optional[Callable[[str], None]] = None):
+        
+        
+        self.llm = llm
+        self.registry = Registry()
+        self.web_agent = WebAgent(llm=llm, max_research_iterations=10000000)
+        self.code_runner = CodeRunner()
+        self.brainstormer = Brainstormer(model_name="claude-sonnet-4-0")
+        self.script_generator = ScriptGenerator(task_prompt="", claude_api_key=os.getenv("CLAUDE_API_KEY", ""))
+        self.max_iterations = max_iterations
+        self.update_callback = update_callback
+
+        # Define the tools available to the internal LlamaIndex Agent
+        self._agent_tools = self._define_agent_tools()
+
+        # Initialize the internal LlamaIndex ReAct Agent with improved system prompt
+        self.agent = ReActAgent.from_tools(
+            tools=self._agent_tools,
+            llm=self.llm,
+            verbose=True,
+            system_prompt=self._get_system_prompt(),
+            max_iterations=self.max_iterations,  # Use the configurable max_iterations parameter
+            temperature=0.2  # Lower temperature for more focused responses
+        )
+        print("🤖 ManagerAgent initialized with ReActAgent and enhanced workflow (temperature=0.2).")
+
+    def send_update(self, message: str) -> None:
+        """
+        Send an update message to the user about the agent's progress.
+        """
+        if not any(emoji in message[:2] for emoji in ["📢", "🔄", "✅", "❌", "⚠️", "💬", "🔍", "🚀", "✨"]):
+            message = f"📢 {message}"
+            
+        print(f"📣 AGENT: ManagerAgent.send_update CALLED with message: {message}") # DEBUG
+        print(f"📣 AGENT: self.update_callback is: {self.update_callback}") # DEBUG
+        
+        if self.update_callback:
+            try:
+                self.update_callback(message) # This should call update_status_callback in app.py
+                print(f"📣 AGENT: Callback invoked successfully.") # DEBUG
+            except Exception as e:
+                print(f"❌ AGENT: Error sending update via callback: {e}")
+                import traceback
+                traceback.print_exc()
+        else:
+            print("📣 AGENT: No update_callback configured for ManagerAgent.") # DEBUG
+        # Return a string confirmation, as ReAct tools often expect a string output
+        return f"Update sent: {message}" # MODIFICATION: Return a string
+
+    def _get_system_prompt(self) -> str:
+        """Enhanced system prompt for better workflow orchestration"""
+        return """You are ALITA, an advanced generalist agent. You are here to help people with their requests. You can do many tasks like research, tool creation, automation, analysis, and much more. What is unique about you is that you can create tools to help people with their requests, even if they are not in your capabilities.
+
+Your primary workflow for ANY user request:
+
+1.  **ANALYZE PHASE**:
+    *   Understand the user's request deeply.
+    *   Identify if it's: an information request, a tool request, task automation, research, or creative work.
+    *   Decide whether to answer the request directly, create a new tool, or perform web research.
+    *   If you decide to answer directly, provide your answer right away.
+    *   If you decide to perform web research, use the `perform_web_research` tool with specific queries. Inform the user you are starting research before taking this action.
+    *   If the task requires more than simple text generation or basic web research, proceed to check for existing tools.
+    *   Use `send_user_update` to inform the user about what you're doing and your progress if you don't answer directly.
+    *   Do not apologize for not being able to answer the prompt until you have attempted all subsequent steps (EXISTING TOOLS CHECK, TOOL ANALYSIS PHASE, RESEARCH PHASE, TOOL CREATION PHASE). If all fail, then apologize.
+
+2.  **EXISTING TOOLS CHECK**:
+    *   ALWAYS first use `get_available_tools` to list all tools in your registry.
+    *   If suitable tools exist but are not deployed (check their 'state'), use `deploy_tool` to activate them.
+    *   Once tools are active and deployed, use `use_registry_tool` to execute them with the necessary inputs.
+    *   Keep the user informed of your progress with `send_user_update`.
+
+3.  **TOOL ANALYSIS PHASE**:
+    *   If you need to determine whether existing tools are sufficient or new tools are needed, use `brainstorm_tools`.
+    *   Provide the `brainstorm_tools` function with the `user_task` and the `available_tools` (a comma-separated string of tool names from `get_available_tools`).
+    *   If there are no tools available, provide "none" as the input for `available_tools` to the `brainstorm_tools` function.
+    *   Follow the recommendations from the brainstorming phase.
+    *   Send an update to the user with `send_user_update` about your findings.
+
+4.  **RESEARCH PHASE** (if needed for information or tool creation):
+    *   Use the `perform_web_research` tool for all web-based information gathering.
+        *   For general information or in-depth research on a topic, provide a clear query to `perform_web_research`.
+        *   If you are looking for open-source code, libraries, or technical solutions (including from GitHub), instruct `perform_web_research` in your query to focus on finding code examples or repositories. For instance: "perform_web_research: Find Python code snippets for parsing CSV files from GitHub."
+    *   Send updates to the user with `send_user_update` about your research progress.
+
+5.  **TOOL CREATION PHASE** (if no existing tool works or can be adapted):
+    *   First, use `brainstorm_tools` to define the specifications of the new tool needed.
+    *   Next, use `perform_web_research` to find existing open-source solutions, code examples, or libraries that can help build the tool. Be specific in your query to `perform_web_research` about looking for implementation details.
+    *   Then, use `generate_mcp_script` to create the Python code and environment script for the tool, using the specification from `brainstorm_tools` and insights from your research.
+    *   Finally, use `execute_and_register_mcp` to test the new tool in a safe environment and, if successful, register it in your tool registry.
+    *   Keep the user informed of your progress with `send_user_update`.
+
+6.  **EXECUTION PHASE** (after a tool is ready, either existing or newly created):
+    *   Ensure the required tool is deployed using `deploy_tool` if it's not already active.
+    *   Use `use_registry_tool` to run the active tool with the appropriate inputs.
+    *   Provide comprehensive results with explanations.
+    *   Send a final update to the user with `send_user_update` about the results.
+
+**Key Principles**:
+*   Be proactive in tool discovery and creation.
+*   Always search for existing solutions before creating new ones.
+*   Provide detailed explanations of your reasoning process.
+*   Focus on practical, actionable results.
+*   Leverage open-source resources extensively via `perform_web_research`.
+*   Keep the user informed of your progress with regular updates using `send_user_update`.
+
+**Tool Management Capabilities**:
+*   Use `get_available_tools` to see all tools in your registry.
+*   Use `brainstorm_tools` to analyze if existing tools are sufficient or new ones are needed.
+*   Check tool 'state' from `get_available_tools` to determine if they are active ('activated' or similar) or inactive.
+*   Use `deploy_tool` to activate any inactive tools before running them. Tools must be deployed before they can be executed by `use_registry_tool`.
+
+**Response Style**:
+*   Structure your responses clearly with headers where appropriate.
+*   Explain what you're doing and why.
+*   Provide context and next steps.
+*   Be conversational but informative.
+*   Use `send_user_update` to keep the user informed throughout the process.
+"""
+
+    def _define_agent_tools(self) -> List[FunctionTool]:
+        """Enhanced tool definition with better descriptions"""
+        tools = []
+
+        # User update tool
+        tools.append(
+            FunctionTool.from_defaults(
+                self.send_update,
+                name="send_user_update",
+                description="Send an update message to the user about your current progress or actions. Takes 'message' (string) containing the update information. Use this tool frequently to keep the user informed about what you're doing."
+            )
+        )
+        
+        # Add research tool
+        tools.append(
+            FunctionTool.from_defaults(
+                self.research,
+                name="perform_web_research",
+                description="Performs comprehensive web research on a given topic. Takes 'query' (string) containing the research question or topic to investigate. Returns a detailed research report with findings and sources."
+            )
+        )
+
+        # Get all available tools
+        tools.append(
+            FunctionTool.from_defaults(
+                self.get_available_tools,
+                name="get_available_tools",
+                description="Get a list of all tools currently available in the registry. Returns a list of tool specifications with names, descriptions, and states."
+            )
+        )
+
+        # Use a registered tool
+        tools.append(
+            FunctionTool.from_defaults(
+                self.use_registry_tool,
+                name="use_registry_tool",
+                description="Use a registered tool directly by invoking its endpoint. Takes 'tool_name' (string) and any additional arguments required by the tool. Automatically deploys the tool if needed. Returns the response from the tool."
+            )
+        )
+
+        # Tool brainstorming
+        tools.append(
+            FunctionTool.from_defaults(
+                self.brainstorm_tools,
+                name="brainstorm_tools",
+                description="Analyze the user request against available tools to determine if existing tools are sufficient or new tools are needed. Takes 'user_task' (string) containing the user's request and optionally 'available_tools' (string) with comma-separated tool names. Returns recommendations on which tools to use or what new tools to create."
+            )
+        )
+
+        # Deploy a specific tool
+        tools.append(
+            FunctionTool.from_defaults(
+                self.deploy_tool,
+                name="deploy_tool",
+                description="Deploy and activate a specific tool from the registry. Takes 'tool_name' (string) containing the name of the tool to deploy. Returns the URL of the deployed tool if successful, or an error message if deployment fails."
+            )
+        )
+
+        # Add analysis tool for better decision making
+        tools.append(
+            FunctionTool.from_defaults(
+                self._analyze_user_request,
+                name="analyze_user_request",
+                description="Analyze user request to determine the best approach (research, existing tool, new tool creation). Takes 'user_message' (string). Returns analysis with recommended actions."
+            )
+        )
+
+        return tools
+
+    def _analyze_user_request(self, user_message: str) -> Dict[str, Any]:
+        """Analyze user request to determine optimal workflow path"""
+        analysis = {
+            "request_type": "unknown",
+            "complexity": "medium",
+            "requires_research": False,
+            "requires_tools": False,
+            "suggested_approach": [],
+            "key_concepts": []
+        }
+        
+        message_lower = user_message.lower()
+        
+        # Look for comprehensive research indicators
+        research_terms = ["comprehensive", "thorough", "in-depth", "detailed", "extensive", 
+                        "research", "investigate", "analyze", "report", "study"]
+        
+        # Determine request type
+        if any(word in message_lower for word in research_terms):
+            analysis["request_type"] = "deep_research"
+            analysis["requires_research"] = True
+            analysis["complexity"] = "high"
+            analysis["suggested_approach"].append("research")
+            
+        elif any(word in message_lower for word in ["recherche", "search", "find", "lookup", "information", "what is", "explain"]):
+            analysis["request_type"] = "information_request"
+            analysis["requires_research"] = True
+            analysis["suggested_approach"].append("web_search")
+            
+        elif any(word in message_lower for word in ["outil", "tool", "script", "automatise", "automate", "create", "build"]):
+            analysis["request_type"] = "tool_request"
+            analysis["requires_tools"] = True
+            analysis["suggested_approach"].extend(["find_existing_tools", "brainstorm_if_needed"])
+            
+        elif any(word in message_lower for word in ["analyse", "analyze", "process", "calculate", "compute"]):
+            analysis["request_type"] = "analysis_task"
+            analysis["requires_tools"] = True
+            analysis["suggested_approach"].extend(["find_existing_tools", "research_methods"])
+            
+        elif any(word in message_lower for word in ["tendance", "trend", "market", "news", "current"]):
+            analysis["request_type"] = "research_task"
+            analysis["requires_research"] = True
+            analysis["complexity"] = "high"
+            analysis["suggested_approach"].extend(["web_search", "github_search"])
+
+        # Extract key concepts for better tool matching
+        concepts = []
+        tech_keywords = ["python", "javascript", "api", "database", "csv", "json", "web", "scraping", "ml", "ai"]
+        for keyword in tech_keywords:
+            if keyword in message_lower:
+                concepts.append(keyword)
+        analysis["key_concepts"] = concepts
+        
+        return analysis
+
+    def _run_and_register_mcp(self, spec: Dict[str, Any], python_script: str, env_script: str, input_data: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """Enhanced MCP execution and registration with better error handling"""
+        print(f"🔧 ManagerAgent: Executing and registering MCP: {spec.get('name', 'Unnamed Tool')}")
+        
+        try:
+            mcp_spec_obj = MCPToolSpec.from_dict(spec)
+            env_name_suffix = mcp_spec_obj.name.lower().replace(' ', '-')[:10]
+            env_name = f"alita-{env_name_suffix}-{uuid.uuid4().hex[:8]}"
+
+            print(f"🔄 Setting up environment: {env_name}")
+            env_success = self.code_runner.setup_environment(env_script, env_name)
+            
+            if not env_success:
+                result = MCPExecutionResult(
+                    success=False, 
+                    error_message=f"Environment setup failed for '{env_name}'. Check dependencies in env_script."
+                )
+                return result.to_dict()
+
+            print(f"▶️ Executing script in environment: {env_name}")
+            execution_result = self.code_runner.execute(python_script, env_name, input_data)
+
+            if execution_result.success:
+                print(f"✅ Script execution successful. Registering tool: {mcp_spec_obj.name}")
+                mcp_spec_obj.validated_script = python_script
+                mcp_spec_obj.environment_script = env_script
+                self.registry.register_tool(mcp_spec_obj)
+                print(f"🎯 Tool '{mcp_spec_obj.name}' successfully registered in registry")
+                
+                # Add success message to result
+                execution_result.output_data = execution_result.output_data or {}
+                execution_result.output_data["registration_status"] = "Successfully registered"
+                
+            else:
+                print(f"❌ Script execution failed for '{mcp_spec_obj.name}': {execution_result.error_message}")
+
+            # Always cleanup after validation
+            self.code_runner.cleanup_environment(env_name)
+            return execution_result.to_dict()
+
+        except Exception as e:
+            error_msg = f"Unexpected error in MCP execution: {str(e)}"
+            print(f"🚨 {error_msg}")
+            
+            # Cleanup on error
+            try:
+                if 'env_name' in locals():
+                    self.code_runner.cleanup_environment(env_name)
+            except:
+                pass
+                
+            return MCPExecutionResult(success=False, error_message=error_msg).to_dict()
+
+    def _run_registered_mcp(self, tool_name: str, input_data: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """Enhanced registered tool execution with better logging"""
+        print(f"🎯 ManagerAgent: Running registered tool: {tool_name}")
+        
+        spec = self.registry.get_tool(tool_name)
+        if not spec:
+            error_msg = f"Tool '{tool_name}' not found in registry. Available tools: {list(self.registry.tools.keys())}"
+            print(f"❌ {error_msg}")
+            return MCPExecutionResult(success=False, error_message=error_msg).to_dict()
+
+        if not spec.validated_script or not spec.environment_script:
+            error_msg = f"Tool '{tool_name}' missing validated script or environment configuration"
+            print(f"❌ {error_msg}")
+            return MCPExecutionResult(success=False, error_message=error_msg).to_dict()
+
+        # Create fresh environment for execution
+        env_name_suffix = spec.name.lower().replace(' ', '-')[:10]
+        env_name = f"alita-run-{env_name_suffix}-{uuid.uuid4().hex[:8]}"
+
+        try:
+            print(f"🔄 Setting up execution environment: {env_name}")
+            env_success = self.code_runner.setup_environment(spec.environment_script, env_name)
+            
+            if not env_success:
+                return MCPExecutionResult(
+                    success=False, 
+                    error_message=f"Failed to setup environment for tool '{tool_name}'"
+                ).to_dict()
+
+            print(f"▶️ Executing registered tool: {tool_name}")
+            execution_result = self.code_runner.execute(spec.validated_script, env_name, input_data)
+            
+            print(f"{'✅' if execution_result.success else '❌'} Tool execution completed. Success: {execution_result.success}")
+            
+            return execution_result.to_dict()
+            
+        except Exception as e:
+            error_msg = f"Error executing registered tool '{tool_name}': {str(e)}"
+            print(f"🚨 {error_msg}")
+            return MCPExecutionResult(success=False, error_message=error_msg).to_dict()
+            
+        finally:
+            # Always cleanup
+            try:
+                self.code_runner.cleanup_environment(env_name)
+            except:
+                pass
+
+    def run_task(self, prompt: TaskPrompt) -> str:
+        """
+        Enhanced task execution with detailed logging and structured workflow
+        Optimized for Gradio integration with comprehensive responses
+        """
+        print(f"\n{'='*60}")
+        print(f"🚀 ALITA ManagerAgent: Starting task execution")
+        print(f"📝 User prompt: {prompt.text[:100]}{'...' if len(prompt.text) > 100 else ''}")
+        print(f"{'='*60}")
+
+        # Send initial update to the user
+        self.send_update(f"Starting to process your request: '{prompt.text[:50]}{'...' if len(prompt.text) > 50 else ''}'")
+
+        try:
+            # Use the internal ReAct agent to handle the complete workflow
+            print("🧠 Engaging ReAct Agent for intelligent task orchestration...")
+            
+            # The ReAct agent will use its tools to:
+            # 1. Analyze the request
+            # 2. Search existing tools
+            # 3. Perform web research if needed
+            # 4. Brainstorm solutions
+            # 5. Create/execute tools as necessary
+            # 6. Provide comprehensive response
+            
+            response = self.agent.chat(prompt.text)
+            
+            print("✅ Task execution completed successfully")
+            print(f"{'='*60}\n")
+            
+            # Send final update to the user
+            self.send_update("Task completed successfully! Here's your response.")
+            
+            # Format response for better Gradio presentation
+            formatted_response = self._format_response_for_gradio(response.response)
+            return formatted_response
+            
+        except Exception as e:
+            error_msg = f"🚨 ManagerAgent encountered an error during task execution:\n\n**Error Details:**\n{str(e)}\n\n**Next Steps:**\n- Check your API key and network connection\n- Verify all components are properly initialized\n- Try a simpler request to test basic functionality"
+            
+            print(f"❌ Task execution failed: {e}")
+            print(f"{'='*60}\n")
+            
+            # Send error update to the user
+            self.send_update(f"An error occurred while processing your request: {str(e)}")
+            
+            return error_msg
+
+    def _format_response_for_gradio(self, response: str) -> str:
+        """Format the agent response for better presentation in Gradio"""
+        
+        # Add header if not present
+        if not response.startswith("##") and not response.startswith("#"):
+            response = f"## 🤖 {response}"
+        
+        
+            
+        return response
+
+    def get_registry_status(self) -> Dict[str, Any]:
+        """Get current status of the tool registry"""
+        return {
+            "total_tools": len(self.registry.tools),
+            "tool_names": list(self.registry.tools.keys()),
+            "registry_ready": len(self.registry.tools) > 0
+        }
+
+    def reset_registry(self):
+        """Reset the tool registry (useful for testing)"""
+        self.registry = Registry()
+        print("🔄 Tool registry has been reset")
+
+    def __str__(self):
+        return f"ManagerAgent(llm={type(self.llm).__name__}, tools_registered={len(self.registry.tools)})"
+
+    def research(self, query: str, max_iterations: int = None, verbose: bool = None) -> str:
+        """
+        Performs autonomous web research on the given query using the WebAgent's research function.
+        
+        Args:
+            query: The research question or topic
+            max_iterations: Optional override for the maximum number of research iterations
+            verbose: Optional override for verbose mode
+            
+        Returns:
+            A comprehensive textual report based on web research
+        """
+        print(f"\n{'='*60}")
+        print(f"🌐 ALITA ManagerAgent: Starting web research")
+        print(f"📝 Research query: {query[:100]}{'...' if len(query) > 100 else ''}")
+        print(f"{'='*60}")
+        
+        try:
+            # Configure WebAgent for this research session
+            if max_iterations is not None:
+                self.web_agent.max_research_iterations = max_iterations
+            
+            if verbose is not None:
+                self.web_agent.verbose = verbose
+            
+            # Perform the research
+            print("🔍 Initiating autonomous web research. This may take some time... here is the query: ", query)
+            report = self.web_agent.research(query)
+            print("🔍 here is the report: ", report)
+            
+            print("✅ Research completed successfully")
+            print(f"{'='*60}\n")
+            
+            return report
+            
+        except Exception as e:
+            error_msg = f"���� Error during web research: {str(e)}"
+            print(f"❌ Research failed: {e}")
+            print(f"{'='*60}\n")
+            
+            import traceback
+            print(traceback.format_exc())
+            
+            return error_msg
+
+    def get_available_tools(self) -> List[Dict[str, Any]]:
+        """
+        Get a list of all tools currently available in the registry.
+        
+        Returns:
+            List of dictionaries containing tool information (name, description, state)
+        """
+        print("📋 ManagerAgent: Retrieving list of all available tools")
+        tools = self.registry.list_tools()
+        
+        # Format the tools for easier consumption by the agent
+        formatted_tools = []
+        for tool in tools:
+            formatted_tools.append({
+                "name": tool.name,
+                "description": tool.description,
+                "state": getattr(tool, "state", "unknown"),
+                "input_schema": tool.input_schema if hasattr(tool, "input_schema") else {},
+                "output_schema": tool.output_schema if hasattr(tool, "output_schema") else {}
+            })
+            
+        print(f"🔍 Found {len(formatted_tools)} tools in registry")
+        return formatted_tools
+    
+    def deploy_tool(self, tool_name: str) -> Dict[str, Any]:
+        """
+        Deploy and activate a specific tool from the registry.
+        
+        Args:
+            tool_name: Name of the tool to deploy
+            
+        Returns:
+            Dictionary with deployment status and URL (if successful)
+        """
+        print(f"🚀 ManagerAgent: Deploying tool '{tool_name}'")
+        
+        # Check if tool exists in registry
+        if not self.registry.get_tool(tool_name):
+            error_msg = f"Tool '{tool_name}' not found in registry"
+            print(f"❌ {error_msg}")
+            return {"success": False, "error": error_msg}
+        
+        # Attempt to deploy the tool
+        try:
+            url = self.registry.deploy_tool(tool_name)
+            
+            if url:
+                print(f"✅ Successfully deployed tool '{tool_name}' at {url}")
+                return {
+                    "success": True,
+                    "tool_name": tool_name,
+                    "url": url,
+                    "message": f"Tool '{tool_name}' successfully deployed"
+                }
+            else:
+                error_msg = f"Failed to deploy tool '{tool_name}'"
+                print(f"❌ {error_msg}")
+                return {"success": False, "error": error_msg}
+                
+        except Exception as e:
+            error_msg = f"Error deploying tool '{tool_name}': {str(e)}"
+            print(f"🚨 {error_msg}")
+            return {"success": False, "error": error_msg}
+
+    def brainstorm_tools(self, user_task: str, available_tools: str = "") -> Dict[str, Any]:
+        """
+        Use the Brainstormer to analyze if existing tools are sufficient or new tools are needed.
+        
+        Args:
+            user_task: The user's request or task
+            available_tools: Optional comma-separated list of available tool names
+            
+        Returns:
+            Dictionary with tool recommendations or specifications for new tools
+        """
+        print(f"🧠 ManagerAgent: Brainstorming tools for task: {user_task[:100]}{'...' if len(user_task) > 100 else ''}")
+        
+        # If available_tools is not provided, get them from the registry
+        if not available_tools:
+            tools = self.get_available_tools()
+            available_tools = ", ".join([tool["name"] for tool in tools])
+        
+        try:
+            # Call the brainstormer to analyze the task and available tools
+            result = self.brainstormer.generate_mcp_specs_to_fulfill_user_task(
+                task=user_task,
+                tools_list=available_tools
+            )
+            
+            if isinstance(result, dict) and "error" in result:
+                print(f"❌ Brainstorming failed: {result['error']}")
+                return {
+                    "success": False,
+                    "error": result["error"],
+                    "recommendations": "Unable to analyze tools for this task."
+                }
+                
+            print(f"✅ Brainstorming complete. Found {len(result)} tool recommendations.")
+            
+            # Format the result for better consumption by the agent
+            return {
+                "success": True,
+                "recommendations": result,
+                "summary": f"Analysis complete. Found {len(result)} tool recommendations."
+            }
+            
+        except Exception as e:
+            error_msg = f"Error during tool brainstorming: {str(e)}"
+            print(f"🚨 {error_msg}")
+            return {
+                "success": False,
+                "error": error_msg,
+                "recommendations": "Unable to analyze tools due to an error."
+            }
+
+    def use_registry_tool(self, tool_name: str, *args, **kwargs) -> Dict[str, Any]:
+        """
+        Use a registered tool directly by invoking its endpoint.
+        
+        This method utilizes the Registry's use_tool method to invoke a registered tool.
+        It handles tool deployment if needed and provides proper error handling and user feedback.
+        
+        Args:
+            tool_name: Name of the tool to use
+            *args: Positional arguments to pass to the tool
+            **kwargs: Keyword arguments to pass to the tool
+            
+        Returns:
+            The response from the tool as a Python object
+        """
+        try:
+            # Send update to user
+            self.send_update(f"Using tool: {tool_name}")
+            
+            # Check if tool exists in registry
+            if not self.registry.get_tool(tool_name):
+                error_msg = f"Tool '{tool_name}' not found in registry"
+                self.send_update(error_msg)
+                return {"error": error_msg, "success": False}
+                
+            # Use the tool via Registry's use_tool method
+            self.send_update(f"Executing tool: {tool_name}")
+            result = self.registry.use_tool(tool_name, *args, **kwargs)
+            
+            # Send success update
+            self.send_update(f"Tool '{tool_name}' executed successfully")
+            
+            # Return result with success flag
+            if isinstance(result, dict):
+                result["success"] = True
+                return result
+            else:
+                return {"result": result, "success": True}
+                
+        except ValueError as e:
+            # Handle expected errors (tool not found, deployment failed)
+            error_msg = str(e)
+            self.send_update(f"Error: {error_msg}")
+            return {"error": error_msg, "success": False}
+            
+        except Exception as e:
+            # Handle unexpected errors
+            error_msg = f"Unexpected error using tool '{tool_name}': {str(e)}"
+            self.send_update(f"Error: {error_msg}")
+            return {"error": error_msg, "success": False} 

requirements.txt

@@ -1 +1,22 @@
-huggingface_hub==0.25.2
+gradio
+openai
+llama-index>=0.11.0
+anthropic
+requests
+python-dotenv
+dataclasses
+beautifulsoup4
+duckduckgo-search
+llama-index-llms-anthropic
+modal
+llama-index-core>=0.10.0
+llama-index-readers-web>=0.1.0
+google-api-python-client>=2.70.0
+PyGithub>=1.58.0
+PyPDF2>=3.0.0
+python-docx>=0.8.11
+python-pptx>=0.6.21
+urllib3>=1.26.0
+pathlib>=1.0.1
+argparse>=1.4.0 
+llama-index-tools-mcp

task_prompt.py

@@ -0,0 +1,9 @@
+from dataclasses import dataclass
+
+@dataclass
+class TaskPrompt:
+    """
+    Represents the initial user query or task description.
+    """
+    text: str
+    # Potentially add other fields like context, constraints, etc.

test_research.py

@@ -0,0 +1,63 @@
+"""
+Test script to demonstrate using the ManagerAgent's research function
+"""
+import os
+from dotenv import load_dotenv
+from llama_index.llms.anthropic import Anthropic
+from manager_agent import ManagerAgent
+from models import TaskPrompt
+
+# Load environment variables
+load_dotenv()
+
+# ANSI color codes for prettier output
+COLOR_RESET = "\033[0m"
+COLOR_CYAN = "\033[96m"
+COLOR_GREEN = "\033[92m"
+COLOR_YELLOW = "\033[93m"
+COLOR_RED = "\033[91m"
+
+def color_text(text, color):
+    return f"{color}{text}{COLOR_RESET}"
+
+def main():
+    # Check if API key is available
+    api_key = os.environ.get("ANTHROPIC_API_KEY")
+    if not api_key:
+        print(color_text("Error: ANTHROPIC_API_KEY not found in environment variables.", COLOR_RED))
+        print("Please set your Anthropic API key with:")
+        print("  export ANTHROPIC_API_KEY='your-api-key'")
+        print("  or create a .env file with ANTHROPIC_API_KEY=your-api-key")
+        return
+    
+    # Initialize LLM
+    print(color_text("Initializing Anthropic Claude...", COLOR_CYAN))
+    llm = Anthropic(model="claude-3-5-sonnet-20241022", api_key=api_key)
+    
+    # Initialize ManagerAgent
+    print(color_text("Creating ManagerAgent...", COLOR_CYAN))
+    manager = ManagerAgent(llm=llm)
+    
+    print(color_text("\nTest 1: Using research function directly", COLOR_GREEN))
+    query = "What are the latest developments in AI agents and autonomous systems?"
+    print(color_text(f"Research Query: {query}", COLOR_YELLOW))
+    
+    # Call research function directly
+    report = manager.research(query=query, verbose=True)
+    print(color_text("\n=== Research Report ===", COLOR_GREEN))
+    print(report)
+    
+    print(color_text("\nTest 2: Using research as a tool through the agent", COLOR_GREEN))
+    prompt_text = "I need a comprehensive report on recent developments in quantum computing. Please research this topic thoroughly."
+    print(color_text(f"User Prompt: {prompt_text}", COLOR_YELLOW))
+    
+    # Create task prompt
+    task_prompt = TaskPrompt(text=prompt_text)
+    
+    # Run through agent
+    response = manager.run_task(task_prompt)
+    print(color_text("\n=== Agent Response ===", COLOR_GREEN))
+    print(response)
+
+if __name__ == "__main__":
+    main()