Update main.py

main.py

@@ -1,16 +1,18 @@
 """
-AI-Powered Search API — Perplexity-style
+Synthex AI Search API — Perplexity-style
 Built on SearXNG + LemonData (doubao-1.5-lite-32k)
 ---------------------------------------
 Endpoints:
-  GET  /                      - Welcome + API info
-  GET  /health                - Health check
-  GET  /search                - Raw SearXNG results
-  GET  /search/{engine}       - Raw results from a specific engine
-  GET  /ai/search             - AI-summarized search (any/specific engine)
-  GET  /ai/search/{engine}    - AI search pinned to one engine
-  POST /ai/ask                - Q&A grounded in live web results
-  GET  /ai/news               - AI news briefing
+  GET  /                        - Welcome + API info
+  GET  /health                  - Health check
+  GET  /search                  - Raw SearXNG results (any/specific engine)
+  GET  /search/{engine}         - Raw results from a specific engine
+  GET  /ai/search               - AI-summarized search (any/specific engine)
+  GET  /ai/search/{engine}      - AI search pinned to one engine
+  POST /ai/ask                  - Q&A grounded in live web results
+  GET  /ai/news                 - AI news briefing
+  GET  /ai/videos               - AI-summarized YouTube/video search
+  GET  /ai/code                 - AI-summarized GitHub code search
 """
 
 import os
@@ -21,7 +23,7 @@ from fastapi import FastAPI, Query, HTTPException, Depends, Path
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.security import APIKeyHeader
 from pydantic import BaseModel
-from typing import Optional, Literal
+from typing import Optional
 
 # ─────────────────────────────────────────────
 # Config
@@ -36,17 +38,28 @@ AI_MODEL = "doubao-1.5-lite-32k"
 API_KEY = os.getenv("SEARCH_API_KEY", "")
 API_KEY_HEADER = APIKeyHeader(name="X-API-Key", auto_error=False)
 
+# All engines supported in settings.yml
 SUPPORTED_ENGINES = [
-    "google", "bing", "duckduckgo", "wikipedia",
-    "github", "youtube", "reddit", "twitter",
-    "brave", "yahoo", "startpage"
+    "google", "bing", "duckduckgo", "brave",
+    "wikipedia", "github", "github code",
+    "youtube", "reddit", "yahoo", "startpage", "dailymotion"
 ]
 
+# Maps engine name → correct SearXNG category
+# If engine not in this map, defaults to "general"
+ENGINE_CATEGORIES = {
+    "youtube":      "videos",
+    "dailymotion":  "videos",
+    "github code":  "it",
+    "reddit":       "social media",
+    "wikipedia":    "general",
+}
+
 # ─────────────────────────────────────────────
 # Clients
 # ─────────────────────────────────────────────
 
-ai = OpenAI(api_key=LEMON_API_KEY, base_url=LEMON_BASE_URL)
+ai_client = OpenAI(api_key=LEMON_API_KEY, base_url=LEMON_BASE_URL)
 
 app = FastAPI(
     title="Synthex AI Search API",
@@ -57,15 +70,19 @@ Privacy-respecting search powered by **SearXNG** + **AI summarization**.
 
 ### Features
 - 🤖 AI-powered summaries grounded in real-time web results
-- 🔎 Choose any search engine: Google, Bing, DuckDuckGo, Reddit, YouTube & more
+- 🔎 Multi-engine: Google, Bing, DuckDuckGo, Brave, Reddit, YouTube, GitHub & more
+- 📹 Native YouTube video search with AI summaries
+- 💻 GitHub code search with AI explanations
 - 📰 AI news briefings on any topic
 - ❓ Ask questions, get answers with sources
 - 🔒 No tracking, no profiling
 
 ### Engine shortcuts
-Use `/search/google`, `/search/bing`, `/ai/search/reddit` etc. to pin to a specific engine.
+Use `/search/google`, `/search/youtube`, `/ai/search/reddit` etc. to pin to a specific engine.
+Use `/ai/videos` for YouTube-first video search.
+Use `/ai/code` for GitHub code search.
     """,
-    version="2.0.0",
+    version="3.0.0",
     docs_url="/docs",
     redoc_url="/redoc",
 )
@@ -84,7 +101,10 @@ app.add_middleware(
 
 async def verify_api_key(api_key: str = Depends(API_KEY_HEADER)):
     if API_KEY and api_key != API_KEY:
-        raise HTTPException(status_code=403, detail="Invalid or missing API key. Pass it as X-API-Key header.")
+        raise HTTPException(
+            status_code=403,
+            detail="Invalid or missing API key. Pass it as X-API-Key header."
+        )
     return api_key
 
 # ─────────────────────────────────────────────
@@ -96,15 +116,18 @@ class SearchResult(BaseModel):
     url: str
     snippet: str
     engine: Optional[str] = None
+    thumbnail: Optional[str] = None   # for video results
+    duration: Optional[str] = None    # for video results
 
 class Latency(BaseModel):
-    search_ms: float        # time to fetch from SearXNG
-    ai_ms: Optional[float]  # time for AI summarization (None for raw endpoints)
-    total_ms: float         # end-to-end total
+    search_ms: float
+    ai_ms: Optional[float] = None
+    total_ms: float
 
 class RawSearchResponse(BaseModel):
     query: str
     engine_used: str
+    category: str
     total_results: int
     results: list[SearchResult]
     latency: Latency
@@ -112,6 +135,7 @@ class RawSearchResponse(BaseModel):
 class AISearchResponse(BaseModel):
     query: str
     engine_used: str
+    category: str
     summary: str
     key_points: list[str]
     sources: list[SearchResult]
@@ -137,10 +161,33 @@ class NewsResponse(BaseModel):
     articles: list[SearchResult]
     latency: Latency
 
+class VideoResponse(BaseModel):
+    query: str
+    summary: str
+    videos: list[SearchResult]
+    latency: Latency
+
+class CodeResponse(BaseModel):
+    query: str
+    summary: str
+    results: list[SearchResult]
+    latency: Latency
+
 # ─────────────────────────────────────────────
 # Core helpers
 # ─────────────────────────────────────────────
 
+def resolve_category(engines: Optional[str], override_category: Optional[str] = None) -> str:
+    """Pick the right SearXNG category for the given engine(s)."""
+    if override_category:
+        return override_category
+    if engines and engines != "all":
+        # Use the first engine in the list to determine category
+        first = engines.split(",")[0].strip().lower()
+        return ENGINE_CATEGORIES.get(first, "general")
+    return "general"
+
+
 async def fetch_searxng(
     query: str,
     num_results: int = 5,
@@ -149,8 +196,8 @@ async def fetch_searxng(
     time_range: Optional[str] = None,
     engines: Optional[str] = None,
 ) -> tuple[list[SearchResult], float]:
-    """Returns (results, search_ms)"""
-    params = {
+    """Fetch results from SearXNG. Returns (results, search_ms)."""
+    params: dict = {
         "q": query,
         "format": "json",
         "language": language,
@@ -162,22 +209,24 @@ async def fetch_searxng(
         params["engines"] = engines
 
     t0 = time.perf_counter()
-    async with httpx.AsyncClient(timeout=20) as client:
+    async with httpx.AsyncClient(timeout=25) as client:
         try:
             resp = await client.get(f"{SEARXNG_BASE_URL}/search", params=params)
             resp.raise_for_status()
         except httpx.HTTPError as e:
-            raise HTTPException(status_code=502, detail=f"SearXNG error: {str(e)}")
+            raise HTTPException(status_code=502, detail=f"SearXNG unreachable: {str(e)}")
     search_ms = round((time.perf_counter() - t0) * 1000, 2)
 
     data = resp.json()
-    results = []
+    results: list[SearchResult] = []
     for item in data.get("results", [])[:num_results]:
         results.append(SearchResult(
             title=item.get("title", ""),
             url=item.get("url", ""),
-            snippet=item.get("content", ""),
+            snippet=item.get("content", "") or item.get("description", ""),
             engine=item.get("engine", engines or "mixed"),
+            thumbnail=item.get("thumbnail") or item.get("img_src"),
+            duration=item.get("length") or item.get("duration"),
         ))
     return results, search_ms
 
@@ -189,10 +238,10 @@ def build_context(results: list[SearchResult]) -> str:
     return "\n".join(lines)
 
 
-def ask_ai(prompt: str, max_tokens: int = 1500) -> tuple[str, float]:
-    """Returns (text, ai_ms)"""
+def ask_ai(prompt: str, max_tokens: int = 800) -> tuple[str, float]:
+    """Call LemonData AI. Returns (text, ai_ms)."""
     t0 = time.perf_counter()
-    response = ai.chat.completions.create(
+    response = ai_client.chat.completions.create(
         model=AI_MODEL,
         max_tokens=max_tokens,
         messages=[{"role": "user", "content": prompt}],
@@ -202,48 +251,67 @@ def ask_ai(prompt: str, max_tokens: int = 1500) -> tuple[str, float]:
 
 
 def parse_key_points(text: str) -> tuple[str, list[str]]:
-    """Extract KEY POINTS section from AI response if present."""
-    key_points = []
+    """Extract KEY POINTS section from AI response."""
+    key_points: list[str] = []
     summary = text
 
-    if "KEY POINTS:" in text or "**Key Points" in text:
-        parts = text.split("KEY POINTS:", 1) if "KEY POINTS:" in text else text.split("**Key Points", 1)
+    marker = None
+    if "KEY POINTS:" in text:
+        marker = "KEY POINTS:"
+    elif "**Key Points" in text:
+        marker = "**Key Points"
+
+    if marker:
+        parts = text.split(marker, 1)
         summary = parts[0].strip()
         if len(parts) > 1:
             for line in parts[1].strip().split("\n"):
-                line = line.strip().lstrip("-•*123456789. ")
+                line = line.strip().lstrip("-•*123456789. ").strip("*")
                 if line:
                     key_points.append(line)
 
     return summary, key_points
 
 # ─────────────────────────────────────────────
-# Root
+# Root / Health
 # ─────────────────────────────────────────────
 
 @app.get("/", tags=["Info"])
 async def root():
     return {
         "name": "Synthex AI Search API",
-        "version": "2.0.0",
+        "version": "3.0.0",
         "status": "running",
         "docs": "/docs",
         "supported_engines": SUPPORTED_ENGINES,
+        "engine_categories": ENGINE_CATEGORIES,
         "endpoints": {
-            "raw_search": "/search?q=query&engine=google",
-            "engine_search": "/search/{engine}?q=query",
-            "ai_search": "/ai/search?q=query&engine=bing",
-            "ai_engine_search": "/ai/search/{engine}?q=query",
-            "ai_ask": "POST /ai/ask",
-            "ai_news": "/ai/news?topic=AI&time_range=day",
+            "raw_search":       "GET  /search?q=query&engine=google",
+            "engine_search":    "GET  /search/{engine}?q=query",
+            "ai_search":        "GET  /ai/search?q=query&engine=brave",
+            "ai_engine_search": "GET  /ai/search/{engine}?q=query",
+            "ai_videos":        "GET  /ai/videos?q=query",
+            "ai_code":          "GET  /ai/code?q=query",
+            "ai_ask":           "POST /ai/ask",
+            "ai_news":          "GET  /ai/news?topic=AI&time_range=day",
         }
     }
 
+
 @app.get("/health", tags=["Info"])
 async def health():
+    # Ping SearXNG
+    searxng_status = "unreachable"
+    try:
+        async with httpx.AsyncClient(timeout=5) as client:
+            r = await client.get(f"{SEARXNG_BASE_URL}/")
+            searxng_status = "ok" if r.status_code == 200 else f"http_{r.status_code}"
+    except Exception:
+        pass
+
     return {
         "status": "ok",
-        "searxng": SEARXNG_BASE_URL,
+        "searxng": {"url": SEARXNG_BASE_URL, "status": searxng_status},
         "ai_model": AI_MODEL,
         "ai_provider": "LemonData (api.lemondata.cc)",
         "supported_engines": SUPPORTED_ENGINES,
@@ -253,201 +321,420 @@ async def health():
 # Raw Search Endpoints
 # ─────────────────────────────────────────────
 
-@app.get("/search", response_model=RawSearchResponse, tags=["Search"], dependencies=[Depends(verify_api_key)])
+@app.get(
+    "/search",
+    response_model=RawSearchResponse,
+    tags=["Raw Search"],
+    dependencies=[Depends(verify_api_key)],
+)
 async def raw_search(
     q: str = Query(..., description="Search query"),
-    engine: str = Query("all", description=f"Engine to use: all, or one of {SUPPORTED_ENGINES}"),
+    engine: str = Query("all", description=f"Engine: all, or one of {SUPPORTED_ENGINES}"),
     num_results: int = Query(5, ge=1, le=20),
     language: str = Query("en"),
+    time_range: Optional[str] = Query(None, description="day | week | month | year"),
 ):
-    """Raw search results — no AI. Optionally pin to a specific engine."""
+    """Raw search results — no AI. Auto-selects correct category per engine."""
     t0 = time.perf_counter()
-    results, search_ms = await fetch_searxng(q, num_results, language, engines=engine)
+    category = resolve_category(engine)
+    results, search_ms = await fetch_searxng(
+        q, num_results, language,
+        categories=category,
+        time_range=time_range,
+        engines=None if engine == "all" else engine,
+    )
     return RawSearchResponse(
         query=q,
         engine_used=engine,
+        category=category,
         total_results=len(results),
         results=results,
-        latency=Latency(search_ms=search_ms, ai_ms=None, total_ms=round((time.perf_counter()-t0)*1000,2)),
+        latency=Latency(
+            search_ms=search_ms,
+            total_ms=round((time.perf_counter() - t0) * 1000, 2)
+        ),
     )
 
 
-@app.get("/search/{engine}", response_model=RawSearchResponse, tags=["Search"], dependencies=[Depends(verify_api_key)])
+@app.get(
+    "/search/{engine}",
+    response_model=RawSearchResponse,
+    tags=["Raw Search"],
+    dependencies=[Depends(verify_api_key)],
+)
 async def raw_search_engine(
     engine: str = Path(..., description=f"Engine: {', '.join(SUPPORTED_ENGINES)}"),
     q: str = Query(..., description="Search query"),
     num_results: int = Query(5, ge=1, le=20),
     language: str = Query("en"),
+    time_range: Optional[str] = Query(None, description="day | week | month | year"),
 ):
-    """Raw search pinned to a specific engine. e.g. /search/google?q=openai"""
+    """Raw search pinned to a specific engine. e.g. /search/youtube?q=python tutorial"""
     if engine not in SUPPORTED_ENGINES:
-        raise HTTPException(status_code=400, detail=f"Unsupported engine '{engine}'. Choose from: {SUPPORTED_ENGINES}")
+        raise HTTPException(
+            status_code=400,
+            detail=f"Unsupported engine '{engine}'. Supported: {SUPPORTED_ENGINES}"
+        )
     t0 = time.perf_counter()
-    results, search_ms = await fetch_searxng(q, num_results, language, engines=engine)
+    category = resolve_category(engine)
+    results, search_ms = await fetch_searxng(
+        q, num_results, language,
+        categories=category,
+        time_range=time_range,
+        engines=engine,
+    )
     return RawSearchResponse(
         query=q,
         engine_used=engine,
+        category=category,
         total_results=len(results),
         results=results,
-        latency=Latency(search_ms=search_ms, ai_ms=None, total_ms=round((time.perf_counter()-t0)*1000,2)),
+        latency=Latency(
+            search_ms=search_ms,
+            total_ms=round((time.perf_counter() - t0) * 1000, 2)
+        ),
     )
 
 # ─────────────────────────────────────────────
 # AI Search Endpoints
 # ─────────────────────────────────────────────
 
-@app.get("/ai/search", response_model=AISearchResponse, tags=["AI Search"], dependencies=[Depends(verify_api_key)])
+@app.get(
+    "/ai/search",
+    response_model=AISearchResponse,
+    tags=["AI Search"],
+    dependencies=[Depends(verify_api_key)],
+)
 async def ai_search(
     q: str = Query(..., description="Search query"),
     engine: str = Query("all", description=f"Engine: all, or one of {SUPPORTED_ENGINES}"),
     num_results: int = Query(5, ge=1, le=10),
     language: str = Query("en"),
+    time_range: Optional[str] = Query(None, description="day | week | month | year"),
 ):
-    """
-    AI-enhanced search with deep summary, key points, and source citations.
-    Optionally pin to a specific search engine.
-    """
+    """AI-enhanced search: deep summary + key points + sources. Auto-routes engine category."""
     t0 = time.perf_counter()
-    results, search_ms = await fetch_searxng(q, num_results, language, engines=engine)
+    category = resolve_category(engine)
+    results, search_ms = await fetch_searxng(
+        q, num_results, language,
+        categories=category,
+        time_range=time_range,
+        engines=None if engine == "all" else engine,
+    )
     if not results:
         raise HTTPException(status_code=404, detail="No results found.")
 
     context = build_context(results)
+    engine_label = engine.upper() if engine != "all" else "web"
     raw, ai_ms = ask_ai(
-        f"You are a Perplexity-style AI search assistant. A user searched for: '{q}'\n\n"
-        f"Based on these search results, provide:\n"
-        f"1. A concise summary (3-4 sentences) covering the most important information.\n"
-        f"2. Then write 'KEY POINTS:' followed by 3-5 bullet points of the most critical facts.\n\n"
-        f"Be specific, factual, and cite source numbers like [1], [2] inline.\n\n"
+        f"You are a Perplexity-style AI search assistant using {engine_label} results.\n"
+        f"User searched: '{q}'\n\n"
+        f"Provide:\n"
+        f"1. A concise summary (3-4 sentences) with the most important information.\n"
+        f"2. Then write exactly 'KEY POINTS:' on a new line, followed by 3-5 bullet points.\n\n"
+        f"Be specific and factual. Cite source numbers like [1], [2] inline.\n\n"
         f"Search Results:\n{context}",
-        max_tokens=600,
     )
-
     summary, key_points = parse_key_points(raw)
-    total_ms = round((time.perf_counter()-t0)*1000, 2)
     return AISearchResponse(
         query=q,
         engine_used=engine,
+        category=category,
         summary=summary,
         key_points=key_points,
         sources=results,
-        latency=Latency(search_ms=search_ms, ai_ms=ai_ms, total_ms=total_ms),
+        latency=Latency(
+            search_ms=search_ms,
+            ai_ms=ai_ms,
+            total_ms=round((time.perf_counter() - t0) * 1000, 2)
+        ),
     )
 
 
-@app.get("/ai/search/{engine}", response_model=AISearchResponse, tags=["AI Search"], dependencies=[Depends(verify_api_key)])
+@app.get(
+    "/ai/search/{engine}",
+    response_model=AISearchResponse,
+    tags=["AI Search"],
+    dependencies=[Depends(verify_api_key)],
+)
 async def ai_search_engine(
     engine: str = Path(..., description=f"Engine: {', '.join(SUPPORTED_ENGINES)}"),
     q: str = Query(..., description="Search query"),
     num_results: int = Query(5, ge=1, le=10),
     language: str = Query("en"),
+    time_range: Optional[str] = Query(None, description="day | week | month | year"),
 ):
-    """AI search pinned to a specific engine. e.g. /ai/search/reddit?q=best laptop 2025"""
+    """AI search pinned to one engine. e.g. /ai/search/brave?q=best python frameworks"""
     if engine not in SUPPORTED_ENGINES:
-        raise HTTPException(status_code=400, detail=f"Unsupported engine '{engine}'. Choose from: {SUPPORTED_ENGINES}")
-
+        raise HTTPException(
+            status_code=400,
+            detail=f"Unsupported engine '{engine}'. Supported: {SUPPORTED_ENGINES}"
+        )
     t0 = time.perf_counter()
-    results, search_ms = await fetch_searxng(q, num_results, language, engines=engine)
+    category = resolve_category(engine)
+    results, search_ms = await fetch_searxng(
+        q, num_results, language,
+        categories=category,
+        time_range=time_range,
+        engines=engine,
+    )
     if not results:
-        raise HTTPException(status_code=404, detail=f"No results found from {engine}.")
+        raise HTTPException(status_code=404, detail=f"No results from {engine}.")
 
     context = build_context(results)
     raw, ai_ms = ask_ai(
-        f"You are a Perplexity-style AI search assistant using {engine.upper()} results. "
-        f"A user searched for: '{q}'\n\n"
-        f"Based on these {engine} search results, provide:\n"
+        f"You are a Perplexity-style AI search assistant using {engine.upper()} results.\n"
+        f"User searched: '{q}'\n\n"
+        f"Provide:\n"
         f"1. A thorough summary (3-4 sentences) with the most important information.\n"
-        f"2. Then write 'KEY POINTS:' followed by 3-5 bullet points of critical facts.\n\n"
-        f"Be specific, cite source numbers like [1], [2] inline.\n\n"
+        f"2. Then write exactly 'KEY POINTS:' on a new line, followed by 3-5 bullet points.\n\n"
+        f"Be specific and factual. Cite source numbers like [1], [2] inline.\n\n"
         f"Search Results:\n{context}",
-        max_tokens=600,
     )
-
     summary, key_points = parse_key_points(raw)
-    total_ms = round((time.perf_counter()-t0)*1000, 2)
     return AISearchResponse(
         query=q,
         engine_used=engine,
+        category=category,
         summary=summary,
         key_points=key_points,
         sources=results,
-        latency=Latency(search_ms=search_ms, ai_ms=ai_ms, total_ms=total_ms),
+        latency=Latency(
+            search_ms=search_ms,
+            ai_ms=ai_ms,
+            total_ms=round((time.perf_counter() - t0) * 1000, 2)
+        ),
+    )
+
+# ─────────────────────────────────────────────
+# AI Videos (YouTube-first)
+# ─────────────────────────────────────────────
+
+@app.get(
+    "/ai/videos",
+    response_model=VideoResponse,
+    tags=["AI Search"],
+    dependencies=[Depends(verify_api_key)],
+)
+async def ai_videos(
+    q: str = Query(..., description="Video search query"),
+    num_results: int = Query(5, ge=1, le=10),
+    time_range: Optional[str] = Query(None, description="day | week | month | year"),
+):
+    """
+    YouTube-first video search with AI summary.
+    Returns video titles, URLs, thumbnails, and durations where available.
+    """
+    t0 = time.perf_counter()
+
+    # Try YouTube first
+    results, search_ms = await fetch_searxng(
+        q, num_results,
+        categories="videos",
+        time_range=time_range,
+        engines="youtube",
+    )
+
+    # Fallback: search all video engines if YouTube returned nothing
+    if not results:
+        results, search_ms = await fetch_searxng(
+            q, num_results,
+            categories="videos",
+            time_range=time_range,
+        )
+
+    if not results:
+        raise HTTPException(status_code=404, detail="No video results found.")
+
+    context = build_context(results)
+    summary, ai_ms = ask_ai(
+        f"You are a helpful video search assistant.\n"
+        f"The user searched for videos about: '{q}'\n\n"
+        f"Based on these YouTube/video results, write a 2-3 sentence summary of what these videos cover "
+        f"and which ones look most useful. Mention video titles by name.\n\n"
+        f"Video Results:\n{context}",
+        max_tokens=400,
+    )
+    return VideoResponse(
+        query=q,
+        summary=summary,
+        videos=results,
+        latency=Latency(
+            search_ms=search_ms,
+            ai_ms=ai_ms,
+            total_ms=round((time.perf_counter() - t0) * 1000, 2)
+        ),
+    )
+
+# ─────────────────────────────────────────────
+# AI Code Search (GitHub-first)
+# ─────────────────────────────────────────────
+
+@app.get(
+    "/ai/code",
+    response_model=CodeResponse,
+    tags=["AI Search"],
+    dependencies=[Depends(verify_api_key)],
+)
+async def ai_code(
+    q: str = Query(..., description="Code / repo search query"),
+    num_results: int = Query(5, ge=1, le=10),
+):
+    """
+    GitHub Code search with AI explanation.
+    Great for finding repos, code snippets, and open-source projects.
+    """
+    t0 = time.perf_counter()
+    results, search_ms = await fetch_searxng(
+        q, num_results,
+        categories="it",
+        engines="github code",
+    )
+
+    # Fallback to github engine
+    if not results:
+        results, search_ms = await fetch_searxng(
+            q, num_results,
+            categories="it",
+            engines="github",
+        )
+
+    if not results:
+        raise HTTPException(status_code=404, detail="No code results found.")
+
+    context = build_context(results)
+    summary, ai_ms = ask_ai(
+        f"You are a developer-focused AI assistant.\n"
+        f"The user searched GitHub for: '{q}'\n\n"
+        f"Based on these GitHub results, write a 2-3 sentence summary covering what repos/code "
+        f"are available and which look most relevant. Mention repo names specifically.\n\n"
+        f"GitHub Results:\n{context}",
+        max_tokens=400,
+    )
+    return CodeResponse(
+        query=q,
+        summary=summary,
+        results=results,
+        latency=Latency(
+            search_ms=search_ms,
+            ai_ms=ai_ms,
+            total_ms=round((time.perf_counter() - t0) * 1000, 2)
+        ),
     )
 
 # ─────────────────────────────────────────────
 # AI Ask
 # ─────────────────────────────────────────────
 
-@app.post("/ai/ask", response_model=AskResponse, tags=["AI Search"], dependencies=[Depends(verify_api_key)])
+@app.post(
+    "/ai/ask",
+    response_model=AskResponse,
+    tags=["AI Search"],
+    dependencies=[Depends(verify_api_key)],
+)
 async def ai_ask(body: AskRequest):
     """
-    Ask any question — AI searches the web and answers with sources.
-    Optionally specify engine in the request body.
+    Ask any question — AI searches the web and answers with cited sources.
+    Specify engine in body to pin to a specific search provider.
     """
     engine = body.engine or "all"
     t0 = time.perf_counter()
-    results, search_ms = await fetch_searxng(body.question, body.num_results, body.language, engines=engine)
+    category = resolve_category(engine)
+    results, search_ms = await fetch_searxng(
+        body.question,
+        body.num_results or 5,
+        body.language or "en",
+        categories=category,
+        engines=None if engine == "all" else engine,
+    )
     if not results:
-        raise HTTPException(status_code=404, detail="No results found.")
+        raise HTTPException(status_code=404, detail="No results found for this question.")
 
     context = build_context(results)
     answer, ai_ms = ask_ai(
-        f"You are a helpful AI assistant. Answer this question using the search results below.\n"
+        f"You are a helpful AI assistant. Answer the question below using the web search results provided.\n"
         f"Be thorough, accurate, and helpful. Cite sources inline like [1], [2].\n"
-        f"If results don't fully answer the question, clearly say so.\n\n"
+        f"If results don't fully answer the question, clearly say what is and isn't covered.\n\n"
         f"Question: {body.question}\n\n"
         f"Search Results:\n{context}",
-        max_tokens=600,
+        max_tokens=800,
     )
-    total_ms = round((time.perf_counter()-t0)*1000, 2)
     return AskResponse(
         question=body.question,
         engine_used=engine,
         answer=answer,
         sources=results,
-        latency=Latency(search_ms=search_ms, ai_ms=ai_ms, total_ms=total_ms),
+        latency=Latency(
+            search_ms=search_ms,
+            ai_ms=ai_ms,
+            total_ms=round((time.perf_counter() - t0) * 1000, 2)
+        ),
     )
 
 # ─────────────────────────────────────────────
 # AI News
 # ─────────────────────────────────────────────
 
-@app.get("/ai/news", response_model=NewsResponse, tags=["AI Search"], dependencies=[Depends(verify_api_key)])
+@app.get(
+    "/ai/news",
+    response_model=NewsResponse,
+    tags=["AI Search"],
+    dependencies=[Depends(verify_api_key)],
+)
 async def ai_news(
-    topic: str = Query(..., description="News topic"),
+    topic: str = Query(..., description="News topic e.g. AI, crypto, sports"),
     time_range: str = Query("day", description="day | week | month"),
     engine: str = Query("all", description="Engine to use for news"),
     num_results: int = Query(5, ge=1, le=10),
 ):
-    """AI news briefing — latest news on any topic, AI-summarized."""
+    """AI news briefing — latest news on any topic, AI-summarized with sources."""
     t0 = time.perf_counter()
     results, search_ms = await fetch_searxng(
         query=f"{topic} news",
         num_results=num_results,
         categories="news",
         time_range=time_range,
-        engines=engine if engine != "all" else None,
+        engines=None if engine == "all" else engine,
     )
+
+    # Fallback if news category returns nothing
+    if not results:
+        results, search_ms = await fetch_searxng(
+            f"{topic} latest news",
+            num_results,
+            categories="general",
+            engines=None if engine == "all" else engine,
+        )
+
     if not results:
-        results, search_ms = await fetch_searxng(f"{topic} latest news", num_results, engines=engine if engine != "all" else None)
+        raise HTTPException(status_code=404, detail=f"No news found for topic: {topic}")
 
     context = build_context(results)
     summary, ai_ms = ask_ai(
-        f"You are a news briefing assistant. Summarize the latest news about '{topic}'.\n"
-        f"Write 3-4 sentences covering the most important developments.\n"
-        f"Be neutral, factual, and cite sources like [1], [2].\n\n"
-        f"Articles:\n{context}"
+        f"You are a neutral news briefing assistant.\n"
+        f"Summarize the latest news about '{topic}' in 3-4 sentences.\n"
+        f"Cover the most important developments. Be factual and balanced.\n"
+        f"Cite sources inline like [1], [2].\n\n"
+        f"Articles:\n{context}",
+        max_tokens=500,
     )
-    total_ms = round((time.perf_counter()-t0)*1000, 2)
     return NewsResponse(
         topic=topic,
         engine_used=engine,
         summary=summary,
         articles=results,
-        latency=Latency(search_ms=search_ms, ai_ms=ai_ms, total_ms=total_ms),
+        latency=Latency(
+            search_ms=search_ms,
+            ai_ms=ai_ms,
+            total_ms=round((time.perf_counter() - t0) * 1000, 2)
+        ),
     )
 
 
+# ─────────────────────────────────────────────
+# Entry point
+# ─────────────────────────────────────────────
+
 if __name__ == "__main__":
     import uvicorn
     uvicorn.run("main:app", host="0.0.0.0", port=7860, reload=True)