Update main.py

main.py

@@ -1,808 +1,205 @@
-from fastapi import FastAPI, HTTPException, Depends, Security, BackgroundTasks
-from fastapi.security import APIKeyHeader
-from fastapi.responses import StreamingResponse
-from pydantic import BaseModel, Field
-from typing import Literal, List, Dict
 import os
-from functools import lru_cache
-from openai import OpenAI
-from uuid import uuid4
-import tiktoken
-import sqlite3
-import time
-from datetime import datetime, timedelta
-import asyncio
-import requests
-from prompts import *
-from fastapi_cache import FastAPICache
-from fastapi_cache.backends.inmemory import InMemoryBackend
-from fastapi_cache.decorator import cache
+import shutil
+import zipfile
 import logging
+import tempfile
+import magic
+from pathlib import Path
+from typing import Set, Optional
+from fastapi import FastAPI, File, UploadFile, HTTPException, Request
+from fastapi.responses import HTMLResponse, JSONResponse, FileResponse
+from fastapi.staticfiles import StaticFiles
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.middleware.trustedhost import TrustedHostMiddleware
 
 # Configure logging
 logging.basicConfig(
     level=logging.INFO,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
-    handlers=[
-        logging.FileHandler("app.log"),
-        logging.StreamHandler()
-    ]
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
 )
 logger = logging.getLogger(__name__)
 
-app = FastAPI()
-
-API_KEY_NAME = "X-API-Key"
-API_KEY = os.environ.get("CHAT_AUTH_KEY", "default_secret_key")
-api_key_header = APIKeyHeader(name=API_KEY_NAME, auto_error=False)
-
-from speech_api import router as speech_api_router
-app.include_router(speech_api_router, prefix="/api/v1", tags=["TTS and ASR"])
-
-ModelID = Literal[
-    "openai/gpt-4o-mini",
-    "meta-llama/llama-3-70b-instruct",
-    "anthropic/claude-3.5-sonnet",
-    "deepseek/deepseek-coder",
-    "anthropic/claude-3-haiku",
-    "openai/gpt-3.5-turbo-instruct",
-    "qwen/qwen-72b-chat",
-    "google/gemma-2-27b-it"
-]
-
-class QueryModel(BaseModel):
-    user_query: str = Field(..., description="User's coding query")
-    model_id: ModelID = Field(
-        default="meta-llama/llama-3-70b-instruct",
-        description="ID of the model to use for response generation"
-    )
-    conversation_id: str = Field(default_factory=lambda: str(uuid4()), description="Unique identifier for the conversation")
-    user_id: str = Field(..., description="Unique identifier for the user")
-
-    class Config:
-        schema_extra = {
-            "example": {
-                "user_query": "How do I implement a binary search in Python?",
-                "model_id": "meta-llama/llama-3-70b-instruct",
-                "conversation_id": "123e4567-e89b-12d3-a456-426614174000",
-                "user_id": "user123"
-            }
-        }
-
-class NewsQueryModel(BaseModel):
-    query: str = Field(..., description="News topic to search for")
-    model_id: ModelID = Field(
-        default="openai/gpt-4o-mini",
-        description="ID of the model to use for response generation"
-    )
-    class Config:
-        schema_extra = {
-            "example": {
-                "query": "Latest developments in AI",
-                "model_id": "openai/gpt-4o-mini"
-            }
-        }
-
-@lru_cache()
-def get_api_keys():
-    logger.info("Loading API keys")
-    return {
-        "OPENROUTER_API_KEY": f"sk-or-v1-{os.environ['OPENROUTER_API_KEY']}",
-        "BRAVE_API_KEY": os.environ['BRAVE_API_KEY']
-    }
-
-api_keys = get_api_keys()
-or_client = OpenAI(api_key=api_keys["OPENROUTER_API_KEY"], base_url="https://openrouter.ai/api/v1")
-
-# In-memory storage for conversations
-conversations: Dict[str, List[Dict[str, str]]] = {}
-last_activity: Dict[str, float] = {}
-
-# Token encoding
-encoding = tiktoken.encoding_for_model("gpt-3.5-turbo")
-
-def limit_tokens(input_string, token_limit=6000):
-    return encoding.decode(encoding.encode(input_string)[:token_limit])
-
-def calculate_tokens(msgs):
-    return sum(len(encoding.encode(str(m))) for m in msgs)
-
-def chat_with_llama_stream(messages, model="openai/gpt-4o-mini", max_llm_history=4, max_output_tokens=2500):
-    logger.info(f"Starting chat with model: {model}")
-    while calculate_tokens(messages) > (8000 - max_output_tokens):
-        if len(messages) > max_llm_history:
-            messages = [messages[0]] + messages[-max_llm_history:]
-        else:
-            max_llm_history -= 1
-            if max_llm_history < 2:
-                error_message = "Token limit exceeded. Please shorten your input or start a new conversation."
-                logger.error(error_message)
-                raise HTTPException(status_code=400, detail=error_message)
-
-    try:
-        response = or_client.chat.completions.create(
-            model=model,
-            messages=messages,
-            max_tokens=max_output_tokens,
-            stream=True
-        )
-        
-        full_response = ""
-        for chunk in response:
-            if chunk.choices[0].delta.content is not None:
-                content = chunk.choices[0].delta.content
-                full_response += content
-                yield content
-        
-        # After streaming, add the full response to the conversation history
-        messages.append({"role": "assistant", "content": full_response})
-        logger.info("Chat completed successfully")
-    except Exception as e:
-        logger.error(f"Error in model response: {str(e)}")
-        raise HTTPException(status_code=500, detail=f"Error in model response: {str(e)}")
-
-async def verify_api_key(api_key: str = Security(api_key_header)):
-    if api_key != API_KEY:
-        logger.warning("Invalid API key used")
-        raise HTTPException(status_code=403, detail="Could not validate credentials")
-    return api_key
-
-# SQLite setup
-DB_PATH = '/app/data/conversations.db'
-
-def init_db():
-    logger.info("Initializing database")
-    os.makedirs(os.path.dirname(DB_PATH), exist_ok=True)
-    conn = sqlite3.connect(DB_PATH)
-    c = conn.cursor()
-    c.execute('''CREATE TABLE IF NOT EXISTS conversations
-                 (id INTEGER PRIMARY KEY AUTOINCREMENT,
-                  user_id TEXT,
-                  conversation_id TEXT,
-                  message TEXT,
-                  response TEXT,
-                  timestamp DATETIME DEFAULT CURRENT_TIMESTAMP)''')
-    conn.commit()
-    conn.close()
-    logger.info("Database initialized successfully")
-
-init_db()
-
-def update_db(user_id, conversation_id, message, response):
-    logger.info(f"Updating database for conversation: {conversation_id}")
-    conn = sqlite3.connect(DB_PATH)
-    c = conn.cursor()
-    c.execute('''INSERT INTO conversations (user_id, conversation_id, message, response)
-                 VALUES (?, ?, ?, ?)''', (user_id, conversation_id, message, response))
-    conn.commit()
-    conn.close()
-    logger.info("Database updated successfully")
-
-async def clear_inactive_conversations():
-    while True:
-        
-        current_time = time.time()
-        inactive_convos = [conv_id for conv_id, last_time in last_activity.items() 
-                           if current_time - last_time > 1800]  # 30 minutes
-        for conv_id in inactive_convos:
-            if conv_id in conversations:
-                del conversations[conv_id]
-            if conv_id in last_activity:
-                del last_activity[conv_id]
-        await asyncio.sleep(60)  # Check every minute
-
-@app.on_event("startup")
-async def startup_event():
-    logger.info("Starting up the application")
-    FastAPICache.init(InMemoryBackend(), prefix="fastapi-cache")
-    asyncio.create_task(clear_inactive_conversations())
-
-@app.post("/coding-assistant")
-async def coding_assistant(query: QueryModel, background_tasks: BackgroundTasks, api_key: str = Depends(verify_api_key)):
-    """
-    Coding assistant endpoint that provides programming help based on user queries.
-    Available models:
-    - meta-llama/llama-3-70b-instruct (default)
-    - anthropic/claude-3.5-sonnet
-    - deepseek/deepseek-coder
-    - anthropic/claude-3-haiku
-    - openai/gpt-3.5-turbo-instruct
-    - qwen/qwen-72b-chat
-    - google/gemma-2-27b-it
-    - openai/gpt-4o-mini
-    Requires API Key authentication via X-API-Key header.
-    """
-    logger.info(f"Received coding assistant query: {query.user_query}")
-    if query.conversation_id not in conversations:
-        conversations[query.conversation_id] = [
-            {"role": "system", "content": "You are a helpful assistant proficient in coding tasks. Help the user in understanding and writing code."}
-        ]
-    
-    conversations[query.conversation_id].append({"role": "user", "content": query.user_query})
-    last_activity[query.conversation_id] = time.time()
-    
-    # Limit tokens in the conversation history
-    limited_conversation = conversations[query.conversation_id]
-
-    def process_response():
-        full_response = ""
-        for content in chat_with_llama_stream(limited_conversation, model=query.model_id):
-            full_response += content
-            yield content
-        background_tasks.add_task(update_db, query.user_id, query.conversation_id, query.user_query, full_response)
-        logger.info(f"Completed coding assistant response for query: {query.user_query}")
-
-    return StreamingResponse(process_response(), media_type="text/event-stream")
-
-# New functions for news assistant
-
-def internet_search(query, search_type="web", num_results=20):
-    logger.info(f"Performing internet search for query: {query}, type: {search_type}")
-    url = f"https://api.search.brave.com/res/v1/{'web' if search_type == 'web' else 'news'}/search"
-    
-    headers = {
-        "Accept": "application/json",
-        "Accept-Encoding": "gzip",
-        "X-Subscription-Token": api_keys["BRAVE_API_KEY"]
-    }
-    params = {"q": query}
-
-    response = requests.get(url, headers=headers, params=params)
-
-    if response.status_code != 200:
-        logger.error(f"Failed to fetch search results. Status code: {response.status_code}")
-        return []
-    
-    search_data = response.json()["web"]["results"] if search_type == "web" else response.json()["results"]
-    
-    processed_results = [
-        {
-            "title": item["title"],
-            "snippet": item["extra_snippets"][0],
-            "last_updated": item.get("age", ""),
-            "url":item.get("url", "")
-        }
-        for item in search_data
-        if item.get("extra_snippets")
-    ][:num_results]
-
-    logger.info(f"Retrieved {len(processed_results)} search results")
-    return processed_results
-
-@lru_cache(maxsize=100)
-def cached_internet_search(query: str):
-    logger.info(f"Performing cached internet search for query: {query}")
-    return internet_search(query, search_type="news")
+# Initialize FastAPI app
+app = FastAPI(title="Static Site Server")
 
-def analyze_data(query, data_type="news"):
-    logger.info(f"Analyzing {data_type} for query: {query}")
-    
-    if data_type == "news":
-        data = cached_internet_search(query)
-        prompt_generator = generate_news_prompt
-        system_prompt = NEWS_ASSISTANT_PROMPT
-    else:
-        data = internet_search(query, search_type="web")
-        prompt_generator = generate_search_prompt
-        system_prompt = SEARCH_ASSISTANT_PROMPT
-    
-    if not data:
-        logger.error(f"Failed to fetch {data_type} data")
-        return None
-
-    prompt = prompt_generator(query, data)
-    messages = [
-        {"role": "system", "content": system_prompt},
-        {"role": "user", "content": prompt}
-    ]
-
-    logger.info(f"{data_type.capitalize()} analysis completed")
-    return messages,data
-
-class QueryModel(BaseModel):
-    query: str = Field(..., description="Search query")
-    model_id: ModelID = Field(
-        default="openai/gpt-4o-mini",
-        description="ID of the model to use for response generation"
-    )
-    class Config:
-        schema_extra = {
-            "example": {
-                "query": "What are the latest advancements in quantum computing?",
-                "model_id": "meta-llama/llama-3-70b-instruct"
-            }
-        }
-
-def search_assistant_api(query, data_type, model="openai/gpt-4o-mini"):
-    logger.info(f"Received {data_type} assistant query: {query}")
-    messages, search_data = analyze_data(query, data_type)
-    
-    if not messages:
-        logger.error(f"Failed to fetch {data_type} data")
-        raise HTTPException(status_code=500, detail=f"Failed to fetch {data_type} data")
-    
-    def process_response():
-        logger.info(f"Generating response using LLM: {messages}")
-        full_response = ""
-        for content in chat_with_llama_stream(messages, model=model):
-            full_response += content
-            yield content
-        logger.info(f"Completed {data_type} assistant response for query: {query}")
-        logger.info(f"LLM Response: {full_response}")
-        yield "<json><ref>"+ json.dumps(search_data)+"</ref></json>"
-    return process_response
-
-def create_streaming_response(generator):
-    return StreamingResponse(generator(), media_type="text/event-stream")
-
-@app.post("/news-assistant")
-async def news_assistant(query: QueryModel, api_key: str = Depends(verify_api_key)):
-    """
-    News assistant endpoint that provides summaries and analysis of recent news based on user queries.
-    Requires API Key authentication via X-API-Key header.
-    """
-    response_generator = search_assistant_api(query.query, "news", model=query.model_id)
-    return create_streaming_response(response_generator)
-
-@app.post("/search-assistant")
-async def search_assistant(query: QueryModel, api_key: str = Depends(verify_api_key)):
-    """
-    Search assistant endpoint that provides summaries and analysis of web search results based on user queries.
-    Requires API Key authentication via X-API-Key header.
-    """
-    response_generator = search_assistant_api(query.query, "web", model=query.model_id)
-    return create_streaming_response(response_generator)
-
-from pydantic import BaseModel, Field
-import yaml
-import json
-from yaml.loader import SafeLoader
-
-class FollowupQueryModel(BaseModel):
-    query: str = Field(..., description="User's query for the followup agent")
-    model_id: ModelID = Field(
-        default="openai/gpt-4o-mini",
-        description="ID of the model to use for response generation"
-    )
-    conversation_id: str = Field(default_factory=lambda: str(uuid4()), description="Unique identifier for the conversation")
-    user_id: str = Field(..., description="Unique identifier for the user")
-    tool_call: Literal["web", "news", "auto"] = Field(
-        default="auto",
-        description="Type of tool to call (web, news, auto)"
-    )
-
-    class Config:
-        schema_extra = {
-            "example": {
-                "query": "How can I improve my productivity?",
-                "model_id": "openai/gpt-4o-mini",
-                "conversation_id": "123e4567-e89b-12d3-a456-426614174000",
-                "user_id": "user123",
-                "tool_call": "auto"
-            }
-        }
-
-import re
-
-def parse_followup_and_tools(input_text):
-    # Remove extra brackets and excess quotes
-    cleaned_text = re.sub(r'\[|\]|"+', ' ', input_text)
-    
-    # Extract response content
-    response_pattern = re.compile(r'<response>(.*?)</response>', re.DOTALL)
-    response_parts = response_pattern.findall(cleaned_text)
-    combined_response = ' '.join(response_parts)
-    
-    # Normalize spaces in the combined response
-    combined_response = ' '.join(combined_response.split())
-    
-    parsed_interacts = []
-    parsed_tools = []
-    
-    # Parse interacts and tools
-    blocks = re.finditer(r'<(interact|tools?)(.*?)>(.*?)</\1>', cleaned_text, re.DOTALL)
-    for block in blocks:
-        block_type, _, content = block.groups()
-        content = content.strip()
-        
-        if block_type == 'interact':
-            question_blocks = re.split(r'\s*-\s*text:', content)[1:]
-            for qblock in question_blocks:
-                parts = re.split(r'\s*options:\s*', qblock, maxsplit=1)
-                if len(parts) == 2:
-                    question = ' '.join(parts[0].split())  # Normalize spaces
-                    options = [' '.join(opt.split()) for opt in re.split(r'\s*-\s*', parts[1]) if opt.strip()]
-                    parsed_interacts.append({'question': question, 'options': options})
-        
-        elif block_type.startswith('tool'):  # This will match both 'tool' and 'tools'
-            tool_match = re.search(r'text:\s*(.*?)\s*options:\s*-\s*(.*)', content, re.DOTALL)
-            if tool_match:
-                tool_name = ' '.join(tool_match.group(1).split())  # Normalize spaces
-                option = ' '.join(tool_match.group(2).split())  # Normalize spaces
-                parsed_tools.append({'name': tool_name, 'input': option})
-    
-    return combined_response, parsed_interacts, parsed_tools
-
-@app.post("/followup-agent")
-async def followup_agent(query: FollowupQueryModel, background_tasks: BackgroundTasks, api_key: str = Depends(verify_api_key)):
-    """
-    Followup agent endpoint that provides helpful responses or generates clarifying questions based on user queries.
-    Requires API Key authentication via X-API-Key header.
-    """
-    logger.info(f"Received followup agent query: {query.query}")
-
-    if query.conversation_id not in conversations:
-        conversations[query.conversation_id] = [
-            {"role": "system", "content": FOLLOWUP_AGENT_PROMPT}
-        ]
-    
-    conversations[query.conversation_id].append({"role": "user", "content": query.query})
-    last_activity[query.conversation_id] = time.time()
-    
-    # Limit tokens in the conversation history
-    limited_conversation = conversations[query.conversation_id]
-
-    def process_response():
-        full_response = ""
-        for content in chat_with_llama_stream(limited_conversation, model=query.model_id):
-            full_response += content
-            yield content
-
-        logger.info(f"LLM RAW response for query: {query.query}: {full_response}")
-        response_content, interact,tools = parse_followup_and_tools(full_response)
-        
-        result = {
-            "response": response_content,
-            "clarification": interact
-        }
-        
-        yield "\n\n" + json.dumps(result)
-        
-        # Add the assistant's response to the conversation history
-        conversations[query.conversation_id].append({"role": "assistant", "content": full_response})
-        
-        background_tasks.add_task(update_db, query.user_id, query.conversation_id, query.query, full_response)
-        logger.info(f"Completed followup agent response for query: {query.query}, send result: {result}")
-
-    return StreamingResponse(process_response(), media_type="text/event-stream")
-
-@app.post("/v2/followup-agent")
-async def followup_agent(query: FollowupQueryModel, background_tasks: BackgroundTasks, api_key: str = Depends(verify_api_key)):
-    """
-    Followup agent endpoint that provides helpful responses or generates clarifying questions based on user queries.
-    Requires API Key authentication via X-API-Key header.
-    """
-    logger.info(f"Received followup agent query: {query.query}")
-
-    if query.conversation_id not in conversations:
-        conversations[query.conversation_id] = [
-            {"role": "system", "content": FOLLOWUP_AGENT_PROMPT}
-        ]
-    
-    conversations[query.conversation_id].append({"role": "user", "content": query.query})
-    last_activity[query.conversation_id] = time.time()
-    
-    # Limit tokens in the conversation history
-    limited_conversation = conversations[query.conversation_id]
-
-    def process_response():
-        full_response = ""
-        for content in chat_with_llama_stream(limited_conversation, model=query.model_id):
-            full_response += content
-            yield content
-
-        logger.info(f"LLM RAW response for query: {query.query}: {full_response}")
-        response_content, interact,tools = parse_followup_and_tools(full_response)
-        
-        result = {
-            "clarification": interact
-        }
-        
-        yield "\n<json>"
-        yield json.dumps(result)
+# Add security middlewares
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # Configure as needed
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
 
-        
-        # Add the assistant's response to the conversation history
-        conversations[query.conversation_id].append({"role": "assistant", "content": full_response})
-        
-        background_tasks.add_task(update_db, query.user_id, query.conversation_id, query.query, full_response)
-        logger.info(f"Completed followup agent response for query: {query.query}, send result: {result}")
+app.add_middleware(
+    TrustedHostMiddleware,
+    allowed_hosts=["*"]  # Configure as needed
+)
 
-    return StreamingResponse(process_response(), media_type="text/event-stream")
-    
-@app.post("/v2/followup-tools-agent")
-def followup_agent(query: FollowupQueryModel, background_tasks: BackgroundTasks, api_key: str = Depends(verify_api_key)):
-    """
-    Followup agent endpoint that provides helpful responses or generates clarifying questions based on user queries.
-    Requires API Key authentication via X-API-Key header.
-    """
-    logger.info(f"Received followup agent query: {query.query}")
-    if query.conversation_id not in conversations:
-        conversations[query.conversation_id] = [
-            {"role": "system", "content": MULTI_AGENT_PROMPT_V2}
-        ]
-    
-    conversations[query.conversation_id].append({"role": "user", "content": query.query})
-    last_activity[query.conversation_id] = time.time()
-    
-    # Limit tokens in the conversation history
-    limited_conversation = conversations[query.conversation_id]
-    
-    def process_response():
-        full_response = ""
-        result = dict()
-        
-        # Check if tool_call is specified and call the tool directly
-        if query.tool_call in ["web", "news"]:
-            search_query = query.query
-            search_response = search_assistant_api(search_query, query.tool_call, model=query.model_id)
-            
-            yield "<report>"
-            for content in search_response():
-                yield content
-                full_response += content
-            yield "</report>"
-        else:
-            for content in chat_with_llama_stream(limited_conversation, model=query.model_id):
-                yield content
-                full_response += content
-        
-            logger.info(f"LLM RAW response for query: {query.query}: {full_response}")
-            response_content, interact, tools = parse_followup_and_tools(full_response)
+# Constants
+MAX_UPLOAD_SIZE = 100 * 1024 * 1024  # 100MB
+ALLOWED_EXTENSIONS = {'.html', '.css', '.js', '.jpg', '.jpeg', '.png', '.gif', '.svg', '.ico', '.woff', '.woff2', '.ttf', '.eot'}
+
+class SiteManager:
+    def __init__(self):
+        self.sites_dir = Path("/app/sites")
+        self.temp_dir = Path("/app/temp")
+        self.active_sites: Set[str] = set()
+        
+        # Ensure directories exist
+        self.sites_dir.mkdir(parents=True, exist_ok=True)
+        self.temp_dir.mkdir(parents=True, exist_ok=True)
+        
+        # Load existing sites
+        self._load_existing_sites()
+        
+    def _load_existing_sites(self):
+        """Load existing sites from disk"""
+        logger.info("Loading existing sites...")
+        for site_dir in self.sites_dir.iterdir():
+            if site_dir.is_dir() and (site_dir / 'index.html').exists():
+                self.active_sites.add(site_dir.name)
+                logger.info(f"Loaded site: {site_dir.name}")
+
+    def _validate_file_types(self, zip_path: Path) -> bool:
+        """Validate file types in ZIP archive"""
+        mime = magic.Magic(mime=True)
+        with zipfile.ZipFile(zip_path) as zip_ref:
+            for file_info in zip_ref.filelist:
+                if file_info.filename.endswith('/'):  # Skip directories
+                    continue
+                    
+                suffix = Path(file_info.filename).suffix.lower()
+                if suffix not in ALLOWED_EXTENSIONS:
+                    return False
+                
+                # Extract file to check MIME type
+                with tempfile.NamedTemporaryFile() as tmp:
+                    with zip_ref.open(file_info) as source:
+                        shutil.copyfileobj(source, tmp)
+                    tmp.flush()
+                    mime_type = mime.from_file(tmp.name)
+                    if mime_type.startswith('application/x-'):
+                        return False
+        return True
+
+    async def deploy_site(self, unique_id: str, zip_file: UploadFile) -> dict:
+        """Deploy a new site from a ZIP file"""
+        if await zip_file.read(1) == b'':
+            raise HTTPException(status_code=400, detail="Empty file")
+        await zip_file.seek(0)
+
+        # Create temporary file
+        temp_file = self.temp_dir / f"{unique_id}.zip"
+        try:
+            # Save uploaded file
+            content = await zip_file.read()
+            if len(content) > MAX_UPLOAD_SIZE:
+                raise HTTPException(status_code=400, detail="File too large")
             
-            result = {
-                "clarification": interact,
-                "tools": tools
-            }
+            temp_file.write_bytes(content)
             
-            yield "<json>"+ json.dumps(result)+"</json>"
+            # Validate ZIP file
+            if not zipfile.is_zipfile(temp_file):
+                raise HTTPException(status_code=400, detail="Invalid ZIP file")
+                
+            # Validate file types
+            if not self._validate_file_types(temp_file):
+                raise HTTPException(status_code=400, detail="Invalid file types in ZIP")
             
+            # Process the ZIP file
+            site_path = self.sites_dir / unique_id
+            with zipfile.ZipFile(temp_file) as zip_ref:
+                # Verify index.html exists
+                if not any(name.endswith('/index.html') or name == 'index.html' 
+                          for name in zip_ref.namelist()):
+                    raise HTTPException(
+                        status_code=400,
+                        detail="ZIP file must contain index.html in root directory"
+                    )
+                
+                # Clear existing site if present
+                if site_path.exists():
+                    shutil.rmtree(site_path)
+                
+                # Extract files
+                zip_ref.extractall(self.temp_dir / unique_id)
+                
+                # Move to final location
+                extraction_path = self.temp_dir / unique_id
+                root_dir = next(
+                    (p for p in extraction_path.iterdir() if p.is_dir() 
+                     and (p / 'index.html').exists()),
+                    extraction_path
+                )
+                shutil.move(str(root_dir), str(site_path))
+                
+            self.active_sites.add(unique_id)
+            return {
+                "status": "success",
+                "message": f"Site deployed at /{unique_id}",
+                "url": f"/{unique_id}"
+            }
             
-            # Process tool if present
-            if tools and len(tools) > 0:
-                tool = tools[0]  # Assume only one tool is present
-                if tool["name"] in ["news", "web"]:
-                    search_query = tool["input"]
-                    search_response = search_assistant_api(search_query, tool["name"], model=query.model_id)
-                    
-                    yield "<report>"
-                    for content in search_response():
-                        yield content
-                        full_response += content
-                    yield "</report>"
-        
-        # Add the assistant's response to the conversation history
-        conversations[query.conversation_id].append({"role": "assistant", "content": full_response})
-        background_tasks.add_task(update_db, query.user_id, query.conversation_id, query.query, full_response)
-        logger.info(f"Completed followup agent response for query: {query.query}, send result:{result}, Full response: {full_response}")
-    
-    return StreamingResponse(process_response(), media_type="text/event-stream")
-
-
-@app.post("/v3/followup-agent")
-async def followup_agent(query: FollowupQueryModel, background_tasks: BackgroundTasks, api_key: str = Depends(verify_api_key)):
-    """
-    Followup agent endpoint that provides helpful responses or generates clarifying questions based on user queries.
-    Requires API Key authentication via X-API-Key header.
-    """
-    logger.info(f"Received followup agent query: {query.query}")
-
-    if query.conversation_id not in conversations:
-        conversations[query.conversation_id] = [
-            {"role": "system", "content": FOLLOWUP_AGENT_PROMPT}
-        ]
-    
-    conversations[query.conversation_id].append({"role": "user", "content": query.query})
-    last_activity[query.conversation_id] = time.time()
-    
-    # Limit tokens in the conversation history
-    limited_conversation = conversations[query.conversation_id]
-
-    
-    async def process_response():
-        yield "<followup-response>\n\n"
-        full_response = ""
-        for content in chat_with_llama_stream(limited_conversation, model=query.model_id):
-            full_response += content
-            yield content
-        yield "</followup-response>\n\n"
-        
-        logger.info(f"LLM RAW response for query: {query.query}: {full_response}")
-        
-        # Add a slight delay after sending the full LLM response
-        await asyncio.sleep(0.01)
-        
-        response_content, interact, tools = parse_followup_and_tools(full_response)
-        result = {
-            "clarification": interact
-        }
-        
-        yield "<followup-json>\n\n"
-        yield json.dumps(result) + "\n\n"
-        yield "</followup-json>\n\n"
-        
-        # Add the assistant's response to the conversation history
-        conversations[query.conversation_id].append({"role": "assistant", "content": full_response})
-        background_tasks.add_task(update_db, query.user_id, query.conversation_id, query.query, full_response)
-        logger.info(f"Completed followup agent response for query: {query.query}, send result: {result}")
-
-    return StreamingResponse(process_response(), media_type="text/event-stream")
-
-
-@app.post("/v4/followup-agent")
-async def followup_agent_v4(query: FollowupQueryModel, background_tasks: BackgroundTasks, api_key: str = Depends(verify_api_key)):
-    """
-    Followup agent endpoint that provides helpful responses or generates clarifying questions based on user queries.
-    Requires API Key authentication via X-API-Key header.
-    """
-    logger.info(f"Received followup agent query: {query.query}")
-
-    if query.conversation_id not in conversations:
-        conversations[query.conversation_id] = [
-            {"role": "system", "content": FOLLOWUP_AGENT_PROMPT}
-        ]
-    
-    conversations[query.conversation_id].append({"role": "user", "content": query.query})
-    last_activity[query.conversation_id] = time.time()
-    
-    # Limit tokens in the conversation history
-    limited_conversation = conversations[query.conversation_id]
-
-    
-    async def process_response():
-        yield "<followup-response>"+"\n"
-        full_response = ""
-        for content in chat_with_llama_stream(limited_conversation, model=query.model_id):
-            full_response += content
-            yield content
-        yield "</followup-response>"+"\n"
-        yield "--END_SECTION--\n"
-        
-        logger.info(f"LLM RAW response for query: {query.query}: {full_response}")
-
-        
-        response_content, interact, tools = parse_followup_and_tools(full_response)
-        result = {
-            "clarification": interact
-        }
-        
-        yield "<followup-json>" + "\n"
-        yield json.dumps(result) + "\n"
-        yield "</followup-json>" +"\n"
-        yield "--END_SECTION--\n"
-        # Add the assistant's response to the conversation history
-        conversations[query.conversation_id].append({"role": "assistant", "content": full_response})
-        background_tasks.add_task(update_db, query.user_id, query.conversation_id, query.query, full_response)
-        logger.info(f"Completed followup agent response for query: {query.query}, send result: {result}")
-
-    return StreamingResponse(process_response(), media_type="text/event-stream")
-
-## Digiyatra
-
-@app.post("/digiyatra-followup")
-async def followup_agent(query: FollowupQueryModel, background_tasks: BackgroundTasks, api_key: str = Depends(verify_api_key)):
-    """
-    Followup agent endpoint that provides helpful responses or generates clarifying questions based on user queries.
-    Requires API Key authentication via X-API-Key header.
-    """
-    logger.info(f"Received followup agent query: {query.query}")
-
-    if query.conversation_id not in conversations:
-        conversations[query.conversation_id] = [
-            {"role": "system", "content": FOLLOWUP_DIGIYATRA_PROMPT}
-        ]
-    
-    conversations[query.conversation_id].append({"role": "user", "content": query.query})
-    last_activity[query.conversation_id] = time.time()
-    
-    # Limit tokens in the conversation history
-    limited_conversation = conversations[query.conversation_id]
-
-    def process_response():
-        full_response = ""
-        for content in chat_with_llama_stream(limited_conversation, model=query.model_id):
-            full_response += content
-            yield content
-
-        logger.info(f"LLM RAW response for query: {query.query}: {full_response}")
-        response_content, interact,tools = parse_followup_and_tools(full_response)
-        
-        result = {
-            "response": response_content,
-            "clarification": interact
-        }
-        
-        yield "\n\n" + json.dumps(result)
-        
-        # Add the assistant's response to the conversation history
-        conversations[query.conversation_id].append({"role": "assistant", "content": full_response})
-        
-        background_tasks.add_task(update_db, query.user_id, query.conversation_id, query.query, full_response)
-        logger.info(f"Completed followup agent response for query: {query.query}, send result: {result}")
-
-    return StreamingResponse(process_response(), media_type="text/event-stream")
-
-
-@app.post("/v2/digiyatra-followup")
-async def digi_followup_agent_v2(query: FollowupQueryModel, background_tasks: BackgroundTasks, api_key: str = Depends(verify_api_key)):
-    """
-    Followup agent endpoint that provides helpful responses or generates clarifying questions based on user queries.
-    Requires API Key authentication via X-API-Key header.
-    """
-    logger.info(f"Received followup agent query: {query.query}")
-
-    if query.conversation_id not in conversations:
-        conversations[query.conversation_id] = [
-            {"role": "system", "content": FOLLOWUP_DIGIYATRA_PROMPT}
-        ]
-    
-    conversations[query.conversation_id].append({"role": "user", "content": query.query})
-    last_activity[query.conversation_id] = time.time()
-    
-    # Limit tokens in the conversation history
-    limited_conversation = conversations[query.conversation_id]
-
-    def process_response():
-        full_response = ""
-        for content in chat_with_llama_stream(limited_conversation, model=query.model_id):
-            full_response += content
-            yield json.dumps({"type": "response","content": content}) + "\n"
-
-        logger.info(f"LLM RAW response for query: {query.query}: {full_response}")
-        response_content, interact,tools = parse_followup_and_tools(full_response)
-        
-        result = {
-            "response": response_content,
-            "clarification": interact
-        }
-        yield json.dumps({"type": "interact","content": result}) +"\n"
-        
-        # Add the assistant's response to the conversation history
-        conversations[query.conversation_id].append({"role": "assistant", "content": full_response})
-        
-        background_tasks.add_task(update_db, query.user_id, query.conversation_id, query.query, full_response)
-        logger.info(f"Completed followup agent response for query: {query.query}, send result: {result}")
-
-    return StreamingResponse(process_response(), media_type="text/event-stream")
-
-
-from document_generator import router as document_generator_router
-app.include_router(document_generator_router, prefix="/api/v1")
-
-from document_generator_v2 import router as document_generator_router_v2
-app.include_router(document_generator_router_v2, prefix="/api/v2")
-
-from document_generator_v3 import router as document_generator_router_v3
-app.include_router(document_generator_router_v3, prefix="/api/v3")
-
-from document_generator_v4 import router as document_generator_router_v4
-app.include_router(document_generator_router_v4, prefix="/api/v4")
-
-from fastapi.middleware.cors import CORSMiddleware
+        except Exception as e:
+            logger.error(f"Error deploying site {unique_id}: {str(e)}")
+            raise HTTPException(status_code=500, detail=str(e))
+        finally:
+            # Cleanup
+            if temp_file.exists():
+                temp_file.unlink()
+            cleanup_path = self.temp_dir / unique_id
+            if cleanup_path.exists():
+                shutil.rmtree(cleanup_path)
+
+    def remove_site(self, unique_id: str) -> bool:
+        """Remove a deployed site"""
+        if unique_id in self.active_sites:
+            site_path = self.sites_dir / unique_id
+            if site_path.exists():
+                shutil.rmtree(site_path)
+            self.active_sites.remove(unique_id)
+            return True
+        return False
+
+# Initialize site manager
+site_manager = SiteManager()
+
+@app.post("/deploy/{unique_id}")
+async def deploy_site(unique_id: str, file: UploadFile = File(...)):
+    """Deploy a new site from a ZIP file"""
+    if not file.filename.endswith('.zip'):
+        raise HTTPException(status_code=400, detail="File must be a ZIP archive")
+    
+    result = await site_manager.deploy_site(unique_id, file)
+    return JSONResponse(content=result)
+
+@app.delete("/site/{unique_id}")
+async def remove_site(unique_id: str):
+    """Remove a deployed site"""
+    if site_manager.remove_site(unique_id):
+        return {"status": "success", "message": f"Site {unique_id} removed"}
+    raise HTTPException(status_code=404, detail="Site not found")
+
+@app.get("/sites")
+async def list_sites():
+    """List all deployed sites"""
+    return {"sites": list(site_manager.active_sites)}
+
+@app.get("/health")
+async def health_check():
+    """Health check endpoint"""
+    return {"status": "healthy", "sites_count": len(site_manager.active_sites)}
+
+# Mount static file handlers for each site
+@app.on_event("startup")
+async def startup_event():
+    """Configure static file handlers for existing sites"""
+    logger.info("Starting up server...")
+    for site_id in site_manager.active_sites:
+        site_path = site_manager.sites_dir / site_id
+        app.mount(f"/{site_id}", StaticFiles(directory=str(site_path), html=True), name=site_id)
 
-# CORS middleware setup
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=[
-        "http://127.0.0.1:5501/",
-        "http://localhost:3000",
-        "https://www.elevaticsai.com",
-        "https://www.elevatics.cloud",
-        "https://www.elevatics.online",
-        "https://www.elevatics.ai",
-        "https://elevaticsai.com",
-        "https://elevatics.cloud",
-        "https://elevatics.online",
-        "https://elevatics.ai",
-        "https://pvanand-specialized-agents.hf.space",
-        "https://pvanand-general-chat.hf.space"
-    ],
-    allow_credentials=True,
-    allow_methods=["GET", "POST"],
-    allow_headers=["*"],
-    expose_headers=["Content-Disposition"]
-)
 if __name__ == "__main__":
     import uvicorn
-    logger.info("Starting the application")
-    uvicorn.run(app, host="0.0.0.0", port=7860)
+    uvicorn.run(app, host="0.0.0.0", port=8000)