devcopilot 0.2.0__py3-none-any.whl

providers/transports/openai_chat/transport.py

@@ -0,0 +1,156 @@
+"""OpenAI-compatible chat transport base."""
+
+from __future__ import annotations
+
+from abc import abstractmethod
+from collections.abc import AsyncIterator, Iterator
+from typing import Any
+
+import httpx
+from openai import AsyncOpenAI
+
+from core.anthropic import SSEBuilder
+from providers.base import BaseProvider, ProviderConfig
+from providers.error_mapping import (
+    extract_provider_error_detail,
+    map_error,
+    user_visible_message_for_mapped_provider_error,
+)
+from providers.model_listing import extract_openai_model_ids
+from providers.rate_limit import GlobalRateLimiter
+
+from .stream import OpenAIChatStreamRunner
+
+
+class OpenAIChatTransport(BaseProvider):
+    """Base for OpenAI-compatible ``/chat/completions`` adapters."""
+
+    def __init__(
+        self,
+        config: ProviderConfig,
+        *,
+        provider_name: str,
+        base_url: str,
+        api_key: str,
+    ):
+        super().__init__(config)
+        self._provider_name = provider_name
+        self._api_key = api_key
+        self._base_url = base_url.rstrip("/")
+        self._global_rate_limiter = GlobalRateLimiter.get_scoped_instance(
+            provider_name.lower(),
+            rate_limit=config.rate_limit,
+            rate_window=config.rate_window,
+            max_concurrency=config.max_concurrency,
+        )
+        http_client = None
+        if config.proxy:
+            http_client = httpx.AsyncClient(
+                proxy=config.proxy,
+                timeout=httpx.Timeout(
+                    config.http_read_timeout,
+                    connect=config.http_connect_timeout,
+                    read=config.http_read_timeout,
+                    write=config.http_write_timeout,
+                ),
+            )
+        self._client = AsyncOpenAI(
+            api_key=self._api_key,
+            base_url=self._base_url,
+            max_retries=0,
+            timeout=httpx.Timeout(
+                config.http_read_timeout,
+                connect=config.http_connect_timeout,
+                read=config.http_read_timeout,
+                write=config.http_write_timeout,
+            ),
+            http_client=http_client,
+        )
+
+    async def cleanup(self) -> None:
+        """Release HTTP client resources."""
+        client = getattr(self, "_client", None)
+        if client is not None:
+            await client.close()
+
+    async def list_model_ids(self) -> frozenset[str]:
+        """Return model ids from the provider's OpenAI-compatible models endpoint."""
+        payload = await self._client.models.list()
+        return extract_openai_model_ids(payload, provider_name=self._provider_name)
+
+    @abstractmethod
+    def _build_request_body(
+        self, request: Any, thinking_enabled: bool | None = None
+    ) -> dict:
+        """Build request body. Must be implemented by subclasses."""
+
+    def _handle_extra_reasoning(
+        self, delta: Any, sse: SSEBuilder, *, thinking_enabled: bool
+    ) -> Iterator[str]:
+        """Hook for provider-specific reasoning."""
+        return iter(())
+
+    def _get_retry_request_body(self, error: Exception, body: dict) -> dict | None:
+        """Return a modified request body for one retry, or None."""
+        return None
+
+    def _prepare_create_body(self, body: dict[str, Any]) -> dict[str, Any]:
+        """Return the body passed to the upstream OpenAI-compatible client."""
+        return body
+
+    def _record_tool_call_extra_content(
+        self, tool_call_id: str, extra_content: dict[str, Any]
+    ) -> None:
+        """Hook for providers that must replay OpenAI tool-call metadata later."""
+
+    def _tool_argument_aliases(self, body: dict[str, Any]) -> dict[str, dict[str, str]]:
+        """Return provider-specific per-tool argument aliases for this request."""
+        return {}
+
+    async def _create_stream(self, body: dict) -> tuple[Any, dict]:
+        """Create a streaming chat completion, optionally retrying once."""
+        try:
+            create_body = self._prepare_create_body(body)
+            stream = await self._global_rate_limiter.execute_with_retry(
+                self._client.chat.completions.create, **create_body, stream=True
+            )
+            return stream, body
+        except Exception as error:
+            retry_body = self._get_retry_request_body(error, body)
+            if retry_body is None:
+                raise
+
+            create_retry_body = self._prepare_create_body(retry_body)
+            stream = await self._global_rate_limiter.execute_with_retry(
+                self._client.chat.completions.create, **create_retry_body, stream=True
+            )
+            return stream, retry_body
+
+    def _openai_error_message(self, error: Exception, request_id: str | None) -> str:
+        mapped_error = map_error(error, rate_limiter=self._global_rate_limiter)
+        return user_visible_message_for_mapped_provider_error(
+            mapped_error,
+            provider_name=self._provider_name,
+            read_timeout_s=self._config.http_read_timeout,
+            detail=extract_provider_error_detail(error),
+            request_id=request_id,
+        )
+
+    async def stream_response(
+        self,
+        request: Any,
+        input_tokens: int = 0,
+        *,
+        request_id: str | None = None,
+        thinking_enabled: bool | None = None,
+    ) -> AsyncIterator[str]:
+        """Stream response in Anthropic SSE format."""
+        runner = OpenAIChatStreamRunner(
+            self,
+            request=request,
+            input_tokens=input_tokens,
+            request_id=request_id,
+            thinking_enabled=thinking_enabled,
+        )
+        async for event in runner.run():
+            yield event

providers/wafer/__init__.py

@@ -0,0 +1,10 @@
+"""Wafer provider exports."""
+
+from providers.defaults import WAFER_DEFAULT_BASE
+
+from .client import WaferProvider
+
+__all__ = [
+    "WAFER_DEFAULT_BASE",
+    "WaferProvider",
+]

providers/wafer/client.py

@@ -0,0 +1,50 @@
+"""Wafer provider implementation (native Anthropic-compatible Messages)."""
+
+from typing import Any
+
+from providers.base import ProviderConfig
+from providers.defaults import WAFER_DEFAULT_BASE
+from providers.transports.anthropic_messages import AnthropicMessagesTransport
+
+_ANTHROPIC_VERSION = "2023-06-01"
+
+
+class WaferProvider(AnthropicMessagesTransport):
+    """Wafer using ``https://pass.wafer.ai/v1/messages``."""
+
+    def __init__(self, config: ProviderConfig):
+        super().__init__(
+            config,
+            provider_name="WAFER",
+            default_base_url=WAFER_DEFAULT_BASE,
+        )
+
+    def _build_request_body(
+        self, request: Any, thinking_enabled: bool | None = None
+    ) -> dict:
+        """Build native body; Wafer rejects omitted thinking as ``reasoning_effort=none``."""
+        effective_thinking_enabled = self._is_thinking_enabled(
+            request, thinking_enabled
+        )
+        body = self._build_request_body_with_resolved_thinking(
+            request,
+            thinking_enabled=effective_thinking_enabled,
+        )
+        if "thinking" not in body:
+            body["thinking"] = (
+                {"type": "enabled"}
+                if effective_thinking_enabled
+                else {"type": "disabled"}
+            )
+        return body
+
+    def _request_headers(self) -> dict[str, str]:
+        return {
+            "Accept": "text/event-stream",
+            "Authorization": f"Bearer {self._api_key}",
+            "Content-Type": "application/json",
+            "anthropic-version": _ANTHROPIC_VERSION,
+        }
+
+    def _model_list_headers(self) -> dict[str, str]:
+        return {"Authorization": f"Bearer {self._api_key}"}

providers/zai/__init__.py

@@ -0,0 +1,10 @@
+"""Z.ai provider exports."""
+
+from providers.defaults import ZAI_DEFAULT_BASE
+
+from .client import ZaiProvider
+
+__all__ = [
+    "ZAI_DEFAULT_BASE",
+    "ZaiProvider",
+]

providers/zai/client.py

@@ -0,0 +1,46 @@
+"""Z.ai provider implementation (Anthropic-compatible Messages API)."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from providers.base import ProviderConfig
+from providers.defaults import ZAI_DEFAULT_BASE
+from providers.transports.anthropic_messages import AnthropicMessagesTransport
+
+from .request import build_request_body
+
+_ANTHROPIC_VERSION = "2023-06-01"
+
+
+class ZaiProvider(AnthropicMessagesTransport):
+    """Z.ai using Anthropic-compatible Messages at api.z.ai/api/anthropic/v1."""
+
+    def __init__(self, config: ProviderConfig):
+        super().__init__(
+            config,
+            provider_name="ZAI",
+            default_base_url=ZAI_DEFAULT_BASE,
+        )
+
+    def _build_request_body(
+        self, request: Any, thinking_enabled: bool | None = None
+    ) -> dict:
+        return build_request_body(
+            request,
+            thinking_enabled=self._is_thinking_enabled(request, thinking_enabled),
+        )
+
+    def _request_headers(self) -> dict[str, str]:
+        return {
+            "Accept": "text/event-stream",
+            "Content-Type": "application/json",
+            "x-api-key": self._api_key,
+            "anthropic-version": _ANTHROPIC_VERSION,
+        }
+
+    def _model_list_headers(self) -> dict[str, str]:
+        return {
+            "x-api-key": self._api_key,
+            "anthropic-version": _ANTHROPIC_VERSION,
+        }

providers/zai/request.py

@@ -0,0 +1,42 @@
+"""Native Anthropic Messages request builder for Z.ai."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from loguru import logger
+
+from config.constants import ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS
+from core.anthropic.native_messages_request import (
+    build_base_native_anthropic_request_body,
+)
+from providers.exceptions import InvalidRequestError
+
+
+def build_request_body(request_data: Any, *, thinking_enabled: bool) -> dict:
+    """Build JSON for Z.ai Anthropic-compat ``POST …/messages``."""
+    logger.debug(
+        "ZAI_REQUEST: native build model={} msgs={}",
+        getattr(request_data, "model", "?"),
+        len(getattr(request_data, "messages", [])),
+    )
+
+    body = build_base_native_anthropic_request_body(
+        request_data,
+        default_max_tokens=ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS,
+        thinking_enabled=thinking_enabled,
+    )
+    extra = getattr(request_data, "extra_body", None)
+    if extra:
+        raise InvalidRequestError(
+            "Z.ai native Messages API does not support extra_body on requests."
+        )
+    body["stream"] = True
+
+    logger.debug(
+        "ZAI_REQUEST: build done model={} msgs={} tools={}",
+        body.get("model"),
+        len(body.get("messages", [])),
+        len(body.get("tools", [])),
+    )
+    return body