Web_Search: 4 new free search engine backends, new date filters, disabling safesearch by default

Modules/Web_Search.py

@@ -19,6 +19,80 @@ TOOL_SUMMARY = (
 
 _SAFESEARCH_LEVEL = "off"
 
+# Defaults and choices for newly added parameters
+BACKEND_CHOICES = [
+    "auto",
+    "duckduckgo",
+    "bing",
+    "brave",
+    "yahoo",
+    "wikipedia",
+]
+
+# Allowed backends per type (explicit selection set)
+_ALLOWED_BACKENDS = {
+    "text": ["duckduckgo", "bing", "brave", "yahoo", "wikipedia"],
+    "news": ["duckduckgo", "bing", "yahoo"],
+    "images": ["duckduckgo"],
+    "videos": ["duckduckgo"],
+    "books": ["annasarchive"],
+}
+
+# Auto order per type (used when backend == "auto"); wikipedia excluded for text
+_AUTO_ORDER = {
+    "text": ["duckduckgo", "bing", "brave", "yahoo"],
+    "news": ["duckduckgo", "bing", "yahoo"],
+    "images": ["duckduckgo"],
+    "videos": ["duckduckgo"],
+    "books": ["annasarchive"],
+}
+
+# Date filter choices: canonical values used by resolver
+DATE_FILTER_CHOICES = ["any", "day", "week", "month", "year"]
+
+
+def _resolve_backend(search_type: str, backend_choice: str) -> str:
+    """Resolve backend string for DDGS based on search type and user choice.
+
+    - If backend_choice is "auto", return a comma-separated fallback order for that type.
+    - If backend_choice is not supported by the type, fall back to the first allowed backend.
+    - Books endpoint uses only 'annasarchive'.
+    """
+    stype = search_type if search_type in _ALLOWED_BACKENDS else "text"
+    allowed = _ALLOWED_BACKENDS[stype]
+    if backend_choice == "auto":
+        return ", ".join(_AUTO_ORDER[stype])
+    if stype == "books":
+        return "annasarchive"
+    # Validate backend against allowed set for this type
+    if backend_choice in allowed:
+        return backend_choice
+    # Fallback to first allowed backend
+    return allowed[0]
+
+
+def _resolve_timelimit(date_filter: str, search_type: str) -> str | None:
+    """Map UI date filter to DDGS timelimit code per endpoint.
+
+    Returns one of: None, 'd', 'w', 'm', 'y'. For news/videos (which support d/w/m),
+    selecting 'year' will coerce to 'm' to stay within supported range.
+    """
+    normalized = (date_filter or "any").strip().lower()
+    if normalized in ("any", "none", ""):
+        return None
+    mapping = {
+        "day": "d",
+        "week": "w",
+        "month": "m",
+        "year": "y",
+    }
+    code = mapping.get(normalized)
+    if not code:
+        return None
+    if search_type in ("news", "videos") and code == "y":
+        return "m"
+    return code
+
 
 def _extract_date_from_snippet(snippet: str) -> str:
     if not snippet:
@@ -116,10 +190,21 @@ def Web_Search(
     query: Annotated[str, "The search query (supports operators like site:, quotes, OR)."],
     max_results: Annotated[int, "Number of results to return (1–20)."] = 5,
     page: Annotated[int, "Page number for pagination (1-based, each page contains max_results items)."] = 1,
-    search_type: Annotated[str, "Type of search: 'text' (web pages), 'news', 'images', 'videos', or 'books'."] = "text",
     offset: Annotated[int, "Result offset to start from (overrides page if > 0, for precise continuation)."] = 0,
+    search_type: Annotated[str, "Type of search: 'text' (web pages), 'news', 'images', 'videos', or 'books'."] = "text",
+    backend: Annotated[str, "Search backend or ordered fallbacks. Use 'auto' for recommended order."] = "auto",
+    date_filter: Annotated[str, "Time filter: any, day, week, month, year."] = "any",
 ) -> str:
-    _log_call_start("Web_Search", query=query, max_results=max_results, page=page, search_type=search_type, offset=offset)
+    _log_call_start(
+        "Web_Search",
+        query=query,
+        max_results=max_results,
+        page=page,
+        search_type=search_type,
+        offset=offset,
+        backend=backend,
+        date_filter=date_filter,
+    )
     if not query or not query.strip():
         result = "No search query provided. Please enter a search term."
         _log_call_end("Web_Search", _truncate_for_log(result))
@@ -139,21 +224,144 @@ def Web_Search(
     total_needed = actual_offset + max_results
     used_fallback = False
     original_search_type = search_type
+    # Prepare cross-cutting parameters
+    resolved_backend = _resolve_backend(search_type, (backend or "auto").lower())
+    timelimit = _resolve_timelimit(date_filter, search_type)
 
     def _perform_search(stype: str) -> list[dict]:
         try:
             _search_rate_limiter.acquire()
             with DDGS() as ddgs:
                 if stype == "text":
-                    raw_gen = ddgs.text(query, max_results=total_needed + 10, safesearch=_SAFESEARCH_LEVEL)
+                    user_backend_choice = (backend or "auto").lower()
+                    if user_backend_choice == "auto":
+                        # Custom auto: DDG first, then append other engines
+                        results: list[dict] = []
+                        seen: set[str] = set()
+
+                        def add_unique(items: list[dict], key_field: str) -> None:
+                            for it in items or []:
+                                url = (it.get(key_field, "") or "").strip()
+                                if url and url not in seen:
+                                    seen.add(url)
+                                    results.append(it)
+
+                        # First: duckduckgo
+                        try:
+                            ddg_items = list(
+                                ddgs.text(
+                                    query,
+                                    max_results=total_needed + 10,
+                                    safesearch=_SAFESEARCH_LEVEL,
+                                    timelimit=timelimit,
+                                    backend="duckduckgo",
+                                )
+                            )
+                        except Exception:
+                            ddg_items = []
+                        add_unique(ddg_items, "href")
+
+                        # Then: other engines appended (excluding duckduckgo)
+                        for eng in [b for b in _AUTO_ORDER["text"] if b != "duckduckgo"]:
+                            try:
+                                extra = list(
+                                    ddgs.text(
+                                        query,
+                                        max_results=total_needed + 10,
+                                        safesearch=_SAFESEARCH_LEVEL,
+                                        timelimit=timelimit,
+                                        backend=eng,
+                                    )
+                                )
+                            except Exception:
+                                extra = []
+                            add_unique(extra, "href")
+
+                        return results
+                    else:
+                        raw_gen = ddgs.text(
+                            query,
+                            max_results=total_needed + 10,
+                            safesearch=_SAFESEARCH_LEVEL,
+                            timelimit=timelimit,
+                            backend=resolved_backend,
+                        )
                 elif stype == "news":
-                    raw_gen = ddgs.news(query, max_results=total_needed + 10, safesearch=_SAFESEARCH_LEVEL)
+                    user_backend_choice = (backend or "auto").lower()
+                    if user_backend_choice == "auto":
+                        # Custom auto: DDG first, then append other engines
+                        results: list[dict] = []
+                        seen: set[str] = set()
+
+                        def add_unique(items: list[dict], key_field: str) -> None:
+                            for it in items or []:
+                                url = (it.get(key_field, "") or "").strip()
+                                if url and url not in seen:
+                                    seen.add(url)
+                                    results.append(it)
+
+                        # First: duckduckgo news
+                        try:
+                            ddg_news = list(
+                                ddgs.news(
+                                    query,
+                                    max_results=total_needed + 10,
+                                    safesearch=_SAFESEARCH_LEVEL,
+                                    timelimit=timelimit,
+                                    backend="duckduckgo",
+                                )
+                            )
+                        except Exception:
+                            ddg_news = []
+                        add_unique(ddg_news, "url")
+
+                        # Then: other news engines appended
+                        for eng in [b for b in _AUTO_ORDER["news"] if b != "duckduckgo"]:
+                            try:
+                                extra = list(
+                                    ddgs.news(
+                                        query,
+                                        max_results=total_needed + 10,
+                                        safesearch=_SAFESEARCH_LEVEL,
+                                        timelimit=timelimit,
+                                        backend=eng,
+                                    )
+                                )
+                            except Exception:
+                                extra = []
+                            add_unique(extra, "url")
+
+                        return results
+                    else:
+                        raw_gen = ddgs.news(
+                            query,
+                            max_results=total_needed + 10,
+                            safesearch=_SAFESEARCH_LEVEL,
+                            timelimit=timelimit,
+                            backend=_resolve_backend("news", (backend or "auto").lower()),
+                        )
                 elif stype == "images":
-                    raw_gen = ddgs.images(query, max_results=total_needed + 10, safesearch=_SAFESEARCH_LEVEL)
+                    raw_gen = ddgs.images(
+                        query,
+                        max_results=total_needed + 10,
+                        safesearch=_SAFESEARCH_LEVEL,
+                        timelimit=timelimit,
+                        backend=_resolve_backend("images", (backend or "auto").lower()),
+                    )
                 elif stype == "videos":
-                    raw_gen = ddgs.videos(query, max_results=total_needed + 10, safesearch=_SAFESEARCH_LEVEL)
+                    raw_gen = ddgs.videos(
+                        query,
+                        max_results=total_needed + 10,
+                        safesearch=_SAFESEARCH_LEVEL,
+                        timelimit=timelimit,
+                        backend=_resolve_backend("videos", (backend or "auto").lower()),
+                    )
                 else:
-                    raw_gen = ddgs.books(query, max_results=total_needed + 10, safesearch=_SAFESEARCH_LEVEL)
+                    raw_gen = ddgs.books(
+                        query,
+                        max_results=total_needed + 10,
+                        backend=_resolve_backend("books", (backend or "auto").lower()),
+                    )
                 try:
                     return list(raw_gen)
                 except Exception as inner_exc:
@@ -242,12 +450,6 @@ def build_interface() -> gr.Interface:
             gr.Textbox(label="Query", placeholder="topic OR site:example.com", max_lines=1),
             gr.Slider(minimum=1, maximum=20, value=5, step=1, label="Max results"),
             gr.Slider(minimum=1, maximum=10, value=1, step=1, label="Page", info="Page number for pagination (ignored if offset > 0)"),
-            gr.Radio(
-                label="Search Type",
-                choices=["text", "news", "images", "videos", "books"],
-                value="text",
-                info="Type of content to search for",
-            ),
             gr.Slider(
                 minimum=0,
                 maximum=1000,
@@ -256,6 +458,24 @@ def build_interface() -> gr.Interface:
                 label="Offset",
                 info="Result offset to start from (overrides page if > 0, use next_offset from previous search)",
             ),
+            gr.Radio(
+                label="Search Type",
+                choices=["text", "news", "images", "videos", "books"],
+                value="text",
+                info="Type of content to search for",
+            ),
+            gr.Radio(
+                label="Backend",
+                choices=BACKEND_CHOICES,
+                value="auto",
+                info="Search engine backend or fallback order (auto applies recommended order)",
+            ),
+            gr.Radio(
+                label="Date filter",
+                choices=DATE_FILTER_CHOICES,
+                value="any",
+                info="Limit results to: day, week, month, or year (varies by type)",
+            ),
         ],
         outputs=gr.Textbox(label="Search Results", interactive=False, lines=20, max_lines=20),
         title="Web Search",