deepparallel 0.5.2__tar.gz → 0.5.3__tar.gz

{deepparallel-0.5.2 → deepparallel-0.5.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepparallel
-Version: 0.5.2
+Version: 0.5.3
 Summary: DeepParallel - a multi-model agentic coding CLI with cross-model Guardian review, served via Crowe Logic.
 Author-email: Michael Crowe <michael@crowelogic.com>
 License: Apache-2.0

{deepparallel-0.5.2 → deepparallel-0.5.3}/deepparallel/__init__.py

@@ -1,3 +1,3 @@
 """DeepParallel CLI package."""
 
-__version__ = "0.5.2"
+__version__ = "0.5.3"

{deepparallel-0.5.2 → deepparallel-0.5.3}/deepparallel/system_prompt.txt

@@ -12,3 +12,7 @@ Engineering discipline — how you build:
 - Treat warnings as signal, not noise. A Guardian "risky/bug" verdict, a supply-chain flag, a parser or valence error, or a low similarity-to-reference score is evidence that something is wrong. Investigate and fix the cause; never rationalize it away or approve through it.
 - Validate against known-good references. When generating structured artifacts (molecules, schemas, configs, queries), check a sample against a known-correct example before trusting the whole batch. If your output does not resemble the references you expect, the generator is wrong, not the references.
 - Label honestly. Never emit an output whose name, ID, or label does not match what it actually is. If you cannot represent something correctly, say so rather than silently substituting a near-miss.
+
+Where to write files: write into the current working directory using relative paths (e.g. `analysis/report.md`), or a path the user explicitly gave you. Do NOT invent absolute system paths like `/home/user/...`; the run_code sandbox is a SEPARATE environment from where write_file and edit_file act, and a host path like `/home/user` may not exist (writes there fail). Create any folders you need under the working directory.
+
+Grounding is mandatory, not optional. Before writing substantive domain content (a protocol, analysis, dataset, literature claim, or any statement of fact a reader would trust), you MUST ground it first: web_search (works with no API key), web_fetch on a specific source, mcp_search to find a domain data server (try a single keyword like "pubmed", "clinicaltrials", "pubchem"), or read_file/grep for local truth. If one grounding tool errors, try another route before proceeding — never conclude "search is down, I'll rely on my knowledge" and generate from memory. When you genuinely cannot ground a claim, state that explicitly and label it unverified rather than presenting recall as established fact. Cite the sources you used.

deepparallel-0.5.3/deepparallel/tools/web.py

@@ -0,0 +1,187 @@
+"""Web tools: fetch a page's text, and search.
+
+web_search needs NO API key: providers are tried in order of quality and the
+keyless DuckDuckGo scrape is the always-available floor, so search never dies
+for lack of a key.
+- PERPLEXITY_API_KEY -> Perplexity Sonar: synthesized, cited answers (best for
+  research; Enterprise does not train on your data).
+- DEEPPARALLEL_SEARCH_API_KEY -> Brave Search: ranked link results.
+- (no key) -> DuckDuckGo HTML scrape.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+from urllib.parse import parse_qs, urlparse
+
+import httpx
+
+from deepparallel.tools import tool
+
+_SCRIPT_STYLE = re.compile(r"<(script|style)\b[^>]*>.*?</\1>", re.IGNORECASE | re.DOTALL)
+_TAG = re.compile(r"<[^>]+>")
+_TITLE = re.compile(r"<title[^>]*>(.*?)</title>", re.IGNORECASE | re.DOTALL)
+_WS = re.compile(r"\s+")
+_TIMEOUT = 15.0
+_RESEARCH_TIMEOUT = 40.0  # Perplexity synthesizes; it is slower than a link API
+_UA = "DeepParallel/0.1"
+# DuckDuckGo's HTML endpoint rejects non-browser agents, so the fallback needs
+# a realistic UA. Kept separate from _UA (used for plain fetches).
+_BROWSER_UA = (
+    "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"
+)
+_DDG_LINK = re.compile(r'<a[^>]+class="result__a"[^>]+href="([^"]+)"[^>]*>(.*?)</a>', re.I | re.S)
+_DDG_SNIP = re.compile(r'<a[^>]+class="result__snippet"[^>]*>(.*?)</a>', re.I | re.S)
+
+
+@tool(dangerous=False)
+def web_fetch(url: str, max_chars: int = 8000) -> str:
+    """Fetch a web page and return its readable text (HTML stripped).
+
+    :param url: The URL to fetch.
+    :param max_chars: Maximum characters of text to return.
+    """
+    try:
+        r = httpx.get(url, timeout=_TIMEOUT, follow_redirects=True, headers={"user-agent": _UA})
+        r.raise_for_status()
+    except Exception as e:  # noqa: BLE001 - surface fetch failure to the model
+        return json.dumps({"error": f"fetch failed: {type(e).__name__}: {e}"})
+    html = r.text or ""
+    title_m = _TITLE.search(html)
+    title = _WS.sub(" ", _TAG.sub("", title_m.group(1))).strip() if title_m else ""
+    text = _WS.sub(" ", _TAG.sub(" ", _SCRIPT_STYLE.sub(" ", html))).strip()
+    return json.dumps({"url": url, "title": title, "text": text[:max_chars]})
+
+
+def _strip_html(fragment: str) -> str:
+    return _WS.sub(" ", _TAG.sub("", fragment)).strip()
+
+
+def _ddg_decode(href: str) -> str:
+    """DuckDuckGo wraps result links as //duckduckgo.com/l/?uddg=<encoded-url>.
+    Pull the real destination back out; pass through anything already direct."""
+    if "uddg=" in href:
+        query = urlparse(href if href.startswith("http") else "https:" + href).query
+        target = parse_qs(query).get("uddg")
+        if target:
+            return target[0]
+    return href
+
+
+def _perplexity_search(query: str, count: int, key: str):
+    """(ok, payload | error-string) from Perplexity Sonar: a synthesized,
+    citation-backed answer plus its source URLs."""
+    try:
+        r = httpx.post(
+            "https://api.perplexity.ai/chat/completions",
+            headers={"authorization": f"Bearer {key}", "content-type": "application/json"},
+            json={
+                "model": os.environ.get("PERPLEXITY_MODEL", "sonar"),
+                "messages": [{"role": "user", "content": query}],
+            },
+            timeout=_RESEARCH_TIMEOUT,
+        )
+        if r.status_code >= 400:
+            return False, f"HTTP {r.status_code}: {(r.text or '')[:200]}"
+        data = r.json()
+    except Exception as e:  # noqa: BLE001 - surface to caller for fallback
+        return False, f"{type(e).__name__}: {e}"
+    answer = (data.get("choices") or [{}])[0].get("message", {}).get("content", "")
+    sources = data.get("search_results") or []
+    if sources:
+        results = [
+            {"title": s.get("title", ""), "url": s.get("url", ""), "snippet": s.get("date", "")}
+            for s in sources[:count]
+        ]
+    else:
+        results = [{"title": "", "url": u, "snippet": ""} for u in (data.get("citations") or [])[:count]]
+    return True, {"provider": "perplexity", "answer": answer, "results": results}
+
+
+def _brave_search(query: str, count: int, key: str):
+    """(ok, results | error-string) from the Brave Search API."""
+    url = os.environ.get(
+        "DEEPPARALLEL_SEARCH_URL", "https://api.search.brave.com/res/v1/web/search"
+    )
+    try:
+        r = httpx.get(
+            url,
+            params={"q": query, "count": count},
+            headers={"X-Subscription-Token": key, "accept": "application/json"},
+            timeout=_TIMEOUT,
+        )
+        if r.status_code >= 400:
+            return False, f"HTTP {r.status_code}: {(r.text or '')[:200]}"
+        data = r.json()
+    except Exception as e:  # noqa: BLE001 - surface to caller for fallback
+        return False, f"{type(e).__name__}: {e}"
+    results = [
+        {"title": it.get("title", ""), "url": it.get("url", ""), "snippet": it.get("description", "")}
+        for it in (data.get("web", {}).get("results") or [])[:count]
+    ]
+    return True, results
+
+
+def _duckduckgo_search(query: str, count: int):
+    """(ok, results | error-string) by scraping DuckDuckGo's keyless HTML endpoint."""
+    try:
+        r = httpx.post(
+            "https://html.duckduckgo.com/html/",
+            data={"q": query},
+            headers={"user-agent": _BROWSER_UA},
+            timeout=_TIMEOUT,
+            follow_redirects=True,
+        )
+        if r.status_code >= 400:
+            return False, f"HTTP {r.status_code}"
+        html = r.text or ""
+    except Exception as e:  # noqa: BLE001 - surface to caller
+        return False, f"{type(e).__name__}: {e}"
+    links = _DDG_LINK.findall(html)
+    snippets = _DDG_SNIP.findall(html)
+    results = []
+    for i, (href, title) in enumerate(links[:count]):
+        results.append(
+            {
+                "title": _strip_html(title),
+                "url": _ddg_decode(href),
+                "snippet": _strip_html(snippets[i]) if i < len(snippets) else "",
+            }
+        )
+    if not results:
+        return False, "no results parsed"
+    return True, results
+
+
+@tool(dangerous=False)
+def web_search(query: str, count: int = 5) -> str:
+    """Search the web and return result titles, URLs, and snippets.
+
+    Works with no API key (DuckDuckGo fallback). Providers are tried best-first:
+    Perplexity Sonar (PERPLEXITY_API_KEY) for cited, synthesized answers, then
+    Brave (DEEPPARALLEL_SEARCH_API_KEY), then keyless DuckDuckGo.
+
+    :param query: The search query.
+    :param count: Maximum number of results.
+    """
+    errors = []
+    pplx = (os.environ.get("PERPLEXITY_API_KEY") or "").strip()
+    if pplx:
+        ok, payload = _perplexity_search(query, count, pplx)
+        if ok:
+            return json.dumps(payload)
+        errors.append(f"perplexity: {payload}")
+    brave = (os.environ.get("DEEPPARALLEL_SEARCH_API_KEY") or "").strip()
+    if brave:
+        ok, payload = _brave_search(query, count, brave)
+        if ok:
+            return json.dumps({"provider": "brave", "results": payload})
+        errors.append(f"brave: {payload}")
+    ok, payload = _duckduckgo_search(query, count)
+    if ok:
+        return json.dumps({"provider": "duckduckgo", "results": payload})
+    errors.append(f"duckduckgo: {payload}")
+    return json.dumps({"error": "search failed: " + "; ".join(errors)})

{deepparallel-0.5.2 → deepparallel-0.5.3}/deepparallel.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepparallel
-Version: 0.5.2
+Version: 0.5.3
 Summary: DeepParallel - a multi-model agentic coding CLI with cross-model Guardian review, served via Crowe Logic.
 Author-email: Michael Crowe <michael@crowelogic.com>
 License: Apache-2.0

{deepparallel-0.5.2 → deepparallel-0.5.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "deepparallel"
-version = "0.5.2"
+version = "0.5.3"
 description = "DeepParallel - a multi-model agentic coding CLI with cross-model Guardian review, served via Crowe Logic."
 readme = "README.md"
 license = { text = "Apache-2.0" }

deepparallel-0.5.3/tests/test_tools_web.py

@@ -0,0 +1,140 @@
+import json
+
+import httpx
+
+import deepparallel.tools.web as web_mod
+from deepparallel.tools import get_registry
+
+_HTML = """<html><head><title>Hello Page</title>
+<style>.x{color:red}</style><script>var a=1;</script></head>
+<body><h1>Welcome</h1><p>This is the <b>main</b> content.</p></body></html>"""
+
+_DDG_HTML = """
+<div class="result results_links">
+  <a class="result__a" href="//duckduckgo.com/l/?uddg=https%3A%2F%2Fpubmed.ncbi.nlm.nih.gov%2F123%2F&rut=x">Psilocybin PTSD trial</a>
+  <a class="result__snippet">A randomized controlled trial of psilocybin for PTSD.</a>
+</div>
+<div class="result results_links">
+  <a class="result__a" href="//duckduckgo.com/l/?uddg=https%3A%2F%2Fwww.thelancet.com%2Fa&rut=y">Lancet review</a>
+  <a class="result__snippet">Systematic review of psychedelics.</a>
+</div>
+"""
+
+_PPLX_JSON = {
+    "choices": [{"message": {"content": "Yes, psilocybin is studied for PTSD [1][2]."}}],
+    "search_results": [
+        {"title": "PMC article", "url": "https://pmc.ncbi.nlm.nih.gov/x", "date": "2025"},
+        {"title": "Lancet", "url": "https://thelancet.com/y", "date": "2025"},
+    ],
+}
+
+_BRAVE_JSON = {
+    "web": {"results": [
+        {"title": "T1", "url": "https://a", "description": "d1"},
+        {"title": "T2", "url": "https://b", "description": "d2"},
+    ]}
+}
+
+
+class _Resp:
+    def __init__(self, text="", payload=None, status=200):
+        self.text = text
+        self._payload = payload
+        self.status_code = status
+
+    def raise_for_status(self):
+        if self.status_code >= 400:
+            raise httpx.HTTPStatusError("err", request=None, response=self)
+
+    def json(self):
+        return self._payload
+
+
+def test_web_fetch_strips_html_to_text(monkeypatch):
+    monkeypatch.setattr(httpx, "get", lambda url, **kw: _Resp(text=_HTML))
+    out = json.loads(web_mod.web_fetch("https://example.com"))
+    assert "Welcome" in out["text"] and "main" in out["text"]
+    assert "var a=1" not in out["text"] and "color:red" not in out["text"]
+    assert "<" not in out["text"]
+    assert out["title"] == "Hello Page"
+
+
+def test_web_fetch_truncates(monkeypatch):
+    big = "<p>" + ("word " * 5000) + "</p>"
+    monkeypatch.setattr(httpx, "get", lambda url, **kw: _Resp(text=big))
+    out = json.loads(web_mod.web_fetch("https://example.com", max_chars=100))
+    assert len(out["text"]) <= 100
+
+
+def test_web_fetch_is_non_dangerous():
+    assert get_registry().get("web_fetch").dangerous is False
+
+
+def test_web_search_is_non_dangerous():
+    assert get_registry().get("web_search").dangerous is False
+
+
+def test_ddg_decode_extracts_real_url():
+    href = "//duckduckgo.com/l/?uddg=https%3A%2F%2Fpubmed.ncbi.nlm.nih.gov%2F999%2F&rut=z"
+    assert web_mod._ddg_decode(href) == "https://pubmed.ncbi.nlm.nih.gov/999/"
+    assert web_mod._ddg_decode("https://direct.example/x") == "https://direct.example/x"
+
+
+def test_web_search_perplexity_first_when_keyed(monkeypatch):
+    monkeypatch.setenv("PERPLEXITY_API_KEY", "pplx-test")
+    monkeypatch.delenv("DEEPPARALLEL_SEARCH_API_KEY", raising=False)
+    called = {"get": False}
+    monkeypatch.setattr(httpx, "post", lambda url, **kw: _Resp(payload=_PPLX_JSON))
+    monkeypatch.setattr(httpx, "get", lambda *a, **k: called.__setitem__("get", True) or _Resp())
+    out = json.loads(web_mod.web_search("psilocybin PTSD", count=2))
+    assert out["provider"] == "perplexity"
+    assert "psilocybin" in out["answer"].lower()
+    assert out["results"][0]["url"].startswith("https://")
+    assert called["get"] is False  # never fell through to Brave
+
+
+def test_web_search_brave_when_only_brave_keyed(monkeypatch):
+    monkeypatch.delenv("PERPLEXITY_API_KEY", raising=False)
+    monkeypatch.setenv("DEEPPARALLEL_SEARCH_API_KEY", "k")
+    captured = {}
+
+    def fake_get(url, **kw):
+        captured["params"] = kw.get("params", {})
+        captured["headers"] = kw.get("headers", {})
+        return _Resp(payload=_BRAVE_JSON)
+
+    monkeypatch.setattr(httpx, "get", fake_get)
+    out = json.loads(web_mod.web_search("python testing"))
+    assert out["provider"] == "brave"
+    assert [r["title"] for r in out["results"]] == ["T1", "T2"]
+    assert captured["params"]["q"] == "python testing"
+    assert captured["headers"]["X-Subscription-Token"] == "k"
+
+
+def test_web_search_duckduckgo_without_any_key(monkeypatch):
+    monkeypatch.delenv("PERPLEXITY_API_KEY", raising=False)
+    monkeypatch.delenv("DEEPPARALLEL_SEARCH_API_KEY", raising=False)
+    monkeypatch.setattr(httpx, "post", lambda url, **kw: _Resp(text=_DDG_HTML))
+    out = json.loads(web_mod.web_search("psilocybin PTSD", count=2))
+    assert out["provider"] == "duckduckgo"
+    assert out["results"][0]["url"] == "https://pubmed.ncbi.nlm.nih.gov/123/"
+    assert "randomized" in out["results"][0]["snippet"].lower()
+
+
+def test_web_search_recovers_to_ddg_when_brave_fails(monkeypatch):
+    monkeypatch.delenv("PERPLEXITY_API_KEY", raising=False)
+    monkeypatch.setenv("DEEPPARALLEL_SEARCH_API_KEY", "k")
+    monkeypatch.setattr(httpx, "get", lambda url, **kw: _Resp(text="bad", status=422))
+    monkeypatch.setattr(httpx, "post", lambda url, **kw: _Resp(text=_DDG_HTML))
+    out = json.loads(web_mod.web_search("psilocybin"))
+    assert out["provider"] == "duckduckgo"  # recovered after Brave 422
+
+
+def test_web_search_reports_all_errors_when_all_fail(monkeypatch):
+    monkeypatch.setenv("PERPLEXITY_API_KEY", "pplx-test")
+    monkeypatch.setenv("DEEPPARALLEL_SEARCH_API_KEY", "k")
+    monkeypatch.setattr(httpx, "post", lambda url, **kw: _Resp(text="down", status=500))
+    monkeypatch.setattr(httpx, "get", lambda url, **kw: _Resp(text="down", status=500))
+    out = json.loads(web_mod.web_search("x"))
+    assert "error" in out
+    assert "perplexity" in out["error"] and "duckduckgo" in out["error"]

deepparallel-0.5.2/deepparallel/tools/web.py

@@ -1,82 +0,0 @@
-"""Web tools: fetch a page's text, and search (key-gated)."""
-
-from __future__ import annotations
-
-import json
-import os
-import re
-
-import httpx
-
-from deepparallel.tools import tool
-
-_SCRIPT_STYLE = re.compile(r"<(script|style)\b[^>]*>.*?</\1>", re.IGNORECASE | re.DOTALL)
-_TAG = re.compile(r"<[^>]+>")
-_TITLE = re.compile(r"<title[^>]*>(.*?)</title>", re.IGNORECASE | re.DOTALL)
-_WS = re.compile(r"\s+")
-_TIMEOUT = 15.0
-_UA = "DeepParallel/0.1"
-
-
-@tool(dangerous=False)
-def web_fetch(url: str, max_chars: int = 8000) -> str:
-    """Fetch a web page and return its readable text (HTML stripped).
-
-    :param url: The URL to fetch.
-    :param max_chars: Maximum characters of text to return.
-    """
-    try:
-        r = httpx.get(url, timeout=_TIMEOUT, follow_redirects=True, headers={"user-agent": _UA})
-        r.raise_for_status()
-    except Exception as e:  # noqa: BLE001 - surface fetch failure to the model
-        return json.dumps({"error": f"fetch failed: {type(e).__name__}: {e}"})
-    html = r.text or ""
-    title_m = _TITLE.search(html)
-    title = _WS.sub(" ", _TAG.sub("", title_m.group(1))).strip() if title_m else ""
-    text = _WS.sub(" ", _TAG.sub(" ", _SCRIPT_STYLE.sub(" ", html))).strip()
-    return json.dumps({"url": url, "title": title, "text": text[:max_chars]})
-
-
-@tool(dangerous=False)
-def web_search(query: str, count: int = 5) -> str:
-    """Search the web and return result titles, URLs, and snippets.
-
-    Requires DEEPPARALLEL_SEARCH_API_KEY (Brave Search API by default).
-
-    :param query: The search query.
-    :param count: Maximum number of results.
-    """
-    key = (os.environ.get("DEEPPARALLEL_SEARCH_API_KEY") or "").strip()
-    if not key:
-        return json.dumps(
-            {"error": "search not configured: set DEEPPARALLEL_SEARCH_API_KEY (Brave Search API key)"}
-        )
-    url = os.environ.get(
-        "DEEPPARALLEL_SEARCH_URL", "https://api.search.brave.com/res/v1/web/search"
-    )
-    try:
-        r = httpx.get(
-            url,
-            params={"q": query, "count": count},
-            headers={"X-Subscription-Token": key, "accept": "application/json"},
-            timeout=_TIMEOUT,
-        )
-        if r.status_code >= 400:
-            # Surface the provider's error body: a bare "422" hides the reason
-            # (missing key header, over-long query, plan limit). The body tells
-            # the model and the user exactly what to fix.
-            return json.dumps(
-                {"error": f"search failed: HTTP {r.status_code}: {(r.text or '')[:300]}"}
-            )
-        data = r.json()
-    except Exception as e:  # noqa: BLE001 - surface search failure to the model
-        return json.dumps({"error": f"search failed: {type(e).__name__}: {e}"})
-    results = [
-        {
-            "title": item.get("title", ""),
-            "url": item.get("url", ""),
-            "snippet": item.get("description", ""),
-        }
-        for item in (data.get("web", {}).get("results") or [])[:count]
-    ]
-    return json.dumps({"results": results})

deepparallel-0.5.2/tests/test_tools_web.py

@@ -1,97 +0,0 @@
-import json
-
-import httpx
-
-import deepparallel.tools.web as web_mod
-from deepparallel.tools import get_registry
-
-_HTML = """<html><head><title>Hello Page</title>
-<style>.x{color:red}</style><script>var a=1;</script></head>
-<body><h1>Welcome</h1><p>This is the <b>main</b> content.</p></body></html>"""
-
-
-class _Resp:
-    def __init__(self, text="", payload=None, status=200):
-        self.text = text
-        self._payload = payload
-        self.status_code = status
-
-    def raise_for_status(self):
-        if self.status_code >= 400:
-            raise httpx.HTTPStatusError("err", request=None, response=self)
-
-    def json(self):
-        return self._payload
-
-
-def test_web_fetch_strips_html_to_text(monkeypatch):
-    monkeypatch.setattr(httpx, "get", lambda url, **kw: _Resp(text=_HTML))
-    out = json.loads(web_mod.web_fetch("https://example.com"))
-    assert "Welcome" in out["text"]
-    assert "main" in out["text"]
-    assert "var a=1" not in out["text"]  # script stripped
-    assert "color:red" not in out["text"]  # style stripped
-    assert "<" not in out["text"]  # tags stripped
-    assert out["title"] == "Hello Page"
-
-
-def test_web_fetch_truncates(monkeypatch):
-    big = "<p>" + ("word " * 5000) + "</p>"
-    monkeypatch.setattr(httpx, "get", lambda url, **kw: _Resp(text=big))
-    out = json.loads(web_mod.web_fetch("https://example.com", max_chars=100))
-    assert len(out["text"]) <= 100
-
-
-def test_web_fetch_is_non_dangerous():
-    assert get_registry().get("web_fetch").dangerous is False
-
-
-def test_web_search_unconfigured_returns_error(monkeypatch):
-    monkeypatch.delenv("DEEPPARALLEL_SEARCH_API_KEY", raising=False)
-    out = json.loads(web_mod.web_search("anything"))
-    assert "error" in out
-    assert "DEEPPARALLEL_SEARCH_API_KEY" in out["error"]
-
-
-def test_web_search_parses_results(monkeypatch):
-    monkeypatch.setenv("DEEPPARALLEL_SEARCH_API_KEY", "k")
-    payload = {
-        "web": {
-            "results": [
-                {"title": "T1", "url": "https://a", "description": "d1"},
-                {"title": "T2", "url": "https://b", "description": "d2"},
-            ]
-        }
-    }
-    captured = {}
-
-    def fake_get(url, **kw):
-        captured["url"] = url
-        captured["headers"] = kw.get("headers", {})
-        captured["params"] = kw.get("params", {})
-        return _Resp(payload=payload)
-
-    monkeypatch.setattr(httpx, "get", fake_get)
-    out = json.loads(web_mod.web_search("python testing"))
-    assert [r["title"] for r in out["results"]] == ["T1", "T2"]
-    assert captured["params"]["q"] == "python testing"
-    assert captured["headers"]["X-Subscription-Token"] == "k"
-
-
-def test_web_search_is_non_dangerous():
-    assert get_registry().get("web_search").dangerous is False
-
-
-def test_web_search_surfaces_http_error_body(monkeypatch):
-    monkeypatch.setenv("DEEPPARALLEL_SEARCH_API_KEY", "k")
-    body = '{"error":{"detail":"x-subscription-token Field required"}}'
-    monkeypatch.setattr(httpx, "get", lambda url, **kw: _Resp(text=body, status=422))
-    out = json.loads(web_mod.web_search("anything"))
-    assert "HTTP 422" in out["error"]
-    assert "x-subscription-token" in out["error"]  # the real reason, not a bare 422
-
-
-def test_web_search_blank_key_treated_as_unconfigured(monkeypatch):
-    monkeypatch.setenv("DEEPPARALLEL_SEARCH_API_KEY", "   ")
-    out = json.loads(web_mod.web_search("anything"))
-    assert "DEEPPARALLEL_SEARCH_API_KEY" in out["error"]