Keyless search: DuckDuckGo + direct HTTP browse; optional Serper/Jina

.gitattributes

@@ -1,2 +1,4 @@
 # Linux containers require LF in shell scripts (CRLF causes: env: 'bash\r': No such file)
 *.sh text eol=lf
+vendor/rllm/docs/assets/rllm_components.png filter=lfs diff=lfs merge=lfs -text
+vendor/rllm/docs/assets/sdk_arch.png filter=lfs diff=lfs merge=lfs -text

README.md

@@ -25,8 +25,11 @@ Configure in the Space **Settings → Variables and secrets** (or a mounted `.en
 
 | Variable | Purpose |
 |----------|---------|
-| `SERPER_KEY_ID` | Serper API key ([serper.dev](https://serper.dev)) |
-| `JINA_API_KEYS` | Jina reader key for `r.jina.ai` |
+| `SERPER_KEY_ID` | Optional. Serper API key for Google web + image search. If **unset**, text and image search use **DuckDuckGo** (no key; quality and availability vary, and some datacenter IPs may be rate-limited). |
+| `JINA_API_KEYS` | Optional. Jina reader for `r.jina.ai`. If **unset**, the visit tool uses a **direct HTTP GET** and strips HTML to text (many sites block bots or return paywalls). |
+| `WEB_TEXT_SEARCH_PROVIDER` | Override text search: `duckduckgo` or `serper` (default is **auto**: Serper when `SERPER_KEY_ID` is set, else DuckDuckGo). |
+| `WEB_IMAGE_SEARCH_PROVIDER` | Override image search: `duckduckgo` or `serper` (same auto rule using `SERPER_KEY_ID`). |
+| `BROWSE_READ_ENGINE` | Override page fetch: `direct` or `jina` (default is **auto**: Jina when `JINA_API_KEYS` is set, else direct). |
 | `OPENAI_BASE_URL` | OpenAI-compatible base URL for GenSearcher-8B (e.g. `https://.../v1`) |
 | `OPENAI_API_KEY` | API key for that endpoint (use `EMPTY` if unused) |
 | `GEN_EVAL_MODEL` | Served model name (default `Gen-Searcher-8B`) |
@@ -44,6 +47,16 @@ See [`dotenv.example`](./dotenv.example) for a full template.
 - **Minimum practical:** 1× GPU for FireRed + Gradio, with **external** vLLM endpoints for GenSearcher and browse (set `START_VLLM_GENSEARCHER=0`, `START_VLLM_BROWSE=0` — defaults).
 - **Full local (as in upstream scripts):** multiple GPUs — enable `START_VLLM_GENSEARCHER=1`, `START_VLLM_BROWSE=1`, and set `GENSEARCHER_CUDA_VISIBLE_DEVICES`, `BROWSE_CUDA_VISIBLE_DEVICES`, `FIRERED_CUDA_VISIBLE_DEVICES` to disjoint GPU indices.
 
+## Troubleshooting: `Connection error` / model call failed
+
+The agent talks to your LLM over HTTP (OpenAI-compatible). A **connection error** almost always means **nothing is listening** at `OPENAI_BASE_URL`, or the URL is wrong for where the Space runs.
+
+1. **Default `http://127.0.0.1:8002/v1`** only works if **vLLM for GenSearcher-8B** is started **inside the same container** (`START_VLLM_GENSEARCHER=1` and enough GPU). On a typical 1×GPU Space with only FireRed running, **127.0.0.1:8002 is empty** → connection error.
+
+2. **Fix:** Set Space secret **`OPENAI_BASE_URL`** to a **reachable** HTTPS (or HTTP) base URL that ends with **`/v1`**, where you host [GenSearcher/Gen-Searcher-8B](https://huggingface.co/GenSearcher/Gen-Searcher-8B) behind vLLM, Text Generation Inference, or any OpenAI-compatible stack. The UI shows an **endpoint check** on load; use **Re-check endpoints** after you change secrets.
+
+3. **Browse tool:** If `BROWSE_GENERATE_ENGINE=vllm`, set **`BROWSE_SUMMARY_BASE_URL`** the same way (not localhost unless you run that vLLM in-container with `START_VLLM_BROWSE=1`).
+
 ## Local build
 
 ```bash

app.py

@@ -14,6 +14,7 @@ import gradio as gr
 from PIL import Image
 
 from space_gen import run_sync
+from space_health import llm_endpoint_status
 
 
 def _trajectory_to_markdown(trajectory: list) -> str:
@@ -74,9 +75,22 @@ with gr.Blocks(title="GenSearcher + FireRed") as demo:
         "## GenSearcher + FireRed-Image-Edit-1.1\n"
         "Runs the **official** GenSearcher search/browse/image-search agent (vLLM), "
         "then generates with **FireRed** via the same `/generate` API as the Qwen edit server.\n\n"
-        "**Required secrets:** `SERPER_KEY_ID`, `JINA_API_KEYS`, and vLLM endpoints for "
-        "`OPENAI_BASE_URL` + `BROWSE_SUMMARY_BASE_URL` (see README)."
+        "**LLM (required):** a reachable **OpenAI-compatible** URL in `OPENAI_BASE_URL` (must include `/v1`) for "
+        "[Gen-Searcher-8B](https://huggingface.co/GenSearcher/Gen-Searcher-8B), plus `BROWSE_SUMMARY_BASE_URL` when "
+        "using browse summarization with `BROWSE_GENERATE_ENGINE=vllm` (see README).\n\n"
+        "**Search / browse (optional keys):** without `SERPER_KEY_ID` and `JINA_API_KEYS`, the agent uses **DuckDuckGo** "
+        "for web and image search and **direct HTTP** page fetch for visits. Set those secrets if you prefer Serper + Jina.\n\n"
+        "**Connection errors:** On Hugging Face Spaces, `http://127.0.0.1:8002/v1` only works if you run vLLM "
+        "in the same container (`START_VLLM_GENSEARCHER=1` + GPU). Otherwise set `OPENAI_BASE_URL` to your **public** inference server."
     )
+    status_md = gr.Markdown(llm_endpoint_status())
+    refresh_status = gr.Button("Re-check endpoints", size="sm")
+
+    def _refresh():
+        return llm_endpoint_status()
+
+    refresh_status.click(fn=_refresh, outputs=status_md)
+    demo.load(fn=_refresh, outputs=status_md)
     with gr.Row():
         prompt = gr.Textbox(
             label="Image task / prompt",

dotenv.example

@@ -9,7 +9,9 @@ export GEN_EVAL_MODEL="Gen-Searcher-8B"
 export QWEN_EDIT_APP_URL="http://127.0.0.1:8765"
 export QWEN_EDIT_APP_PATH="/generate"
 
-# Serper + Jina (required for official tools)
+# Optional: Serper + Jina (Google-quality search / reader proxy). If unset, tools use
+# DuckDuckGo for text+image search and plain HTTP fetch for browse (no API keys).
+# Force backends: WEB_TEXT_SEARCH_PROVIDER=duckduckgo|serper, WEB_IMAGE_SEARCH_PROVIDER=..., BROWSE_READ_ENGINE=direct|jina
 export SERPER_KEY_ID=""
 export JINA_API_KEYS=""
 export TEXT_SEARCH_API_BASE_URL="https://google.serper.dev/search"

requirements.txt

@@ -4,3 +4,4 @@ accelerate>=0.26.0
 gradio>=4.44.0
 tiktoken>=0.7.0
 uvicorn[standard]>=0.30.0
+duckduckgo-search>=6.0.0

scripts/entrypoint.sh

@@ -13,6 +13,16 @@ if [[ -f /app/.env.gen_image ]]; then
   set +a
 fi
 
+if [[ "${START_VLLM_GENSEARCHER:-0}" != "1" ]]; then
+  case "${OPENAI_BASE_URL:-}" in
+    *127.0.0.1*|*localhost*)
+      echo "[entrypoint] WARNING: OPENAI_BASE_URL points to loopback but START_VLLM_GENSEARCHER is not 1."
+      echo "[entrypoint]          The GenSearcher agent will get 'Connection error' unless a server listens here,"
+      echo "[entrypoint]          or you set OPENAI_BASE_URL to an external OpenAI-compatible URL (ending in /v1)."
+      ;;
+  esac
+fi
+
 wait_http() {
   local url=$1
   local name=$2

scripts/verify_env.py

@@ -5,8 +5,9 @@ from __future__ import annotations
 import os
 
 CHECKS = [
-    ("SERPER_KEY_ID", True),
-    ("JINA_API_KEYS", True),
+    # Serper / Jina optional: without them the agent uses DuckDuckGo + direct HTTP fetch.
+    ("SERPER_KEY_ID", False),
+    ("JINA_API_KEYS", False),
     ("OPENAI_BASE_URL", True),
     ("GEN_EVAL_MODEL", False),
     ("OPENAI_API_KEY", False),

space_gen.py

@@ -12,6 +12,8 @@ from typing import Any, Dict, List, Optional, Tuple
 
 import requests
 
+from space_health import check_v1_models, is_localhost_url
+
 from rllm.engine.agent_workflow_engine import AgentWorkflowEngine
 from rllm.engine.rollout import OpenAIEngine
 from vision_deepresearch_async_workflow.gen_image_deepresearch_tools_executor import (
@@ -121,11 +123,24 @@ async def run_gensearcher_then_generate(
     }
 
     model = os.environ.get("GEN_EVAL_MODEL", "Gen-Searcher-8B")
-    base_url = os.environ.get("OPENAI_BASE_URL", "http://127.0.0.1:8002/v1").rstrip("/")
+    base_url = os.environ.get("OPENAI_BASE_URL", "http://127.0.0.1:8002/v1").strip().rstrip("/")
     if not base_url.endswith("/v1"):
         base_url = base_url + "/v1"
     api_key = os.environ.get("OPENAI_API_KEY", "EMPTY")
 
+    ok_llm, llm_msg = check_v1_models(base_url, api_key)
+    if not ok_llm:
+        hint = ""
+        if is_localhost_url(base_url):
+            hint = (
+                " You are targeting localhost inside the Space container. Nothing is listening unless you set "
+                "Space variable START_VLLM_GENSEARCHER=1 (and GPU) or change OPENAI_BASE_URL to a reachable "
+                "OpenAI-compatible server (your vLLM / TGI URL ending in /v1)."
+            )
+        raise RuntimeError(
+            f"GenSearcher LLM is not reachable at {base_url}/models — {llm_msg}.{hint}"
+        )
+
     rollout_engine = OpenAIEngine(
         model=model,
         base_url=base_url,

space_health.py

@@ -0,0 +1,95 @@
+"""Preflight checks for OpenAI-compatible LLM endpoints (GenSearcher + browse)."""
+from __future__ import annotations
+
+import os
+from typing import Tuple
+
+import requests
+
+
+def normalize_openai_v1_base(url: str) -> str:
+    u = (url or "").strip().rstrip("/")
+    if not u:
+        return ""
+    if not u.endswith("/v1"):
+        u = u + "/v1"
+    return u
+
+
+def check_v1_models(base_url_v1: str, api_key: str, timeout: float = 15.0) -> Tuple[bool, str]:
+    """
+    GET {base}/models — standard OpenAI-compatible discovery (vLLM, etc.).
+    """
+    if not base_url_v1:
+        return False, "URL is empty"
+    url = base_url_v1.rstrip("/") + "/models"
+    headers = {"Authorization": f"Bearer {api_key or 'EMPTY'}"}
+    try:
+        r = requests.get(url, headers=headers, timeout=timeout)
+        if r.status_code == 200:
+            return True, "OK"
+        return False, f"HTTP {r.status_code}: {r.text[:300]}"
+    except requests.exceptions.ConnectionError as e:
+        return False, f"Connection failed (nothing listening or blocked): {e}"
+    except requests.exceptions.Timeout:
+        return False, "Timeout — server not responding"
+    except requests.exceptions.RequestException as e:
+        return False, str(e)
+
+
+def is_localhost_url(url: str) -> bool:
+    u = (url or "").lower()
+    return "127.0.0.1" in u or "localhost" in u
+
+
+def llm_endpoint_status() -> str:
+    """Human-readable markdown for Gradio banner."""
+    gen_base = normalize_openai_v1_base(os.environ.get("OPENAI_BASE_URL", ""))
+    gen_key = os.environ.get("OPENAI_API_KEY", "EMPTY")
+    browse_base = normalize_openai_v1_base(os.environ.get("BROWSE_SUMMARY_BASE_URL", ""))
+    browse_key = os.environ.get("BROWSE_SUMMARY_API_KEY", os.environ.get("OPENAI_API_KEY", "EMPTY"))
+
+    lines = ["### Endpoint checks", ""]
+
+    if not gen_base:
+        lines.append(
+            "**GenSearcher LLM:** `OPENAI_BASE_URL` is **not set**. "
+            "Add a Space secret pointing to an OpenAI-compatible server that serves **GenSearcher/Gen-Searcher-8B** "
+            "(e.g. your own vLLM URL ending in `/v1`)."
+        )
+    else:
+        ok, msg = check_v1_models(gen_base, gen_key)
+        if ok:
+            lines.append(f"**GenSearcher LLM** (`OPENAI_BASE_URL`): reachable — `{gen_base}`")
+        else:
+            lines.append(
+                f"**GenSearcher LLM** (`OPENAI_BASE_URL`): **unreachable** — `{gen_base}`\n\n"
+                f"- Detail: `{msg}`\n"
+            )
+            if is_localhost_url(gen_base):
+                lines.append(
+                    "- You are using **localhost / 127.0.0.1**. Inside a Hugging Face Space, that is **this container only**. "
+                    "Either set `START_VLLM_GENSEARCHER=1` (and enough GPU) to run vLLM here, "
+                    "or set `OPENAI_BASE_URL` to a **public** inference URL (your vLLM, TGI, etc.).\n"
+                )
+
+    lines.append("")
+    if os.environ.get("BROWSE_GENERATE_ENGINE", "").strip().lower() == "vllm":
+        if not browse_base:
+            lines.append(
+                "**Browse summarizer:** `BROWSE_SUMMARY_BASE_URL` is **not set** (needed when `BROWSE_GENERATE_ENGINE=vllm`)."
+            )
+        else:
+            ok_b, msg_b = check_v1_models(browse_base, browse_key)
+            if ok_b:
+                lines.append(f"**Browse LLM:** OK — `{browse_base}`")
+            else:
+                lines.append(
+                    f"**Browse LLM:** **unreachable** — `{browse_base}` — `{msg_b}`"
+                )
+                if is_localhost_url(browse_base):
+                    lines.append(
+                        "- Same **localhost** note: use an external Qwen3-VL server or `START_VLLM_BROWSE=1` with extra GPU.\n"
+                    )
+
+    return "\n".join(lines)

vendor/rllm/vision_deepresearch_async_workflow/tools/gen_jina_browse_impl.py

@@ -11,6 +11,7 @@ for clean open-source distribution.
 
 import os
 import random
+import re
 import time
 from typing import Optional
 
@@ -31,6 +32,84 @@ def _get_jina_proxies() -> Optional[dict]:
     return None
 
 
+_BROWSE_UA = os.environ.get(
+    "BROWSE_DIRECT_UA",
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 "
+    "(KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+)
+
+
+def _html_to_text(html: str, max_chars: int) -> str:
+    """Cheap HTML→text for keyless browse (no extra dependencies)."""
+    html = re.sub(r"(?is)<script[^>]*>.*?</script>", " ", html)
+    html = re.sub(r"(?is)<style[^>]*>.*?</style>", " ", html)
+    html = re.sub(r"(?is)<noscript[^>]*>.*?</noscript>", " ", html)
+    html = re.sub(r"(?s)<[^>]+>", " ", html)
+    for a, b in (
+        ("&nbsp;", " "),
+        ("&amp;", "&"),
+        ("&lt;", "<"),
+        ("&gt;", ">"),
+        ("&quot;", '"'),
+        ("&#39;", "'"),
+    ):
+        html = html.replace(a, b)
+    html = re.sub(r"\s+", " ", html).strip()
+    return html[:max_chars] if max_chars > 0 else html
+
+
+def direct_readpage(url: str, max_retry: int = 10) -> str:
+    """Fetch a URL with HTTP GET and strip HTML to plain text (no Jina / API key)."""
+    if not requests:
+        return "[browse] requests library not available."
+
+    u = (url or "").strip()
+    if not u:
+        return "[browse] Empty URL."
+
+    timeout = float(os.environ.get("BROWSE_DIRECT_TIMEOUT", "35"))
+    max_chars = int(os.environ.get("BROWSE_DIRECT_MAX_CHARS", "500000"))
+    headers = {
+        "User-Agent": _BROWSE_UA,
+        "Accept": "text/html,application/xhtml+xml;q=0.9,*/*;q=0.8",
+        "Accept-Language": "en-US,en;q=0.9",
+    }
+
+    for attempt in range(max_retry):
+        try:
+            response = requests.get(
+                u,
+                headers=headers,
+                timeout=timeout,
+                allow_redirects=True,
+                proxies=None,
+            )
+            if response.status_code == 429:
+                wait_time = 4 + random.uniform(2, 4)
+                print(
+                    f"[Browse] direct_readpage 429, retrying in {wait_time:.2f}s url={u!r}",
+                    flush=True,
+                )
+                time.sleep(wait_time)
+                continue
+            response.raise_for_status()
+            ct = (response.headers.get("Content-Type") or "").lower()
+            if "text/html" not in ct and "application/xhtml" not in ct and "text/plain" not in ct:
+                return f"[browse] Non-HTML response (Content-Type: {ct or 'unknown'})."
+            raw = response.content.decode(response.encoding or "utf-8", errors="replace")
+            text = _html_to_text(raw, max_chars=max_chars)
+            if not text.strip():
+                return "[browse] Empty page after stripping HTML."
+            return text
+        except Exception as e:
+            print(f"[Browse] direct_readpage attempt={attempt} url={u!r} error: {e}", flush=True)
+            if attempt == max_retry - 1:
+                return "[browse] Failed to read page."
+            time.sleep(0.5 + random.uniform(0, 1.0))
+
+    return "[browse] Failed to read page."
+
+
 def jina_readpage(url: str, max_retry: int = 10) -> str:
     """Fetch page content via the read-proxy."""
     if not requests:

vendor/rllm/vision_deepresearch_async_workflow/tools/gen_universal_image_search_impl.py

@@ -171,15 +171,73 @@ def download_image(
     return local_path
 
 
+def _resolve_image_search_backend() -> str:
+    explicit = (os.environ.get("WEB_IMAGE_SEARCH_PROVIDER") or "").strip().lower()
+    if explicit in ("duckduckgo", "ddg", "free"):
+        return "duckduckgo"
+    if explicit in ("serper", "google", "api"):
+        return "serper"
+    return "serper" if (os.environ.get("SERPER_KEY_ID") or "").strip() else "duckduckgo"
+
+
+def _fetch_ddg_image_results(query: str, topk: int, max_retry: int) -> List[dict]:
+    try:
+        from duckduckgo_search import DDGS
+    except ImportError as e:
+        raise RuntimeError("duckduckgo-search is not installed") from e
+
+    topk = min(max(1, topk), 20)
+    for retry in range(max_retry):
+        try:
+            items: List[dict] = []
+            with DDGS() as ddgs:
+                for row in ddgs.images(query, max_results=topk):
+                    image_url = row.get("image") or row.get("thumbnail") or ""
+                    page_url = row.get("url") or row.get("link") or ""
+                    title_txt = (row.get("title") or row.get("source") or "image").strip() or "image"
+                    if not image_url:
+                        continue
+                    items.append(
+                        {
+                            "title": title_txt,
+                            "imageUrl": image_url,
+                            "thumbnailUrl": row.get("thumbnail") or "",
+                            "link": page_url,
+                            "sourceUrl": "",
+                        }
+                    )
+            print(
+                f"[ImageSearch] DuckDuckGo results_len={len(items)} query={query!r}",
+                flush=True,
+            )
+            if items:
+                return items
+            sleep_time = random.uniform(1, 5)
+            print(f"[ImageSearch] DDG empty results, retry={retry} sleep={sleep_time:.2f}s", flush=True)
+            time.sleep(sleep_time)
+        except Exception as e:
+            print(f"[ImageSearch] _fetch_ddg_image_results retry={retry} error: {e}", flush=True)
+            if retry == max_retry - 1:
+                raise
+            time.sleep(1 + random.uniform(0, 2))
+
+    raise RuntimeError(f"DuckDuckGo image search failed after {max_retry} retries")
+
+
 def _fetch_universal_image_results(query: str, topk: int, max_retry: int) -> List[dict]:
     """
-    Fetch image search results via POST to IMAGE_SEARCH_API_BASE_URL (e.g. Serper /images),
+    Fetch image search results via Serper (Google) or DuckDuckGo (no API key),
     normalizing each hit to the schema expected by _download_from_items().
-    Uses SERPER_KEY_ID as X-API-KEY.
     """
+    if _resolve_image_search_backend() == "duckduckgo":
+        return _fetch_ddg_image_results(query, topk, max_retry)
+
     api_key = (os.environ.get("SERPER_KEY_ID") or "").strip()
     if not api_key:
-        raise ValueError("SERPER_KEY_ID is not set for image search")
+        raise ValueError(
+            "SERPER_KEY_ID is not set for image search "
+            "(set WEB_IMAGE_SEARCH_PROVIDER=duckduckgo for keyless image search)"
+        )
 
     url = (os.environ.get("IMAGE_SEARCH_API_BASE_URL") or "").strip()
     if not url:

vendor/rllm/vision_deepresearch_async_workflow/tools/gen_web_tools.py

@@ -16,7 +16,7 @@ import os
 import random
 import re
 import time
-from typing import List, Optional, Union
+from typing import List, Optional, Union, Literal
 
 try:
     import requests
@@ -30,14 +30,72 @@ def _clean_html_b(text: str) -> str:
     return re.sub(r"</?b>", "", text or "")
 
 
+def _resolve_text_search_backend() -> Literal["serper", "duckduckgo"]:
+    """Serper when key is present (unless overridden); otherwise DuckDuckGo (no API key)."""
+    explicit = (os.environ.get("WEB_TEXT_SEARCH_PROVIDER") or "").strip().lower()
+    if explicit in ("duckduckgo", "ddg", "free"):
+        return "duckduckgo"
+    if explicit in ("serper", "google", "api"):
+        return "serper"
+    return "serper" if (os.environ.get("SERPER_KEY_ID") or "").strip() else "duckduckgo"
+
+
+def _resolve_browse_read_engine() -> Literal["jina", "direct"]:
+    """Jina when key is present (unless overridden); otherwise plain HTTP fetch."""
+    explicit = (os.environ.get("BROWSE_READ_ENGINE") or "").strip().lower()
+    if explicit in ("direct", "fetch", "http"):
+        return "direct"
+    if explicit == "jina":
+        return "jina"
+    if explicit:
+        return "jina"
+    return "jina" if (os.environ.get("JINA_API_KEYS") or "").strip() else "direct"
+
+
+def _text_search_duckduckgo(queries: List[str], topk: int = 10) -> str:
+    try:
+        from duckduckgo_search import DDGS
+    except ImportError:
+        return "[Search] duckduckgo-search is not installed."
+
+    topk = min(10, max(1, topk))
+    results: List[str] = []
+    for query in queries:
+        q_clean = (query or "").replace('"', "").replace("'", "").strip()
+        if not q_clean:
+            results.append("No results for empty query.")
+            continue
+        snippets: List[str] = []
+        try:
+            with DDGS() as ddgs:
+                for row in ddgs.text(q_clean, max_results=topk):
+                    title = _clean_html_b(row.get("title", "") or "")
+                    href = row.get("href", "") or ""
+                    body = _clean_html_b(row.get("body", "") or "")
+                    snippets.append(f"[{title}]({href}) {body}")
+        except Exception as e:
+            print(f"[Search] DuckDuckGo query={q_clean!r} error: {e}", flush=True)
+            results.append(f"Search failed for '{q_clean}': {e}")
+            continue
+        results.append("\n\n".join(snippets) if snippets else f"No results for '{q_clean}'.")
+
+    return "\n\n".join(
+        f"--- search result for [{q}] ---\n{r}\n--- end of search result ---"
+        for q, r in zip(queries, results)
+    )
+
+
 def _text_search_sync(queries: List[str], topk: int = 10, max_retry: int = 100) -> str:
-    """Blocking web search: POST to TEXT_SEARCH_API_BASE_URL (e.g. Serper /search), markdown formatted."""
+    """Blocking web search: Serper (Google API) or DuckDuckGo (no key)."""
     if requests is None:
         return "[Search] requests is not installed."
 
+    if _resolve_text_search_backend() == "duckduckgo":
+        return _text_search_duckduckgo(queries, topk=topk)
+
     api_key = (os.environ.get("SERPER_KEY_ID") or "").strip()
     if not api_key:
-        return "[Search] SERPER_KEY_ID is not set."
+        return "[Search] SERPER_KEY_ID is not set (or set WEB_TEXT_SEARCH_PROVIDER=duckduckgo for keyless search)."
 
     url = (os.environ.get("TEXT_SEARCH_API_BASE_URL") or "").strip()
     if not url:
@@ -190,33 +248,55 @@ def _image_search_sync(
 def _browse_sync(
     url: str,
     query: str,
-    read_engine: str = "jina",
+    read_engine: Optional[str] = None,
     generate_engine: str = "deepseekchat",
     max_retry: int = 10,
 ) -> str:
-    """Fetch page via read-proxy and summarize with an LLM."""
+    """Fetch page via Jina reader or direct HTTP, then summarize with an LLM."""
     # Optional random delay to spread traffic.
     if os.environ.get("BROWSE_RANDOM_SLEEP", "").strip().lower() in ("1", "true", "yes"):
         time.sleep(random.uniform(0, 16))
 
-    if read_engine != "jina":
-        return "[Browse] Only jina read engine is supported in the open-source version."
-
-    try:
-        from vision_deepresearch_async_workflow.tools.gen_jina_browse_impl import jina_readpage
-    except ImportError:
-        jina_readpage = None
-
-    if jina_readpage is None:
-        return "[Browse] browse backend is not available."
-
-    try:
-        source_text = jina_readpage(url, max_retry=max_retry)
-    except Exception as e:
-        print(f"[Browse] jina_readpage error url={url!r}: {e}", flush=True)
-        return "Browse error. Please try again."
-
-    if not source_text.strip() or source_text.startswith("[browse] Failed"):
+    engine = ((read_engine or "").strip().lower() or _resolve_browse_read_engine())
+
+    if engine == "direct":
+        try:
+            from vision_deepresearch_async_workflow.tools.gen_jina_browse_impl import direct_readpage
+        except ImportError:
+            direct_readpage = None  # type: ignore
+        if direct_readpage is None:
+            return "[Browse] direct read backend is not available."
+        try:
+            source_text = direct_readpage(url, max_retry=max_retry)
+        except Exception as e:
+            print(f"[Browse] direct_readpage error url={url!r}: {e}", flush=True)
+            return "Browse error. Please try again."
+    elif engine == "jina":
+        try:
+            from vision_deepresearch_async_workflow.tools.gen_jina_browse_impl import jina_readpage
+        except ImportError:
+            jina_readpage = None  # type: ignore
+
+        if jina_readpage is None:
+            return "[Browse] browse backend is not available."
+
+        try:
+            source_text = jina_readpage(url, max_retry=max_retry)
+        except Exception as e:
+            print(f"[Browse] jina_readpage error url={url!r}: {e}", flush=True)
+            return "Browse error. Please try again."
+    else:
+        return f"[Browse] Unsupported read_engine={engine!r} (use jina or direct)."
+
+    _browse_err = (
+        "[browse] Failed",
+        "[browse] JINA_API_KEYS",
+        "[browse] requests library",
+        "[browse] Empty URL",
+        "[browse] Non-HTML",
+        "[browse] Empty page",
+    )
+    if not source_text.strip() or any(source_text.startswith(p) for p in _browse_err):
         print(f"[Browse] Empty or failed read for url={url!r}", flush=True)
         return "Browse error. Please try again."
 
@@ -289,7 +369,7 @@ def _browse_sync(
 
 
 class WebTextSearchTool(DeepResearchTool):
-    """Text search tool (Serper Google web search API)."""
+    """Text search tool (Serper or DuckDuckGo via WEB_TEXT_SEARCH_PROVIDER / SERPER_KEY_ID)."""
 
     def __init__(self):
         super().__init__(
@@ -373,7 +453,6 @@ class JinaBrowseTool(DeepResearchTool):
                 "required": ["url", "goal"],
             },
         )
-        self._read_engine = "jina"
         self._generate_engine = os.environ.get("BROWSE_GENERATE_ENGINE", "deepseekchat")
         self._max_retry = 10
 
@@ -390,13 +469,14 @@ class JinaBrowseTool(DeepResearchTool):
         # Gen-image agent passes "query"; other callers may use "goal"
         effective_goal = (goal or query or kwargs.get("query") or "").strip()
         goal = effective_goal or "Detailed summary of the page."
+        read_engine = _resolve_browse_read_engine()
         results: List[str] = []
         for u in urls[:5]:
             r = await self._run_blocking(
                 lambda uu=u: _browse_sync(
                     url=uu,
                     query=goal,
-                    read_engine=self._read_engine,
+                    read_engine=read_engine,
                     generate_engine=self._generate_engine,
                     max_retry=self._max_retry,
                 )