Second

Dockerfile

@@ -1,72 +0,0 @@
-# Use a slim Python image for a smaller, faster build
-FROM python:3.12-slim
-
-# Set environment variables early (improves caching)
-ENV SEARXNG_URL="https://search.endorisk.nl" \
-    SEARXNG_USERNAME="user" \
-    SEARXNG_PASSWORD="password" \
-    PATH="/home/user/.local/bin:$PATH"
-
-# 1) Install system dependencies
-RUN apt-get update -y && \
-    apt-get install -y --no-install-recommends \
-      git \
-      ffmpeg \
-      wget \
-      curl \
-      build-essential \
-      tmux && \
-    rm -rf /var/lib/apt/lists/*
-
-# 2) Install Node.js (required for MCP server)
-RUN curl -fsSL https://deb.nodesource.com/setup_18.x | bash - && \
-    apt-get install -y --no-install-recommends nodejs && \
-    rm -rf /var/lib/apt/lists/*
-
-# 3) Create a non-root user (uid 1000 is typical in Spaces)
-RUN useradd -m -u 1000 user
-
-WORKDIR /app
-
-# 4) Clone the repositories
-RUN git clone https://github.com/CultriX-Github/smolagents.git && \
-    git clone https://github.com/ihor-sokoliuk/mcp-searxng.git
-
-# 5) Build the MCP server: install dependencies and build assets
-WORKDIR /app/mcp-searxng
-RUN echo "SEARXNG_USERNAME=user" > .env && \
-    echo "SEARXNG_PASSWORD=password" >> .env && \
-    cp .env /app/smolagents/examples/open_deep_research/.env && \
-    npm install && \
-    npm run build
-
-# 6) Install Python dependencies
-WORKDIR /app/smolagents/examples/open_deep_research
-# Copy the local requirements file into the container to trigger caching if unchanged
-COPY requirements.txt .
-RUN pip install --no-cache-dir --upgrade pip && \
-    pip install --no-cache-dir -r requirements.txt --break-system-packages && \
-    pip install --no-cache-dir mcp --break-system-packages && \
-    pip install --no-cache-dir 'smolagents[litellm, mcp]' --break-system-packages
-
-# 7) Create the downloads directory and fix permissions
-RUN mkdir -p downloads && \
-    chown -R user:user /app/smolagents/examples/open_deep_research && \
-    chown -R user:user /app/mcp-searxng
-
-# 8) Copy the custom startup and application files
-COPY start.sh .
-COPY app.py .
-COPY run.py .
-
-# 9) Ensure the startup script is executable
-RUN chmod +x start.sh
-
-# 10) Switch to the non-root user for runtime
-USER user
-
-# 11) Expose Gradio's default port
-EXPOSE 7860
-
-# 12) Set the default command to run the startup script
-ENTRYPOINT ["python", "app.py"]

app.py

@@ -1,108 +1,94 @@
-import os
+from run import create_agent
 import gradio as gr
-from run import create_agent, log_formatter, MODEL_CONFIGS
-import io
-import logging
-import contextlib
-
-# Simple dark theme styling.
-CSS = """
-body {
-    background-color: #2c2c2c;
-    color: #ffffff;
-}
-.gradio-container {
-    background-color: #3a3a3a;
-    border-radius: 10px;
-    padding: 20px;
-}
-h1, h2, h3 {
-    color: #79c0ff;
-}
-"""
-
-def set_keys(openai_api_key, serper_api_key, hf_token, gemini_api_key, groq_api_key):
-    os.environ["OPENAI_API_KEY"] = openai_api_key
-    os.environ["SERPER_API_KEY"] = serper_api_key
-    os.environ["HF_TOKEN"] = hf_token
-    os.environ["GEMINI_API_KEY"] = gemini_api_key
-    os.environ["GROQ_API_KEY"] = groq_api_key
-    return "API keys have been updated successfully! Please restart the agent for changes to take effect."
-
-def get_answer(question, model_name):
-    log_buffer = io.StringIO()
-    stdout_buffer = io.StringIO()
-    stream_handler = logging.StreamHandler(log_buffer)
-    stream_handler.setFormatter(log_formatter)
-    root_logger = logging.getLogger()
-    root_logger.setLevel(logging.DEBUG)
-    root_logger.addHandler(stream_handler)
-
-    conversation = []
-    try:
-        agent = create_agent(model_name=model_name)
-        answer = agent.run(question)
-        if isinstance(answer, str):
-            conversation = [
-                {"role": "user", "content": question},
-                {"role": "assistant", "content": answer}
-            ]
-        else:
-            result = ""
-            for chunk in answer:
-                result += chunk
-            conversation = [
-                {"role": "user", "content": question},
-                {"role": "assistant", "content": result}
-            ]
-    except Exception as e:
-        conversation = [
-            {"role": "user", "content": question},
-            {"role": "assistant", "content": f"An error occurred: {e}"}
-        ]
-    finally:
-        root_logger.removeHandler(stream_handler)
-        stream_handler.close()
-        logs = log_buffer.getvalue()
-    return conversation, f"```\n{stdout_buffer.getvalue()}\n{logs}\n```"
-
-def build_app():
-    with gr.Blocks(css=CSS) as demo:
-        # Title and header.
-        gr.HTML("<h1>SmolAgents Open Deep Search 🥳</h1>")
-        gr.Markdown("## Enhanced Agent UI")
-
-        # Configuration Accordion.
-        with gr.Accordion("Configuration (Click to Expand)", open=False):
-            openai_field = gr.Textbox(label="OPENAI_API_KEY", type="password", placeholder="Enter your OpenAI API key")
-            serper_field = gr.Textbox(label="SERPER_API_KEY", type="password", placeholder="Enter your Serper API key")
-            hf_field = gr.Textbox(label="HF_TOKEN", type="password", placeholder="Enter your Hugging Face Token")
-            gemini_field = gr.Textbox(label="GEMINI_API_KEY", type="password", placeholder="Enter your Gemini API key")
-            groq_field = gr.Textbox(label="GROQ_API_KEY", type="password", placeholder="Enter your Groq API key")
-            update_btn = gr.Button("Update Keys")
-            status_box = gr.Markdown("*(No keys set yet)*")
-            update_btn.click(fn=set_keys, inputs=[openai_field, serper_field, hf_field, gemini_field, groq_field], outputs=status_box)
-
-        # Placeholder for agent logs.
-        log_markdown = gr.Markdown(label="Agent Logs")
-
-        gr.Markdown("### Select a model and ask your question below:")
-        model_names = list(MODEL_CONFIGS.keys())
-        model_dropdown = gr.Dropdown(choices=model_names, label="Select Model", value="o1", allow_custom_value=True)
-        question_input = gr.Textbox(label="Your Question", placeholder="Enter your question here...")
-        submit_btn = gr.Button("Get Answer")
-        # Use Chatbot component with type "messages" for OpenAI-style dict format.
-        chatbot = gr.Chatbot(label="Answer", type="messages")
-
-        # Connect the answer function.
-        submit_btn.click(
-            fn=get_answer,
-            inputs=[question_input, model_dropdown],
-            outputs=[chatbot, log_markdown]
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+CONFIG_FILE = ".user_config.env"
+
+def save_env_vars_to_file(env_vars):
+    print("[DEBUG] Saving user config to file")
+    with open(CONFIG_FILE, "w") as f:
+        for key, value in env_vars.items():
+            f.write(f"{key}={value}\n")
+
+def launch_interface():
+    def setup_agent(question, model_id, hf_token, serpapi_key, use_custom_endpoint,
+                    custom_api_endpoint, custom_api_key, search_provider, search_api_key, custom_search_url):
+        print("[DEBUG] Setting up agent with input question:", question)
+
+        if question.strip() == "":
+            return "Please enter a question."
+
+        endpoint = custom_api_endpoint if use_custom_endpoint else None
+        api_key = custom_api_key if use_custom_endpoint else None
+
+        save_env_vars_to_file({
+            "HF_TOKEN": hf_token,
+            "SERPAPI_API_KEY": serpapi_key,
+        })
+
+        print("[DEBUG] Instantiating agent with UI configuration")
+        agent = create_agent(
+            model_id=model_id,
+            hf_token=hf_token,
+            serpapi_key=serpapi_key,
+            custom_api_endpoint=endpoint,
+            custom_api_key=api_key,
+            search_provider=search_provider,
+            search_api_key=search_api_key,
+            custom_search_url=custom_search_url
         )
 
-    return demo
+        return agent.run(question)
+
+    with gr.Blocks(theme=gr.themes.Base(), css=".gr-box { border-radius: 15px; padding: 20px; }") as demo:
+        gr.Markdown("# 🤖 SmolAgent Configurable Interface")
+
+        with gr.Row():
+            with gr.Column(scale=2):
+                question = gr.Textbox(label="🧠 Question", placeholder="Ask me anything...")
+                model_id = gr.Textbox(value="gpt-4o-mini", label="🧬 Model ID")
+                hf_token = gr.Textbox(value=os.getenv("HF_TOKEN", ""), label="🔑 HuggingFace Token", type="password")
+                serpapi_key = gr.Textbox(value=os.getenv("SERPAPI_API_KEY", ""), label="🔍 Serper API Key", type="password", visible=True)
+                use_custom_endpoint = gr.Checkbox(label="🌐 Use Custom API Endpoint")
+                custom_api_endpoint = gr.Textbox(label="🔌 Custom API Endpoint URL", placeholder="https://your-api-endpoint.com", visible=False)
+                custom_api_key = gr.Textbox(label="🔐 Custom API Endpoint Key", type="password", visible=False)
+                search_provider = gr.Dropdown(label="🔎 Search Provider", choices=["serper", "searxng"], value="serper")
+                search_api_key = gr.Textbox(label="🔑 Search Provider API Key (optional)", type="password", visible=False)
+                custom_search_url = gr.Textbox(label="🌐 Custom SearxNG Instance URL", placeholder="https://your-searxng-instance/search", visible=False)
+                submit_btn = gr.Button("🚀 Run Agent")
+            with gr.Column(scale=1):
+                output = gr.Textbox(label="📤 Answer", lines=15)
+
+        def update_search_visibility(provider):
+            return {
+                serpapi_key: gr.update(visible=(provider == "serper")),
+                custom_search_url: gr.update(visible=(provider == "searxng")),
+                search_api_key: gr.update(visible=(provider == "searxng")),
+            }
+
+        def update_custom_endpoint_visibility(checked):
+            return {
+                custom_api_endpoint: gr.update(visible=checked),
+                custom_api_key: gr.update(visible=checked),
+            }
+
+        search_provider.change(fn=update_search_visibility, inputs=search_provider,
+                               outputs=[serpapi_key, custom_search_url, search_api_key])
+
+        use_custom_endpoint.change(fn=update_custom_endpoint_visibility, inputs=use_custom_endpoint,
+                                   outputs=[custom_api_endpoint, custom_api_key])
+
+        submit_btn.click(fn=setup_agent,
+                         inputs=[question, model_id, hf_token, serpapi_key,
+                                 use_custom_endpoint, custom_api_endpoint, custom_api_key,
+                                 search_provider, search_api_key, custom_search_url],
+                         outputs=output)
+
+    print("[DEBUG] Launching Gradio interface")
+    demo.launch()
 
 if __name__ == "__main__":
-    demo = build_app()
-    demo.launch(server_name="0.0.0.0")
+    launch_interface()
+

requirements.txt

@@ -1,5 +1,3 @@
-gradio
-uvicorn
 dotenv
 anthropic>=0.37.1
 audioop-lts<1.0; python_version >= "3.13" # required to use pydub in Python >=3.13; LTS port of the removed Python builtin module audioop

run.py

@@ -1,6 +1,7 @@
 import argparse
 import os
-import logging
+import threading
+
 from dotenv import load_dotenv
 from huggingface_hub import login
 from scripts.text_inspector_tool import TextInspectorTool
@@ -14,285 +15,86 @@ from scripts.text_web_browser import (
     VisitTool,
 )
 from scripts.visual_qa import visualizer
+
 from smolagents import (
     CodeAgent,
-    DuckDuckGoSearchTool,
-    LiteLLMModel,
     ToolCallingAgent,
+    LiteLLMModel,
+    DuckDuckGoSearchTool,
+    Tool,
 )
 
-# Initialize logging
-logger = logging.getLogger("smolagents")
-logger.setLevel(logging.INFO)
-log_formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
-
-# Load environment variables
-load_dotenv(override=True)
-
-hf_token = os.getenv("HF_TOKEN")
-if hf_token:
-    login(hf_token)
-    logger.info("Logged into Hugging Face Hub.")
-else:
-    logger.warning("HF_TOKEN not found. Proceeding without authentication.")
-
 AUTHORIZED_IMPORTS = [
-    "requests", "zipfile", "os", "pandas", "numpy", "sympy", "json", "bs4",
+    "shell_gpt", "sgpt", "openai", "requests", "zipfile", "os", "pandas", "numpy", "sympy", "json", "bs4",
     "pubchempy", "xml", "yahoo_finance", "Bio", "sklearn", "scipy", "pydub",
-    "io", "PIL", "chess", "PyPDF2", "pptx", "torch", "datetime", "fractions", "csv", "string", "secrets",
+    "yaml", "string", "secrets", "io", "PIL", "chess", "PyPDF2", "pptx", "torch", "datetime", "fractions", "csv",
 ]
 
-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"
-)
-
-BROWSER_CONFIG = {
-    "viewport_size": 5120,
-    "downloads_folder": "downloads_folder",
-    "request_kwargs": {
-        "headers": {"User-Agent": USER_AGENT},
-        "timeout": 150,
-        "max_retries": 2,
-    },
-    "serpapi_key": os.getenv("SERPAPI_API_KEY"),
-}
+append_answer_lock = threading.Lock()
 
-os.makedirs(f"./{BROWSER_CONFIG['downloads_folder']}", exist_ok=True)
 
-custom_role_conversions = {"tool-call": "assistant", "tool-response": "user"}
+def create_agent(
+    model_id="gpt-4o-mini",
+    hf_token=None,
+    serpapi_key=None,
+    custom_api_endpoint=None,
+    custom_api_key=None,
+    search_provider="serper",
+    search_api_key=None,
+    custom_search_url=None
+):
+    print("[DEBUG] Creating agent with model_id:", model_id)
 
-# Define the model configurations (custom models intact)
-MODEL_CONFIGS = {
-    # OPENAI MODELS
-    "gpt-3.5-turbo": {
-        "litellm_params": {
-            "model_id": "openai/gpt-3.5-turbo",
-            "api_key": os.getenv("OPENAI_API_KEY"),
-            "custom_role_conversions": custom_role_conversions,
-            "max_completion_tokens": 8192,
-        },
-    },
-    "gpt-3.5-turbo-16k": {
-        "litellm_params": {
-            "model_id": "openai/gpt-3.5-turbo-16k",
-            "api_key": os.getenv("OPENAI_API_KEY"),
-            "custom_role_conversions": custom_role_conversions,
-            "max_completion_tokens": 16384,
-        },
-    },
-    "gpt-4o-mini": {
-        "litellm_params": {
-            "model_id": "openai/gpt-4o-mini",
-            "api_key": os.getenv("OPENAI_API_KEY"),
-            "custom_role_conversions": custom_role_conversions,
-            "max_completion_tokens": 8192,
-        },
-    },
-    "chatgpt-4o-latest": {
-        "litellm_params": {
-            "model_id": "openai/chatgpt-4o-latest",
-            "api_key": os.getenv("OPENAI_API_KEY"),
-            "custom_role_conversions": custom_role_conversions,
-            "max_completion_tokens": 8192,
-        },
-    },
-    "gpt-4-turbo": {
-        "litellm_params": {
-            "model_id": "openai/gpt-4-turbo",
-            "api_key": os.getenv("OPENAI_API_KEY"),
-            "custom_role_conversions": custom_role_conversions,
-            "max_completion_tokens": 8192,
-        },
-    },
-    "gpt-4o": {
-        "litellm_params": {
-            "model_id": "openai/gpt-4o",
-            "api_key": os.getenv("OPENAI_API_KEY"),
-            "custom_role_conversions": custom_role_conversions,
-            "max_completion_tokens": 8192,
-        },
-    },
-    "o1-mini": {
-        "litellm_params": {
-            "model_id": "openai/o1-mini",
-            "api_key": os.getenv("OPENAI_API_KEY"),
-            "custom_role_conversions": custom_role_conversions,
-            "max_completion_tokens": 8192,
-            "reasoning_effort": "high",
-        },
-    },
-    "o1-preview": {
-        "litellm_params": {
-            "model_id": "openai/o1-preview",
-            "api_key": os.getenv("OPENAI_API_KEY"),
-            "custom_role_conversions": custom_role_conversions,
-            "max_completion_tokens": 8192,
-            "reasoning_effort": "high",
-        },
-    },
-    # HUGGINGFACE MODELS
-    "hf-llama-3.1-8B-instruct": {
-        "litellm_params": {
-            "model_id": "huggingface/meta-llama/Meta-Llama-3.1-8B-Instruct",
-            "api_key": os.getenv("HF_TOKEN"),
-            "custom_role_conversions": custom_role_conversions,
-            "max_completion_tokens": 8192,
-        },
-    },
-    "hf-DeepSeek-R1-Distill-Qwen-32B": {
-        "litellm_params": {
-            "model_id": "huggingface/deepseek-ai/DeepSeek-R1-Distill-Qwen-32B",
-            "api_key": os.getenv("HF_TOKEN"),
-            "custom_role_conversions": custom_role_conversions,
-            "max_completion_tokens": 8192,
-        },
-    },
-    "hf-Qwen2.5-Coder-32B-Instruct": {
-        "litellm_params": {
-            "model_id": "huggingface/Qwen/Qwen2.5-Coder-32B-Instruct",
-            "api_key": os.getenv("HF_TOKEN"),
-            "custom_role_conversions": custom_role_conversions,
-            "max_completion_tokens": 8192,
-        },
-    },
-    "hf-QwQ-32B-Preview": {
-        "litellm_params": {
-            "model_id": "huggingface/Qwen/QwQ-32B-Preview",
-            "api_key": os.getenv("HF_TOKEN"),
-            "custom_role_conversions": custom_role_conversions,
-            "max_completion_tokens": 8192,
-        },
-    },
-    "hf-Llama-3.1-70B-Instruct": {
-        "litellm_params": {
-            "model_id": "huggingface/meta-llama/Llama-3.1-70B-Instruct",
-            "api_key": os.getenv("HF_TOKEN"),
-            "custom_role_conversions": custom_role_conversions,
-            "max_completion_tokens": 8192,
-        },
-    },
-    # GROQ MODELS
-    "groq-llama3-8b-8192": {
-        "litellm_params": {
-            "model_id": "groq/llama3-8b-8192",
-            "api_key": os.getenv("GROQ_API_KEY"),
-            "custom_role_conversions": custom_role_conversions,
-            "max_completion_tokens": 8192,
-        },
-    },
-    "groq-llama3-70b-8192": {
-        "litellm_params": {
-            "model_id": "groq/llama3-70b-8192",
-            "api_key": os.getenv("GROQ_API_KEY"),
-            "custom_role_conversions": custom_role_conversions,
-            "max_completion_tokens": 8192,
-        },
-    },
-    "groq-mixtral-8x7b-32768": {
-        "litellm_params": {
-            "model_id": "groq/mixtral-8x7b-32768",
-            "api_key": os.getenv("GROQ_API_KEY"),
-            "custom_role_conversions": custom_role_conversions,
-            "max_completion_tokens": 32768,
-        },
-    },
-    # GEMINI MODELS
-    "gemini-pro": {
-        "litellm_params": {
-            "model_id": "gemini/gemini-pro",
-            "api_key": os.getenv("GEMINI_API_KEY"),
-            "custom_role_conversions": custom_role_conversions,
-            "max_completion_tokens": 8192,
-        },
-    },
-    "gemini-1.5-pro": {
-        "litellm_params": {
-            "model_id": "gemini/gemini-1.5-pro",
-            "api_key": os.getenv("GEMINI_API_KEY"),
-            "custom_role_conversions": custom_role_conversions,
-            "max_completion_tokens": 8192,
-        },
-    },
-    "gemini-1.5-flash": {
-        "litellm_params": {
-            "model_id": "gemini/gemini-1.5-flash",
-            "api_key": os.getenv("GEMINI_API_KEY"),
-            "custom_role_conversions": custom_role_conversions,
-            "max_completion_tokens": 8192,
-        },
-    },
-    "gemini-pro-vision": {
-        "litellm_params": {
-            "model_id": "gemini/gemini-pro-vision",
-            "api_key": os.getenv("GEMINI_API_KEY"),
-            "custom_role_conversions": custom_role_conversions,
-            "max_completion_tokens": 8192,
-        },
-    },
-    "gemini-2.0-flash": {
-        "litellm_params": {
-            "model_id": "gemini/gemini-2.0-flash",
-            "api_key": os.getenv("GEMINI_API_KEY"),
-            "custom_role_conversions": custom_role_conversions,
-            "max_completion_tokens": 8192,
-        },
-    },
-    "gemini-2.0-flash-thinking-exp-01-21": {
-        "litellm_params": {
-            "model_id": "gemini/gemini-2.0-flash-thinking-exp-01-21",
-            "api_key": os.getenv("GEMINI_API_KEY"),
-            "custom_role_conversions": custom_role_conversions,
-            "max_completion_tokens": 8192,
-        },
-    },
-    # Default o1 model
-    "o1": {
-        "litellm_params": {
-            "model_id": "o1",
-            "custom_role_conversions": custom_role_conversions,
-            "max_completion_tokens": 8192,
-            "reasoning_effort": "high",
-        },
-    },
-}
+    if hf_token:
+        print("[DEBUG] Logging into HuggingFace")
+        login(hf_token)
 
-def parse_args():
-    parser = argparse.ArgumentParser(
-        description="Run the search agent to answer questions using web browsing tools."
-    )
-    parser.add_argument(
-        "question",
-        type=str,
-        help="Example: 'How many studio albums did Mercedes Sosa release before 2007?'"
-    )
-    parser.add_argument(
-        "--model-id",
-        type=str,
-        default="o1",
-        help="Model identifier (default: o1)"
-    )
-    return parser.parse_args()
+    model_params = {
+        "model_id": model_id,
+        "custom_role_conversions": {"tool-call": "assistant", "tool-response": "user"},
+        "max_completion_tokens": 8192,
+    }
 
-def create_agent(model_name="o1"):
-    if model_name not in MODEL_CONFIGS:
-        raise ValueError(f"Model '{model_name}' is not a valid model. Available models are: {list(MODEL_CONFIGS.keys())}")
+    if model_id == "gpt-4o-mini":
+        model_params["reasoning_effort"] = "high"
 
-    model_params = MODEL_CONFIGS[model_name]["litellm_params"]
-    model_params.setdefault("custom_role_conversions", custom_role_conversions)
-    model_params.setdefault("max_completion_tokens", 8192)
-    # (Optional: adjust parameters here to lower temperature for more factual answers.)
+    if custom_api_endpoint and custom_api_key:
+        print("[DEBUG] Using custom API endpoint:", custom_api_endpoint)
+        model_params["base_url"] = custom_api_endpoint
+        model_params["api_key"] = custom_api_key
 
     model = LiteLLMModel(**model_params)
-    logger.info(f"Initialized LiteLLMModel with model_name={model_name}")
-    text_limit = 100000
+    print("[DEBUG] Model initialized")
 
-    browser = SimpleTextBrowser(**BROWSER_CONFIG)
-    logger.info("Initialized SimpleTextBrowser with custom configuration.")
+    text_limit = 100000
+    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"
+
+    browser_config = {
+        "viewport_size": 1024 * 5,
+        "downloads_folder": "downloads_folder",
+        "request_kwargs": {
+            "headers": {"User-Agent": user_agent},
+            "timeout": 300,
+        },
+        "serpapi_key": serpapi_key,
+    }
+
+    os.makedirs(f"./{browser_config['downloads_folder']}", exist_ok=True)
+    browser = SimpleTextBrowser(**browser_config)
+    print("[DEBUG] Browser initialized")
+
+    # Correct tool selection
+    if search_provider == "searxng":
+        print("[DEBUG] Using SearxNG-compatible DuckDuckGoSearchTool with base_url override")
+        search_tool = DuckDuckGoSearchTool()
+        if custom_search_url:
+            search_tool.base_url = custom_search_url  # Override default DuckDuckGo URL (only if supported)
+    else:
+        print("[DEBUG] Using default DuckDuckGoSearchTool for Serper/standard search")
+        search_tool = DuckDuckGoSearchTool()
 
     WEB_TOOLS = [
-        DuckDuckGoSearchTool(),
+        search_tool,
         VisitTool(browser),
         PageUpTool(browser),
         PageDownTool(browser),
@@ -301,49 +103,70 @@ def create_agent(model_name="o1"):
         ArchiveSearchTool(browser),
         TextInspectorTool(model, text_limit),
     ]
-    logger.info("Initialized web tools for ToolCallingAgent.")
 
     text_webbrowser_agent = ToolCallingAgent(
         model=model,
         tools=WEB_TOOLS,
-        max_steps=10,
-        verbosity_level=2,
+        max_steps=20,
+        verbosity_level=3,
         planning_interval=4,
         name="search_agent",
-        description=(
-            "A team member that will search the internet to answer your question. "
-            "Ask all questions that require browsing the web using complete sentences. "
-            "Provide as much context as possible, especially if searching within a specific timeframe."
-        ),
+        description="A team member that will search the internet to answer your question.",
         provide_run_summary=True,
     )
-    logger.info("Initialized ToolCallingAgent.")
+
+    text_webbrowser_agent.prompt_templates["managed_agent"]["task"] += """You can navigate to .txt online files.
+If a non-html page is in another format, especially .pdf or a Youtube video, use tool 'inspect_file_as_text' to inspect it.
+Additionally, if after some searching you find out that you need more information to answer the question, you can use `final_answer` with your request for clarification as argument to request for more information."""
 
     manager_agent = CodeAgent(
         model=model,
         tools=[visualizer, TextInspectorTool(model, text_limit)],
-        max_steps=12,
-        verbosity_level=2,
+        max_steps=16,
+        verbosity_level=3,
         additional_authorized_imports=AUTHORIZED_IMPORTS,
         planning_interval=4,
         managed_agents=[text_webbrowser_agent],
     )
-    logger.info("Initialized Manager CodeAgent.")
+
+    print("[DEBUG] Agent fully initialized")
     return manager_agent
 
+
 def main():
-    args = parse_args()
-    logger.info(f"Received question: {args.question} with model_id={args.model_id}")
-    agent = create_agent(model_name=args.model_id)
+    print("[DEBUG] Loading environment variables")
+    load_dotenv(override=True)
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument("question", type=str)
+    parser.add_argument("--model-id", type=str, default="gpt-4o-mini")
+    parser.add_argument("--hf-token", type=str, default=os.getenv("HF_TOKEN"))
+    parser.add_argument("--serpapi-key", type=str, default=os.getenv("SERPAPI_API_KEY"))
+    parser.add_argument("--custom-api-endpoint", type=str, default=None)
+    parser.add_argument("--custom-api-key", type=str, default=None)
+    parser.add_argument("--search-provider", type=str, default="serper")
+    parser.add_argument("--search-api-key", type=str, default=None)
+    parser.add_argument("--custom-search-url", type=str, default=None)
+    args = parser.parse_args()
+
+    print("[DEBUG] CLI arguments parsed:", args)
+
+    agent = create_agent(
+        model_id=args.model_id,
+        hf_token=args.hf_token,
+        serpapi_key=args.serpapi_key,
+        custom_api_endpoint=args.custom_api_endpoint,
+        custom_api_key=args.custom_api_key,
+        search_provider=args.search_provider,
+        search_api_key=args.search_api_key,
+        custom_search_url=args.custom_search_url,
+    )
+
+    print("[DEBUG] Running agent...")
     answer = agent.run(args.question)
-    if isinstance(answer, str):
-        print(f"Got this answer: {answer}")
-    else:
-        result = ""
-        for chunk in answer:
-            result += chunk
-        print(f"Got this answer: {result}")
-    logger.info("Agent has completed processing the question.")
+    print(f"Got this answer: {answer}")
+
 
 if __name__ == "__main__":
     main()
+

start.sh

@@ -1,8 +0,0 @@
-#!/bin/bash
-# Exit immediately if a command exits with a non-zero status.
-set -e
-
-echo "Starting Gradio UI with enhanced performance optimizations..."
-cd /app/smolagents/examples/open_deep_research
-/bin/bash -c "python app.py &"
-exec "$@"