deepy-cli 0.1.2__tar.gz → 0.1.3__tar.gz

{deepy_cli-0.1.2 → deepy_cli-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: deepy-cli
-Version: 0.1.2
+Version: 0.1.3
 Summary: Deepy - Vibe coding for DeepSeek models in your terminal
 Keywords: deepseek,coding-agent,terminal,cli,agents
 Author: kirineko
@@ -144,6 +144,14 @@ context_window_tokens = 1048576
 compact_threshold = 0.8
 ```
 
+WebSearch uses Deepy's hosted SearXNG endpoint by default. You can override it
+with your own SearXNG instance:
+
+```toml
+[tools.web_search]
+searxng_url = "https://your-searxng.example/"
+```
+
 You can also initialize config non-interactively:
 
 ```bash
@@ -200,6 +208,6 @@ assets live outside the package directory and are not included in the wheel.
 
 ## Release Status
 
-Deepy is preparing its first public `0.1.2` release. The current release path is
+Deepy is preparing its first public `0.1.3` release. The current release path is
 GitHub + PyPI. Standalone binaries and npm wrappers can be added later, but the
 primary distribution is the Python CLI.

{deepy_cli-0.1.2 → deepy_cli-0.1.3}/README.md

@@ -116,6 +116,14 @@ context_window_tokens = 1048576
 compact_threshold = 0.8
 ```
 
+WebSearch uses Deepy's hosted SearXNG endpoint by default. You can override it
+with your own SearXNG instance:
+
+```toml
+[tools.web_search]
+searxng_url = "https://your-searxng.example/"
+```
+
 You can also initialize config non-interactively:
 
 ```bash
@@ -172,6 +180,6 @@ assets live outside the package directory and are not included in the wheel.
 
 ## Release Status
 
-Deepy is preparing its first public `0.1.2` release. The current release path is
+Deepy is preparing its first public `0.1.3` release. The current release path is
 GitHub + PyPI. Standalone binaries and npm wrappers can be added later, but the
 primary distribution is the Python CLI.

{deepy_cli-0.1.2 → deepy_cli-0.1.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "deepy-cli"
-version = "0.1.2"
+version = "0.1.3"
 description = "Deepy - Vibe coding for DeepSeek models in your terminal"
 readme = "README.md"
 authors = [

{deepy_cli-0.1.2 → deepy_cli-0.1.3}/src/deepy/__init__.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-__version__ = "0.1.2"
+__version__ = "0.1.3"
 
 
 def main() -> None:

{deepy_cli-0.1.2 → deepy_cli-0.1.3}/src/deepy/cli.py

@@ -11,7 +11,7 @@ import tomli_w
 
 from . import __version__
 from .config import Settings, load_settings, settings_to_toml_dict
-from .config.settings import DEFAULT_BASE_URL, DEFAULT_MODEL
+from .config.settings import DEFAULT_BASE_URL, DEFAULT_MODEL, DEFAULT_WEB_SEARCH_SEARXNG_URL
 from .errors import format_error_display
 from .llm.provider import build_provider_bundle
 from .llm.runner import DEFAULT_MAX_TURNS, run_prompt_once
@@ -159,9 +159,7 @@ def _write_config(config_path: Path, *, api_key: str, model: str, base_url: str)
         },
         "tools": {
             "web_search": {
-                "command": "",
-                "api_url": "",
-                "machine_id": "",
+                "searxng_url": DEFAULT_WEB_SEARCH_SEARXNG_URL,
             },
         },
     }

{deepy_cli-0.1.2 → deepy_cli-0.1.3}/src/deepy/config/__init__.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 from .settings import (
     ContextConfig,
+    DEFAULT_WEB_SEARCH_SEARXNG_URL,
     ModelConfig,
     Settings,
     default_config_path,
@@ -12,6 +13,7 @@ from .settings import (
 
 __all__ = [
     "ContextConfig",
+    "DEFAULT_WEB_SEARCH_SEARXNG_URL",
     "ModelConfig",
     "Settings",
     "default_config_path",

{deepy_cli-0.1.2 → deepy_cli-0.1.3}/src/deepy/config/settings.py

@@ -11,6 +11,7 @@ DEFAULT_BASE_URL = "https://api.deepseek.com"
 DEFAULT_CONTEXT_WINDOW_TOKENS = 1_048_576
 DEFAULT_COMPACT_TRIGGER_RATIO = 0.8
 DEFAULT_COMPACT_PROMPT_TOKEN_THRESHOLD = 838_861
+DEFAULT_WEB_SEARCH_SEARXNG_URL = "https://s.kirineko.tech/"
 REASONING_EFFORTS = {"high", "max"}
 
 
@@ -142,16 +143,12 @@ class NotifyConfig:
 
 @dataclass(frozen=True)
 class WebSearchToolConfig:
-    command: str | None = None
-    api_url: str | None = None
-    machine_id: str | None = None
+    searxng_url: str | None = DEFAULT_WEB_SEARCH_SEARXNG_URL
 
     @classmethod
     def from_mapping(cls, raw: Mapping[str, Any]) -> Self:
         return cls(
-            command=_as_str(raw.get("command")) or None,
-            api_url=_as_str(raw.get("api_url")) or None,
-            machine_id=_as_str(raw.get("machine_id")) or None,
+            searxng_url=_as_str(raw.get("searxng_url"), DEFAULT_WEB_SEARCH_SEARXNG_URL),
         )
 
 

deepy_cli-0.1.3/src/deepy/data/tools/WebSearch.md

@@ -0,0 +1,15 @@
+## WebSearch
+
+Search when current or external information is required.
+
+Args: `query`.
+
+Uses `tools.web_search.searxng_url` when configured, otherwise uses Deepy's
+default SearXNG endpoint. Requests include browser-like headers so private
+SearXNG instances with limiter enabled are less likely to reject the request as
+bot traffic. If SearXNG cannot be reached or returns no parseable results, falls
+back to Deepy's built-in DuckDuckGo HTML search implementation.
+
+Keep searches targeted. After several successful searches, stop searching and
+synthesize from the gathered sources. Use `WebFetch` for exact URLs that need
+deeper reading instead of continuing broad search queries.

{deepy_cli-0.1.2 → deepy_cli-0.1.3}/src/deepy/llm/runner.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+import asyncio
+import contextlib
 import time
 from collections.abc import Callable
 from dataclasses import dataclass, field
@@ -83,6 +85,7 @@ async def run_prompt_once(
     waiting_for_user = False
     pending_questions: list[dict[str, Any]] = []
     usage = TokenUsage()
+    interrupt_task: asyncio.Task[bool] | None = None
     try:
         result = Runner.run_streamed(
             agent,
@@ -91,6 +94,14 @@ async def run_prompt_once(
             run_config=run_config,
             session=session,
         )
+        if should_interrupt is not None:
+            interrupt_task = asyncio.create_task(
+                _watch_stream_interrupt(
+                    result,
+                    should_interrupt=should_interrupt,
+                    cancel_mode=cancel_mode,
+                )
+            )
         async for event in result.stream_events():
             if should_interrupt is not None and should_interrupt():
                 _cancel_stream_result(result, mode=cancel_mode)
@@ -120,6 +131,7 @@ async def run_prompt_once(
                 interrupted = True
                 break
     except MaxTurnsExceeded:
+        interrupted = interrupted or await _finish_interrupt_task(interrupt_task)
         result_usage = usage_from_run_result(result)
         if result_usage.known:
             usage = result_usage
@@ -134,6 +146,7 @@ async def run_prompt_once(
             duration_ms=duration_ms,
         )
     except APIStatusError as exc:
+        interrupted = interrupted or await _finish_interrupt_task(interrupt_task)
         log_api_error(
             {
                 "timestamp": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
@@ -164,6 +177,7 @@ async def run_prompt_once(
             duration_ms=duration_ms,
         )
     except Exception as exc:
+        await _finish_interrupt_task(interrupt_task)
         log_api_error(
             {
                 "timestamp": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
@@ -181,6 +195,8 @@ async def run_prompt_once(
         )
         raise
 
+    interrupted = interrupted or await _finish_interrupt_task(interrupt_task)
+
     final_output = getattr(result, "final_output", None)
     output = final_output if isinstance(final_output, str) else "".join(chunks)
     result_usage = usage_from_run_result(result)
@@ -386,6 +402,31 @@ def _cancel_stream_result(
         cancel()
 
 
+async def _watch_stream_interrupt(
+    result: Any,
+    *,
+    should_interrupt: Callable[[], bool],
+    cancel_mode: Literal["immediate", "after_turn"],
+) -> bool:
+    while not bool(getattr(result, "is_complete", False)):
+        if should_interrupt():
+            _cancel_stream_result(result, mode=cancel_mode)
+            return True
+        await asyncio.sleep(0.05)
+    return False
+
+
+async def _finish_interrupt_task(task: asyncio.Task[bool] | None) -> bool:
+    if task is None:
+        return False
+    if task.done():
+        return task.result()
+    task.cancel()
+    with contextlib.suppress(asyncio.CancelledError):
+        await task
+    return False
+
+
 def _pending_questions_from_tool_output(output: str) -> list[dict[str, Any]]:
     if not output.strip():
         return []

{deepy_cli-0.1.2 → deepy_cli-0.1.3}/src/deepy/tools/agents.py

@@ -84,7 +84,11 @@ def build_function_tools(runtime: ToolRuntime) -> list[object]:
         ),
         FunctionTool(
             name="WebSearch",
-            description="Perform web searching using a natural language query.",
+            description=(
+                "Perform web searching using a natural language query. Use a small number of "
+                "targeted searches, then stop and synthesize once enough sources are available; "
+                "prefer WebFetch for exact URLs."
+            ),
             params_json_schema=WEB_SEARCH_SCHEMA,
             on_invoke_tool=invoke_web_search,
             strict_json_schema=False,

{deepy_cli-0.1.2 → deepy_cli-0.1.3}/src/deepy/tools/builtin.py

@@ -1,24 +1,25 @@
 from __future__ import annotations
 
 import base64
+import gzip
 import math
 import os
 import re
 import signal
-import shlex
 import subprocess
 import tempfile
 import time
 import urllib.parse
 import urllib.request
 import uuid
+import zlib
 from dataclasses import dataclass, field
 from difflib import unified_diff
 from fnmatch import fnmatch
 from html.parser import HTMLParser
 from pathlib import Path
 
-from deepy.config import Settings
+from deepy.config import DEFAULT_WEB_SEARCH_SEARXNG_URL, Settings, mask_secret
 from deepy.utils import json as json_utils
 
 from .file_state import FileSnippet, FileState
@@ -36,6 +37,20 @@ MAX_WEB_FETCH_BYTES = 2 * 1024 * 1024
 MAX_WEB_FETCH_OUTPUT_CHARS = 30_000
 DEFAULT_WEB_SEARCH_URL = "https://html.duckduckgo.com/html/"
 DEFAULT_WEB_SEARCH_RESULTS = 8
+MAX_WEB_SEARCH_CALLS_PER_TURN = 8
+WEB_SEARCH_BROWSER_HEADERS = {
+    "User-Agent": (
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) "
+        "AppleWebKit/537.36 (KHTML, like Gecko) "
+        "Chrome/124.0.0.0 Safari/537.36"
+    ),
+    "Accept": "application/json,text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+    "Accept-Language": "zh-CN,zh;q=0.9,en;q=0.8",
+    "Accept-Encoding": "gzip, deflate",
+    "Sec-Fetch-Site": "none",
+    "Sec-Fetch-Mode": "navigate",
+    "Sec-Fetch-Dest": "document",
+}
 PDF_LARGE_PAGE_THRESHOLD = 10
 PDF_MAX_PAGE_RANGE = 20
 MAX_CANDIDATE_COUNT = 5
@@ -164,6 +179,26 @@ class WebSearchResult:
     snippet: str = ""
 
 
+@dataclass(frozen=True)
+class WebSearchProviderFailure:
+    provider: str
+    error: str
+    search_url: str | None = None
+
+    def metadata(self) -> dict[str, str]:
+        payload = {"provider": self.provider, "error": self.error}
+        if self.search_url:
+            payload["searchUrl"] = _mask_url_secrets(self.search_url)
+        return payload
+
+
+@dataclass(frozen=True)
+class WebSearchProviderResult:
+    provider: str
+    search_url: str
+    results: list[WebSearchResult]
+
+
 def _find_occurrences(text: str, needle: str, scope: tuple[int, int]) -> list[MatchOccurrence]:
     matches: list[MatchOccurrence] = []
     scoped_text = text[scope[0] : scope[1]]
@@ -773,6 +808,86 @@ def _format_search_results(query: str, results: list[WebSearchResult]) -> str:
     return "\n".join(lines).strip()
 
 
+def _parse_searxng_results(body: str) -> list[WebSearchResult]:
+    payload = json_utils.loads(body)
+    if not isinstance(payload, dict):
+        raise ValueError("SearXNG response must be a JSON object.")
+    raw_results = payload.get("results")
+    if not isinstance(raw_results, list):
+        raise ValueError("SearXNG response is missing a results array.")
+    results: list[WebSearchResult] = []
+    seen_urls: set[str] = set()
+    for item in raw_results:
+        if not isinstance(item, dict):
+            continue
+        title = item.get("title")
+        url = item.get("url")
+        if not isinstance(title, str) or not title.strip():
+            continue
+        if not isinstance(url, str) or not url.strip() or url in seen_urls:
+            continue
+        content = item.get("content")
+        snippet = content if isinstance(content, str) else ""
+        seen_urls.add(url)
+        results.append(WebSearchResult(title=" ".join(title.split()), url=url, snippet=snippet.strip()))
+    return results
+
+
+def _build_searxng_search_url(base_url: str, query: str) -> str:
+    stripped = base_url.strip()
+    parsed = urllib.parse.urlparse(stripped)
+    if not parsed.scheme or not parsed.netloc:
+        raise ValueError("SearXNG URL must be a complete http or https URL.")
+    if parsed.scheme not in {"http", "https"}:
+        raise ValueError("SearXNG URL must use http or https.")
+    path = parsed.path.rstrip("/")
+    endpoint_path = parsed.path if path.endswith("/search") else f"{path}/search"
+    parts = parsed._replace(path=endpoint_path or "/search")
+    query_params = urllib.parse.parse_qsl(parts.query, keep_blank_values=True)
+    query_params.extend([("q", query), ("format", "json")])
+    return urllib.parse.urlunparse(parts._replace(query=urllib.parse.urlencode(query_params)))
+
+
+def _decode_http_body(body: bytes, *, encoding: str | None, charset: str = "utf-8") -> str:
+    normalized_encoding = (encoding or "").split(";", 1)[0].strip().lower()
+    if normalized_encoding == "gzip":
+        body = gzip.decompress(body)
+    elif normalized_encoding == "deflate":
+        try:
+            body = zlib.decompress(body)
+        except zlib.error:
+            body = zlib.decompress(body, -zlib.MAX_WBITS)
+    elif normalized_encoding not in {"", "identity"}:
+        raise ValueError(f"Unsupported content encoding: {encoding}")
+    return body.decode(charset, errors="replace")
+
+
+def _response_header(response: object, name: str) -> str | None:
+    headers = getattr(response, "headers", None)
+    if headers is None:
+        return None
+    getter = getattr(headers, "get", None)
+    if not callable(getter):
+        return None
+    value = getter(name)
+    return value if isinstance(value, str) else None
+
+
+def _mask_url_secrets(url: str) -> str:
+    parsed = urllib.parse.urlparse(url)
+    query_params = urllib.parse.parse_qsl(parsed.query, keep_blank_values=True)
+    sensitive_keys = {"api_key", "apikey", "key", "token", "access_token", "auth", "authorization"}
+    masked = [
+        (key, mask_secret(value) if key.lower() in sensitive_keys else value)
+        for key, value in query_params
+    ]
+    return urllib.parse.urlunparse(parsed._replace(query=urllib.parse.urlencode(masked)))
+
+
+def _format_provider_failures(failures: list[WebSearchProviderFailure]) -> str:
+    return "; ".join(f"{failure.provider}: {failure.error}" for failure in failures)
+
+
 class _ReadableHtmlParser(HTMLParser):
     BLOCK_TAGS = {
         "address",
@@ -928,6 +1043,7 @@ class ToolRuntime:
     settings: Settings
     file_state: FileState = field(default_factory=FileState)
     running_processes: dict[str, dict[str, str]] = field(default_factory=dict)
+    web_search_calls: int = 0
 
     def read(
         self,
@@ -1317,12 +1433,21 @@ class ToolRuntime:
         name = "WebSearch"
         if not query.strip():
             return ToolResult.error_result(name, 'Missing required "query" string.').to_json()
-        command = self.settings.tools.web_search.command
-        if command:
-            return self._web_search_command(query, command)
-        api_url = self.settings.tools.web_search.api_url
-        if api_url:
-            return self._web_search_api(query, api_url)
+        self.web_search_calls += 1
+        if self.web_search_calls > MAX_WEB_SEARCH_CALLS_PER_TURN:
+            return ToolResult.error_result(
+                name,
+                (
+                    f"WebSearch call limit reached for this turn "
+                    f"({MAX_WEB_SEARCH_CALLS_PER_TURN}). Stop searching and answer from the "
+                    "results already gathered, or use WebFetch only for a specific URL that is "
+                    "essential."
+                ),
+                metadata={
+                    "callLimit": MAX_WEB_SEARCH_CALLS_PER_TURN,
+                    "callCount": self.web_search_calls,
+                },
+            ).to_json()
         return self._web_search_builtin(query)
 
     def web_fetch(self, url: str) -> str:
@@ -1398,196 +1523,147 @@ class ToolRuntime:
             },
         ).to_json()
 
-    def _web_search_command(self, query: str, command: str) -> str:
-        name = "WebSearch"
-        prepared = _prepare_web_search_query(query)
-        activity_label = _format_web_search_activity_label(query)
-        process: subprocess.Popen[str] | None = None
-        try:
-            process = subprocess.Popen(
-                f"{command} {shlex.quote(prepared.resolved_query)}",
-                shell=True,
-                cwd=self.cwd,
-                text=True,
-                stdout=subprocess.PIPE,
-                stderr=subprocess.PIPE,
-                stdin=subprocess.DEVNULL,
-                executable="/bin/zsh",
-            )
-            process_id = str(process.pid)
-            self.running_processes[process_id] = {
-                "startTime": _now_iso(),
-                "command": activity_label,
-            }
-            stdout, stderr = process.communicate(timeout=60)
-        except subprocess.TimeoutExpired:
-            if process is not None:
-                _terminate_process(process)
-                stdout, stderr = process.communicate()
-                self.running_processes.pop(str(process.pid), None)
-            output, output_truncated = _truncate_output((stdout or "") + (stderr or ""))
-            return ToolResult.error_result(
-                name,
-                "WebSearch command timed out after 60000ms.",
-                output=output,
-                metadata={
-                    **prepared.metadata(),
-                    "activityLabel": activity_label,
-                    "outputTruncated": output_truncated,
-                    "interrupted": True,
-                },
-            ).to_json()
-        finally:
-            if process is not None:
-                self.running_processes.pop(str(process.pid), None)
-        output = (stdout or "") + (stderr or "")
-        output, output_truncated = _truncate_output(output)
-        if process.returncode != 0:
-            return ToolResult.error_result(
-                name,
-                f"WebSearch command exited with code {process.returncode}.",
-                output=output,
-                metadata={
-                    **prepared.metadata(),
-                    "exitCode": process.returncode,
-                    "activityLabel": activity_label,
-                    "outputTruncated": output_truncated,
-                },
-            ).to_json()
-        return ToolResult.ok_result(
-            name,
-            output,
-            metadata={
-                **prepared.metadata(),
-                "exitCode": process.returncode,
-                "activityLabel": activity_label,
-                "outputTruncated": output_truncated,
-            },
-        ).to_json()
-
     def _web_search_builtin(self, query: str) -> str:
         name = "WebSearch"
         prepared, prepare_error = _prepare_web_search_query_with_llm(query, self.settings)
-        search_url = (
-            DEFAULT_WEB_SEARCH_URL
-            + "?"
-            + urllib.parse.urlencode({"q": prepared.resolved_query}, doseq=False)
-        )
         activity_label = _format_web_search_activity_label(prepared.resolved_query)
         activity_id = f"web-search-{uuid.uuid4().hex}"
         self.running_processes[activity_id] = {
             "startTime": _now_iso(),
             "command": activity_label,
         }
-        request = urllib.request.Request(
-            search_url,
-            headers={
-                "User-Agent": (
-                    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) "
-                    "AppleWebKit/537.36 (KHTML, like Gecko) Deepy/0.1"
-                )
-            },
-            method="GET",
-        )
+        failures: list[WebSearchProviderFailure] = []
+        query_metadata = {
+            **prepared.metadata(),
+            "activityLabel": activity_label,
+            **({"queryPreparationWarning": prepare_error} if prepare_error else {}),
+        }
         try:
-            with urllib.request.urlopen(request, timeout=30) as response:
-                body = response.read().decode("utf-8", errors="replace")
-        except Exception as exc:
+            searxng_url = self.settings.tools.web_search.searxng_url or DEFAULT_WEB_SEARCH_SEARXNG_URL
+            result, failure = self._try_searxng_search(prepared.resolved_query, searxng_url)
+            if result is not None:
+                return ToolResult.ok_result(
+                    name,
+                    _format_search_results(prepared.resolved_query, result.results),
+                    metadata={
+                        **query_metadata,
+                        "backend": result.provider,
+                        "provider": result.provider,
+                        "searchUrl": _mask_url_secrets(result.search_url),
+                        "providerAttempts": [
+                            {**item.metadata(), "ok": False} for item in failures
+                        ]
+                        + [{"provider": result.provider, "ok": True}],
+                        "resultCount": min(len(result.results), DEFAULT_WEB_SEARCH_RESULTS),
+                    },
+                ).to_json()
+            if failure is not None:
+                failures.append(failure)
+
+            result, failure = self._try_duckduckgo_search(prepared.resolved_query)
+            if result is not None:
+                return ToolResult.ok_result(
+                    name,
+                    _format_search_results(prepared.resolved_query, result.results),
+                    metadata={
+                        **query_metadata,
+                        "backend": result.provider,
+                        "provider": result.provider,
+                        "searchUrl": _mask_url_secrets(result.search_url),
+                        "providerAttempts": [
+                            {**item.metadata(), "ok": False} for item in failures
+                        ]
+                        + [{"provider": result.provider, "ok": True}],
+                        "resultCount": min(len(result.results), DEFAULT_WEB_SEARCH_RESULTS),
+                    },
+                ).to_json()
+            if failure is not None:
+                failures.append(failure)
+
             return ToolResult.error_result(
                 name,
-                f"WebSearch request failed: {exc}",
+                "WebSearch failed: " + _format_provider_failures(failures),
                 metadata={
-                    **prepared.metadata(),
-                    "backend": "duckduckgo_html",
-                    "searchUrl": search_url,
-                    "activityLabel": activity_label,
-                    **({"queryPreparationWarning": prepare_error} if prepare_error else {}),
+                    **query_metadata,
+                    "backend": "provider_chain",
+                    "providerAttempts": [
+                        {**item.metadata(), "ok": False} for item in failures
+                    ],
                 },
             ).to_json()
         finally:
             self.running_processes.pop(activity_id, None)
 
-        results = _parse_search_results(body)
-        if not results:
-            return ToolResult.error_result(
-                name,
-                "WebSearch returned no parseable results.",
-                metadata={
-                    **prepared.metadata(),
-                    "backend": "duckduckgo_html",
-                    "searchUrl": search_url,
-                    "activityLabel": activity_label,
-                    **({"queryPreparationWarning": prepare_error} if prepare_error else {}),
-                },
-            ).to_json()
-        return ToolResult.ok_result(
-            name,
-            _format_search_results(prepared.resolved_query, results),
-            metadata={
-                **prepared.metadata(),
-                "backend": "duckduckgo_html",
-                "searchUrl": search_url,
-                "activityLabel": activity_label,
-                "resultCount": min(len(results), DEFAULT_WEB_SEARCH_RESULTS),
-                **({"queryPreparationWarning": prepare_error} if prepare_error else {}),
-            },
-        ).to_json()
-
-    def _web_search_api(self, query: str, api_url: str) -> str:
-        name = "WebSearch"
-        prepared, prepare_error = _prepare_web_search_query_with_llm(query, self.settings)
-        if prepare_error is not None:
-            return ToolResult.error_result(
-                name,
-                f"WebSearch custom API mode failed: {prepare_error}",
-                metadata={"query": query, "apiUrl": api_url},
-            ).to_json()
-        machine_id = self.settings.tools.web_search.machine_id
-        if not machine_id:
-            return ToolResult.error_result(
-                name,
-                "WebSearch custom API mode requires machine_id in the TOML tools.web_search config.",
-                metadata={**prepared.metadata(), "apiUrl": api_url},
-            ).to_json()
-        body = json_utils.dumps({"query": prepared.resolved_query}).encode("utf-8")
+    def _try_duckduckgo_search(
+        self,
+        query: str,
+    ) -> tuple[WebSearchProviderResult | None, WebSearchProviderFailure | None]:
+        provider = "duckduckgo_html"
+        search_url = DEFAULT_WEB_SEARCH_URL + "?" + urllib.parse.urlencode({"q": query}, doseq=False)
         request = urllib.request.Request(
-            api_url,
-            data=body,
+            search_url,
             headers={
-                "Content-Type": "application/json",
-                "Token": machine_id,
+                **WEB_SEARCH_BROWSER_HEADERS,
+                "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
             },
-            method="POST",
+            method="GET",
         )
         try:
             with urllib.request.urlopen(request, timeout=30) as response:
-                body = response.read().decode("utf-8", errors="replace")
+                body = _decode_http_body(
+                    response.read(),
+                    encoding=_response_header(response, "Content-Encoding"),
+                )
         except Exception as exc:
-            return ToolResult.error_result(
-                name,
-                f"WebSearch API request failed: {exc}",
-                metadata={**prepared.metadata(), "apiUrl": api_url},
-            ).to_json()
-        output = body.strip()
+            return None, WebSearchProviderFailure(
+                provider=provider,
+                error=f"request failed: {exc}",
+                search_url=search_url,
+            )
+        results = _parse_search_results(body)
+        if not results:
+            return None, WebSearchProviderFailure(
+                provider=provider,
+                error="no parseable results",
+                search_url=search_url,
+            )
+        return WebSearchProviderResult(provider=provider, search_url=search_url, results=results), None
+
+    def _try_searxng_search(
+        self,
+        query: str,
+        base_url: str,
+    ) -> tuple[WebSearchProviderResult | None, WebSearchProviderFailure | None]:
+        provider = "searxng_json"
         try:
-            payload = json_utils.loads(body)
-        except json_utils.JSONDecodeError:
-            payload = None
-        if isinstance(payload, dict):
-            result = payload.get("result")
-            if isinstance(result, str) and result.strip():
-                output = result.strip()
-        if not output:
-            return ToolResult.error_result(
-                name,
-                "WebSearch custom API mode failed: The web search response was empty.",
-                metadata={**prepared.metadata(), "apiUrl": api_url},
-            ).to_json()
-        return ToolResult.ok_result(
-            name,
-            output,
-            metadata={**prepared.metadata(), "apiUrl": api_url, "usedMachineId": bool(machine_id)},
-        ).to_json()
+            search_url = _build_searxng_search_url(base_url, query)
+        except ValueError as exc:
+            return None, WebSearchProviderFailure(provider=provider, error=str(exc))
+        request = urllib.request.Request(
+            search_url,
+            headers=WEB_SEARCH_BROWSER_HEADERS,
+            method="GET",
+        )
+        try:
+            with urllib.request.urlopen(request, timeout=30) as response:
+                body = _decode_http_body(
+                    response.read(),
+                    encoding=_response_header(response, "Content-Encoding"),
+                )
+            results = _parse_searxng_results(body)
+        except Exception as exc:
+            return None, WebSearchProviderFailure(
+                provider=provider,
+                error=f"request failed: {exc}",
+                search_url=search_url,
+            )
+        if not results:
+            return None, WebSearchProviderFailure(
+                provider=provider,
+                error="no parseable results",
+                search_url=search_url,
+            )
+        return WebSearchProviderResult(provider=provider, search_url=search_url, results=results), None
 
 
 def _unified_diff(old: str, new: str, *, path: str) -> str:

{deepy_cli-0.1.2 → deepy_cli-0.1.3}/src/deepy/ui/terminal.py

@@ -1,8 +1,14 @@
 from __future__ import annotations
 
 import asyncio
+import contextlib
+import os
+import select
+import sys
+import termios
 import threading
 import time
+import tty
 from collections.abc import Awaitable, Callable
 from dataclasses import dataclass
 from pathlib import Path
@@ -220,10 +226,19 @@ def _run_once_with_status(
     **kwargs: object,
 ) -> RunSummary:
     original_emit_event = kwargs.pop("emit_event", None)
+    original_should_interrupt = kwargs.pop("should_interrupt", None)
     project_root = kwargs.get("project_root")
     project_root_text = str(project_root) if project_root is not None else None
     renderer: TerminalStreamRenderer | None = None
     started_at = time.monotonic()
+    interrupt_requested = threading.Event()
+
+    def should_interrupt() -> bool:
+        if interrupt_requested.is_set():
+            return True
+        return bool(callable(original_should_interrupt) and original_should_interrupt())
+
+    kwargs["should_interrupt"] = should_interrupt
 
     with console.status(_working_status_text(started_at), spinner="dots") as status:
         renderer = TerminalStreamRenderer(
@@ -241,12 +256,13 @@ def _run_once_with_status(
         status_thread.start()
 
         try:
-            def emit_event(event: DeepyStreamEvent) -> None:
-                renderer(event)
-                if callable(original_emit_event):
-                    original_emit_event(event)
+            with _esc_interrupt_watcher(interrupt_requested):
+                def emit_event(event: DeepyStreamEvent) -> None:
+                    renderer(event)
+                    if callable(original_emit_event):
+                        original_emit_event(event)
 
-            summary = asyncio.run(run_once(prompt, **kwargs, emit_event=emit_event))
+                summary = asyncio.run(run_once(prompt, **kwargs, emit_event=emit_event))
         finally:
             stop_status_refresh.set()
             status_thread.join(timeout=0.2)
@@ -255,6 +271,58 @@ def _run_once_with_status(
     return summary
 
 
+@contextlib.contextmanager
+def _esc_interrupt_watcher(interrupt_requested: threading.Event):
+    if not sys.stdin.isatty() and not Path("/dev/tty").exists():
+        yield
+        return
+
+    stop_event = threading.Event()
+    thread = threading.Thread(
+        target=_watch_esc_keypress,
+        args=(interrupt_requested, stop_event),
+        daemon=True,
+    )
+    thread.start()
+    try:
+        yield
+    finally:
+        stop_event.set()
+        thread.join(timeout=0.2)
+
+
+def _watch_esc_keypress(
+    interrupt_requested: threading.Event,
+    stop_event: threading.Event,
+) -> None:
+    fd: int | None = None
+    old_attrs: list[Any] | None = None
+    try:
+        fd = os.open("/dev/tty", os.O_RDONLY | os.O_NONBLOCK)
+        old_attrs = termios.tcgetattr(fd)
+        tty.setcbreak(fd)
+        while not stop_event.is_set() and not interrupt_requested.is_set():
+            readable, _, _ = select.select([fd], [], [], 0.05)
+            if not readable:
+                continue
+            try:
+                data = os.read(fd, 32)
+            except BlockingIOError:
+                continue
+            if b"\x1b" in data:
+                interrupt_requested.set()
+                return
+    except Exception:
+        return
+    finally:
+        if fd is not None:
+            if old_attrs is not None:
+                with contextlib.suppress(Exception):
+                    termios.tcsetattr(fd, termios.TCSADRAIN, old_attrs)
+            with contextlib.suppress(Exception):
+                os.close(fd)
+
+
 class TerminalStreamRenderer:
     def __init__(
         self,

deepy_cli-0.1.2/src/deepy/data/tools/WebSearch.md

@@ -1,9 +0,0 @@
-## WebSearch
-
-Search when current or external information is required.
-
-Args: `query`.
-
-Uses the configured local command first, then configured API endpoint if present. If
-neither is configured, uses Deepy's built-in local web search implementation and
-returns parsed search result titles, URLs, and snippets.