Update app.py

app.py

@@ -1,17 +1,9 @@
-"""Main application for the OpenDeepResearch Gradio interface."""
-
-import sys
 import mimetypes
-import traceback
-from dataclasses import dataclass
 import os
 import re
 import shutil
-import time
-from typing import Optional, Dict, Any
-from datetime import datetime
+from typing import Optional
 
-from cleantext import clean
 from dotenv import load_dotenv
 from huggingface_hub import login
 import gradio as gr
@@ -27,7 +19,6 @@ from scripts.text_web_browser import (
     VisitTool,
 )
 from scripts.visual_qa import visualizer
-from scripts.text_cleaner_tool import TextCleanerTool
 
 from smolagents import (
     CodeAgent,
@@ -38,11 +29,11 @@ from smolagents import (
     GoogleSearchTool,
     Tool,
 )
-from smolagents.agent_types import AgentText  # AgentImage, AgentAudio
+from smolagents.agent_types import AgentText, AgentImage, AgentAudio
 from smolagents.gradio_ui import pull_messages_from_step, handle_agent_output_types
 
-
-# Constants and configurations - Converted to UPPER_CASE
+# ------------------------ Configuration and Setup ------------------------
+# Constants and configurations
 AUTHORIZED_IMPORTS = [
     "requests",  # Web requests (fetching data from the internet)
     "zipfile",  # Working with ZIP archives
@@ -90,7 +81,6 @@ AUTHORIZED_IMPORTS = [
     "schedule",  # Allow the agent to schedule tasks
 ]
 
-
 USER_AGENT = (
     "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 "
     "(KHTML, like Gecko) Chrome/119.0.0.0 Safari/537.36 Edg/119.0.0.0"
@@ -124,89 +114,63 @@ ALLOWED_FILE_TYPES = [
     "audio/ogg",
 ]
 
-# Maximum chat history length to prevent memory issues
-MAX_CHAT_HISTORY = 100
-# Maximum uploaded file size in MB
-MAX_FILE_SIZE_MB = 50
-# File cleanup schedule (in days)
-FILE_RETENTION_DAYS = 7
-
 
 def setup_environment():
-    """
-    Initialize environment variables and authentication.
-    Returns:
-        bool: True if setup was successful, False otherwise
-    """
+    """Initialize environment variables and authentication."""
     load_dotenv(override=True)
-    hf_token = os.getenv("HF_TOKEN")
-    if hf_token:  # check if token is actually set
-        try:
-            login(hf_token)
-            print("HF_TOKEN (last 10 characters):", hf_token[-10:])
-            return True
-        except (ValueError, ConnectionError) as e:  # More specific exceptions
-            print(f"Failed to login with HF token: {e}")
-            return False
+    if os.getenv("HF_TOKEN"):  # Check if token is actually set
+        login(os.getenv("HF_TOKEN"))
+        print("HF_TOKEN (last 10 characters):", os.getenv("HF_TOKEN")[-10:])
     else:
         print("HF_TOKEN not found in environment variables.")
-        return False
 
 
+# ------------------------ Model and Tool Management ------------------------
 class ModelManager:
     """Manages model loading and initialization."""
 
     @staticmethod
     def load_model(chosen_inference: str, model_id: str, key_manager=None):
-        """
-        Load the specified model with appropriate configuration.
-        Args:
-            chosen_inference: Type of inference to use
-            model_id: ID of the model to load
-            key_manager: Optional key manager for API keys
-        Returns:
-            Model instance
-        Raises:
-            ValueError: If inference type is invalid or required parameters missing
-            RuntimeError: If model loading fails
-        """
-        if chosen_inference == "hf_api":
-            return HfApiModel(model_id=model_id)
-        if chosen_inference == "hf_api_provider":
-            return HfApiModel(provider="together")
-        if chosen_inference == "litellm":
-            return LiteLLMModel(model_id=model_id)
-        if chosen_inference == "openai":
-            if not key_manager:
-                raise ValueError("Key manager required for OpenAI model")
-            return OpenAIServerModel(
-                model_id=model_id, api_key=key_manager.get_key("openai_api_key")
-            )
-        if chosen_inference == "transformers":
-            return TransformersModel(
-                model_id="huggingfacetb/smollm2-1.7b-instruct",
-                device_map="auto",
-                max_new_tokens=1000,
-            )
-        raise ValueError(f"Invalid inference type: {chosen_inference}")
+        """Load the specified model with appropriate configuration."""
+        try:
+            if chosen_inference == "hf_api":
+                return HfApiModel(model_id=model_id)
+
+            elif chosen_inference == "hf_api_provider":
+                return HfApiModel(provider="together")
+
+            elif chosen_inference == "litellm":
+                return LiteLLMModel(model_id=model_id)
+
+            elif chosen_inference == "openai":
+                if not key_manager:
+                    raise ValueError("Key manager required for OpenAI model")
+
+                return OpenAIServerModel(
+                    model_id=model_id, api_key=key_manager.get_key("openai_api_key")
+                )
+
+            elif chosen_inference == "transformers":
+                return TransformersModel(
+                    model_id="HuggingFaceTB/SmolLM2-1.7B-Instruct",
+                    device_map="auto",
+                    max_new_tokens=1000,
+                )
+
+            else:
+                raise ValueError(f"Invalid inference type: {chosen_inference}")
+
+        except Exception as e:
+            print(f"✗ Couldn't load model: {e}")
+            raise
 
 
-# This class only has one public method, but that's acceptable for a registry class
-# whose purpose is to provide factory methods
 class ToolRegistry:
     """Manages tool initialization and organization."""
 
     @staticmethod
     def load_web_tools(model, browser, text_limit=20000):
-        """
-        Initialize and return web-related tools.
-        Args:
-            model: LLM model for text inspector
-            browser: Browser instance for web tools
-            text_limit: Maximum text length for processing
-        Returns:
-            List of web tools
-        """
+        """Initialize and return web-related tools."""
         return [
             GoogleSearchTool(provider="serper"),
             VisitTool(browser),
@@ -220,710 +184,439 @@ class ToolRegistry:
 
     @staticmethod
     def load_image_generation_tools():
-        """
-        Initialize and return image generation tools.
-        Returns:
-            Image generation tool
-        Raises:
-            RuntimeError: If tool initialization fails
-        """
+        """Initialize and return image generation tools."""
         try:
             return Tool.from_space(
-                space_id="xkerser/flux.1-dev",
+                space_id="xkerser/FLUX.1-dev",
                 name="image_generator",
-                description=(
-                    "Generates high-quality AgentImage. "
-                    "With text prompt (77 token limit)."
-                ),
+                description="Generates high-quality AgentImage using the FLUX.1-dev model based on text prompts.",
             )
-        except (
-            ConnectionError,
-            ValueError,
-            RuntimeError,
-        ) as e:  # More specific exceptions
-            print(f" Couldn't initialize image generation tool: {e}")
-            raise RuntimeError(f"Image generation tool initialization failed: {e}")
-
-    @staticmethod
-    def load_clean_text_tool():
-        """
-        Initialize and return text cleaning tool.
-        Returns:
-            Text cleaning tool
-        Raises:
-            RuntimeError: If tool initialization fails
-        """
-        try:
-            return TextCleanerTool()
-        except (ValueError, RuntimeError) as e:  # More specific exceptions
-            print(f" Couldn't initialize clean text tool: {e}")
-            raise RuntimeError(f"Clean text tool initialization failed: {e}")
+        except Exception as e:
+            print(f"✗ Couldn't initialize image generation tool: {e}")
+            raise
 
 
+# ------------------------ Agent Creation and Execution ------------------------
 def create_agent():
-    """
-    Creates a fresh agent instance with properly configured tools.
-    Returns:
-        CodeAgent: Configured agent ready for use
-    Raises:
-        ValueError: If tool validation fails
-        RuntimeError: If agent creation fails
-    """
-    try:
-        # Initialize model
-        model = LiteLLMModel(
-            custom_role_conversions=CUSTOM_ROLE_CONVERSIONS,
-            model_id="openrouter/deepseek/deepseek-chat-v3-0324:free",
-        )
-
-        # Initialize tools
-        text_limit = 30000
-        browser = SimpleTextBrowser(**BROWSER_CONFIG)
-
-        # Collect all tools in a single list
-        web_tools = ToolRegistry.load_web_tools(model, browser, text_limit)
-        image_generator = ToolRegistry.load_image_generation_tools()
-        clean_text = TextCleanerTool()
-
-        # Combine all tools into a single list
-        all_tools = [visualizer] + web_tools + [image_generator, clean_text]
-
-        # Validate tools before creating agent
-        for tool in all_tools:
-            if not isinstance(tool, Tool):
-                raise ValueError(
-                    f"Invalid tool type: {type(tool)}. "
-                    f"All tools must be instances of Tool class."
-                )
+    """Creates a fresh agent instance with properly configured tools."""
+    # Initialize model
+    model = LiteLLMModel(
+        custom_role_conversions=CUSTOM_ROLE_CONVERSIONS,
+        model_id="openrouter/google/gemini-2.0-flash-001",  # currently serving:
+    )  # DEEPSEEK = openrouter/perplexity/r1-1776 <--- boss model
+
+    # Initialize tools
+    text_limit = 30000
+    browser = SimpleTextBrowser(**BROWSER_CONFIG)
+
+    # Collect all tools in a single list
+    web_tools = ToolRegistry.load_web_tools(model, browser, text_limit)
+    image_generator = ToolRegistry.load_image_generation_tools()
+
+    # Combine all tools into a single list (not a tuple)
+    all_tools = [visualizer] + web_tools + [image_generator]
+
+    # Validate tools before creating agent
+    for tool in all_tools:
+        if not isinstance(tool, Tool):
+            raise ValueError(
+                f"Invalid tool type: {type(tool)}. All tools must be instances of Tool class."
+            )
 
-        return CodeAgent(
-            model=model,
-            tools=all_tools,
-            max_steps=12,
-            verbosity_level=2,
-            additional_authorized_imports=AUTHORIZED_IMPORTS,
-            planning_interval=4,
-        )
-    except (ValueError, RuntimeError) as e:
-        print(f"Failed to create agent: {e}")
-        raise RuntimeError(f"Agent creation failed: {e}")
-
-
-# Define standalone functions outside of classes
-def process_message_content(content_lower: str) -> Dict[str, bool]:
-    """
-    Process message content to determine message type.
-    Args:
-        content_lower: Lowercase message content
-    Returns:
-        Dictionary with message type flags
-    """
-    return {
-        "is_document_analysis": "document analysis" in content_lower,
-        "is_search": "search" in content_lower,
-        "is_error": "error" in content_lower,
-    }
+    return CodeAgent(
+        model=model,
+        tools=all_tools,  # Pass a single list containing all tools
+        max_steps=10,
+        verbosity_level=1,
+        additional_authorized_imports=AUTHORIZED_IMPORTS,
+        planning_interval=4,
+    )
 
 
 def stream_to_gradio(
     agent,
     task: str,
     reset_agent_memory: bool = False,
-    additional_args: Optional[Dict] = None,
+    additional_args: Optional[dict] = None,
 ):
-    """
-    Streams agent responses with improved status indicators.
-    Args:
-        agent: The agent instance to use
-        task: The task to perform
-        reset_agent_memory: Whether to reset agent memory
-        additional_args: Optional additional arguments
-    Yields:
-        Gradio ChatMessage objects
-    """
-    try:
-        # Initial processing indicator
-        yield gr.ChatMessage(role="assistant", content="⏳ Processing your request...")
-
-        # Track what we've yielded to replace the processing indicator
-        first_message_yielded = False
-
-        # Store the step_log outside the loop to avoid the undefined-loop-variable issue
-        steps = list(
-            agent.run(
-                task,
-                stream=True,
-                reset=reset_agent_memory,
-                additional_args=additional_args,
-            )
-        )
-
-        # If no steps were returned, handle it gracefully
-        if not steps:
-            yield gr.ChatMessage(
-                role="assistant", content="⚠️ No response from agent. Please try again."
-            )
-            return
-
-        # Process each step
-        for step_log in steps:
-            # pull_messages_from_step is a generator function that yields messages
-            for message in pull_messages_from_step(step_log):
-                if not first_message_yielded:
-                    # Replace the initial "processing" message
-                    first_message_yielded = True
-                    message.content = message.content.replace(
-                        "⏳ Processing your request...", ""
-                    )
-
-                # Check message content for document analysis or search references
-                if hasattr(message, "content") and message.content:
-                    content_lower = message.content.lower()
-                    message_types = process_message_content(content_lower)
-
-                    if message_types["is_document_analysis"]:
-                        message.content = f"📄 **Document Analysis:** {message.content}"
-                    elif message_types["is_search"]:
-                        message.content = f"🔍 **Search:** {message.content}"
-
-                yield message
-
-        # Final answer with enhanced formatting
-        if steps:  # Make sure we have at least one step before accessing
-            final_answer = handle_agent_output_types(steps[-1])  # Use the last step
-            if isinstance(final_answer, AgentText):
-                yield gr.ChatMessage(
-                    role="assistant",
-                    content=f"✅ **Final Answer:**\n{final_answer.to_string()}",
-                )
-            else:
-                yield gr.ChatMessage(
-                    role="assistant",
-                    content=f"✅ **Final Answer:** {str(final_answer)}",
-                )
-
-    except (ValueError, RuntimeError) as e:
-        # More specific error handling
+    """Runs an agent with the given task and streams messages as Gradio ChatMessages."""
+    for step_log in agent.run(
+        task, stream=True, reset=reset_agent_memory, additional_args=additional_args
+    ):
+        for message in pull_messages_from_step(step_log):
+            yield message
+
+    # Process final answer : Use a more comprehensive media output
+    final_answer = step_log  # Last log is the run's final_answer
+    final_answer = handle_agent_output_types(final_answer)
+
+    if isinstance(final_answer, AgentText):
         yield gr.ChatMessage(
             role="assistant",
-            content=(
-                f"❌ **Error:** {str(e)}\n" f"Please try again with a different query."
-            ),
+            content=f"**Final answer:**\n{final_answer.to_string()}\n",
         )
-    except Exception as e:  # Fallback for truly unexpected errors
-        print(f"Unexpected error in stream_to_gradio: {e}")
-        traceback.print_exc()
+    elif isinstance(final_answer, AgentImage):
         yield gr.ChatMessage(
             role="assistant",
-            content=(
-                "❌ **Unexpected Error:** An unknown error occurred.\n"
-                "Please try again or contact support if the issue persists."
-            ),
+            content={"image": final_answer.to_string(), "type": "file"},
+        )  # Send as Gradio-compatible file object:
+    elif isinstance(final_answer, AgentAudio):
+        yield gr.ChatMessage(
+            role="assistant",
+            content={"audio": final_answer.to_string(), "type": "file"},
+        )  # Send as Gradio-compatible file object
+    else:
+        yield gr.ChatMessage(
+            role="assistant", content=f"**Final answer:** {str(final_answer)}"
         )
 
 
-# This is a helper method that can be called statically
-def cleanup_old_files(directory: str, days: int = FILE_RETENTION_DAYS):
-    """
-    Removes files older than the specified number of days.
-    Args:
-        directory: Directory to clean up
-        days: Number of days to keep files
-    """
-    if not os.path.exists(directory):
-        return
-
-    cutoff_time = time.time() - (days * 24 * 60 * 60)
-    for filename in os.listdir(directory):
-        file_path = os.path.join(directory, filename)
-        if os.path.isfile(file_path):
-            file_mod_time = os.path.getmtime(file_path)
-            if file_mod_time < cutoff_time:
-                try:
-                    os.remove(file_path)
-                    print(f"Deleted old file: {file_path}")
-                except (PermissionError, OSError) as e:
-                    print(f"Failed to delete {file_path}: {str(e)}")
-
-
-@dataclass
-class UIComponents:
-    """Container for UI components to reduce main class attribute count."""
-
-    text_input: Any = None
-    submit_btn: Any = None
-    stop_btn: Any = None
-    clear_btn: Any = None
-    status: Any = None
-    chatbot: Any = None
-    file_uploader: Any = None  # renamed from upload_file to avoid conflict
-    upload_status: Any = None
-
-
+# ------------------------ Gradio UI Components ------------------------
 class GradioUI:
-    """Gradio user interface for the OpenDeepResearch application."""
+    """A one-line interface to launch your agent in Gradio."""
 
-    def __init__(self, file_upload_folder=None, max_queue_size=50):
-        """Initialize the Gradio UI."""
-        # Basic configuration
+    def __init__(self, file_upload_folder: str | None = None):
+        """Initialize the Gradio UI with optional file upload functionality."""
         self.file_upload_folder = file_upload_folder
-        self.max_queue_size = max_queue_size
-        self.max_chat_history = MAX_CHAT_HISTORY
-        self.max_file_size_mb = MAX_FILE_SIZE_MB
 
-        # Initialize UI components container
-        self.components = UIComponents()
-
-        # Job handle for cancellation
-        self.job = None
-
-        # Create upload directory if specified
-        if self.file_upload_folder is not None:  # Simplified if expression
-            os.makedirs(file_upload_folder, exist_ok=True)
-
-        # Clean up old files
-        if file_upload_folder:
-            cleanup_old_files(file_upload_folder)
+        if self.file_upload_folder is not None:
+            if not os.path.exists(file_upload_folder):
+                os.mkdir(file_upload_folder)
 
     def interact_with_agent(self, prompt, messages, session_state):
-        """
-        Main interaction handler with the agent.
-        Args:
-            prompt: User input prompt
-            messages: Current message history
-            session_state: Session state dictionary
-        Yields:
-            Updated message history
-        """
+        """Main interaction handler with the agent."""
+
         # Get or create session-specific agent
         if "agent" not in session_state:
-            try:
-                session_state["agent"] = create_agent()
-            except RuntimeError as e:
-                messages.append(
-                    gr.ChatMessage(
-                        role="assistant", content=f"Failed to create agent: {str(e)}"
-                    )
-                )
-                yield messages
-                return
+            session_state["agent"] = create_agent()
 
+        # Adding monitoring
         try:
             # Log the existence of agent memory
             has_memory = hasattr(session_state["agent"], "memory")
             print(f"Agent has memory: {has_memory}")
-            if has_memory and hasattr(session_state["agent"].memory, "steps"):
-                print(f"Memory steps: {len(session_state['agent'].memory.steps)}")
+            if has_memory:
+                print(f"Memory type: {type(session_state['agent'].memory)}")
 
-            # Truncate messages if they exceed the maximum
-            if len(messages) > self.max_chat_history:
-                # Keep only the latest messages
-                messages = messages[-self.max_chat_history :]
-
-            # Add user message
             messages.append(gr.ChatMessage(role="user", content=prompt))
             yield messages
 
-            # Process with agent and stream responses
             for msg in stream_to_gradio(
                 session_state["agent"], task=prompt, reset_agent_memory=False
             ):
                 messages.append(msg)
-                yield messages
+                yield messages  # Yield messages after each step
+            yield messages  # Yield messages one last time
 
-        except ValueError as e:
-            print(f"Value error in interaction: {str(e)}")
-            messages.append(
-                gr.ChatMessage(role="assistant", content=f"Input error: {str(e)}")
-            )
-            yield messages
         except Exception as e:
             print(f"Error in interaction: {str(e)}")
-            traceback.print_exc()
-            messages.append(
-                gr.ChatMessage(role="assistant", content=f"Error occurred: {str(e)}")
-            )
-            yield messages
+            raise
 
-    def handle_file_upload(self, files, file_uploads_log):
-        """
-        Handle file uploads with proper validation and security.
-        Args:
-            files: Files to upload
-            file_uploads_log: List of uploaded files
-        Returns:
-            Tuple of (status textbox, updated file_uploads_log, updated upload button visibility)
-        """
-        if not files:
-            return (
-                gr.Textbox(value="No file uploaded", visible=True),
-                file_uploads_log,
-            )
+    def upload_file(
+        self,
+        file,
+        file_uploads_log,
+    ):
+        """Handle file uploads with proper validation and security."""
+        if file is None:
+            return gr.Textbox("No file uploaded", visible=True), file_uploads_log
 
         try:
-            # Process the file (files[0] since we're using file_count="single")
-            file = files[0]
-
-            # Validate file exists
-            if not os.path.exists(file.name):
-                return (
-                    gr.Textbox(value="File not found", visible=True),
-                    file_uploads_log,
-                )
+            mime_type, _ = mimetypes.guess_type(file.name)
+        except Exception as e:
+            return gr.Textbox(f"Error: {e}", visible=True), file_uploads_log
 
-            # Check file size
-            file_size_mb = os.path.getsize(file.name) / (1024 * 1024)
-            if file_size_mb > self.max_file_size_mb:
-                return (
-                    gr.Textbox(
-                        value=f"File size exceeds {self.max_file_size_mb} MB limit.",
-                        visible=True,
-                    ),
-                    file_uploads_log,
-                )
+        if mime_type not in ALLOWED_FILE_TYPES:
+            return gr.Textbox("File type disallowed", visible=True), file_uploads_log
 
-            # Validate mime type
-            mime_type, _ = mimetypes.guess_type(file.name)
-            if mime_type not in ALLOWED_FILE_TYPES:
-                return (
-                    gr.Textbox(value="File type disallowed", visible=True),
-                    file_uploads_log,
-                )
+        # Sanitize file name
+        original_name = os.path.basename(file.name)
+        sanitized_name = re.sub(
+            r"[^\w\-.]", "_", original_name
+        )  # Replace invalid chars with underscores
 
-            # Sanitize file name
-            original_name = os.path.basename(file.name)
-            # Replace invalid chars with underscores
-            sanitized_name = re.sub(r"[^\w\-.]", "_", original_name)
-            # Add timestamp to ensure uniqueness
-            timestamp = datetime.now().strftime(
-                "%y%m%d_%H%M%S"
-            )  # Correct format string
-            name_parts = os.path.splitext(sanitized_name)
-            sanitized_name = f"{name_parts[0]}_{timestamp}{name_parts[1]}"
-
-            # Save the uploaded file to the specified folder
-            file_path = os.path.join(self.file_upload_folder, sanitized_name)
-            shutil.copy(file.name, file_path)
+        # Ensure the extension correlates to the mime type
+        type_to_ext = {}
+        for ext, t in mimetypes.types_map.items():
+            if t not in type_to_ext:
+                type_to_ext[t] = ext
 
-            return (
-                gr.Textbox(value=f"File uploaded: {original_name}", visible=True),
-                file_uploads_log + [file_path],
-            )
+        # Build sanitized filename with proper extension
+        name_parts = sanitized_name.split(".")[:-1]
+        extension = type_to_ext.get(mime_type, "")
+        sanitized_name = "".join(name_parts) + extension
 
-        except FileNotFoundError as e:
-            return (
-                gr.Textbox(value=f"File not found: {str(e)}", visible=True),
-                file_uploads_log,
-            )
-        except PermissionError as e:
-            return (
-                gr.Textbox(value=f"Permission denied: {str(e)}", visible=True),
-                file_uploads_log,
-            )
-        except (IOError, OSError) as e:
-            return (
-                gr.Textbox(value=f"I/O error during upload: {str(e)}", visible=True),
-                file_uploads_log,
-            )
-        except Exception as e:
-            # For truly unexpected errors, log with more detail
-            print(f"Unexpected upload error: {e}")
-            traceback.print_exc()
+        # Limit File Size, and Throw Error
+        max_file_size_mb = 50  # Define the limit
+        file_size_mb = os.path.getsize(file.name) / (1024 * 1024)  # Size in MB
+
+        if file_size_mb > max_file_size_mb:
             return (
-                gr.Textbox(value=f"Error processing upload: {str(e)}", visible=True),
+                gr.Textbox(
+                    f"File size exceeds {max_file_size_mb} MB limit.", visible=True
+                ),
                 file_uploads_log,
             )
 
-    def log_user_message(self, text_input, file_uploads_log):
-        """
-        Process user message and handle file references.
-        Args:
-            text_input: User's text input
-            file_uploads_log: List of uploaded files
-        Returns:
-            Tuple of (processed message, updated text input, submit button)
-        """
-        if not text_input.strip():
-            return (
-                "",
-                gr.Textbox(value="", interactive=True),
-                gr.Button(interactive=True),
-            )
+        # Save the uploaded file to the specified folder
+        file_path = os.path.join(self.file_upload_folder, sanitized_name)
+        shutil.copy(file.name, file_path)
+
+        return gr.Textbox(
+            f"File uploaded: {file_path}", visible=True
+        ), file_uploads_log + [file_path]
 
-        # Only clean if necessary (avoid unnecessary processing)
+    def log_user_message(self, text_input, file_uploads_log):
+        """Process user message and handle file references."""
         message = text_input
-        if any(char in text_input for char in "€¥£-"):
-            message = clean(
-                text_input,
-                fix_unicode=True,
-                to_ascii=True,
-                lower=False,  # Keep original case
-                no_line_breaks=False,
-                no_urls=False,
-                no_emails=False,
-                no_phone_numbers=False,
-                no_numbers=False,
-                no_digits=False,
-                no_currency_symbols=False,
-                no_punct=False,
-                lang="en",
-            )
 
-        # Add file references if any
-        if file_uploads_log:
-            files_info = "\n".join(
-                [f"- {os.path.basename(f)}" for f in file_uploads_log]
-            )
-            message += f"\nYou have been provided with these files:\n{files_info}"
+        if len(file_uploads_log) > 0:
+            message += f"\nYou have been provided with these files, which might be helpful or not: {file_uploads_log}"  # Added file list
 
         return (
             message,
             gr.Textbox(
                 value="",
                 interactive=False,
-                placeholder="Processing your request...",
+                placeholder="Processing...",  # Changed placeholder.
             ),
             gr.Button(interactive=False),
         )
 
-    def clear_chat(self):
-        """
-        Clear the chat history and reset UI elements.
-        Returns:
-            Tuple of (empty chat history, interactive text input, interactive button, empty status)
-        """
-        return (
-            [],  # Empty chat history
-            [],  # Empty stored messages
-            gr.Textbox(value="", interactive=True),
-            gr.Button(interactive=True),
-            gr.Textbox(value="", visible=False),  # Clear status
-        )
+    def detect_device(self, request: gr.Request):
+        """Detect whether the user is on mobile or desktop device."""
+        if not request:
+            return "Unknown device"  # Handle case where request is none.
+
+        # Method 1: Check sec-ch-ua-mobile header
+        is_mobile_header = request.headers.get("sec-ch-ua-mobile")
+        if is_mobile_header:
+            return "Mobile" if "?1" in is_mobile_header else "Desktop"
+
+        # Method 2: Check user-agent string
+        user_agent = request.headers.get("user-agent", "").lower()
+        mobile_keywords = ["android", "iphone", "ipad", "mobile", "phone"]
+
+        if any(keyword in user_agent for keyword in mobile_keywords):
+            return "Mobile"
+
+        # Method 3: Check platform
+        platform = request.headers.get("sec-ch-ua-platform", "").lower()
+        if platform:
+            if platform in ['"android"', '"ios"']:
+                return "Mobile"
+            if platform in ['"windows"', '"macos"', '"linux"']:
+                return "Desktop"
 
-    def launch(self, share=False, **kwargs):
-        """
-        Launch the Gradio UI with responsive layout.
-        Args:
-            share: Whether to create a public link
-            **kwargs: Additional keyword arguments for launch
-        """
+        # Default case if no clear indicators
+        return "Desktop"
+
+    def launch(self, **kwargs):
+        """Launch the Gradio UI with responsive layout."""
         with gr.Blocks(theme="ocean", fill_height=True) as demo:
-            # Use Gradio's built-in responsive layout
-            with gr.Row():
-                # Sidebar (smaller on mobile)
-                with gr.Column(scale=1, min_width=100):
-                    gr.Markdown(
-                        """# OpenDeepResearch
-                        AI-powered research assistant using SmoLAgents
-                        Model: deepseek/deepseek-chat-v3-0324:free"""
+            # Different layouts for mobile and computer devices
+            @gr.render()
+            def layout(request: gr.Request):
+                device = self.detect_device(request)
+                print(f"device - {device}")
+                # Render layout with sidebar
+                if device == "Desktop":
+                    return self._create_desktop_layout()
+                return self._create_mobile_layout()
+
+        demo.queue(max_size=20).launch(
+            debug=True, **kwargs
+        )  # Add queue with reasonable size
+
+    def _create_desktop_layout(self):
+        """Create the desktop layout with sidebar."""
+        with gr.Blocks(fill_height=True) as sidebar_demo:
+            with gr.Sidebar():
+                gr.Markdown(
+                    """#OpenDeepResearch - 3theSmolagents!
+                Model_id: google/gemini-2.0-flash-001"""
+                )
+                with gr.Group():
+                    gr.Markdown("**What's on your mind mate?**", container=True)
+                    text_input = gr.Textbox(
+                        lines=3,
+                        label="Your request",
+                        container=False,
+                        placeholder="Enter your prompt here and press Shift+Enter or press the button",
                     )
+                    launch_research_btn = gr.Button("Run", variant="primary")
 
-                    with gr.Group():
-                        gr.Markdown("**Research Query**", container=True)
-                        self.components.text_input = gr.Textbox(
-                            lines=3,
-                            label="Your request",
-                            placeholder="Enter your research question or task",
-                            container=False,
-                        )
-
-                        with gr.Row():
-                            self.components.submit_btn = gr.Button(
-                                "Run", variant="primary"
-                            )
-                            self.components.stop_btn = gr.Button("Stop", variant="stop")
-                            self.components.clear_btn = gr.Button(
-                                "Clear", variant="secondary"
-                            )
-
-                    # File upload in collapsible section
-                    if self.file_upload_folder is not None:
-                        with gr.Accordion("Upload Files", open=False):
-                            self.components.file_uploader = gr.UploadButton(
-                                "Upload a file",
-                                file_count="single",
-                                file_types=["pdf", "docx", "txt", "md", "json"],
-                            )
-                            self.components.upload_status = gr.Textbox(
-                                label="Upload status", interactive=False, visible=False
-                            )
-
-                    # Tool information
-                    with gr.Accordion("Available Tools", open=False):
-                        gr.Markdown(
-                            """
-                            - **Web Search**: Find information online
-                            - **Document Analysis**: Analyze uploaded documents
-                            - **Text Cleaning**: Format and clean text
-                            - **Image Generation**: Create images from descriptions
-                            """
-                        )
-
-                    gr.HTML("<br><h5>Powered by:</h5>")
-                    with gr.Row():
-                        gr.HTML(
-                            """
-                            <div style="display: flex; align-items: center; gap: 8px;
-                            font-family: system-ui, -apple-system, sans-serif;">
-                            <img src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/smolagents/mascot_smol.png"
-                            style="width: 32px; height: 32px; object-fit: contain;"
-                            alt="logo">
-                            <a target="_blank" href="https://github.com/huggingface/smolagents">
-                            <b>huggingface/smolagents</b>
-                            </a>
-                            </div>
-                            """
-                        )
-
-                # Main chat area (larger)
-                with gr.Column(scale=3, min_width=500):
-                    # Add session state to store session-specific data
-                    session_state = gr.State({})
-                    stored_messages = gr.State([])
+                # If an upload folder is provided, enable the upload feature
+                if self.file_upload_folder is not None:
+                    upload_file = gr.File(label="Upload a file")
+                    upload_status = gr.Textbox(
+                        label="Upload Status", interactive=False, visible=False
+                    )
                     file_uploads_log = gr.State([])
-
-                    # Chat interface
-                    self.components.chatbot = gr.Chatbot(
-                        label="Research Assistant",
-                        type="messages",
-                        avatar_images=(
-                            None,
-                            "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/smolagents/mascot_smol.png",
-                        ),
-                        height=600,
-                        elem_id="research-chatbot",
+                    upload_file.change(
+                        self.upload_file,
+                        [upload_file, file_uploads_log],
+                        [upload_status, file_uploads_log],
                     )
 
-                    # Status indicator
-                    self.components.status = gr.Textbox(
-                        "", label="Status", interactive=False, visible=False
+                gr.HTML("<br><br><h4><center>Powered by:</center></h4>")
+                with gr.Row():
+                    gr.HTML(
+                        """
+                    <div style="display: flex; align-items: center; gap: 8px; font-family: system-ui, -apple-system, sans-serif;">
+                    <img src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/smolagents/mascot_smol.png"
+                         style="width: 32px; height: 32px; object-fit: contain;" alt="logo">
+                    <a target="_blank" href="https://github.com/huggingface/smolagents">
+                        <b>huggingface/smolagents</b>
+                    </a>
+                    </div>
+                    """
                     )
 
-                    # Connect event handlers with appropriate cancellation
-                    # File upload handler - Updated for UploadButton
-                    if hasattr(self.components, "file_uploader") and hasattr(
-                        self.components, "upload_status"
-                    ):
-                        self.components.file_uploader.upload(
-                            self.handle_file_upload,
-                            [self.components.file_uploader, file_uploads_log],
-                            [self.components.upload_status, file_uploads_log],
-                        )
-
-                    # Text input handler with cancellation
-                    submit_event = (
-                        self.components.text_input.submit(
-                            self.log_user_message,
-                            [self.components.text_input, file_uploads_log],
-                            [
-                                stored_messages,
-                                self.components.text_input,
-                                self.components.submit_btn,
-                            ],
-                        )
-                        .then(
-                            self.interact_with_agent,
-                            [stored_messages, self.components.chatbot, session_state],
-                            [self.components.chatbot],
-                        )
-                        .then(
-                            lambda: (
-                                gr.Textbox(interactive=True),
-                                gr.Button(interactive=True),
-                            ),
-                            None,
-                            [self.components.text_input, self.components.submit_btn],
-                        )
-                    )
+            # Add session state to store session-specific data
+            session_state = gr.State({})  # Initialize empty state for each session
+            stored_messages = gr.State([])
+            if "file_uploads_log" not in locals():
+                file_uploads_log = gr.State([])
+
+            chatbot = gr.Chatbot(
+                label="open-Deep-Research",
+                type="messages",
+                avatar_images=(
+                    None,
+                    "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/smolagents/mascot_smol.png",
+                ),
+                resizeable=False,
+                scale=1,
+                elem_id="my-chatbot",
+            )
 
-                    # Button click handler with same flow
-                    click_event = (
-                        self.components.submit_btn.click(
-                            self.log_user_message,
-                            [self.components.text_input, file_uploads_log],
-                            [
-                                stored_messages,
-                                self.components.text_input,
-                                self.components.submit_btn,
-                            ],
-                        )
-                        .then(
-                            self.interact_with_agent,
-                            [stored_messages, self.components.chatbot, session_state],
-                            [self.components.chatbot],
-                        )
-                        .then(
-                            lambda: (
-                                gr.Textbox(interactive=True),
-                                gr.Button(interactive=True),
-                            ),
-                            None,
-                            [self.components.text_input, self.components.submit_btn],
-                        )
-                    )
+            self._connect_event_handlers(
+                text_input,
+                launch_research_btn,
+                file_uploads_log,
+                stored_messages,
+                chatbot,
+                session_state,
+            )
 
-                    # Stop button cancels ongoing operations
-                    self.components.stop_btn.click(
-                        None, None, None, cancels=[submit_event, click_event]
-                    )
+            return sidebar_demo
+
+    def _create_mobile_layout(self):
+        """Create the mobile layout (simpler without sidebar)."""
+        with gr.Blocks(fill_height=True) as simple_demo:
+            gr.Markdown("""#OpenDeepResearch - free the AI agents!""")
+            # Add session state to store session-specific data
+            session_state = gr.State({})
+            stored_messages = gr.State([])
+            file_uploads_log = gr.State([])
+
+            chatbot = gr.Chatbot(
+                label="open-Deep-Research",
+                type="messages",
+                avatar_images=(
+                    None,
+                    "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/smolagents/mascot_smol.png",
+                ),
+                resizeable=True,
+                scale=1,
+            )
 
-                    # Clear button
-                    self.components.clear_btn.click(
-                        self.clear_chat,
-                        None,
-                        [
-                            self.components.chatbot,
-                            stored_messages,
-                            self.components.text_input,
-                            self.components.submit_btn,
-                            self.components.status,
-                        ],
-                    )
+            # If an upload folder is provided, enable the upload feature
+            if self.file_upload_folder is not None:
+                upload_file = gr.File(label="Upload a file")
+                upload_status = gr.Textbox(
+                    label="Upload Status", interactive=False, visible=False
+                )
+                upload_file.change(
+                    self.upload_file,
+                    [upload_file, file_uploads_log],
+                    [upload_status, file_uploads_log],
+                )
 
-            # Launch with fixed queue settings (avoiding the problematic parameter)
-            demo.launch(
-                share=share,
-                debug=True,
+            text_input = gr.Textbox(
+                lines=1,
+                label="What's on your mind mate?",
+                placeholder="Chuck in a question and we'll take care of the rest",
             )
+            launch_research_btn = gr.Button("Run", variant="primary")
 
+            self._connect_event_handlers(
+                text_input,
+                launch_research_btn,
+                file_uploads_log,
+                stored_messages,
+                chatbot,
+                session_state,
+            )
+
+            return simple_demo
+
+    def _connect_event_handlers(
+        self,
+        text_input,
+        launch_research_btn,
+        file_uploads_log,
+        stored_messages,
+        chatbot,
+        session_state,
+    ):
+        """Connect the event handlers for input elements."""
+        # Connect text input submit event
+        text_input.submit(
+            self.log_user_message,
+            [text_input, file_uploads_log],
+            [stored_messages, text_input, launch_research_btn],
+        ).then(
+            self.interact_with_agent,
+            [stored_messages, chatbot, session_state],
+            [chatbot],
+        ).then(
+            lambda: (
+                gr.Textbox(
+                    interactive=True,
+                    placeholder="Enter your prompt here and press the button",
+                ),
+                gr.Button(interactive=True),
+            ),
+            None,
+            [text_input, launch_research_btn],
+        )
 
+        # Connect button click event
+        launch_research_btn.click(
+            self.log_user_message,
+            [text_input, file_uploads_log],
+            [stored_messages, text_input, launch_research_btn],
+        ).then(
+            self.interact_with_agent,
+            [stored_messages, chatbot, session_state],
+            [chatbot],
+        ).then(
+            lambda: (
+                gr.Textbox(
+                    interactive=True,
+                    placeholder="Enter your prompt here and press the button",
+                ),
+                gr.Button(interactive=True),
+            ),
+            None,
+            [text_input, launch_research_btn],
+        )
+
+
+# ------------------------ Execution ------------------------
 def main():
-    """
-    Main entry point for the application.
-    Returns:
-        int: Exit code (0 for success, 1 for failure)
-    """
-    try:
-        # Initialize environment
-        if not setup_environment():
-            print("Failed to set up environment properly.")
-            return 1
-
-        # Ensure downloads folder exists
-        downloads_folder = BROWSER_CONFIG["downloads_folder"]
-        os.makedirs(f"./{downloads_folder}", exist_ok=True)
-
-        # Create uploads folder
-        uploads_folder = "uploaded_files"
-        os.makedirs(uploads_folder, exist_ok=True)
-
-        # Launch UI
-        print("Starting OpenDeepResearch Gradio interface...")
-        gradio_ui = GradioUI(file_upload_folder=uploads_folder)
-        gradio_ui.launch()
-
-        return 0
-
-    except KeyError as e:
-        print(f"Configuration error: Missing key {e}")
-        traceback.print_exc()
-        return 1
-    except Exception as e:
-        print(f"Application failed to start: {e}")
-        traceback.print_exc()
-        return 1
+    """Main entry point for the application."""
+    # Initialize environment
+    setup_environment()
+
+    # Ensure downloads folder exists
+    os.makedirs(f"./{BROWSER_CONFIG['downloads_folder']}", exist_ok=True)
+
+    # Launch UI
+    GradioUI(file_upload_folder="uploaded_files").launch()
 
 
 if __name__ == "__main__":
-    EXIT_CODE = main()  # UPPER_CASE for constants
-    sys.exit(EXIT_CODE)  # Use sys.exit instead of exit
+    main()