alpiecode 10.5.6__tar.gz → 10.5.7__tar.gz

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

@@ -1,12 +1,11 @@
 Metadata-Version: 2.4
 Name: alpiecode
-Version: 10.5.6
+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

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

@@ -4,14 +4,13 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "alpiecode"
-version = "10.5.6"
+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",

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

@@ -1,12 +1,11 @@
 Metadata-Version: 2.4
 Name: alpiecode
-Version: 10.5.6
+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

{alpiecode-10.5.6 → 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

{alpiecode-10.5.6 → 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.6"
+__version__ = "10.5.7"
 
 def run(task: str, workdir: str = ".", reasoning_level: str = "thinking", **kwargs):
     """Run an autonomous coding task programmatically."""

{alpiecode-10.5.6 → 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)