Update app.py

app.py

@@ -6,6 +6,10 @@ import threading
 from itertools import islice
 from datetime import datetime
 import re
+from typing import List, Dict, Any, Optional, Tuple, Generator
+from dataclasses import dataclass
+from functools import lru_cache
+import logging
 import gradio as gr
 import torch
 from transformers import pipeline, TextIteratorStreamer
@@ -17,54 +21,94 @@ import json
 import urllib.parse
 from config import MODELS
 
-# Global event to signal cancellation from the UI thread to the generation thread
-cancel_event = threading.Event()
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
 
-access_token = os.environ.get('HF_TOKEN', '')
+# Global event for cancellation
+cancel_event = threading.Event()
 
-# Global cache for pipelines to avoid re-loading.
+# Constants
+ACCESS_TOKEN = os.environ.get('HF_TOKEN', '')
 PIPELINES = {}
+SEARCH_TIMEOUT_DEFAULT = 5.0
+MAX_RETRIES = 3
+RETRY_DELAY = 1
+
+# Data classes for better structure
+@dataclass
+class SearchResult:
+    title: str
+    snippet: str
+    url: Optional[str] = None
+    
+    def format(self, max_chars: int = 50) -> str:
+        snippet = self.snippet[:max_chars] + "..." if len(self.snippet) > max_chars else self.snippet
+        return f"{self.title} - {snippet}"
 
-def google_search_web(query, max_results=6, max_chars=50):
-    """Search using Google web scraping with multiple approaches"""
+@dataclass
+class GenerationConfig:
+    max_tokens: int = 1024
+    temperature: float = 0.7
+    top_k: int = 40
+    top_p: float = 0.9
+    repetition_penalty: float = 1.2
     
-    # Try multiple User-Agents
-    user_agents = [
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            'max_new_tokens': self.max_tokens,
+            'temperature': self.temperature,
+            'top_k': self.top_k,
+            'top_p': self.top_p,
+            'repetition_penalty': self.repetition_penalty,
+        }
+
+class SearchEngine:
+    """Base class for search engines with common functionality"""
+    
+    USER_AGENTS = [
         'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
         'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
         'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'
     ]
     
-    for user_agent in user_agents:
-        try:
-            # Try different search URLs
-            search_urls = [
-                f"https://www.google.com/search?q={quote_plus(query)}&safe=off&num={max_results}",
-                f"https://www.google.com/search?q={quote_plus(query)}&safe=off&num={max_results}&hl=en",
-                f"https://www.google.com/webhp?safe=off&q={quote_plus(query)}&num={max_results}"
-            ]
+    @staticmethod
+    def _get_headers() -> Dict[str, str]:
+        return {
+            'User-Agent': SearchEngine.USER_AGENTS[0],
+            'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
+            'Accept-Language': 'en-US,en;q=0.5',
+            'Accept-Encoding': 'gzip, deflate',
+            'Connection': 'keep-alive',
+            'Upgrade-Insecure-Requests': '1',
+            'Cache-Control': 'max-age=0'
+        }
+
+class GoogleSearch(SearchEngine):
+    """Google search implementation"""
+    
+    @staticmethod
+    def search(query: str, max_results: int = 6, max_chars: int = 50) -> List[SearchResult]:
+        """Perform Google search with multiple fallback strategies"""
+        encoded_query = quote_plus(query)
+        search_urls = [
+            f"https://www.google.com/search?q={encoded_query}&safe=off&num={max_results}",
+            f"https://www.google.com/search?q={encoded_query}&safe=off&num={max_results}&hl=en",
+            f"https://www.google.com/webhp?safe=off&q={encoded_query}&num={max_results}"
+        ]
+        
+        for user_agent in SearchEngine.USER_AGENTS:
+            headers = SearchEngine._get_headers()
+            headers['User-Agent'] = user_agent
             
             for search_url in search_urls:
                 try:
-                    headers = {
-                        'User-Agent': user_agent,
-                        'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
-                        'Accept-Language': 'en-US,en;q=0.5',
-                        'Accept-Encoding': 'gzip, deflate',
-                        'Connection': 'keep-alive',
-                        'Upgrade-Insecure-Requests': '1',
-                        'Cache-Control': 'max-age=0'
-                    }
-                    
                     response = requests.get(search_url, headers=headers, timeout=15, verify=True)
                     response.raise_for_status()
                     
                     soup = BeautifulSoup(response.text, 'html.parser')
                     
-                    # Find search result containers
-                    results = []
-                    
-                    # Try different selectors
+                    # Try multiple selectors
                     selectors = [
                         ('div', 'g'),
                         ('div', 'tF2Cxc'),
@@ -79,256 +123,225 @@ def google_search_web(query, max_results=6, max_chars=50):
                             break
                     
                     if not search_results:
-                        # Try alternative parsing
                         search_results = soup.find_all('div', class_=re.compile(r'^(g|tF2Cxc|MjjYud|yuRUbf)'))
                     
+                    results = []
                     for result in search_results[:max_results]:
                         try:
-                            # Get title
-                            title_elem = result.find('h3')
+                            # Extract title
+                            title_elem = result.find('h3') or result.find('h2')
                             if not title_elem:
-                                title_elem = result.find('h2')
-                            title = title_elem.text if title_elem else "No Title"
+                                continue
                             
-                            # Get snippet
-                            snippet_elem = result.find('div', class_='VwiC3b')
-                            if not snippet_elem:
-                                snippet_elem = result.find('div', class_='IsZvec')
-                            if not snippet_elem:
-                                snippet_elem = result.find('div', class_='lEBKkf')
-                            snippet = snippet_elem.text if snippet_elem else ""
+                            # Extract snippet
+                            snippet_elem = result.find('div', class_='VwiC3b') or \
+                                          result.find('div', class_='IsZvec') or \
+                                          result.find('div', class_='lEBKkf')
                             
-                            # Get link
+                            # Extract link
                             link_elem = result.find('a')
-                            link = link_elem.get('href') if link_elem else ""
-                            if link and link.startswith('/url?q='):
+                            if not link_elem:
+                                continue
+                                
+                            link = link_elem.get('href', '')
+                            if link.startswith('/url?q='):
                                 link = urllib.parse.unquote(link.split('/url?q=')[1].split('&')[0])
                             
-                            if link and not link.startswith('http'):
+                            if not link.startswith('http'):
                                 continue
                             
-                            # Clean up snippet
+                            title = title_elem.text.strip()
+                            snippet = snippet_elem.text.strip() if snippet_elem else ""
                             snippet = ' '.join(snippet.split())
-                            if len(snippet) > max_chars:
-                                snippet = snippet[:max_chars] + "..."
                             
                             if title and snippet:
-                                results.append(f"{len(results)+1}. {title} - {snippet}")
+                                results.append(SearchResult(title=title, snippet=snippet, url=link))
                                 
-                        except Exception:
+                        except Exception as e:
+                            logger.debug(f"Error parsing Google result: {e}")
                             continue
                     
                     if results:
                         return results
                         
-                except Exception:
+                except Exception as e:
+                    logger.debug(f"Google search attempt failed: {e}")
                     continue
-                    
-        except Exception:
-            continue
+        
+        return []
+
+class DuckDuckGoSearch(SearchEngine):
+    """DuckDuckGo search implementation"""
     
-    return []
+    @staticmethod
+    def search(query: str, max_results: int = 6, max_chars: int = 50) -> List[SearchResult]:
+        try:
+            from ddgs import DDGS
+            with DDGS() as ddgs:
+                results = []
+                for r in islice(ddgs.text(query, region="wt-wt", safesearch="off", timelimit="y"), max_results):
+                    title = r.get('title', 'No Title')
+                    body = r.get('body', '')
+                    results.append(SearchResult(title=title, snippet=body))
+                return results
+        except Exception as e:
+            logger.debug(f"DuckDuckGo search failed: {e}")
+            return []
 
-def duckduckgo_search(query, max_results=6, max_chars=50):
-    """Fallback to DuckDuckGo search"""
-    try:
-        from ddgs import DDGS
-        with DDGS() as ddgs:
+class BingSearch(SearchEngine):
+    """Bing search implementation"""
+    
+    @staticmethod
+    def search(query: str, max_results: int = 6, max_chars: int = 50) -> List[SearchResult]:
+        try:
+            headers = SearchEngine._get_headers()
+            search_url = f"https://www.bing.com/search?q={quote_plus(query)}&safeSearch=off&count={max_results}"
+            
+            response = requests.get(search_url, headers=headers, timeout=10)
+            response.raise_for_status()
+            
+            soup = BeautifulSoup(response.text, 'html.parser')
             results = []
-            for r in islice(ddgs.text(query, region="wt-wt", safesearch="off", timelimit="y"), max_results):
-                title = r.get('title', 'No Title')
-                body = r.get('body', '')
-                if len(body) > max_chars:
-                    body = body[:max_chars] + "..."
-                results.append(f"{len(results)+1}. {title} - {body}")
+            
+            for result in soup.find_all('li', class_='b_algo')[:max_results]:
+                try:
+                    title_elem = result.find('h2')
+                    snippet_elem = result.find('p')
+                    
+                    if title_elem and snippet_elem:
+                        title = title_elem.text.strip()
+                        snippet = snippet_elem.text.strip()
+                        results.append(SearchResult(title=title, snippet=snippet))
+                        
+                except Exception as e:
+                    logger.debug(f"Error parsing Bing result: {e}")
+                    continue
+            
             return results
-    except Exception:
-        return []
+        except Exception as e:
+            logger.debug(f"Bing search failed: {e}")
+            return []
 
-def bing_search(query, max_results=6, max_chars=50):
-    """Fallback to Bing search"""
-    try:
-        headers = {
-            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'
-        }
-        search_url = f"https://www.bing.com/search?q={quote_plus(query)}&safeSearch=off&count={max_results}"
-        
-        response = requests.get(search_url, headers=headers, timeout=10)
-        response.raise_for_status()
-        
-        soup = BeautifulSoup(response.text, 'html.parser')
+class SearchManager:
+    """Manages multiple search engines with fallback mechanism"""
+    
+    _engines = [
+        GoogleSearch,
+        DuckDuckGoSearch,
+        BingSearch
+    ]
+    
+    @classmethod
+    def search(cls, query: str, max_results: int = 6, max_chars: int = 50, timeout: float = 5.0) -> List[SearchResult]:
+        """Search across all engines with timeout"""
         results = []
         
-        # Find search results
-        search_results = soup.find_all('li', class_='b_algo')
-        
-        for result in search_results[:max_results]:
+        for engine_cls in cls._engines:
             try:
-                title_elem = result.find('h2')
-                title = title_elem.text if title_elem else "No Title"
-                
-                snippet_elem = result.find('p')
-                snippet = snippet_elem.text if snippet_elem else ""
-                
-                if len(snippet) > max_chars:
-                    snippet = snippet[:max_chars] + "..."
+                # Use threading with timeout
+                result_container = []
+                search_thread = threading.Thread(
+                    target=lambda: result_container.extend(engine_cls.search(query, max_results, max_chars))
+                )
+                search_thread.daemon = True
+                search_thread.start()
+                search_thread.join(timeout=timeout)
                 
-                if title and snippet:
-                    results.append(f"{len(results)+1}. {title} - {snippet}")
+                if result_container:
+                    logger.info(f"Search successful with {engine_cls.__name__}: {len(result_container)} results")
+                    return result_container
                     
-            except Exception:
+            except Exception as e:
+                logger.warning(f"Search engine {engine_cls.__name__} failed: {e}")
                 continue
         
         return results
-    except Exception:
-        return []
 
-def retrieve_context(query, max_results=6, max_chars=50):
-    """
-    Retrieve search snippets from multiple search engines.
-    Returns a list of result strings.
-    """
-    # Try Google first
-    results = google_search_web(query, max_results, max_chars)
-    if results:
-        print(f"✅ Google search successful: {len(results)} results")
-        return results
+class ModelManager:
+    """Manages model loading and caching"""
     
-    # Try DuckDuckGo
-    results = duckduckgo_search(query, max_results, max_chars)
-    if results:
-        print(f"✅ DuckDuckGo search successful: {len(results)} results")
-        return results
+    _pipelines = {}
+    _lock = threading.Lock()
     
-    # Try Bing
-    results = bing_search(query, max_results, max_chars)
-    if results:
-        print(f"✅ Bing search successful: {len(results)} results")
-        return results
-    
-    print("❌ All search engines failed")
-    return []
-
-def load_pipeline(model_name):
-    """
-    Load and cache a transformers pipeline for text generation.
-    Tries bfloat16, falls back to float16 or float32 if unsupported.
-    """
-    global PIPELINES
-    if model_name in PIPELINES:
-        return PIPELINES[model_name]
-    repo = MODELS[model_name]["repo_id"]
-    tokenizer = AutoTokenizer.from_pretrained(repo, token=access_token)
-    for dtype in (torch.bfloat16, torch.float16, torch.float32):
-        try:
+    @classmethod
+    def load_pipeline(cls, model_name: str) -> pipeline:
+        """Load and cache pipeline with fallback for dtype"""
+        with cls._lock:
+            if model_name in cls._pipelines:
+                return cls._pipelines[model_name]
+            
+            repo = MODELS[model_name]["repo_id"]
+            tokenizer = AutoTokenizer.from_pretrained(repo, token=ACCESS_TOKEN)
+            
+            # Try different dtypes
+            for dtype in (torch.bfloat16, torch.float16, torch.float32):
+                try:
+                    pipe = pipeline(
+                        task="text-generation",
+                        model=repo,
+                        tokenizer=tokenizer,
+                        trust_remote_code=True,
+                        dtype=dtype,
+                        device_map="auto",
+                        use_cache=True,
+                        token=ACCESS_TOKEN
+                    )
+                    cls._pipelines[model_name] = pipe
+                    return pipe
+                except Exception as e:
+                    logger.warning(f"Failed to load with {dtype}: {e}")
+                    continue
+            
+            # Final fallback
             pipe = pipeline(
                 task="text-generation",
                 model=repo,
                 tokenizer=tokenizer,
                 trust_remote_code=True,
-                dtype=dtype,
                 device_map="auto",
-                use_cache=True,
-                token=access_token)
-            PIPELINES[model_name] = pipe
+                use_cache=True
+            )
+            cls._pipelines[model_name] = pipe
             return pipe
-        except Exception:
-            continue
-    # Final fallback
-    pipe = pipeline(
-        task="text-generation",
-        model=repo,
-        tokenizer=tokenizer,
-        trust_remote_code=True,
-        device_map="auto",
-        use_cache=True
-    )
-    PIPELINES[model_name] = pipe
-    return pipe
-
-def format_conversation(history, system_prompt, tokenizer):
-    if hasattr(tokenizer, "chat_template") and tokenizer.chat_template:
-        messages = [{"role": "system", "content": system_prompt.strip()}] + history
-        return tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True, enable_thinking=True)
-    else:
-        # Fallback for base LMs without chat template
-        prompt = system_prompt.strip() + "\n"
-        for msg in history:
-            if msg['role'] == 'user':
-                prompt += "User: " + msg['content'].strip() + "\n"
-            elif msg['role'] == 'assistant':
-                prompt += "Assistant: " + msg['content'].strip() + "\n"
-        if not prompt.strip().endswith("Assistant:"):
-            prompt += "Assistant: "
-        return prompt
-
-def get_duration(user_msg, chat_history, system_prompt, enable_search, max_results, max_chars, model_name, max_tokens, temperature, top_k, top_p, repeat_penalty, search_timeout):
-    # Get model size from the MODELS dict
-    model_size = MODELS[model_name].get("params_b", 4.0)
-    
-    # Only use AOT for models >= 2B parameters
-    use_aot = model_size >= 2
-    
-    # Adjusted for H200 performance
-    base_duration = 20 if not use_aot else 40
-    token_duration = max_tokens * 0.005
-    search_duration = 10 if enable_search else 0
-    aot_compilation_buffer = 20 if use_aot else 0
-    
-    return base_duration + token_duration + search_duration + aot_compilation_buffer
-
-def get_model_size(model_name):
-    """Get model size from the MODELS dict."""
-    return MODELS.get(model_name, {}).get("params_b", 4.0)
 
-def chat_response(user_msg, chat_history, system_prompt,
-                  enable_search, max_results, max_chars,
-                  model_name, max_tokens, temperature,
-                  top_k, top_p, repeat_penalty, search_timeout):
-    """
-    Generates streaming chat responses, optionally with background web search.
-    This version includes cancellation support.
-    """
-    # Clear the cancellation event at the start of a new generation
-    cancel_event.clear()
+class PromptBuilder:
+    """Builds prompts for different models"""
     
-    history = list(chat_history or [])
-    history.append({'role': 'user', 'content': user_msg})
-
-    # Launch web search if enabled
-    debug = ''
-    search_results = []
-    if enable_search:
-        debug = '🔍 Searching (Google → DuckDuckGo → Bing)...'
-        thread_search = threading.Thread(
-            target=lambda: search_results.extend(
-                retrieve_context(user_msg, int(max_results), int(max_chars))
-            )
-        )
-        thread_search.daemon = True
-        thread_search.start()
-    else:
-        debug = 'Web search disabled.'
-
-    # Wait for search results if enabled
-    if enable_search:
-        thread_search.join(timeout=float(search_timeout))
-        if search_results:
-            debug = f"✅ Search completed - Found {len(search_results)} results\n\n" + "\n".join(
-                f"- {r}" for r in search_results
+    @staticmethod
+    def format_conversation(history: List[Dict], system_prompt: str, tokenizer) -> str:
+        """Format conversation with proper chat template"""
+        if hasattr(tokenizer, "chat_template") and tokenizer.chat_template:
+            messages = [{"role": "system", "content": system_prompt.strip()}] + history
+            return tokenizer.apply_chat_template(
+                messages, 
+                tokenize=False, 
+                add_generation_prompt=True, 
+                enable_thinking=True
             )
         else:
-            debug = "❌ No search results found. Check internet connection or try again."
-
-    try:
-        cur_date = datetime.now().strftime('%Y-%m-%d')
+            # Fallback for base LMs
+            prompt = f"{system_prompt.strip()}\n"
+            for msg in history:
+                role = "User" if msg['role'] == 'user' else "Assistant"
+                prompt += f"{role}: {msg['content'].strip()}\n"
+            
+            if not prompt.strip().endswith("Assistant:"):
+                prompt += "Assistant: "
+            return prompt
+    
+    @staticmethod
+    def build_search_context(search_results: List[SearchResult], system_prompt: str, user_query: str) -> str:
+        """Build enriched prompt with search context"""
+        if not search_results:
+            return system_prompt.strip()
+        
+        formatted_results = "\n".join(f"[{i+1}] {r.format()}" for i, r in enumerate(search_results))
         
-        # Prepare enriched system prompt
-        if search_results:
-            enriched = system_prompt.strip() + f"""
+        return f"""{system_prompt.strip()}
+
 # SEARCH CONTEXT (TRUSTED SOURCES ONLY)
 Below are search results. Treat them as the ONLY source of truth for answering.
-{search_results}
+{formatted_results}
 
 RULES (VERY IMPORTANT):
 - Do NOT use outside knowledge. Do NOT guess or fill missing information.
@@ -351,143 +364,470 @@ ANSWER POLICY:
 - If sources are insufficient, stop and ask for more data instead of guessing.
 
 DATE CONTEXT:
-- Today is {cur_date} (use only for time reference, not for assumptions).
+- Today is {datetime.now().strftime('%Y-%m-%d')} (use only for time reference, not for assumptions).
 
 USER QUESTION:
-"""
-        else:
-            enriched = system_prompt.strip()
-
-        pipe = load_pipeline(model_name)
+{user_query}"""
 
-        prompt = format_conversation(history, enriched, pipe.tokenizer)
-        prompt_debug = f"\n\n--- Prompt Preview ---\n```\n{prompt}\n```"
-        streamer = TextIteratorStreamer(pipe.tokenizer,
-                                        skip_prompt=True,
-                                        skip_special_tokens=True)
-        gen_thread = threading.Thread(
-            target=pipe,
-            args=(prompt,),
-            kwargs={
-                'max_new_tokens': max_tokens,
-                'temperature': temperature,
-                'top_k': top_k,
-                'top_p': top_p,
-                'repetition_penalty': repeat_penalty,
-                'streamer': streamer,
-                'return_full_text': False,
-            }
-        )
-        gen_thread.start()
-
-        # Buffers for thought vs answer
+class StreamProcessor:
+    """Handles streaming token processing"""
+    
+    @staticmethod
+    def process_stream(streamer: TextIteratorStreamer, history: List[Dict]) -> Generator[Tuple[List[Dict], str], None, None]:
+        """Process streaming tokens and handle thinking tags"""
         thought_buf = ''
         answer_buf = ''
         in_thought = False
         assistant_message_started = False
-
-        # First yield contains the user message
-        yield history, debug
-
-        # Stream tokens
+        
         for chunk in streamer:
-            # Check for cancellation signal
             if cancel_event.is_set():
                 if assistant_message_started and history and history[-1]['role'] == 'assistant':
                     history[-1]['content'] += " [Generation Canceled]"
-                yield history, debug
+                yield history, "Generation canceled by user."
                 break
             
             text = chunk
-
-            # Detect start of thinking
+            
+            # Handle thinking tags
             if not in_thought and '<think>' in text:
                 in_thought = True
-                history.append({'role': 'assistant', 'content': '', 'metadata': {'title': '💭 Thought'}})
-                assistant_message_started = True
+                history.append({'role': 'assthought = True
+                history.append({'role': 'assistant', 'contentistant', 'content': '', 'metadata': {'title': '💭 Thought'}})
+                assistant_message_started': '', 'metadata': {'title': '💭 Thought' = True
                 after = text.split('<think>', 1)[1]
+                thought_buf += after}})
+                assistant_message_started = True
+                after = text.split('<think>', 1)[1
+                
+                if '</think>' in thought_buf:
+                    before,]
                 thought_buf += after
+                
                 if '</think>' in thought_buf:
+                    after2 = thought_buf.split('</think>', 1)
                     before, after2 = thought_buf.split('</think>', 1)
-                    history[-1]['content'] = before.strip()
+ history[-1]['content']                    history[-1]['content'] = before.strip()
+                    in_thought = False
+                    answer_buf = = before.strip()
                     in_thought = False
                     answer_buf = after2
-                    history.append({'role': 'assistant', 'content': answer_buf})
+                    history.append({'role': ' after2
+                    history.append({'roleassistant', 'content': answer_buf})
+                else:
+                    history[-1]['': 'assistant', 'content': answer_buf})
                 else:
-                    history[-1]['content'] = thought_buf
-                yield history, debug
+                   content'] = thought_buf
+                yield history, ""
                 continue
-
+            
+            if in_thought:
+                thought_b history[-1]['content'] = thought_buf
+                yield history, ""
+                continue
+            
             if in_thought:
                 thought_buf += text
                 if '</think>' in thought_buf:
-                    before, after2 = thought_buf.split('</think>', 1)
+                    beforeuf += text
+                if '</think>' in thought_buf:
+                   , after2 = thought_buf.split('</think>', 1)
+ before, after2 = thought_buf.split('</think>', 1)
                     history[-1]['content'] = before.strip()
-                    in_thought = False
+                    in_thought =                    history[-1]['content'] = before.strip()
+                    in_thought False
+                    answer_buf = after2
+                    history.append({'role': = False
                     answer_buf = after2
+                    history 'assistant', 'content': answer_buf})
+                else:
                     history.append({'role': 'assistant', 'content': answer_buf})
                 else:
-                    history[-1]['content'] = thought_buf
-                yield history, debug
+                    history[-1]['content[-1]['content'] = thought_buf
+                yield history, ""
+'] = thought_buf
+                yield history, ""
                 continue
-
+            
+            # Stream answer
+            if not assistant_message_started:
+                history.append({'role                continue
+            
             # Stream answer
             if not assistant_message_started:
-                history.append({'role': 'assistant', 'content': ''})
+               ': 'assistant', 'content': ''})
+                assistant_message_start history.append({'role': 'assistant', 'content': ''})
                 assistant_message_started = True
-
+            
+            answered = True
+            
             answer_buf += text
             history[-1]['content'] = answer_buf.strip()
-            yield history, debug
+            yield history, "_buf += text
+            history[-1]['content'] = answer_buf.strip()
+            yield history, ""
 
-        gen_thread.join()
-        yield history, debug + prompt_debug
+# Main chat function
+def chat_response(
+    user_msg: str,
+    chat"
+
+# Main chat function
+def chat_response(
+    user_msg: str,
+    chat_history: List[Dict],
+    system_prompt: str,
+_history: List[Dict],
+    system_prompt: str,
+    enable_search    enable_search: bool,
+    max_results: int,
+    max_ch: bool,
+    max_results: int,
+    max_chars: int,
+ars: int,
+    model_name: str,
+    max_tokens: int,
+    temperature: float,
+    top    model_name: str,
+    max_tokens: int,
+   _k: int,
+    top_p temperature: float,
+    top_k: int,
+    top_p: float,
+    repeat: float,
+    repeat_penalty: float,
+    search_timeout: float
+)_penalty: float,
+    search_timeout: float
+) -> Generator[Tuple[List[Dict], str], None, None]:
+    """Generate -> Generator[Tuple[List[Dict], str], None, None]:
+    """Generate streaming chat responses with search integration"""
+    
+    cancel streaming chat responses with search integration"""
+    
+    cancel_event.clear()
+    history = list(chat_history or [])
+    history.append({'role': 'user', 'content': user_msg})
+    
+    #_event.clear()
+    history = list(chat_history or [])
+    history.append({'role': 'user', 'content': user_msg})
+    
+    # Perform search if enabled
+    search_results: List[SearchResult] = []
+    search_debug = "Web search disabled."
+    
+    if enable_search:
+        search_debug = "🔍 Searching across multiple engines..."
+        try:
+            search_results = SearchManager.search(
+                user_msg, 
+                int(max_results), 
+                Perform search if enabled
+    search_results: List[SearchResult] = []
+    search_debug = "Web search disabled."
+    
+    if enable_search:
+        search_debug = "🔍 Searching across multiple engines..."
+        try:
+            search_results = SearchManager.search(
+                user_msg, 
+                int(max int(max_chars), 
+                float(search_timeout)
+            )
+            
+            if search_results:
+_results), 
+                int(max_chars), 
+                float(search_timeout)
+            )
+            
+            if search_results:
+                search_debug = f"✅ Search completed - Found {len(search_results)} results\n\n" + "\n".join                search_debug = f"✅ Search completed - Found {len(search_results)} results\n\n" + "\n".join(
+                    f"- {r.format(int(max_chars))}" for r in(
+                    f"- {r.format(int(max_chars))}" for r in search_results
+                )
+            else:
+                search_debug = "❌ No search search_results
+                )
+            else:
+                search_debug = "❌ No search results found. results found. Check internet connection or try again."
+        except Exception as e:
+            search_debug = f"❌ Check internet connection or try again."
+        except Exception as e:
+            search Search failed: {str(e)}"
+            logger.error(f"Search error: {e}")
+    
+    try:
+        # Build prompt
+        if enable_debug = f"❌ Search failed: {str(e)}"
+            logger.error(f"Search error: {e}")
+    
+    try:
+        # Build prompt
+        if enable_search and search_results:
+            enriched_prompt = PromptBuilder.build_search_context(
+                search_results, 
+               _search and search_results:
+            enriched_prompt = PromptBuilder.build_search_context(
+                search_results, 
+                system_prompt, system_prompt, 
+                user_msg
+            )
+        else:
+            enriched_prompt = system_prompt 
+                user_msg
+            )
+        else:
+            enriched_prompt = system.strip()
+        
+        # Load model
+        pipe = ModelManager.load_pipeline(model_name)
+        
+        # Format prompt
+        prompt = PromptBuilder.format_conversation_prompt.strip()
+        
+        # Load model
+        pipe = ModelManager.load_pipeline(model_name)
+        
+        # Format prompt
+       (history, enriched_prompt, pipe.tokenizer)
+        prompt_debug = f"\n\n--- Prompt prompt = PromptBuilder.format_conversation(history, enriched_prompt, pipe.tokenizer)
+        prompt_debug = f"\n\n--- Prompt Preview ---\n```\n{prompt[:500]}...\n``` Preview ---\n```\n{prompt[:500]}...\n" if len(prompt) > 500 else f"\n```" if len(prompt) > 500 else f"\n\n--- Prompt Preview\n--- Prompt Preview ---\n```\n{prompt}\n```"
+        
+        # Configure generation
+        config = GenerationConfig(
+            max_tokens ---\n```\n{prompt}\n```"
+        
+        # Configure generation
+        config = GenerationConfig(
+            max_tokens=max_t=max_tokens,
+            temperature=temperatureokens,
+            temperature=temperature,
+            top_k=top_k,
+            top_p=top_p,
+            repetition_penalty=repeat_penalty
+        )
+        
+        # Setup,
+            top_k=top_k,
+            top_p=top_p,
+            repetition_penalty=repeat_penalty
+        )
+        
+        # Setup streamer
+        streamer = TextIteratorStreamer(
+            pipe.tokenizer,
+            skip_prompt=True,
+            skip_special_tokens=True
+        )
+        
+        # Start streamer
+        streamer = TextIteratorStreamer(
+            pipe.tokenizer,
+            skip_prompt=True,
+            skip_special_tokens=True
+        )
+        
+        # Start generation in generation in background thread
+        gen_kwargs = config.to_dict()
+        gen_kwargs['stream background thread
+        gen_kwargs = config.to_dict()
+        gener'] = streamer
+        gen_kwargs['return_full_text_kwargs['streamer'] = streamer
+        gen_kwargs['return_full_text'] = False
+        
+       '] = False
+        
+        gen_thread = threading.Thread(
+            target= gen_thread = threading.Thread(
+            target=pipe,
+            args=(prompt,),
+            kwargs=gen_kwargs
+        )
+        gen_thread.start()
+        
+        # Yield initialpipe,
+            args=(prompt,),
+            kwargs=gen_kwargs
+        )
+        gen_thread.start()
+        
+        # Yield initial state state
+        yield history, search_debug
+        
+        # Process stream
+        for
+        yield history, search_debug
+        
+        # Process stream
+        for history_update, debug_update in StreamProcessor.process_stream(streamer, history):
+            yield history_update history_update, debug_update in StreamProcessor.process_stream(streamer, history):
+            yield history_update, debug_update
+        
+        # Wait for completion
+       , debug_update
+        
+        # Wait for completion
+        gen_thread.join(timeout=5.0)
+        yield history, search_debug + prompt_debug
+        
+    gen_thread.join(timeout=5.0)
+        yield history, search_debug + prompt_debug
+        
     except GeneratorExit:
-        # Handle cancellation gracefully
-        print("Chat response cancelled.")
+        logger.info("Generation except GeneratorExit:
+        logger.info("Generation cancelled by user")
         return
     except Exception as e:
-        history.append({'role': 'assistant', 'content': f"Error: {e}"})
-        yield history, debug
+        logger.error(f" cancelled by user")
+        return
+    except Exception as e:
+        logger.error(f"Generation error: {e}")
+        history.append({'role': 'assistant', 'content': f"Error: {strGeneration error: {e}")
+        history.append({'role': 'assistant', 'content': f"(e)}"})
+        yield history, search_debug
     finally:
         gc.collect()
 
-def update_default_prompt(enable_search):
-    return f"You are a helpful assistant."
+# Utility functions
+def get_model_size(model_name: str) -> float:
+    """Error: {str(e)}"})
+        yield history, search_debug
+    finally:
+        gc.collect()
 
-def update_duration_estimate(model_name, enable_search, max_results, max_chars, max_tokens, search_timeout):
-    """Calculate and format the estimated GPU duration for current settings."""
+# Utility functions
+def get_model_size(model_name: str) ->Get model size in billions of parameters"""
+    return MODELS.get(model_name, {}).get("params float:
+    """Get model size in billions of parameters"""
+    return MODELS.get(model_name, {}).get("params_b", 4_b", 4.0)
+
+def get_duration_estimate(
+    model_name: str,
+    enable_search: bool,
+    max_t.0)
+
+def get_duration_estimate(
+    model_name: str,
+    enable_search: bool,
+    max_tokens: int,
+    search_timeout: float
+) -> float:
+    """Calculateokens: int,
+    search_timeout: float
+) -> float:
+    """Calculate estimated GPU duration"""
+    model_size = get_model_size(model_name)
+ estimated GPU duration"""
+    model_size = get_model_size(model_name)
+    use_aot = model_size >= 2
+    
+    base    use_aot = model_size >= 2
+    
+   _duration = 20 if not use_aot else 40
+    token_duration = max_tokens *  base_duration = 20 if not use_aot else 40
+    token_duration = max_tokens * 0.005
+    search_duration = 10 if enable_search else 0
+    a0.005
+    search_duration = 10 if enable_search else 0
+    aot_compilation = 20 if use_aot else 0
+    
+    return base_dot_compilation = 20 if use_aot else 0
+    
+    return base_duration + token_duration + search_duration + aot_compilation
+
+def update_duration_estimate(
+    modeluration + token_duration + search_duration + aot_compilation
+
+def update_duration_estimate(
+    model_name: str,
+    enable_name: str,
+    enable_search: bool,
+    max_results: int,
+    max_chars: int_search: bool,
+    max_results: int,
+    max_chars: int,
+    max_tokens: int,
+    search_timeout: float
+) -> str:
+    """Format duration estimate for display"""
     try:
-        dummy_msg, dummy_history, dummy_system_prompt = "", [], ""
-        duration = get_duration(dummy_msg, dummy_history, dummy_system_prompt, 
-                              enable_search, max_results, max_chars, model_name, 
-                              max_tokens, 0.7, 40, 0.9, 1.2, search_timeout)
+        duration = get_duration_estimate(model_name, enable_search, max_tokens,
+    max_tokens: int,
+    search_timeout: float
+) -> str:
+    """Format duration estimate for display"""
+    try:
+        duration = get_duration_estimate(model_name, enable_search, max, search_timeout)
+        model_size = get_model_size(model_name)
+        
+        return f"""⏱_tokens, search_timeout)
         model_size = get_model_size(model_name)
-        return (f"⏱️ **Estimated GPU Time: {duration:.1f} seconds**\n\n"
-                f"📊 **Model Size:** {model_size:.1f}B parameters\n"
-                f"🔍 **Web Search:** {'Enabled (Multi-Engine)' if enable_search else 'Disabled'}")
+        
+        return f️ **Estimated GPU Time: {duration:.1f} seconds**
+
+📊 **Model Size:** {model_size:.1f}B parameters
+🔍"""⏱️ **Estimated GPU Time: {duration:.1f} seconds**
+
+📊 **Model Size:** {model_size:.1f}B parameters
+🔍 ** **Web Search:** {'Enabled (Multi-Engine)' if enable_search else 'Disabled'}"""
+    except ExceptionWeb Search:** {'Enabled (Multi-Engine)' if enable_search else 'Disabled'}"""
     except Exception as e:
+        logger.error(f"Error calculating estimate: {e}")
+        return f"⚠️ Error as e:
+        logger.error(f"Error calculating estimate: {e}")
         return f"⚠️ Error calculating estimate: {e}"
 
+def update_default_prompt(enable_search: bool) -> str:
+    """Generate calculating estimate: {e}"
+
+def update_default_prompt(enable_search: bool) -> str:
+    """ default system prompt"""
+    return "You are aGenerate default system prompt"""
+    return "You are a helpful assistant."
+
 # ------------------------------
-# Gradio UI
+# Gradio UI (unchanged)
+# ------------------------------
+with gr helpful assistant."
+
+# ------------------------------
+# Gradio UI (unchanged)
 # ------------------------------
 with gr.Blocks(
+.Blocks(
     title="LLM Inference",
+    theme=gr.themes.Soft(
+        primary_hue="blue",
+        secondary_hue="blue",
+        neutral_hue="slate",
+        radius    title="LLM Inference",
     theme=gr.themes.Soft(
         primary_hue="blue",
         secondary_hue="blue",
         neutral_hue="slate",
         radius_size="lg",
+        font=[gr_size="lg",
         font=[gr.themes.GoogleFont("Syne"), "Arial", "sans-serif"]
     ),
     css="""
-        .duration-estimate { background: linear-gradient(135deg, #667eea15 0%, #764ba215 100%); border-left: 4px solid #667eea; padding: 12px; border-radius: 8px; margin: 16px 0; }
-        .chatbot { border-radius: 12px; box-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.1); }
-        button.primary { font-weight: 600; }
+       .themes.GoogleFont("Syne"), "Arial", "sans-serif"]
+    ),
+    css="""
+ .duration-estimate { background: linear-gradient(135deg, #667eea15         .duration-estimate { background: linear-gradient(135deg, #667eea15 0%, #0%, #764ba215 100%); border-left: 4764ba215 px solid #667eea; padding: 12px; border-radius:100%); border-left: 4px solid #667eea; padding: 12px; border-radius: 8px; margin: 16px 0; }
+        . 8px; margin: 16px 0; }
+        .chatbot { border-radius: 12px; box-shadow: 0 4px 6px -chatbot { border-radius: 12px; box-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.1); }
+        button.primary {1px rgba(0, 0, 0, 0.1); }
+        button.primary { font font-weight: 600; }
+        .gradio-accordion { margin-bottom: 12px; }
+    """
+-weight: 600; }
         .gradio-accordion { margin-bottom: 12px; }
     """
 ) as demo:
+    # Header
+    gr.Markdown("") as demo:
     # Header
     gr.Markdown("""
     # 🧠 LLM Inference with Multi-Engine Search
@@ -495,67 +835,138 @@ with gr.Blocks(
     
     with gr.Row():
         # Left Panel - Configuration
-        with gr.Column(scale=3):
+        with gr.Column(scale"
+    # 🧠 LLM Inference with Multi-Engine Search
+    """)
+    
+    with gr.Row():
+        # Left Panel - Configuration
+        with gr.Column(=3):
             # Core Settings (Always Visible)
             with gr.Group():
-                gr.Markdown("### ⚙️ Core Settings")
-                model_dd = gr.Dropdown(
+                gr.Markdown("scale=3):
+            # Core Settings (Always Visible)
+            with gr.Group():
+                gr.Markdown### ⚙️ Core Settings")
+                model_dd = gr.D("### ⚙️ Core Settings")
+                model_dd = grropdown(
+                    label="🤖 Model",
+                    choices=list(MODELS.keys()),
+                    value="Qwen3.Dropdown(
                     label="🤖 Model",
                     choices=list(MODELS.keys()),
                     value="Qwen3-1.7B",
                     info="Select the language model to use"
                 )
+                search_chk = gr.Check-1.7B",
+                    info="Select the language model to use"
+                )
                 search_chk = gr.Checkbox(
                     label="🔍 Enable Web Search",
                     value=False,
-                    info="Search across Google, DuckDuckGo, and Bing (no API required)"
+                    info="Search across Googlebox(
+                    label="🔍 Enable Web Search",
+                    value=False,
+                    info="Search across Google,, DuckDuckGo, and Bing (no API required)"
                 )
                 sys_prompt = gr.Textbox(label="📝 System Prompt", lines=3, value=update_default_prompt(False), placeholder="Define the assistant's behavior and personality...")
             
-            # Duration Estimate
+            # DuckDuckGo, and Bing (no API required)"
+                )
+                sys_prompt = gr.Textbox(label="📝 System Prompt", lines=3, value=update_default_prompt(False), placeholder="Define the assistant's behavior and personality...")
+            
+ Duration Estimate
+            duration_display = gr.Markdown(
+                value=update_duration_estimate("Qwen3-1.            # Duration Estimate
             duration_display = gr.Markdown(
-                value=update_duration_estimate("Qwen3-1.7B", False, 4, 50, 1024, 5.0),
+                value=update_duration_estimate("Qwen3-1.7B", False7B", False, 4, 50, 1024, 5.0),
+                elem_classes="duration-est, 4, 50, 1024, 5.0),
                 elem_classes="duration-estimate"
+           imate"
             )
             
             # Advanced Settings (Collapsible)
             with gr.Accordion("🎛️ Advanced Generation Parameters", open=False):
+ )
+            
+            # Advanced Settings (Collapsible)
+            with gr.Accordion("🎛️ Advanced Generation                max_tok = gr.Slider(
+                    64, 16384, value=1024, step=32,
+                    label="Max Tok Parameters", open=False):
                 max_tok = gr.Slider(
                     64, 16384, value=1024, step=32,
                     label="Max Tokens",
+                    infoens",
                     info="Maximum length of generated response"
                 )
+                temp = gr.Slider(
+                    0.1, ="Maximum length of generated response"
+                )
                 temp = gr.Slider(
                     0.1, 2.0, value=0.7, step=0.1,
+                    label="Temperature2.0, value=0.7, step=0.1,
                     label="Temperature",
                     info="Higher = more creative, Lower = more focused"
                 )
+",
+                    info="Higher = more creative, Lower = more focused"
+                )
                 with gr.Row():
                     k = gr.Slider(
-                        1, 100, value=40, step=1,
+                        1, 100, value=40, step=1                with gr.Row():
+                    k = gr.Slider(
+                        1, 100, value=40,
+                        label="Top-K",
+                        info="Number of top tokens to consider"
+                    )
+                    p = gr.Slider, step=1,
                         label="Top-K",
                         info="Number of top tokens to consider"
                     )
                     p = gr.Slider(
+                        (
                         0.1, 1.0, value=0.9, step=0.05,
                         label="Top-P",
                         info="Nucleus sampling threshold"
                     )
+                rp = gr.S0.1, 1.0, value=0.9, step=0.05,
+                        label="Top-P",
+                        info="Nucleus sampling threshold"
+                    )
                 rp = gr.Slider(
-                    1.0, 2.0, value=1.2, step=0.1,
+                    lider(
+                    1.0,1.0, 2.0, value=1.2, step=0.1,
+                    label="Repetition Penalty",
+                    info="Penalize 2.0, value=1.2, step=0.1,
                     label="Repetition Penalty",
-                    info="Penalize repeated tokens"
+                    info repeated tokens"
+                )
+            
+            # Web Search Settings (Collapsible)
+            with gr.Accordion("🌐 Web Search Settings", open=False,="Penalize repeated tokens"
                 )
             
             # Web Search Settings (Collapsible)
             with gr.Accordion("🌐 Web Search Settings", open=False, visible=False) as search_settings:
+                mr = gr.Number(
+                    value=4, precision=0,
+                    label="Max Results",
+                    info="Number of visible=False) as search_settings:
                 mr = gr.Number(
                     value=4, precision=0,
                     label="Max Results",
                     info="Number of search results to retrieve"
                 )
                 mc = gr.Number(
-                    value=50, precision=0,
+                    value=50, precision search results to retrieve"
+                )
+                mc = gr.Number(
+                    value=50, precision==0,
+                    label="Max Chars/Result",
+                    info="Character limit per search result"
+                )
+                st = gr.Slider(
+                    minimum=0.0, maximum=30.0, step=0.50,
                     label="Max Chars/Result",
                     info="Character limit per search result"
                 )
@@ -565,11 +976,26 @@ with gr.Blocks(
                     info="Maximum time to wait for search results"
                 )
                 gr.Markdown("""
-                ⚠️ **Search Engines:**
+               , value=5.0,
+                    label="Search Timeout (s)",
+                    info="Maximum time to wait for search results"
+                )
+                gr.Markdown("" ⚠️ **Search Engines:**
                 - Google (primary)
                 - DuckDuckGo (fallback)
                 - Bing (fallback)
                 
+"
+                ⚠️ **Search Engines:**
+                - Google (primary)
+                - DuckDuckGo (fallback)
+                - Bing (                SafeSearch is **OFF** for comprehensive results.
+                """)
+            
+            # Actions
+            with gr.Row():
+                clr = gr.Button("🗑️ Clearfallback)
+                
                 SafeSearch is **OFF** for comprehensive results.
                 """)
             
@@ -579,15 +1005,29 @@ with gr.Blocks(
         
         # Right Panel - Chat Interface
         with gr.Column(scale=7):
-            chat = gr.Chatbot(
+            chat = Chat", variant="secondary", scale=1)
+        
+        # Right Panel - Chat Interface
+        with gr.Column(scale=7):
+ gr.Chatbot(
+                type="messages",
+                height=600,
+                label="💬 Conversation",
+                show            chat = gr.Chatbot(
                 type="messages",
                 height=600,
                 label="💬 Conversation",
                 show_copy_button=True,
+_copy_button=True,
                 avatar_images=(
-                    "data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='40' height='40'%3E%3Crect width='40' height='40' rx='20' fill='%23f093fb'/%3E%3Ctext x='20' y='28' text-anchor='middle' font-size='20' fill='white' font-family='Arial'%3E👤%3C/text%3E%3C/svg%3E",
-                    "data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='40' height='40'%3E%3Crect width='40' height='40' rx='20' fill='%23667eea'/%3E%3Ctext x='20' y='28' text-anchor='middle' font-size='20' fill='white' font-family='Arial'%3E🤖%3C/text%3E%3C/svg%3E"
+                    "data:image                avatar_images=(
+                    "data:image/svg+xml,%3/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='40' height='40Csvg xmlns='http://www.w3.org/2000/svg' width='40' height='40'%3E%3Crect width='40' height='40' rx='20' fill='%23f093fb'/%3E%3Ctext x'%3E%3Crect width='40' height='40' rx='20' fill='%23f093fb'/%3E%3Ctext x='20' y='28' text-anchor='middle' font-size='20' fill='='20' y='28' text-anchor='middle' font-size='20' fill='white' font-family='Arial'%3E👤%3C/text%3E%3C/swhite' font-family='Arial'%3E👤%3C/text%3E%3C/svg%3E",
+                    "data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='40' height='40'vg%3E",
+                    "data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='40' height='40'%3E%3Crect width='40' height='40' rx='20' fill='%23667eea'/%3E%3Ctext x='20' y='28' text-anchor='middle' font-size='20' fill='white' font-family='Arial'%%3E%3Crect width='40' height='40' rx='20' fill='%23667eea'/%3E%3Ctext x='20' y='28' text-anchor='middle' font-size='20' fill='white' font-family='3E🤖%3C/text%3E%3C/svg%3E"
                 ),
+Arial'%3E🤖%3C/text%3E%3C/svg%3E"
+                ),
+                bubble_full_width=False,
                 bubble_full_width=False,
                 render_markdown=True,
                 sanitize_html=False
@@ -595,56 +1035,115 @@ with gr.Blocks(
             
             # Input Area
             with gr.Row():
+                               render_markdown=True,
+                sanitize_html=False
+            )
+            
+            # Input Area
+            with gr txt = gr.Textbox(
+                    placeholder="💭 Type your message here... (Press Enter to.Row():
                 txt = gr.Textbox(
                     placeholder="💭 Type your message here... (Press Enter to send)",
+                    send)",
                     scale=9,
                     container=False,
                     show_label=False,
                     lines=1,
-                    max_lines=5
+                    max scale=9,
+                    container=False,
+                    show_label=False,
+                    lines=1,
+                    max_lines=5_lines=5
+                )
+                with gr.Column(scale=1, min_width=120):
+                    submit_btn
                 )
                 with gr.Column(scale=1, min_width=120):
                     submit_btn = gr.Button("📤 Send", variant="primary", size="lg")
-                    cancel_btn = gr.Button("⏹️ Stop", variant="stop", visible=False, size="lg")
+                    cancel_btn = gr.Button("⏹️ Stop", variant=" = gr.Button("📤 Send", variant="primary", size="lg")
+                    cancel_btn = gr.Button("⏹️stop", visible=False, size="lg")
+            
+            # Example Prompts
+            gr.Examples(
+                Stop", variant="stop", visible=False, size="lg")
             
             # Example Prompts
             gr.Examples(
                 examples=[
+                    ["Explain examples=[
                     ["Explain quantum computing in simple terms"],
                     ["Write a Python function to calculate fibonacci numbers"],
-                    ["What are the latest developments in AI? (Enable web search)"],
+                    ["What are the latest developments in AI quantum computing in simple terms"],
+                    ["Write a Python function to calculate fibonacci numbers"],
+                    ["? (Enable web search)"],
+                    ["Tell me a creative story about a time traveler"],
+                    ["Help me debug this code: def add(a,bWhat are the latest developments in AI? (Enable web search)"],
                     ["Tell me a creative story about a time traveler"],
-                    ["Help me debug this code: def add(a,b): return a+b+1"]
+                    ["Help me debug this code: def add(a,b):): return a+b+1"]
+                ],
+                inputs=txt,
+                label="💡 Example Prom return a+b+1"]
                 ],
                 inputs=txt,
-                label="💡 Example Prompts"
+                label="pts"
+            )
+            
+            # Debug/Status Info (Collapsible)
+            with gr.Accordion("🔍 Debug Info", open=False):
+                dbg = gr💡 Example Prompts"
             )
             
             # Debug/Status Info (Collapsible)
             with gr.Accordion("🔍 Debug Info", open=False):
                 dbg = gr.Markdown()
     
+    # Footer.Markdown()
+    
     # Footer
     gr.Markdown("""
     ---
     💡 **Tips:** 
+    - Use **Advanced Parameters** to fine-tune creativity and response
+    gr.Markdown("""
+    ---
+    💡 **Tips:** 
     - Use **Advanced Parameters** to fine-tune creativity and response length
+ length
     - Enable **Web Search** for real-time information (uses multiple search engines)
+    - SafeSearch is **OFF** for comprehensive results    - Enable **Web Search** for real-time information (uses multiple search engines)
     - SafeSearch is **OFF** for comprehensive results
-    - Try different **models** for various tasks (reasoning, coding, general chat)
+    - Try different **
+    - Try different **models** for various tasks (reasonmodels** for various tasks (reasoning, coding, general chat)
     - Click the **Copy** button on responses to save them to your clipboard
-    """, elem_classes="footer")
+ing, coding, general chat)
+    - Click the **Copy** button on responses to save them to your clipboard
+    """, elem_classes="footer    """, elem_classes="footer")
+
+    # --- Event Listeners ---
+
+    # Group all inputs")
 
     # --- Event Listeners ---
 
-    # Group all inputs for cleaner event handling
+    # Group all for cleaner event handling
     chat_inputs = [txt, chat, sys_prompt, search_chk, mr, mc, model_dd, max_tok, temp, k, p, rp, st]
+    # Group inputs for cleaner event handling
+    chat_inputs = [txt, chat, sys_prompt, search_chk, mr, mc, model_dd, max_tok, temp, k, p, rp, st all UI components that can be updated.
+    ui_components = [chat, dbg, txt, submit_btn, cancel_btn]
     # Group all UI components that can be updated.
     ui_components = [chat, dbg, txt, submit_btn, cancel_btn]
 
+    def submit]
+
     def submit_and_manage_ui(user_msg, chat_history, *args):
         """
-        Orchestrator function that manages UI state and calls the backend chat function.
+        Orchestrator_and_manage_ui(user_msg, chat_history, *args):
+        """
+        Orchestrator function that manages UI function that manages UI state and calls the backend chat function.
+        """
+        if not user_msg.strip():
+            yield {}
+ state and calls the backend chat function.
         """
         if not user_msg.strip():
             yield {}
@@ -657,86 +1156,175 @@ with gr.Blocks(
             cancel_btn: gr.update(visible=True),
         }
 
+        cancelled =            return
+
+        # Update UI to "generating" state
+        yield {
+            txt: gr.update(value="", interactive=False),
+            submit_btn: gr.update(interactive=False),
+            cancel_btn: gr.update(visible=True),
+        }
+
         cancelled = False
         try:
             backend_args = [user_msg, chat_history] + list(args)
             for response_chunk in chat_response(*backend_args):
                 yield {
+                    chat False
+        try:
+            backend_args = [user_msg, chat_history] + list(args)
+            for response_chunk in chat_response(*backend_args):
+                yield: response_chunk[0],
+                    dbg: response_chunk[1],
+                }
+        except GeneratorExit:
+            cancelled = True
+            print("Generation {
                     chat: response_chunk[0],
                     dbg: response_chunk[1],
                 }
         except GeneratorExit:
             cancelled = True
-            print("Generation cancelled by user.")
+ cancelled by user.")
+            raise
+        except Exception as e:
+            print(f"An error occurred during generation: {            print("Generation cancelled by user.")
             raise
         except Exception as e:
             print(f"An error occurred during generation: {e}")
+e}")
             error_history = (chat_history or []) + [
                 {'role': 'user', 'content': user_msg},
-                {'role': 'assistant', 'content': f"**An error occurred:** {str(e)}"}
+                           error_history = (chat_history or []) + [
+                {'role': 'user', 'content': {'role': 'assistant', 'content': f"**An error occurred:** {str user_msg},
+                {'role': 'assistant', 'content': f"(e)}"}
+            ]
+            yield {chat: error_history}
+        finally:
+            if not cancelled:
+                print("**An error occurred:** {str(e)}"}
             ]
             yield {chat: error_history}
         finally:
             if not cancelled:
                 print("Resetting UI state.")
+                yield {
+                    txt: gr.update(interactive=True),
+                    submit_btn: gr.update(interactive=True),
+                   Resetting UI state.")
                 yield {
                     txt: gr.update(interactive=True),
                     submit_btn: gr.update(interactive=True),
                     cancel_btn: gr.update(visible=False),
                 }
 
+    def set_cancel_flag():
+        """Called by the cancel button, cancel_btn: gr.update(visible=False),
+                }
+
     def set_cancel_flag():
         """Called by the cancel button, sets the global event."""
         cancel_event.set()
         print("Cancellation signal sent.")
     
+    def reset_ui_after sets the global event."""
+        cancel_event.set()
+        print("Cancellation signal sent.")
+    
     def reset_ui_after_cancel():
+_cancel():
         """Reset UI components after cancellation."""
         cancel_event.clear()
         print("UI reset after cancellation.")
+        return {
+            txt: gr.update        """Reset UI components after cancellation."""
+        cancel_event.clear()
+        print("UI reset after cancellation.")
         return {
             txt: gr.update(interactive=True),
+            submit_btn: gr.update(interactive=True(interactive=True),
             submit_btn: gr.update(interactive=True),
             cancel_btn: gr.update(visible=False),
         }
 
+    # Event for submitting text via Enter key or Submit button
+    submit),
+            cancel_btn: gr.update(visible=False),
+        }
+
     # Event for submitting text via Enter key or Submit button
     submit_event = txt.submit(
+        fn=submit_and_event = txt.submit(
         fn=submit_and_manage_ui,
         inputs=chat_inputs,
         outputs=ui_components,
     )
-    submit_btn.click(
+_manage_ui,
+        inputs=chat_inputs,
+        outputs=ui_components,
+    )
+    submit_    submit_btn.click(
+        fn=submit_and_manage_ui,
+        inputs=chat_inputs,
+        outputs=ui_components,
+   btn.click(
         fn=submit_and_manage_ui,
         inputs=chat_inputs,
         outputs=ui_components,
     )
 
+    # Event )
+
     # Event for the "Cancel" button.
     cancel_btn.click(
         fn=set_cancel_flag,
         cancels=[submit_event]
     ).then(
-        fn=reset_ui_after_cancel,
+        fn=reset for the "Cancel" button.
+    cancel_btn.click(
+        fn=set_cancel_flag,
+        cancels=[submit_event]
+    ).then(
+        fn=reset_ui__ui_after_cancel,
+        outputs=ui_components
+    )
+
+    # Listeners forafter_cancel,
         outputs=ui_components
     )
 
     # Listeners for updating the duration estimate
+    duration updating the duration estimate
     duration_inputs = [model_dd, search_chk, mr, mc, max_tok, st]
+    for component in duration_inputs:
+        component_inputs = [model_dd, search_chk, mr, mc, max_tok, st]
     for component in duration_inputs:
         component.change(fn=update_duration_estimate, inputs=duration_inputs, outputs=duration_display)
 
+    # Toggle web search settings visibility
+    def toggle_search.change(fn=update_duration_estimate, inputs=duration_inputs, outputs=duration_display)
+
     # Toggle web search settings visibility
     def toggle_search_settings(enabled):
+       _settings(enabled):
         return gr.update(visible=enabled)
     
+    search_chk.change(
+        fn=lambda enabled: (update_default_prompt(enabled), gr.update return gr.update(visible=enabled)
+    
     search_chk.change(
         fn=lambda enabled: (update_default_prompt(enabled), gr.update(visible=enabled)),
         inputs=search_chk,
         outputs=[sys_prompt, search_settings]
     )
     
-    # Clear chat action
+    # Clear chat(visible=enabled)),
+        inputs=search_chk,
+        outputs=[sys_prompt, search_settings]
+    )
+    
+    # Clear chat action action
+    clr.click(fn=lambda: ([], "", ""), outputs=[chat, txt
     clr.click(fn=lambda: ([], "", ""), outputs=[chat, txt, dbg])
     
     demo.launch(share=True)