alpiecode 10.5.5__tar.gz → 10.5.7__tar.gz

{alpiecode-10.5.5 → alpiecode-10.5.7}/PKG-INFO

@@ -1,12 +1,11 @@
 Metadata-Version: 2.4
 Name: alpiecode
-Version: 10.5.5
+Version: 10.5.7
 Summary: AlpieCode
 Requires-Python: >=3.9
 Requires-Dist: huggingface_hub>=0.20.0
 Requires-Dist: rich>=13.0
 Requires-Dist: click>=8.0
-Requires-Dist: openai>=1.0.0
 Requires-Dist: httpx[http2]>=0.24.0
 Requires-Dist: beautifulsoup4>=4.12.0
 Requires-Dist: yt-dlp>=2024.0.0
@@ -14,5 +13,3 @@ Requires-Dist: imageio-ffmpeg>=0.4.0
 Requires-Dist: fastapi>=0.100.0
 Requires-Dist: uvicorn>=0.20.0
 Requires-Dist: sse-starlette>=2.0.0
-Provides-Extra: search
-Requires-Dist: duckduckgo-search>=7.0.0; extra == "search"

{alpiecode-10.5.5 → alpiecode-10.5.7}/pyproject.toml

@@ -4,14 +4,13 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "alpiecode"
-version = "10.5.5"
+version = "10.5.7"
 description = "AlpieCode"
 requires-python = ">=3.9"
 dependencies = [
     "huggingface_hub>=0.20.0",
     "rich>=13.0",
     "click>=8.0",
-    "openai>=1.0.0",
     "httpx[http2]>=0.24.0",
     "beautifulsoup4>=4.12.0",
     "yt-dlp>=2024.0.0",
@@ -21,11 +20,6 @@ dependencies = [
     "sse-starlette>=2.0.0",
 ]
 
-[project.optional-dependencies]
-search = [
-    "duckduckgo-search>=7.0.0",
-]
-
 [project.scripts]
 alpiecode = "codeagent.cli:main"
 codeagent = "codeagent.cli:main"

{alpiecode-10.5.5 → alpiecode-10.5.7}/src/alpiecode.egg-info/PKG-INFO

@@ -1,12 +1,11 @@
 Metadata-Version: 2.4
 Name: alpiecode
-Version: 10.5.5
+Version: 10.5.7
 Summary: AlpieCode
 Requires-Python: >=3.9
 Requires-Dist: huggingface_hub>=0.20.0
 Requires-Dist: rich>=13.0
 Requires-Dist: click>=8.0
-Requires-Dist: openai>=1.0.0
 Requires-Dist: httpx[http2]>=0.24.0
 Requires-Dist: beautifulsoup4>=4.12.0
 Requires-Dist: yt-dlp>=2024.0.0
@@ -14,5 +13,3 @@ Requires-Dist: imageio-ffmpeg>=0.4.0
 Requires-Dist: fastapi>=0.100.0
 Requires-Dist: uvicorn>=0.20.0
 Requires-Dist: sse-starlette>=2.0.0
-Provides-Extra: search
-Requires-Dist: duckduckgo-search>=7.0.0; extra == "search"

{alpiecode-10.5.5 → alpiecode-10.5.7}/src/alpiecode.egg-info/requires.txt

@@ -1,7 +1,6 @@
 huggingface_hub>=0.20.0
 rich>=13.0
 click>=8.0
-openai>=1.0.0
 httpx[http2]>=0.24.0
 beautifulsoup4>=4.12.0
 yt-dlp>=2024.0.0
@@ -9,6 +8,3 @@ imageio-ffmpeg>=0.4.0
 fastapi>=0.100.0
 uvicorn>=0.20.0
 sse-starlette>=2.0.0
-
-[search]
-duckduckgo-search>=7.0.0

{alpiecode-10.5.5 → alpiecode-10.5.7}/src/codeagent/__init__.py

@@ -17,7 +17,7 @@ Supports:
 from pathlib import Path
 from typing import Optional, Any, Dict
 
-__version__ = "10.5.5"
+__version__ = "10.5.7"
 
 def run(task: str, workdir: str = ".", reasoning_level: str = "thinking", **kwargs):
     """Run an autonomous coding task programmatically."""

{alpiecode-10.5.5 → alpiecode-10.5.7}/src/codeagent/backends/openai_backend.py

@@ -7,11 +7,138 @@ import json
 import logging
 import re
 from typing import Any, List, Optional
-from openai import OpenAI, NotFoundError
+from types import SimpleNamespace
+from typing import Any, Dict, Generator, List, Optional
+import httpx
 
 logger = logging.getLogger(__name__)
 
 
+class NotFoundError(Exception):
+    """Raised when remote endpoint returns 404 Not Found."""
+    pass
+
+
+class APIError(Exception):
+    """Raised when remote endpoint returns non-200 HTTP status."""
+    pass
+
+
+class _Namespace(SimpleNamespace):
+    """SimpleNamespace subclass that safely returns None for missing attributes instead of raising AttributeError."""
+    def __getattr__(self, name: str) -> Any:
+        return None
+
+
+def _dict_to_obj(d: Any) -> Any:
+    """Recursively wraps a dict into a _Namespace so attribute access works seamlessly."""
+    if isinstance(d, dict):
+        return _Namespace(**{k: _dict_to_obj(v) for k, v in d.items()})
+    if isinstance(d, list):
+        return [_dict_to_obj(item) for item in d]
+    return d
+
+
+class _HTTPXChatCompletions:
+    def __init__(self, client: "_HTTPXClient"):
+        self._client = client
+
+    def create(self, **kwargs: Any) -> Any:
+        stream = kwargs.get("stream", False)
+        timeout = kwargs.get("timeout", 90.0)
+
+        payload: Dict[str, Any] = {
+            "model": kwargs.get("model"),
+            "messages": kwargs.get("messages", []),
+            "temperature": kwargs.get("temperature", 0.1),
+            "max_tokens": kwargs.get("max_tokens", 8192),
+            "stream": stream,
+        }
+        if "tools" in kwargs and kwargs["tools"]:
+            payload["tools"] = kwargs["tools"]
+            payload["tool_choice"] = kwargs.get("tool_choice", "auto")
+        if "extra_body" in kwargs and isinstance(kwargs["extra_body"], dict):
+            payload.update(kwargs["extra_body"])
+
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {self._client.api_key}",
+        }
+
+        base = self._client.base_url.rstrip("/")
+        url = f"{base}/chat/completions"
+
+        if stream:
+            return self._stream_request(url, headers, payload, timeout)
+        return self._sync_request(url, headers, payload, timeout)
+
+    def _stream_request(self, url: str, headers: dict, payload: dict, timeout: float) -> Generator[Any, None, None]:
+        http_client = self._client.http_client
+        req = http_client.build_request("POST", url, headers=headers, json=payload, timeout=timeout)
+        resp = http_client.send(req, stream=True)
+        if resp.status_code == 404:
+            resp.close()
+            raise NotFoundError("Model or endpoint not found")
+        if resp.status_code != 200:
+            err_text = resp.read().decode("utf-8", errors="replace")
+            resp.close()
+            raise APIError(f"HTTP {resp.status_code}: {err_text}")
+
+        try:
+            for line in resp.iter_lines():
+                line = line.strip()
+                if not line or not line.startswith("data: "):
+                    continue
+                data_str = line[6:].strip()
+                if data_str == "[DONE]":
+                    break
+                try:
+                    chunk_dict = json.loads(data_str)
+                except Exception:
+                    continue
+                yield _dict_to_obj(chunk_dict)
+        finally:
+            resp.close()
+
+    def _sync_request(self, url: str, headers: dict, payload: dict, timeout: float) -> Any:
+        resp = self._client.http_client.post(url, headers=headers, json=payload, timeout=timeout)
+        if resp.status_code == 404:
+            raise NotFoundError("Model or endpoint not found")
+        if resp.status_code != 200:
+            raise APIError(f"HTTP {resp.status_code}: {resp.text}")
+        data = json.loads(resp.text)
+        return _dict_to_obj(data)
+
+
+class _HTTPXModels:
+    def __init__(self, client: "_HTTPXClient"):
+        self._client = client
+
+    def list(self) -> Any:
+        base = self._client.base_url.rstrip("/")
+        url = f"{base}/models"
+        headers = {
+            "Authorization": f"Bearer {self._client.api_key}",
+        }
+        try:
+            resp = self._client.http_client.get(url, headers=headers, timeout=3.0)
+            if resp.status_code != 200:
+                return _Namespace(data=[])
+            data = json.loads(resp.text)
+            return _dict_to_obj(data)
+        except Exception:
+            return _Namespace(data=[])
+
+
+class _HTTPXClient:
+    def __init__(self, base_url: str, api_key: str, http_client: Any = None):
+        self.base_url = base_url
+        self.api_key = api_key or "not-needed"
+        self.http_client = http_client if http_client is not None else get_shared_http_client()
+        self.chat = _Namespace(completions=_HTTPXChatCompletions(self))
+        self.models = _HTTPXModels(self)
+
+
 def _repair_and_parse_json_arguments(raw_args: str) -> dict:
     """
     Robustly parse tool call arguments from potentially partial or malformed streaming strings.
@@ -125,7 +252,7 @@ class OpenAIBackend:
 
     def __init__(self, cfg: Config):
         self._cfg = cfg
-        self._client: Optional[OpenAI] = None
+        self._client: Optional[Any] = None
         self._resolved_model: Optional[str] = None
         self._max_model_len: Optional[int] = None
 
@@ -143,16 +270,16 @@ class OpenAIBackend:
             return self._max_model_len
         return 262_144
 
-    def _ensure_client(self) -> OpenAI:
+    def _ensure_client(self) -> Any:
         if self._client is None:
-            self._client = OpenAI(
+            self._client = _HTTPXClient(
                 base_url=self._cfg.base_url,
                 api_key=self._cfg.api_key or "not-needed",
                 http_client=get_shared_http_client(),
             )
         return self._client
 
-    def _get_available_model(self, client: OpenAI) -> str:
+    def _get_available_model(self, client: Any) -> str:
         """Auto-discover the served model name from /v1/models.
 
         Uses a dedicated short-timeout (3s) probe to avoid blocking the agent
@@ -163,18 +290,15 @@ class OpenAIBackend:
             return self._resolved_model
         try:
             import httpx
-            # Use a dedicated short-timeout client for model discovery only.
-            # The shared HTTP client has a 120s read timeout which causes
-            # multi-minute hangs when /v1/models is slow or unresponsive.
-            probe_client = OpenAI(
+            probe_client = _HTTPXClient(
                 base_url=self._cfg.base_url,
                 api_key=self._cfg.api_key or "not-needed",
                 http_client=httpx.Client(timeout=httpx.Timeout(3.0, connect=2.0)),
             )
             models_list = probe_client.models.list()
-            if models_list.data:
+            if hasattr(models_list, "data") and models_list.data:
                 for m in models_list.data:
-                    if m.id == self._cfg.model or getattr(m, "root", None) == self._cfg.model:
+                    if getattr(m, "id", None) == self._cfg.model or getattr(m, "root", None) == self._cfg.model:
                         self._resolved_model = m.id
                         self._max_model_len = getattr(m, "max_model_len", None)
                         logger.info("Resolved model: %s (max_len=%s)", self._resolved_model, self._max_model_len)

{alpiecode-10.5.5 → alpiecode-10.5.7}/src/codeagent/tools.py

@@ -760,14 +760,15 @@ def _apply_patch(workdir: Path, path: str, patch: str) -> str:
 
 
 def _web_search(query: str, num_results: int = 5) -> str:
-    """Search the web using httpx (DuckDuckGo), with optional ddgs fallback."""
+    """Search the web using httpx and DuckDuckGo HTTP endpoints, parsed via BeautifulSoup."""
     import warnings
     import urllib.parse
     warnings.filterwarnings("ignore", category=RuntimeWarning)
     
-    # 1. Primary: Pure-Python search using httpx (no Rust/primp native dependencies)
     try:
         import httpx
+        from bs4 import BeautifulSoup
+        
         headers = {
             "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
             "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
@@ -779,65 +780,44 @@ def _web_search(query: str, num_results: int = 5) -> str:
                 resp = client.post("https://lite.duckduckgo.com/lite/", data={"q": query}, headers=headers)
                 
             if resp.status_code == 200 and resp.text:
-                try:
-                    from bs4 import BeautifulSoup
-                    soup = BeautifulSoup(resp.text, "html.parser")
-                    results = []
-                    for item in soup.select(".result"):
-                        title_elem = item.select_one(".result__title a")
-                        snippet_elem = item.select_one(".result__snippet")
-                        if title_elem:
-                            title = title_elem.get_text(strip=True)
-                            href = title_elem.get("href", "")
+                soup = BeautifulSoup(resp.text, "html.parser")
+                results = []
+                for item in soup.select(".result"):
+                    title_elem = item.select_one(".result__title a")
+                    snippet_elem = item.select_one(".result__snippet")
+                    if title_elem:
+                        title = title_elem.get_text(strip=True)
+                        href = title_elem.get("href", "")
+                        if "uddg=" in href:
+                            parsed = urllib.parse.parse_qs(urllib.parse.urlparse(href).query)
+                            href = parsed.get("uddg", [href])[0]
+                        snippet = snippet_elem.get_text(strip=True) if snippet_elem else ""
+                        results.append({"title": title, "href": href, "body": snippet})
+                        if len(results) >= min(num_results, 10):
+                            break
+                            
+                if not results:
+                    for row in soup.select("table tr"):
+                        link = row.select_one("a.result-link")
+                        snippet = row.select_one(".result-snippet")
+                        if link:
+                            title = link.get_text(strip=True)
+                            href = link.get("href", "")
                             if "uddg=" in href:
                                 parsed = urllib.parse.parse_qs(urllib.parse.urlparse(href).query)
                                 href = parsed.get("uddg", [href])[0]
-                            snippet = snippet_elem.get_text(strip=True) if snippet_elem else ""
-                            results.append({"title": title, "href": href, "body": snippet})
+                            snip_text = snippet.get_text(strip=True) if snippet else ""
+                            results.append({"title": title, "href": href, "body": snip_text})
                             if len(results) >= min(num_results, 10):
                                 break
                                 
-                    if not results:
-                        for row in soup.select("table tr"):
-                            link = row.select_one("a.result-link")
-                            snippet = row.select_one(".result-snippet")
-                            if link:
-                                title = link.get_text(strip=True)
-                                href = link.get("href", "")
-                                if "uddg=" in href:
-                                    parsed = urllib.parse.parse_qs(urllib.parse.urlparse(href).query)
-                                    href = parsed.get("uddg", [href])[0]
-                                snip_text = snippet.get_text(strip=True) if snippet else ""
-                                results.append({"title": title, "href": href, "body": snip_text})
-                                if len(results) >= min(num_results, 10):
-                                    break
-                                    
-                    if results:
-                        formatted = []
-                        for i, r in enumerate(results, 1):
-                            formatted.append(f"{i}. **{r.get('title', 'No title')}**\n   URL: {r.get('href', '')}\n   {r.get('body', '')}")
-                        return "\n\n".join(formatted)
-                except Exception:
-                    pass
-    except Exception:
-        pass
-
-    # 2. Secondary fallback: duckduckgo_search if optionally installed
-    try:
-        try:
-            from ddgs import DDGS
-        except ImportError:
-            from duckduckgo_search import DDGS
-            
-        with DDGS() as ddgs:
-            results = list(ddgs.text(query, max_results=min(num_results, 10)))
-        if results:
-            formatted = []
-            for i, r in enumerate(results, 1):
-                formatted.append(f"{i}. **{r.get('title', 'No title')}**\n   URL: {r.get('href', '')}\n   {r.get('body', '')}")
-            return "\n\n".join(formatted)
-    except Exception:
-        pass
+                if results:
+                    formatted = []
+                    for i, r in enumerate(results, 1):
+                        formatted.append(f"{i}. **{r.get('title', 'No title')}**\n   URL: {r.get('href', '')}\n   {r.get('body', '')}")
+                    return "\n\n".join(formatted)
+    except Exception as e:
+        return f"error during web search: {e}"
 
     return (
         f"No web results found for '{query}'. "