deepparallel 0.5.1__tar.gz → 0.5.3__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepparallel
-Version: 0.5.1
+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.1 → deepparallel-0.5.3}/deepparallel/__init__.py

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

{deepparallel-0.5.1 → deepparallel-0.5.3}/deepparallel/agent.py

@@ -204,6 +204,38 @@ def _guardian_verdict(guardian, name: str, args: dict) -> str | None:
     return guardian_review(guardian, _guardian_review_content(name, args))
 
 
+def _local_module_names(target_path: str) -> set[str]:
+    """Module names that resolve to files in the workspace, so a sibling import
+    like `from compound_library import ...` is never flagged as a hallucinated
+    PyPI package. Scans the target file's directory and the cwd (capped)."""
+    names: set[str] = set()
+    roots = []
+    try:
+        roots.append(Path(target_path).expanduser().resolve().parent)
+    except Exception:  # noqa: BLE001
+        pass
+    try:
+        roots.append(Path.cwd().resolve())
+    except Exception:  # noqa: BLE001
+        pass
+    seen_roots: set[Path] = set()
+    for root in roots:
+        if root in seen_roots:
+            continue
+        seen_roots.add(root)
+        try:
+            for i, p in enumerate(root.rglob("*.py")):
+                names.add(p.stem)
+                if p.name == "__init__.py":
+                    names.add(p.parent.name)
+                if i >= 5000:
+                    break
+        except Exception:  # noqa: BLE001
+            pass
+    names.discard("__init__")
+    return names
+
+
 def _supply_chain_note(name: str, args: dict) -> str | None:
     """Best-effort: flag hallucinated/slopsquatted deps an edit introduces."""
     content = args.get("new_source") or args.get("new_string") or args.get("content") or ""
@@ -213,7 +245,7 @@ def _supply_chain_note(name: str, args: dict) -> str | None:
     try:
         from deepparallel import supply_chain
 
-        result = supply_chain.audit(content, path)
+        result = supply_chain.audit(content, path, _local_module_names(path))
     except Exception:  # noqa: BLE001 - supply-chain check is best-effort
         return None
     if result["hallucinated"]:

{deepparallel-0.5.1 → deepparallel-0.5.3}/deepparallel/supply_chain.py

@@ -44,23 +44,30 @@ _IMPORT_RE = re.compile(r"^\s*(?:import\s+([a-zA-Z0-9_.]+)|from\s+([a-zA-Z0-9_.]
 _REQ_RE = re.compile(r"^\s*([A-Za-z0-9][A-Za-z0-9._-]*)")
 
 
-def extract_dependencies(content: str, filename: str) -> list[dict]:
-    """Return [{name, ecosystem, raw}] introduced by this content."""
+def extract_dependencies(
+    content: str, filename: str, local_modules: set[str] | None = None
+) -> list[dict]:
+    """Return [{name, ecosystem, raw}] introduced by this content.
+
+    `local_modules` names resolve to files in the workspace (sibling modules,
+    local packages) and are never treated as third-party dependencies.
+    """
     fn = filename.rsplit("/", 1)[-1].lower()
     if fn == "package.json":
         return _from_package_json(content)
     if fn in ("requirements.txt",) or fn.startswith("requirements"):
         return _from_requirements(content)
     if fn.endswith(".py"):
-        return _from_python(content)
+        return _from_python(content, local_modules)
     return []
 
 
-def _from_python(content: str) -> list[dict]:
+def _from_python(content: str, local: set[str] | None = None) -> list[dict]:
+    local = local or set()
     out, seen = [], set()
     for imp, frm in _IMPORT_RE.findall(content):
         mod = (imp or frm).split(".")[0]
-        if not mod or mod.startswith("_") or mod in _STDLIB or mod in seen:
+        if not mod or mod.startswith("_") or mod in _STDLIB or mod in seen or mod in local:
             continue
         seen.add(mod)
         dist = _PYPI_ALIASES.get(mod, mod)
@@ -117,11 +124,15 @@ def check_exists(name: str, ecosystem: str) -> bool | None:
     return None
 
 
-def audit(content: str, filename: str) -> dict:
-    """Audit a change's dependencies. Returns findings + the hallucinated list."""
+def audit(content: str, filename: str, local_modules: set[str] | None = None) -> dict:
+    """Audit a change's dependencies. Returns findings + the hallucinated list.
+
+    `local_modules` are workspace-local module names (sibling files, local
+    packages) that must not be checked against PyPI/npm.
+    """
     findings = []
     hallucinated = []
-    for dep in extract_dependencies(content, filename):
+    for dep in extract_dependencies(content, filename, local_modules):
         exists = check_exists(dep["name"], dep["ecosystem"])
         status = "ok" if exists is True else "missing" if exists is False else "unknown"
         findings.append({"name": dep["name"], "ecosystem": dep["ecosystem"], "status": status})

deepparallel-0.5.3/deepparallel/system_prompt.txt

@@ -0,0 +1,18 @@
+You are DeepParallel, a precise coding assistant from Crowe Logic.
+
+Voice: direct and concise. Lead with the answer, not a preamble — never open with "I'd be happy to", "Great question", or by restating the request. Give depth only when asked or when the problem genuinely needs it. Stop when the answer is complete; don't pad with summaries or follow-up offers unless they add real value.
+
+Formatting: clean Markdown. Single blank lines between paragraphs — never double. Fenced code blocks with a language tag for code, inline backticks for identifiers and paths, tight lists (no blank line between items). Prefer a short prose answer over a bulleted list when a sentence will do.
+
+You can use tools to read, search, analyze, edit, open, and run code. Use them when they help; do not call them speculatively. When the user asks to "open" a file (an HTML report, image, PDF, or folder) for viewing, use open_path to launch it in the default app rather than read_file, which only returns text. When asked to run something with different parameters, prefer non-destructive approaches (CLI arguments, environment variables, or a temporary copy) over editing the user's source files. Only edit a source file when changing it is the actual goal, and explain what you changed.
+
+Engineering discipline — how you build:
+- Build the smallest unit that can be verified, and verify it before scaling up. Before generating a multi-file system, write the single most fundamental primitive and run it (or a one-line check) to confirm it works. Never emit hundreds of lines across several files before executing anything — a wrong assumption then costs many rounds of debugging instead of one.
+- Ground before you generate. For domain work (chemistry, biology, finance, an API or library you are not certain of), prefer retrieving real data or references over inventing them. Use mcp_search with a single keyword (e.g. "pubchem") to find a domain MCP server, web_fetch for documentation, and read_file/grep for local truth. Reach for a database or a reference before reconstructing it from memory.
+- 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.1 → deepparallel-0.5.3}/deepparallel/tools/mcp.py

@@ -10,6 +10,7 @@ from __future__ import annotations
 
 import json
 import os
+import re
 import subprocess
 import sys
 import threading
@@ -159,6 +160,35 @@ def _reap_idle() -> None:
             del _pool[key]
 
 
+def _registry_query(query: str, limit: int) -> list[dict]:
+    """One registry search call; returns raw server entries (possibly empty)."""
+    r = httpx.get(
+        _REGISTRY_API,
+        params={"search": query, "limit": limit},
+        timeout=_TIMEOUT,
+        headers={"user-agent": _UA},
+    )
+    r.raise_for_status()
+    return r.json().get("servers", [])
+
+
+def _format_server(entry: dict) -> dict:
+    server = entry.get("server", entry)
+    return {
+        "name": server.get("name", "unknown"),
+        "description": server.get("description", ""),
+        "version": server.get("version", ""),
+        "packages": [
+            {
+                "type": p.get("registryType", ""),
+                "package": p.get("identifier", ""),
+                "transport": p.get("transport", {}).get("type", "unknown"),
+            }
+            for p in server.get("packages", [])
+        ],
+    }
+
+
 @tool(dangerous=False)
 def mcp_search(query: str, limit: int = 10) -> str:
     """Search the MCP server registry (5,800+ servers) for a capability.
@@ -166,39 +196,34 @@ def mcp_search(query: str, limit: int = 10) -> str:
     Returns matching server names, descriptions, and package install info.
     Use this first to discover what exists, then mcp_list_tools to connect.
 
-    :param query: Capability to search for (e.g. "postgres", "slack", "github").
+    :param query: A single capability keyword works best (e.g. "pubchem",
+        "postgres", "slack"); multi-word phrases are split and merged automatically.
     :param limit: Maximum number of results (max 50).
     """
     limit = min(int(limit), 50)
     try:
-        r = httpx.get(
-            _REGISTRY_API,
-            params={"search": query, "limit": limit},
-            timeout=_TIMEOUT,
-            headers={"user-agent": _UA},
-        )
-        r.raise_for_status()
-        data = r.json()
+        servers = _registry_query(query, limit)
+        # The registry matches substrings, not phrases or meaning: a natural-
+        # language query like "chemistry molecular docking" matches nothing,
+        # while the single word "chemistry" finds servers. When a multi-word
+        # query comes back empty, retry each significant word and merge, so the
+        # model discovers servers without having to guess the exact term.
+        if not servers:
+            words = [w for w in re.findall(r"[A-Za-z0-9]+", query.lower()) if len(w) > 2]
+            seen: set[str] = set()
+            merged: list[dict] = []
+            for word in dict.fromkeys(words):
+                for entry in _registry_query(word, limit):
+                    name = entry.get("server", entry).get("name", "")
+                    if name and name not in seen:
+                        seen.add(name)
+                        merged.append(entry)
+                if len(merged) >= limit:
+                    break
+            servers = merged[:limit]
     except Exception as e:  # noqa: BLE001 - surface registry failure to the model
         return json.dumps({"error": f"registry search failed: {type(e).__name__}: {e}"})
-    results = []
-    for entry in data.get("servers", []):
-        server = entry.get("server", entry)
-        results.append(
-            {
-                "name": server.get("name", "unknown"),
-                "description": server.get("description", ""),
-                "version": server.get("version", ""),
-                "packages": [
-                    {
-                        "type": p.get("registryType", ""),
-                        "package": p.get("identifier", ""),
-                        "transport": p.get("transport", {}).get("type", "unknown"),
-                    }
-                    for p in server.get("packages", [])
-                ],
-            }
-        )
+    results = [_format_server(entry) for entry in servers]
     return json.dumps({"query": query, "count": len(results), "servers": results})
 
 

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.1 → deepparallel-0.5.3}/deepparallel.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepparallel
-Version: 0.5.1
+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.1 → deepparallel-0.5.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "deepparallel"
-version = "0.5.1"
+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.1 → deepparallel-0.5.3}/tests/test_supply_chain.py

@@ -69,3 +69,21 @@ def test_check_pypi_existence(monkeypatch):
 def test_audit_empty_when_no_deps():
     out = sc.audit("x = 1\nprint(x)\n", "app.py")
     assert out["findings"] == [] and out["hallucinated"] == []
+
+
+def test_audit_skips_workspace_local_modules(monkeypatch):
+    # 200 for requests, 404 for everything else (so a local module would be
+    # falsely flagged if it were checked).
+    def fake_get(url, **kw):
+        code = 200 if "/requests/" in url else 404
+        return httpx.Response(code, request=httpx.Request("GET", url))
+
+    monkeypatch.setattr(httpx, "get", fake_get)
+    code = "from compound_library import build\nimport receptor_analysis\nimport requests\n"
+    out = sc.audit(code, "scripts/workflow.py",
+                   local_modules={"compound_library", "receptor_analysis"})
+    names = {f["name"] for f in out["findings"]}
+    assert "compound_library" not in names  # local, never checked
+    assert "receptor_analysis" not in names
+    assert "requests" in names
+    assert out["hallucinated"] == []  # the false positive is gone

{deepparallel-0.5.1 → deepparallel-0.5.3}/tests/test_tools_mcp.py

@@ -45,3 +45,38 @@ def test_call_tool_rejects_bad_arguments_json():
 def test_stop_server_not_running():
     out = json.loads(mcp_mod.mcp_stop_server("never-started"))
     assert out["note"] == "never-started was not running"
+
+
+def test_mcp_search_multiword_falls_back_to_keywords(monkeypatch):
+    # The registry matches substrings: a phrase returns nothing, but a single
+    # keyword finds a server. mcp_search should split and merge automatically.
+    calls = []
+
+    def fake_query(query, limit):
+        calls.append(query)
+        if " " in query:
+            return []  # phrase matches nothing, like the real registry
+        if query == "pubchem":
+            return [{"server": {"name": "io.github.cyanheads/pubchem-mcp-server",
+                                "description": "Search compounds.", "packages": []}}]
+        return []
+
+    monkeypatch.setattr(mcp_mod, "_registry_query", fake_query)
+    out = json.loads(mcp_mod.mcp_search("pubchem chembl bioassay"))
+    assert out["count"] >= 1
+    assert any("pubchem" in s["name"] for s in out["servers"])
+    assert "pubchem chembl bioassay" in calls  # tried the phrase first
+    assert "pubchem" in calls  # then fell back to the keyword
+
+
+def test_mcp_search_single_word_skips_fallback(monkeypatch):
+    calls = []
+
+    def fake_query(query, limit):
+        calls.append(query)
+        return [{"server": {"name": "ai.waystation/postgres", "packages": []}}]
+
+    monkeypatch.setattr(mcp_mod, "_registry_query", fake_query)
+    out = json.loads(mcp_mod.mcp_search("postgres"))
+    assert out["count"] == 1
+    assert calls == ["postgres"]  # primary hit, no fallback fan-out

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.1/deepparallel/system_prompt.txt

@@ -1,7 +0,0 @@
-You are DeepParallel, a precise coding assistant from Crowe Logic.
-
-Voice: direct and concise. Lead with the answer, not a preamble — never open with "I'd be happy to", "Great question", or by restating the request. Give depth only when asked or when the problem genuinely needs it. Stop when the answer is complete; don't pad with summaries or follow-up offers unless they add real value.
-
-Formatting: clean Markdown. Single blank lines between paragraphs — never double. Fenced code blocks with a language tag for code, inline backticks for identifiers and paths, tight lists (no blank line between items). Prefer a short prose answer over a bulleted list when a sentence will do.
-
-You can use tools to read, search, analyze, edit, open, and run code. Use them when they help; do not call them speculatively. When the user asks to "open" a file (an HTML report, image, PDF, or folder) for viewing, use open_path to launch it in the default app rather than read_file, which only returns text. When asked to run something with different parameters, prefer non-destructive approaches (CLI arguments, environment variables, or a temporary copy) over editing the user's source files. Only edit a source file when changing it is the actual goal, and explain what you changed.

deepparallel-0.5.1/deepparallel/tools/web.py

@@ -1,76 +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")
-    if not key:
-        return json.dumps(
-            {"error": "search not configured: set DEEPPARALLEL_SEARCH_API_KEY (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,
-        )
-        r.raise_for_status()
-        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.1/tests/test_tools_web.py

@@ -1,82 +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