devsper 2.1.6__py3-none-any.whl

devsper/providers/router/backends/anthropic_backend.py

@@ -0,0 +1,111 @@
+"""Anthropic Claude LLM backend."""
+
+import os
+
+from devsper.providers.router.base import LLMBackend, LLMRequest, LLMResponse
+
+
+def _messages_to_anthropic(messages: list[dict]) -> list:
+    from langchain_core.messages import HumanMessage, AIMessage, SystemMessage
+    out = []
+    for m in messages:
+        role = (m.get("role") or "user").lower()
+        content = m.get("content") or ""
+        if role == "user":
+            out.append(HumanMessage(content=content))
+        elif role == "assistant":
+            out.append(AIMessage(content=content))
+        elif role == "system":
+            out.append(SystemMessage(content=content))
+        else:
+            out.append(HumanMessage(content=content))
+    return out
+
+
+class AnthropicBackend(LLMBackend):
+    """Anthropic API (and Azure Foundry when env is set)."""
+
+    def __init__(
+        self,
+        api_key: str | None = None,
+        *,
+        azure: bool = False,
+        azure_endpoint: str | None = None,
+        azure_api_key: str | None = None,
+        azure_deployment: str | None = None,
+    ) -> None:
+        self.azure = azure or bool(
+            os.environ.get("AZURE_ANTHROPIC_ENDPOINT") or os.environ.get("AZURE_ANTHROPIC_API_KEY")
+        )
+        self.azure_endpoint = (azure_endpoint or os.environ.get("AZURE_ANTHROPIC_ENDPOINT", "")).rstrip("/")
+        if self.azure_endpoint.endswith("/messages"):
+            self.azure_endpoint = self.azure_endpoint[: -len("/messages")]
+        self.api_key = azure_api_key or os.environ.get("AZURE_ANTHROPIC_API_KEY") if self.azure else (api_key or os.environ.get("ANTHROPIC_API_KEY"))
+        self.azure_deployment = (azure_deployment or os.environ.get("AZURE_ANTHROPIC_DEPLOYMENT_NAME") or "").strip()
+        self._llm = None
+
+    @property
+    def name(self) -> str:
+        return "anthropic"
+
+    def _get_llm(self, model: str):
+        if self._llm is not None:
+            return self._llm
+        from langchain_anthropic import ChatAnthropic
+        if self.azure:
+            self._llm = ChatAnthropic(
+                model=model or self.azure_deployment or "claude-3-5-sonnet-20241022",
+                anthropic_api_url=self.azure_endpoint,
+                anthropic_api_key=self.api_key,
+                temperature=0,
+            )
+        else:
+            self._llm = ChatAnthropic(
+                model=model or "claude-3-5-sonnet-20241022",
+                api_key=self.api_key,
+                temperature=0,
+            )
+        return self._llm
+
+    def supports_model(self, model_name: str) -> bool:
+        return (model_name or "").strip().lower().startswith("claude")
+
+    async def complete(self, request: LLMRequest) -> LLMResponse:
+        from langchain_core.messages import HumanMessage
+        model = request.model or "claude-3-5-sonnet-20241022"
+        llm = self._get_llm(model)
+        lc_messages = _messages_to_anthropic(request.messages)
+        msg = await llm.ainvoke(lc_messages)
+        content = msg.content if isinstance(msg.content, str) else str(msg.content or "")
+        usage = {}
+        if hasattr(msg, "response_metadata") and msg.response_metadata:
+            meta = msg.response_metadata
+            usage = {
+                "prompt_tokens": meta.get("input_tokens", 0),
+                "completion_tokens": meta.get("output_tokens", 0),
+                "total_tokens": meta.get("input_tokens", 0) + meta.get("output_tokens", 0),
+            }
+        return LLMResponse(
+            content=content,
+            model=model,
+            usage=usage,
+            finish_reason="stop",
+            backend=self.name,
+        )
+
+    async def stream(self, request: LLMRequest):
+        model = request.model or "claude-3-5-sonnet-20241022"
+        llm = self._get_llm(model)
+        lc_messages = _messages_to_anthropic(request.messages)
+        async for chunk in llm.astream(lc_messages):
+            if hasattr(chunk, "content") and chunk.content:
+                yield chunk.content
+
+    async def health(self) -> bool:
+        try:
+            await self.complete(
+                LLMRequest(model="claude-3-haiku-20240307", messages=[{"role": "user", "content": "Hi"}], max_tokens=2)
+            )
+            return True
+        except Exception:
+            return False

devsper/providers/router/backends/custom_backend.py

@@ -0,0 +1,138 @@
+"""Custom OpenAI-compatible endpoint backend."""
+
+import httpx
+
+from devsper.providers.router.base import LLMBackend, LLMRequest, LLMResponse
+
+
+def _messages_to_openai(messages: list[dict]) -> list[dict]:
+    out = []
+    for m in messages:
+        role = (m.get("role") or "user").lower()
+        content = m.get("content") or ""
+        out.append({"role": role, "content": content})
+    return out
+
+
+class CustomBackend(LLMBackend):
+    """Any OpenAI-compatible endpoint (base_url, optional api_key, optional model_prefix_strip)."""
+
+    def __init__(
+        self,
+        base_url: str,
+        api_key: str | None = None,
+        model_prefix_strip: str | None = None,
+    ) -> None:
+        self.base_url = base_url.rstrip("/")
+        self.api_key = api_key
+        self.model_prefix_strip = (model_prefix_strip or "").strip() or None
+
+    @property
+    def name(self) -> str:
+        return "custom"
+
+    def _model_for_request(self, model: str) -> str:
+        if self.model_prefix_strip and model.startswith(self.model_prefix_strip):
+            return model[len(self.model_prefix_strip):].lstrip("-")
+        return model
+
+    def supports_model(self, model_name: str) -> bool:
+        return True
+
+    def _headers(self) -> dict[str, str]:
+        h = {"Content-Type": "application/json"}
+        if self.api_key:
+            h["Authorization"] = f"Bearer {self.api_key}"
+        return h
+
+    async def complete(self, request: LLMRequest) -> LLMResponse:
+        model = self._model_for_request(request.model or "gpt-4o")
+        messages = _messages_to_openai(request.messages)
+        payload = {
+            "model": model,
+            "messages": messages,
+            "max_tokens": request.max_tokens,
+            "temperature": request.temperature,
+        }
+        if request.tools:
+            payload["tools"] = request.tools
+        url = f"{self.base_url}/v1/chat/completions"
+        from devsper.utils.http import ssl_verify, format_retry_after
+        async with httpx.AsyncClient(timeout=120.0, verify=ssl_verify()) as client:
+            r = await client.post(url, headers=self._headers(), json=payload)
+            try:
+                r.raise_for_status()
+            except httpx.HTTPStatusError as e:
+                hint = format_retry_after(e.response)
+                if hint:
+                    raise httpx.HTTPStatusError(
+                        str(e) + hint, request=e.request, response=e.response
+                    ) from e
+                raise
+            data = r.json()
+        choices = data.get("choices") or []
+        content = ""
+        finish_reason = "stop"
+        if choices:
+            msg = choices[0].get("message") or {}
+            content = msg.get("content") or ""
+            finish_reason = choices[0].get("finish_reason") or "stop"
+        usage = data.get("usage") or {}
+        return LLMResponse(
+            content=content,
+            model=model,
+            usage={
+                "prompt_tokens": usage.get("prompt_tokens", 0),
+                "completion_tokens": usage.get("completion_tokens", 0),
+                "total_tokens": usage.get("total_tokens", 0),
+            },
+            finish_reason=finish_reason,
+            backend=self.name,
+        )
+
+    async def stream(self, request: LLMRequest):
+        model = self._model_for_request(request.model or "gpt-4o")
+        messages = _messages_to_openai(request.messages)
+        payload = {
+            "model": model,
+            "messages": messages,
+            "max_tokens": request.max_tokens,
+            "temperature": request.temperature,
+            "stream": True,
+        }
+        url = f"{self.base_url}/v1/chat/completions"
+        from devsper.utils.http import ssl_verify, format_retry_after
+        async with httpx.AsyncClient(timeout=120.0, verify=ssl_verify()) as client:
+            async with client.stream("POST", url, headers=self._headers(), json=payload) as resp:
+                try:
+                    resp.raise_for_status()
+                except httpx.HTTPStatusError as e:
+                    hint = format_retry_after(e.response)
+                    if hint:
+                        raise httpx.HTTPStatusError(
+                            str(e) + hint, request=e.request, response=e.response
+                        ) from e
+                    raise
+                async for line in resp.aiter_lines():
+                    if not line.strip():
+                        continue
+                    if line.strip() == "data: [DONE]":
+                        return
+                    if line.startswith("data: "):
+                        import json
+                        try:
+                            chunk = json.loads(line[6:])
+                            choices = chunk.get("choices") or []
+                            if choices and choices[0].get("delta", {}).get("content"):
+                                yield choices[0]["delta"]["content"]
+                        except Exception:
+                            pass
+
+    async def health(self) -> bool:
+        try:
+            await self.complete(
+                LLMRequest(model="gpt-4o-mini", messages=[{"role": "user", "content": "Hi"}], max_tokens=2)
+            )
+            return True
+        except Exception:
+            return False

devsper/providers/router/backends/gemini_backend.py

@@ -0,0 +1,89 @@
+"""Google Gemini LLM backend."""
+
+import os
+
+from devsper.providers.router.base import LLMBackend, LLMRequest, LLMResponse
+
+
+def _messages_to_lc(messages: list[dict]) -> list:
+    from langchain_core.messages import HumanMessage, AIMessage, SystemMessage
+    out = []
+    for m in messages:
+        role = (m.get("role") or "user").lower()
+        content = m.get("content") or ""
+        if role == "user":
+            out.append(HumanMessage(content=content))
+        elif role == "assistant":
+            out.append(AIMessage(content=content))
+        elif role == "system":
+            out.append(SystemMessage(content=content))
+        else:
+            out.append(HumanMessage(content=content))
+    return out
+
+
+class GeminiBackend(LLMBackend):
+    """Google Gemini API."""
+
+    def __init__(self, api_key: str | None = None) -> None:
+        self.api_key = api_key or os.environ.get("GOOGLE_API_KEY") or os.environ.get("GEMINI_API_KEY")
+        if not self.api_key:
+            raise ValueError("Gemini requires api_key or GOOGLE_API_KEY or GEMINI_API_KEY")
+        self._llm = None
+
+    @property
+    def name(self) -> str:
+        return "gemini"
+
+    def _get_llm(self, model: str):
+        if self._llm is not None:
+            return self._llm
+        from langchain_google_genai import ChatGoogleGenerativeAI
+        self._llm = ChatGoogleGenerativeAI(
+            model=model or "gemini-1.5-flash",
+            google_api_key=self.api_key,
+            temperature=0,
+        )
+        return self._llm
+
+    def supports_model(self, model_name: str) -> bool:
+        return (model_name or "").strip().lower().startswith("gemini")
+
+    async def complete(self, request: LLMRequest) -> LLMResponse:
+        model = request.model or "gemini-1.5-flash"
+        llm = self._get_llm(model)
+        lc_messages = _messages_to_lc(request.messages)
+        msg = await llm.ainvoke(lc_messages)
+        content = msg.content if isinstance(msg.content, str) else str(msg.content or "")
+        usage = {}
+        if hasattr(msg, "response_metadata") and msg.response_metadata:
+            meta = msg.response_metadata
+            usage = {
+                "prompt_tokens": meta.get("input_tokens", 0),
+                "completion_tokens": meta.get("output_tokens", 0),
+                "total_tokens": meta.get("input_tokens", 0) + meta.get("output_tokens", 0),
+            }
+        return LLMResponse(
+            content=content,
+            model=model,
+            usage=usage,
+            finish_reason="stop",
+            backend=self.name,
+        )
+
+    async def stream(self, request: LLMRequest):
+        model = request.model or "gemini-1.5-flash"
+        llm = self._get_llm(model)
+        lc_messages = _messages_to_lc(request.messages)
+        async for chunk in llm.astream(lc_messages):
+            if hasattr(chunk, "content") and chunk.content:
+                yield chunk.content
+
+    async def health(self) -> bool:
+        try:
+            await self.complete(
+                LLMRequest(model="gemini-1.5-flash", messages=[{"role": "user", "content": "Hi"}], max_tokens=2)
+            )
+            return True
+        except Exception:
+            return False

devsper/providers/router/backends/github_backend.py

@@ -0,0 +1,165 @@
+"""GitHub Models LLM backend (models.github.ai)."""
+
+import json
+import logging
+import os
+import time
+
+import httpx
+
+from devsper.providers.router.base import LLMBackend, LLMRequest, LLMResponse
+
+log = logging.getLogger(__name__)
+
+GITHUB_MODELS_BASE = "https://models.github.ai"
+GITHUB_CHAT_URL = f"{GITHUB_MODELS_BASE}/inference/chat/completions"
+GITHUB_API_VERSION = "2022-11-28"
+DEFAULT_GITHUB_MODEL = "openai/gpt-4.1"
+GITHUB_429_MAX_RETRIES = 3
+GITHUB_429_BASE_DELAY = 1.0
+
+
+def _normalize_model_id(model: str) -> str:
+    s = model.split(":", 1)[-1].strip() if ":" in model else model.strip()
+    if not s or s.lower() == "copilot":
+        return DEFAULT_GITHUB_MODEL
+    return s
+
+
+class GitHubBackend(LLMBackend):
+    """GitHub Models API. Uses GITHUB_TOKEN."""
+
+    def __init__(self, token: str | None = None) -> None:
+        self.token = token or os.environ.get("GITHUB_TOKEN")
+        if not self.token:
+            raise ValueError("GitHub backend requires GITHUB_TOKEN")
+
+    @property
+    def name(self) -> str:
+        return "github"
+
+    def _headers(self) -> dict[str, str]:
+        return {
+            "Accept": "application/vnd.github.v3+json",
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {self.token}",
+            "X-GitHub-Api-Version": GITHUB_API_VERSION,
+        }
+
+    def supports_model(self, model_name: str) -> bool:
+        return True
+
+    async def complete(self, request: LLMRequest) -> LLMResponse:
+        api_model = _normalize_model_id(request.model)
+        messages = request.messages
+        last_content = ""
+        for m in reversed(messages):
+            if (m.get("role") or "user").lower() == "user":
+                last_content = m.get("content") or ""
+                break
+        payload = {
+            "model": api_model,
+            "messages": [{"role": "user", "content": last_content}] if last_content else [{"role": "user", "content": "Hi"}],
+            "max_tokens": request.max_tokens,
+            "temperature": request.temperature,
+        }
+        from devsper.utils.http import ssl_verify, format_retry_after
+        async with httpx.AsyncClient(timeout=60.0, verify=ssl_verify()) as client:
+            for attempt in range(GITHUB_429_MAX_RETRIES):
+                try:
+                    resp = await client.post(
+                        GITHUB_CHAT_URL,
+                        headers=self._headers(),
+                        json=payload,
+                    )
+                    resp.raise_for_status()
+                    data = resp.json()
+                    break
+                except httpx.HTTPStatusError as e:
+                    retry_hint = format_retry_after(e.response)
+                    if e.response.status_code == 429 and attempt < GITHUB_429_MAX_RETRIES - 1:
+                        delay = min(GITHUB_429_BASE_DELAY * (2**attempt), 32.0)
+                        log.warning(
+                            "GitHub 429, retry %s/%s in %.1fs%s",
+                            attempt + 1, GITHUB_429_MAX_RETRIES, delay, retry_hint,
+                        )
+                        time.sleep(delay)
+                    else:
+                        if retry_hint:
+                            raise httpx.HTTPStatusError(
+                                str(e) + retry_hint, request=e.request, response=e.response
+                            ) from e
+                        raise
+        choices = data.get("choices") or []
+        content = ""
+        if choices:
+            msg = choices[0].get("message") or {}
+            c = msg.get("content")
+            if isinstance(c, str):
+                content = c
+            elif isinstance(c, list):
+                parts = [p.get("text", "") for p in c if isinstance(p, dict) and p.get("type") == "text"]
+                content = "\n".join(parts) if parts else ""
+            else:
+                content = str(c or "")
+        usage = data.get("usage") or {}
+        return LLMResponse(
+            content=content,
+            model=api_model,
+            usage={
+                "prompt_tokens": usage.get("prompt_tokens", 0),
+                "completion_tokens": usage.get("completion_tokens", 0),
+                "total_tokens": usage.get("total_tokens", 0),
+            },
+            finish_reason="stop",
+            backend=self.name,
+        )
+
+    async def stream(self, request: LLMRequest):
+        api_model = _normalize_model_id(request.model)
+        last_content = ""
+        for m in reversed(request.messages):
+            if (m.get("role") or "user").lower() == "user":
+                last_content = m.get("content") or ""
+                break
+        payload = {
+            "model": api_model,
+            "messages": [{"role": "user", "content": last_content or "Hi"}],
+            "temperature": request.temperature,
+            "stream": True,
+        }
+        from devsper.utils.http import ssl_verify
+        async with httpx.AsyncClient(timeout=60.0, verify=ssl_verify()) as client:
+            async with client.stream(
+                "POST",
+                GITHUB_CHAT_URL,
+                headers=self._headers(),
+                json=payload,
+            ) as resp:
+                resp.raise_for_status()
+                async for line in resp.aiter_lines():
+                    if not line or not line.strip():
+                        continue
+                    if line.startswith("data: "):
+                        chunk = line[6:].strip()
+                        if chunk == "[DONE]":
+                            return
+                        try:
+                            data = json.loads(chunk)
+                            choices = data.get("choices") or []
+                            if choices:
+                                delta = choices[0].get("delta") or {}
+                                part = delta.get("content")
+                                if part:
+                                    yield part
+                        except Exception:
+                            pass
+
+    async def health(self) -> bool:
+        try:
+            await self.complete(
+                LLMRequest(model="openai/gpt-4.1", messages=[{"role": "user", "content": "Hi"}], max_tokens=2)
+            )
+            return True
+        except Exception:
+            return False

devsper/providers/router/backends/ollama_backend.py

@@ -0,0 +1,104 @@
+"""Ollama local LLM backend (http://localhost:11434). No API key required."""
+
+import httpx
+
+from devsper.providers.router.base import LLMBackend, LLMRequest, LLMResponse
+
+
+class OllamaBackend(LLMBackend):
+    """Ollama local. supports_model via GET /api/tags; complete via POST /api/chat."""
+
+    def __init__(self, base_url: str = "http://localhost:11434") -> None:
+        self.base_url = base_url.rstrip("/")
+        self._models_cache: list[str] | None = None
+
+    @property
+    def name(self) -> str:
+        return "ollama"
+
+    async def _fetch_models(self) -> list[str]:
+        if self._models_cache is not None:
+            return self._models_cache
+        try:
+            async with httpx.AsyncClient(timeout=10.0) as client:
+                r = await client.get(f"{self.base_url}/api/tags")
+                r.raise_for_status()
+                data = r.json()
+                models = data.get("models") or []
+                self._models_cache = [m.get("name", "").split(":")[0] for m in models if m.get("name")]
+                return self._models_cache
+        except Exception:
+            self._models_cache = []
+            return []
+
+    def supports_model(self, model_name: str) -> bool:
+        """Ollama can serve any model that exists on the server; we rely on prefix 'ollama:' for routing."""
+        return True
+
+    async def complete(self, request: LLMRequest) -> LLMResponse:
+        model = request.model or "llama3"
+        messages = request.messages
+        prompt = ""
+        for m in reversed(messages):
+            if (m.get("role") or "user").lower() == "user":
+                prompt = m.get("content") or ""
+                break
+        payload = {
+            "model": model,
+            "messages": [{"role": "user", "content": prompt}] if prompt else [{"role": "user", "content": "Hi"}],
+            "stream": False,
+            "options": {"num_predict": request.max_tokens, "temperature": request.temperature},
+        }
+        async with httpx.AsyncClient(timeout=120.0) as client:
+            r = await client.post(f"{self.base_url}/api/chat", json=payload)
+            r.raise_for_status()
+            data = r.json()
+        msg = data.get("message") or {}
+        content = msg.get("content") or ""
+        usage = data.get("eval_count") or 0
+        return LLMResponse(
+            content=content,
+            model=model,
+            usage={"prompt_tokens": 0, "completion_tokens": usage, "total_tokens": usage},
+            finish_reason="stop",
+            backend=self.name,
+        )
+
+    async def stream(self, request: LLMRequest):
+        model = request.model or "llama3"
+        prompt = ""
+        for m in reversed(request.messages):
+            if (m.get("role") or "user").lower() == "user":
+                prompt = m.get("content") or ""
+                break
+        payload = {
+            "model": model,
+            "messages": [{"role": "user", "content": prompt or "Hi"}],
+            "stream": True,
+            "options": {"num_predict": request.max_tokens, "temperature": request.temperature},
+        }
+        async with httpx.AsyncClient(timeout=120.0) as client:
+            async with client.stream("POST", f"{self.base_url}/api/chat", json=payload) as resp:
+                resp.raise_for_status()
+                async for line in resp.aiter_lines():
+                    if not line.strip():
+                        continue
+                    import json
+                    try:
+                        data = json.loads(line)
+                        msg = data.get("message") or {}
+                        part = msg.get("content")
+                        if part:
+                            yield part
+                        if data.get("done"):
+                            break
+                    except Exception:
+                        pass
+
+    async def health(self) -> bool:
+        try:
+            async with httpx.AsyncClient(timeout=5.0) as client:
+                r = await client.get(f"{self.base_url}/api/tags")
+                return r.status_code == 200
+        except Exception:
+            return False