silvanexum 0.1.0__py3-none-any.whl

silvanexum/__init__.py

@@ -0,0 +1,40 @@
+"""Official Python SDK for Silvanexum — the proof-ranked agent platform.
+
+All request/response models are GENERATED from the API's Zod contracts (see
+packages/codegen) and exposed under ``silvanexum.models``, so they can never
+drift from the live API.
+"""
+from __future__ import annotations
+
+from . import _generated as models
+from ._client import Silvanexum
+from ._errors import (
+    APIConnectionError,
+    APITimeoutError,
+    AuthenticationError,
+    InsufficientCreditsError,
+    InternalServerError,
+    NotFoundError,
+    PermissionError,
+    RateLimitError,
+    SilvanexumError,
+    ValidationError,
+)
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "Silvanexum",
+    "models",
+    "SilvanexumError",
+    "APIConnectionError",
+    "APITimeoutError",
+    "AuthenticationError",
+    "PermissionError",
+    "NotFoundError",
+    "ValidationError",
+    "RateLimitError",
+    "InsufficientCreditsError",
+    "InternalServerError",
+    "__version__",
+]

silvanexum/_client.py

@@ -0,0 +1,98 @@
+"""The Silvanexum client."""
+from __future__ import annotations
+
+from typing import Optional
+
+import httpx
+
+from ._http import HttpClient
+from .resources import (
+    Agents,
+    Bounties,
+    Budgets,
+    Certification,
+    Connectors,
+    Enterprise,
+    Fleet,
+    Insurance,
+    Keys,
+    Marketplace,
+    Models,
+    Overview,
+    Proving,
+    Routing,
+    Runs,
+    Security,
+    Spending,
+    Studio,
+    Suites,
+    Team,
+    Templates,
+    Wallet,
+    Workforce,
+)
+
+
+class Silvanexum:
+    """Entry point for the Silvanexum API.
+
+    Example
+    -------
+    >>> from silvanexum import Silvanexum
+    >>> sx = Silvanexum(api_key="sx_live_...")
+    >>> run = sx.runs.create(agent_id=agent_id, prompt="Summarize this ticket.")
+    >>> print(run.output, sx.runs.share_url(run.id))
+    """
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        *,
+        base_url: Optional[str] = None,
+        timeout: float = 60.0,
+        max_retries: int = 2,
+        http_client: Optional[httpx.Client] = None,
+    ) -> None:
+        self._http = HttpClient(
+            api_key=api_key,
+            base_url=base_url,
+            timeout=timeout,
+            max_retries=max_retries,
+            http_client=http_client,
+        )
+        self.agents = Agents(self._http)
+        self.runs = Runs(self._http)
+        self.templates = Templates(self._http)
+        self.connectors = Connectors(self._http)
+        self.marketplace = Marketplace(self._http)
+        self.wallet = Wallet(self._http)
+        self.suites = Suites(self._http)
+        self.keys = Keys(self._http)
+        self.models = Models(self._http)
+        self.team = Team(self._http)
+        self.overview = Overview(self._http)
+        self.security = Security(self._http)
+        self.proving = Proving(self._http)
+        self.fleet = Fleet(self._http)
+        self.routing = Routing(self._http)
+        self.studio = Studio(self._http)
+        self.workforce = Workforce(self._http)
+        self.certification = Certification(self._http)
+        self.enterprise = Enterprise(self._http)
+        self.insurance = Insurance(self._http)
+        self.bounties = Bounties(self._http)
+        self.budgets = Budgets(self._http)
+        self.spending = Spending(self._http)
+
+    @property
+    def base_url(self) -> str:
+        return self._http.base_url
+
+    def close(self) -> None:
+        self._http.close()
+
+    def __enter__(self) -> "Silvanexum":
+        return self
+
+    def __exit__(self, *_exc: object) -> None:
+        self.close()

silvanexum/_errors.py

@@ -0,0 +1,92 @@
+"""Typed error hierarchy. Catch ``SilvanexumError`` for any API failure."""
+from __future__ import annotations
+
+from typing import Any, Optional
+
+
+class SilvanexumError(Exception):
+    """Base error for all SDK failures."""
+
+    def __init__(
+        self,
+        message: str,
+        *,
+        status: Optional[int] = None,
+        code: Optional[str] = None,
+        body: Optional[dict[str, Any]] = None,
+        request_id: Optional[str] = None,
+    ) -> None:
+        super().__init__(message)
+        self.message = message
+        self.status = status
+        self.code = code
+        self.body = body
+        self.request_id = request_id
+
+
+class APIConnectionError(SilvanexumError):
+    """The request never reached the API (network/DNS/abort)."""
+
+
+class APITimeoutError(APIConnectionError):
+    """The request exceeded the configured timeout."""
+
+
+class AuthenticationError(SilvanexumError):
+    """401 — missing or invalid API key."""
+
+
+class PermissionError(SilvanexumError):  # noqa: A001 - intentional API name
+    """403 — the key lacks the required scope."""
+
+
+class NotFoundError(SilvanexumError):
+    """404."""
+
+
+class ValidationError(SilvanexumError):
+    """400 / 422 — the request body or params failed validation."""
+
+
+class RateLimitError(SilvanexumError):
+    """429 — too many requests."""
+
+
+class InsufficientCreditsError(SilvanexumError):
+    """402 — not enough credits to settle the operation."""
+
+
+class InternalServerError(SilvanexumError):
+    """5xx."""
+
+
+def error_from_response(
+    status: int, body: Optional[dict[str, Any]], request_id: Optional[str]
+) -> SilvanexumError:
+    """Map an HTTP status + body to the most specific error class."""
+    message = ""
+    if body:
+        message = body.get("message") or body.get("error") or ""
+    if not message:
+        message = f"Silvanexum API error (HTTP {status})"
+    kwargs = {
+        "status": status,
+        "code": (body or {}).get("code"),
+        "body": body,
+        "request_id": request_id,
+    }
+    if status in (400, 422):
+        return ValidationError(message, **kwargs)
+    if status == 401:
+        return AuthenticationError(message, **kwargs)
+    if status == 402:
+        return InsufficientCreditsError(message, **kwargs)
+    if status == 403:
+        return PermissionError(message, **kwargs)
+    if status == 404:
+        return NotFoundError(message, **kwargs)
+    if status == 429:
+        return RateLimitError(message, **kwargs)
+    if status >= 500:
+        return InternalServerError(message, **kwargs)
+    return SilvanexumError(message, **kwargs)

silvanexum/_generated/__init__.py

@@ -0,0 +1,2 @@
+"""Generated pydantic models (from the backend's Zod contracts). Do not edit."""
+from .models import *  # noqa: F401,F403