swiftpy-framework 0.1.0__py3-none-any.whl

swiftpy/ai/providers/anthropic_provider.py

@@ -0,0 +1,353 @@
+from __future__ import annotations
+
+import json
+import time
+from collections.abc import AsyncIterator
+from typing import Any
+
+import httpx
+
+_ANTHROPIC_HTTP_ERRORS: tuple[type[Exception], ...] = (httpx.TimeoutException, httpx.RequestError)
+
+from swiftpy.ai.exceptions import (
+    AIAuthenticationError,
+    AIConnectionError,
+    AIProviderError,
+    AIRateLimitError,
+)
+from swiftpy.ai.pool import AIHttpPool
+from swiftpy.ai.providers.base import (
+    LLMRequest,
+    LLMResponse,
+    ProviderInterface,
+    TokenUsage,
+    ToolCall,
+    extract_error_message,
+    parse_retry_after,
+    strip_internal_extra,
+)
+from swiftpy.ai.streaming import parse_sse_events
+
+
+def _coerce_tool_input(raw_args: Any) -> dict[str, Any]:
+    """Ensure tool_use input sent to Anthropic is always a JSON object dictionary."""
+    if isinstance(raw_args, dict):
+        return raw_args
+    if isinstance(raw_args, str):
+        try:
+            parsed = json.loads(raw_args)
+            if isinstance(parsed, dict):
+                return parsed
+        except (json.JSONDecodeError, ValueError):
+            pass
+        return {"raw": raw_args}
+    if raw_args is None:
+        return {}
+    return {"value": raw_args}
+
+
+class AnthropicProvider(ProviderInterface):
+    """
+    Anthropic provider adapter mapping unified requests to the /v1/messages endpoint.
+    """
+
+    def __init__(
+        self,
+        config: dict[str, Any] | None = None,
+        http_pool: AIHttpPool | None = None,
+    ) -> None:
+        super().__init__(config=config, http_pool=http_pool)
+        self._api_key: str = str(self.config.get("api_key", ""))
+        self._default_model: str = str(
+            self.config.get("model")
+            or self.config.get("default_model")
+            or "claude-3-5-sonnet-20241022"
+        )
+        self._base_url: str = str(
+            self.config.get("base_url", "https://api.anthropic.com/v1")
+        ).rstrip("/")
+        self._timeout: float = float(self.config.get("timeout", 60.0))
+        self._anthropic_version: str = str(
+            self.config.get("anthropic_version", "2023-06-01")
+        )
+
+    @property
+    def name(self) -> str:
+        return "anthropic"
+
+    def get_default_model(self) -> str:
+        return self._default_model
+
+    def _build_payload(
+        self,
+        request: LLMRequest,
+        *,
+        stream: bool = False,
+    ) -> tuple[str, dict[str, Any]]:
+        model = request.model or self.get_default_model()
+
+        system_parts: list[str] = []
+        dialogue_messages: list[dict[str, Any]] = []
+        for msg in request.messages:
+            if msg.role == "system":
+                system_parts.append(msg.content)
+            elif msg.role == "tool":
+                tool_result_block = {
+                    "type": "tool_result",
+                    "tool_use_id": msg.tool_call_id or "",
+                    "content": msg.content,
+                }
+                if (
+                    dialogue_messages
+                    and dialogue_messages[-1]["role"] == "user"
+                    and isinstance(dialogue_messages[-1]["content"], list)
+                    and any(
+                        isinstance(b, dict) and b.get("type") == "tool_result"
+                        for b in dialogue_messages[-1]["content"]
+                    )
+                ):
+                    dialogue_messages[-1]["content"].append(tool_result_block)
+                else:
+                    dialogue_messages.append({
+                        "role": "user",
+                        "content": [tool_result_block],
+                    })
+            elif msg.role == "assistant" and msg.tool_calls:
+                content_blocks: list[dict[str, Any]] = []
+                if msg.content:
+                    content_blocks.append({"type": "text", "text": msg.content})
+                for tc in msg.tool_calls:
+                    content_blocks.append({
+                        "type": "tool_use",
+                        "id": tc.id,
+                        "name": tc.name,
+                        "input": _coerce_tool_input(tc.arguments),
+                    })
+                dialogue_messages.append({"role": "assistant", "content": content_blocks})
+            else:
+                dialogue_messages.append({"role": msg.role, "content": msg.content})
+
+        max_tokens = (
+            request.max_tokens
+            if request.max_tokens is not None
+            else int(self.config.get("max_tokens", 1024))
+        )
+
+        payload: dict[str, Any] = {
+            "model": model,
+            "messages": dialogue_messages,
+            "max_tokens": max_tokens,
+        }
+        if stream:
+            payload["stream"] = True
+
+        if system_parts:
+            payload["system"] = "\n\n".join(system_parts)
+        if request.temperature is not None:
+            payload["temperature"] = request.temperature
+        if request.top_p is not None:
+            payload["top_p"] = request.top_p
+        if request.stop is not None:
+            payload["stop_sequences"] = request.stop
+        if request.tools is not None:
+            anthropic_tools: list[dict[str, Any]] = []
+            for t in request.tools:
+                if "input_schema" in t:
+                    anthropic_tools.append(t)
+                elif "function" in t:
+                    fn = t["function"]
+                    anthropic_tools.append({
+                        "name": fn.get("name"),
+                        "description": fn.get("description", ""),
+                        "input_schema": fn.get("parameters", {}),
+                    })
+                elif "parameters" in t:
+                    anthropic_tools.append({
+                        "name": t.get("name"),
+                        "description": t.get("description", ""),
+                        "input_schema": t.get("parameters", {}),
+                    })
+                else:
+                    anthropic_tools.append(t)
+            payload["tools"] = anthropic_tools
+        if request.extra:
+            payload.update(strip_internal_extra(request.extra))
+
+        return model, payload
+
+    def _raise_for_http_error(self, response: httpx.Response, body_text: str, data: Any) -> None:
+        if response.status_code in (401, 403):
+            err_msg = extract_error_message(data, body_text) or "Authentication failed"
+            raise AIAuthenticationError(
+                f"Anthropic authentication failed ({response.status_code}): {err_msg}",
+                provider=self.name,
+                status_code=response.status_code,
+                response_body=body_text,
+            )
+        if response.status_code == 429:
+            retry_after = parse_retry_after(response.headers.get("Retry-After"))
+            err_msg = extract_error_message(data, body_text) or "Rate limit reached"
+            raise AIRateLimitError(
+                f"Anthropic rate limit exceeded: {err_msg}",
+                provider=self.name,
+                status_code=response.status_code,
+                response_body=body_text,
+                retry_after=retry_after,
+            )
+        err_msg = extract_error_message(data, body_text) or f"HTTP {response.status_code}"
+        raise AIProviderError(
+            f"Anthropic API error ({response.status_code}): {err_msg}",
+            provider=self.name,
+            status_code=response.status_code,
+            response_body=body_text,
+        )
+
+    async def send(self, request: LLMRequest) -> LLMResponse:
+        url = f"{self._base_url}/messages"
+        headers = {
+            "x-api-key": self._api_key,
+            "anthropic-version": self._anthropic_version,
+            "content-type": "application/json",
+        }
+        model, payload = self._build_payload(request, stream=False)
+        client = self._http_pool.get_client()
+
+        async def _attempt() -> tuple[httpx.Response, float, str, Any]:
+            start_time = time.perf_counter()
+            try:
+                response = await client.post(
+                    url,
+                    headers=headers,
+                    json=payload,
+                    timeout=self._timeout,
+                )
+            except _ANTHROPIC_HTTP_ERRORS as exc:
+                sanitized_exc = self.sanitize_error(str(exc))
+                raise AIConnectionError(
+                    f"Failed to connect to Anthropic ({type(exc).__name__}): {sanitized_exc}",
+                    provider=self.name,
+                ) from exc
+
+            latency_ms = (time.perf_counter() - start_time) * 1000
+            body_text = self.sanitize_error(response.text)
+            try:
+                data: Any = response.json()
+            except (json.JSONDecodeError, ValueError):
+                data = None
+
+            if response.status_code >= 400:
+                self._raise_for_http_error(response, body_text, data)
+            return response, latency_ms, body_text, data
+
+        response, latency_ms, body_text, data = await self._call_with_retries(_attempt)
+
+        if not isinstance(data, dict):
+            raise AIProviderError(
+                f"Anthropic returned non-JSON response ({response.status_code}): {body_text[:200]}",
+                provider=self.name,
+                status_code=response.status_code,
+                response_body=body_text,
+            )
+
+        raw_content = data.get("content")
+        text_parts: list[str] = []
+        extracted_tool_calls: list[ToolCall] = []
+        if isinstance(raw_content, list):
+            for block in raw_content:
+                if isinstance(block, dict):
+                    b_type = block.get("type")
+                    if b_type == "text":
+                        text_parts.append(str(block.get("text") or ""))
+                    elif b_type == "tool_use":
+                        tc_id = str(block.get("id") or "")
+                        tc_name = str(block.get("name") or "")
+                        tc_input = block.get("input")
+                        tc_args = tc_input if isinstance(tc_input, dict) else {}
+                        extracted_tool_calls.append(ToolCall(id=tc_id, name=tc_name, arguments=tc_args))
+        content = "".join(text_parts)
+
+        raw_usage = data.get("usage")
+        if isinstance(raw_usage, dict):
+            input_tokens = int(raw_usage.get("input_tokens") or 0)
+            output_tokens = int(raw_usage.get("output_tokens") or 0)
+            usage = TokenUsage(
+                prompt_tokens=input_tokens,
+                completion_tokens=output_tokens,
+                total_tokens=input_tokens + output_tokens,
+            )
+        else:
+            usage = TokenUsage(prompt_tokens=0, completion_tokens=0, total_tokens=0)
+
+        finish_reason = data.get("stop_reason")
+        model_reported = str(data.get("model") or model)
+
+        return LLMResponse(
+            content=content,
+            role=str(data.get("role") or "assistant"),
+            model=model_reported,
+            usage=usage,
+            raw=data,
+            latency_ms=round(latency_ms, 2),
+            finish_reason=str(finish_reason) if finish_reason else None,
+            tool_calls=extracted_tool_calls,
+        )
+
+    async def stream(self, request: LLMRequest) -> AsyncIterator[str]:
+        url = f"{self._base_url}/messages"
+        headers = {
+            "x-api-key": self._api_key,
+            "anthropic-version": self._anthropic_version,
+            "content-type": "application/json",
+            "Accept": "text/event-stream",
+        }
+        _, payload = self._build_payload(request, stream=True)
+        client = self._http_pool.get_client()
+
+        async def _open_stream() -> httpx.Response:
+            try:
+                req = client.build_request(
+                    "POST",
+                    url,
+                    headers=headers,
+                    json=payload,
+                    timeout=self._timeout,
+                )
+                resp = await client.send(req, stream=True)
+            except _ANTHROPIC_HTTP_ERRORS as exc:
+                sanitized_exc = self.sanitize_error(str(exc))
+                raise AIConnectionError(
+                    f"Failed to connect to Anthropic stream ({type(exc).__name__}): {sanitized_exc}",
+                    provider=self.name,
+                ) from exc
+
+            if resp.status_code >= 400:
+                raw_bytes = await resp.aread()
+                body_text = self.sanitize_error(raw_bytes.decode("utf-8", errors="replace"))
+                await resp.aclose()
+                try:
+                    err_data: Any = json.loads(body_text)
+                except (json.JSONDecodeError, ValueError):
+                    err_data = None
+                self._raise_for_http_error(resp, body_text, err_data)
+            return resp
+
+        response = await self._call_with_retries(_open_stream)
+
+        try:
+            async for event in parse_sse_events(response.aiter_lines()):
+                event_type = event.get("event")
+                data = event.get("data")
+                if isinstance(data, dict):
+                    # Check for content_block_delta
+                    data_type = data.get("type")
+                    if event_type == "content_block_delta" or data_type == "content_block_delta":
+                        delta = data.get("delta")
+                        if isinstance(delta, dict) and delta.get("type") == "text_delta":
+                            text = delta.get("text")
+                            if text:
+                                yield str(text)
+                    elif event_type == "message_stop" or data_type == "message_stop":
+                        break
+        finally:
+            await response.aclose()
+

swiftpy/ai/providers/base.py

@@ -0,0 +1,273 @@
+from __future__ import annotations
+
+import asyncio
+import json
+import math
+import random
+import re
+from abc import ABC, abstractmethod
+from collections.abc import AsyncIterator, Awaitable, Callable
+from dataclasses import dataclass, field
+from datetime import UTC, datetime
+from email.utils import parsedate_to_datetime
+from typing import Any, TypeVar
+
+from swiftpy.ai.exceptions import AIConnectionError, AIProviderError, AIRateLimitError
+from swiftpy.ai.pool import AIHttpPool
+
+INTERNAL_ATTRIBUTION_KEYS: frozenset[str] = frozenset({"user_id", "tenant_id", "user", "tenant"})
+
+_T = TypeVar("_T")
+_SK_TOKEN_RE = re.compile(r"sk-[A-Za-z0-9_-]{12,}")
+_BEARER_TOKEN_RE = re.compile(r"Bearer\s+[A-Za-z0-9._\-+/=]{8,}", re.IGNORECASE)
+
+
+def redact_sensitive_text(message: str, api_key: str = "") -> str:
+    """Redact API keys, Bearer tokens, and sk-* credentials from text."""
+    result = message
+    if api_key and len(api_key) > 6:
+        result = result.replace(api_key, "[REDACTED]")
+    result = _SK_TOKEN_RE.sub("[REDACTED]", result)
+    result = _BEARER_TOKEN_RE.sub("Bearer [REDACTED]", result)
+    return result
+
+
+def parse_retry_after(header_value: str | None) -> float | None:
+    """Parse Retry-After header supporting both numeric seconds and HTTP-date."""
+    if not header_value:
+        return None
+    raw = str(header_value).strip()
+    if not raw:
+        return None
+    try:
+        seconds = float(raw)
+        if math.isfinite(seconds):
+            return max(0.0, seconds)
+        return None
+    except ValueError:
+        pass
+    try:
+        dt = parsedate_to_datetime(raw)
+    except (TypeError, ValueError):
+        return None
+    if dt is None:
+        return None
+    if dt.tzinfo is None:
+        dt = dt.replace(tzinfo=UTC)
+    delta = (dt - datetime.now(UTC)).total_seconds()
+    return max(0.0, round(delta, 2))
+
+
+def extract_error_message(data: Any, fallback: str) -> str:
+    """Safely extract provider error message from parsed JSON without assuming dict shape."""
+    if isinstance(data, dict):
+        err = data.get("error")
+        if isinstance(err, dict):
+            msg = err.get("message")
+            if msg:
+                return str(msg)
+        elif isinstance(err, str) and err:
+            return err
+        msg_top = data.get("message")
+        if msg_top:
+            return str(msg_top)
+    return fallback
+
+
+def strip_internal_extra(extra: dict[str, Any]) -> dict[str, Any]:
+    """Return copy of extra parameters with framework attribution keys removed."""
+    return {k: v for k, v in extra.items() if k not in INTERNAL_ATTRIBUTION_KEYS}
+
+VALID_ROLES: frozenset[str] = frozenset({"system", "user", "assistant", "tool"})
+
+
+@dataclass(frozen=True)
+class ToolCall:
+    """Represents a tool call requested by an LLM."""
+
+    id: str
+    name: str
+    arguments: dict[str, Any] = field(default_factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert ToolCall to OpenAI-compatible function call representation."""
+        return {
+            "id": self.id,
+            "type": "function",
+            "function": {
+                "name": self.name,
+                "arguments": (
+                    json.dumps(self.arguments)
+                    if isinstance(self.arguments, dict)
+                    else str(self.arguments)
+                ),
+            },
+        }
+
+
+@dataclass(frozen=True)
+class ToolResult:
+    """Represents the execution result of an invoked tool."""
+
+    tool_call_id: str
+    name: str
+    result: Any
+    is_error: bool = False
+
+
+@dataclass(frozen=True)
+class Message:
+    """Represents a single message in an LLM conversation."""
+
+    role: str
+    content: str = ""
+    name: str | None = None
+    tool_calls: list[ToolCall] | None = None
+    tool_call_id: str | None = None
+
+    def __post_init__(self) -> None:
+        if not isinstance(self.role, str) or self.role.lower() not in VALID_ROLES:
+            valid = ", ".join(sorted(f"'{r}'" for r in VALID_ROLES))
+            raise ValueError(
+                f"Invalid message role '{self.role}'. Expected one of: {valid}"
+            )
+        if not isinstance(self.content, str):
+            raise TypeError(
+                f"Message content must be a string, got {type(self.content).__name__}"
+            )
+        if not self.content.strip() and not self.tool_calls:
+            raise ValueError(
+                "Message content cannot be empty or whitespace only when no tool_calls are present"
+            )
+
+    def to_dict(self) -> dict[str, Any]:
+        payload: dict[str, Any] = {"role": self.role.lower(), "content": self.content}
+        if self.name:
+            payload["name"] = self.name
+        if self.tool_call_id:
+            payload["tool_call_id"] = self.tool_call_id
+        if self.tool_calls:
+            payload["tool_calls"] = [tc.to_dict() for tc in self.tool_calls]
+        return payload
+
+
+@dataclass(frozen=True)
+class TokenUsage:
+    """Telemetry detailing token consumption for a completion."""
+
+    prompt_tokens: int = 0
+    completion_tokens: int = 0
+    total_tokens: int = 0
+
+
+@dataclass
+class LLMRequest:
+    """Unified request parameters passed to an LLM provider adapter."""
+
+    messages: list[Message]
+    model: str | None = None
+    temperature: float | None = None
+    max_tokens: int | None = None
+    top_p: float | None = None
+    stop: list[str] | None = None
+    tools: list[dict[str, Any]] | None = None
+    extra: dict[str, Any] = field(default_factory=dict)
+    metadata: dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass(frozen=True)
+class LLMResponse:
+    """Unified completion response returned by an LLM provider adapter."""
+
+    content: str = ""
+    role: str = "assistant"
+    model: str = ""
+    usage: TokenUsage = field(default_factory=TokenUsage)
+    raw: dict[str, Any] = field(default_factory=dict)
+    latency_ms: float = 0.0
+    finish_reason: str | None = None
+    tool_calls: list[ToolCall] = field(default_factory=list)
+
+
+
+class ProviderInterface(ABC):
+    """
+    Contract every LLM provider adapter must implement.
+    """
+
+    def __init__(
+        self,
+        config: dict[str, Any] | None = None,
+        http_pool: AIHttpPool | None = None,
+    ) -> None:
+        self.config: dict[str, Any] = config or {}
+        self._http_pool = http_pool or AIHttpPool.get_instance()
+
+    @property
+    @abstractmethod
+    def name(self) -> str:
+        """Provider identifier (e.g. 'openai', 'anthropic')."""
+
+    @abstractmethod
+    def get_default_model(self) -> str:
+        """Return the default model name configured for this provider."""
+
+    @abstractmethod
+    async def send(self, request: LLMRequest) -> LLMResponse:
+        """
+        Execute a completion request against the provider's API.
+
+        Maps the unified request shape onto the provider's native payload,
+        executes the call via the shared HTTP pool, and transforms the response.
+        """
+
+    @abstractmethod
+    def stream(self, request: LLMRequest) -> AsyncIterator[str]:
+        """
+        Execute a streaming completion request against the provider's API.
+
+        Yields string token chunks incrementally as they are emitted by the model.
+        """
+
+    def sanitize_error(self, message: str) -> str:
+        """Sanitize error messages to avoid leaking API credentials in logs/exceptions."""
+        return redact_sensitive_text(
+            message,
+            api_key=str(self.config.get("api_key", "")),
+        )
+
+    def _max_retries(self) -> int:
+        raw = self.config.get("max_retries", 0)
+        if isinstance(raw, bool):
+            return 0
+        try:
+            return max(0, int(raw))
+        except (TypeError, ValueError):
+            return 0
+
+    async def _call_with_retries(self, fn: Callable[[], Awaitable[_T]]) -> _T:
+        """Execute an async provider operation honoring configured max_retries."""
+        max_retries = self._max_retries()
+        base_delay = float(self.config.get("retry_delay", 0.05))
+        max_delay = float(self.config.get("max_retry_delay", 2.0))
+
+        attempt = 0
+        while True:
+            try:
+                return await fn()
+            except (AIConnectionError, AIRateLimitError, AIProviderError) as exc:
+                retryable = isinstance(exc, (AIConnectionError, AIRateLimitError)) or (
+                    exc.status_code is not None and exc.status_code >= 500
+                )
+                if attempt >= max_retries or not retryable:
+                    raise
+
+                if isinstance(exc, AIRateLimitError) and exc.retry_after is not None:
+                    delay = min(max(0.0, float(exc.retry_after)), max_delay)
+                else:
+                    delay = min(base_delay * (2**attempt), max_delay) + random.uniform(
+                        0.0, min(0.02, base_delay)
+                    )
+                attempt += 1
+                if delay > 0:
+                    await asyncio.sleep(delay)