swiftapi-python 1.0.2__tar.gz → 1.1.0__tar.gz

{swiftapi_python-1.0.2 → swiftapi_python-1.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: swiftapi-python
-Version: 1.0.2
+Version: 1.1.0
 Summary: SwiftAPI Python SDK - AI Action Verification Gateway
 Author-email: Rayan Pal <rayan@swiftapi.ai>
 License-Expression: MIT

{swiftapi_python-1.0.2 → swiftapi_python-1.1.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "swiftapi-python"
-version = "1.0.2"
+version = "1.1.0"
 description = "SwiftAPI Python SDK - AI Action Verification Gateway"
 readme = "README.md"
 license = "MIT"

{swiftapi_python-1.0.2 → swiftapi_python-1.1.0}/swiftapi/__init__.py

@@ -29,13 +29,14 @@ Usage:
         db.update(user_id, data)
 """
 
-__version__ = "1.0.0"
+__version__ = "1.1.0"
 __author__ = "Rayan Pal"
 
 # Core exports
 from .client import SwiftAPI
 from .enforcement import Enforcement, enforce
 from .verifier import verify_signature, is_valid, get_public_key
+from .openai import OpenAI
 
 # Exceptions
 from .exceptions import (
@@ -67,6 +68,8 @@ __all__ = [
     "SwiftAPI",
     "Enforcement",
     "enforce",
+    # Drop-in OpenAI replacement
+    "OpenAI",
     # Verification
     "verify_signature",
     "is_valid",

{swiftapi_python-1.0.2 → swiftapi_python-1.1.0}/swiftapi/client.py

@@ -213,6 +213,30 @@ class SwiftAPI:
             # If endpoint fails, assume not revoked (fail-open for availability)
             return False
 
+    def attest(
+        self,
+        action_type: str,
+        action_data: Dict[str, Any],
+    ) -> Dict[str, Any]:
+        """
+        Request an execution attestation from the authority.
+
+        Calls /attest to get a signed attestation for the given action.
+        The attestation can then be passed to gated endpoints like /chat/vibe.
+
+        Args:
+            action_type: Type of action (e.g., "chat_completion")
+            action_data: Action payload to be attested
+
+        Returns:
+            Signed attestation dict with jti, signature, action_fingerprint, etc.
+        """
+        payload = {
+            "action_type": action_type,
+            "action_data": action_data,
+        }
+        return self._request("POST", "/attest", json=payload)
+
     # =========================================================================
     # Info Endpoints
     # =========================================================================

swiftapi_python-1.1.0/swiftapi/openai.py

@@ -0,0 +1,200 @@
+"""
+SwiftAPI Attested OpenAI - Drop-in replacement.
+
+    # Before (vibe coding):
+    from openai import OpenAI
+    client = OpenAI()
+
+    # After (attested):
+    from swiftapi import OpenAI
+    client = OpenAI(swiftapi_key="swiftapi_live_...")
+
+Same interface. Same return type. Every completion is cryptographically attested.
+No attestation, no output.
+"""
+
+import json
+import requests
+from typing import List, Dict, Union, Optional, Any
+
+from .exceptions import SwiftAPIError, AuthenticationError, NetworkError
+
+
+class Message:
+    """OpenAI-compatible message object."""
+
+    def __init__(self, role: str, content: str):
+        self.role = role
+        self.content = content
+
+    def __repr__(self):
+        truncated = self.content[:80] if self.content else ""
+        return f"Message(role='{self.role}', content='{truncated}')"
+
+
+class Choice:
+    """OpenAI-compatible choice object."""
+
+    def __init__(self, index: int, message: Message, finish_reason: str):
+        self.index = index
+        self.message = message
+        self.finish_reason = finish_reason
+
+
+class ChatCompletion:
+    """OpenAI-compatible chat completion response."""
+
+    def __init__(self, content: str, model: str, attested: bool = False, jti: str = None):
+        self.choices = [
+            Choice(
+                index=0,
+                message=Message(role="assistant", content=content),
+                finish_reason="stop" if content else "void",
+            )
+        ]
+        self.model = model
+        self.attested = attested
+        self.jti = jti
+
+    @property
+    def content(self):
+        """Convenience: response.content instead of response.choices[0].message.content"""
+        return self.choices[0].message.content
+
+
+class Completions:
+    """Handles chat.completions.create() calls."""
+
+    def __init__(self, key: str, base_url: str, timeout: int):
+        self._key = key
+        self._base_url = base_url.rstrip("/")
+        self._timeout = timeout
+        self._session = requests.Session()
+        self._session.headers.update({
+            "X-SwiftAPI-Authority": key,
+            "Content-Type": "application/json",
+            "User-Agent": "swiftapi-python/1.1.0",
+        })
+
+    def create(
+        self,
+        model: str,
+        messages: List[Dict[str, Any]],
+        temperature: float = 0.7,
+        max_completion_tokens: int = 300,
+        max_tokens: Optional[int] = None,
+        **kwargs,
+    ) -> ChatCompletion:
+        """
+        Create an attested chat completion.
+
+        Same interface as openai.chat.completions.create().
+        Attestation is handled transparently. If any gate fails, content is empty string.
+
+        Args:
+            model: Model name (e.g. "gpt-4o-mini")
+            messages: List of message dicts with role and content
+            temperature: Sampling temperature
+            max_completion_tokens: Max tokens in response
+            max_tokens: Alias for max_completion_tokens (OpenAI compat)
+
+        Returns:
+            ChatCompletion with .choices[0].message.content
+        """
+        payload = {
+            "model": model,
+            "messages": messages,
+            "temperature": temperature,
+            "max_completion_tokens": max_tokens or max_completion_tokens,
+        }
+
+        # Step 1: Attest
+        try:
+            attest_resp = self._session.post(
+                f"{self._base_url}/attest",
+                json={"action_type": "chat_completion", "action_data": payload},
+                timeout=self._timeout,
+            )
+        except requests.exceptions.RequestException as e:
+            raise NetworkError(f"Attestation request failed: {e}")
+
+        if attest_resp.status_code == 403:
+            raise AuthenticationError("Invalid SwiftAPI authority key")
+        if attest_resp.status_code == 429:
+            raise SwiftAPIError("Rate limit exceeded")
+        if attest_resp.status_code != 200:
+            raise SwiftAPIError(f"Attestation failed: {attest_resp.text[:200]}")
+
+        attestation = attest_resp.json()
+
+        if not attestation.get("approved"):
+            return ChatCompletion(content="", model=model)
+
+        # Step 2: Forward to /chat/vibe with attestation
+        try:
+            vibe_resp = self._session.post(
+                f"{self._base_url}/chat/vibe",
+                json=payload,
+                headers={"X-SwiftAPI-Attestation": json.dumps(attestation)},
+                timeout=self._timeout,
+            )
+        except requests.exceptions.RequestException as e:
+            raise NetworkError(f"Chat request failed: {e}")
+
+        if vibe_resp.status_code == 403:
+            raise AuthenticationError("Invalid SwiftAPI authority key")
+        if vibe_resp.status_code != 200:
+            raise SwiftAPIError(f"Chat failed: {vibe_resp.text[:200]}")
+
+        content = vibe_resp.json()
+        if content is None:
+            content = ""
+
+        return ChatCompletion(
+            content=content,
+            model=model,
+            attested=True,
+            jti=attestation.get("jti"),
+        )
+
+
+class _ChatNamespace:
+    """Namespace for client.chat.completions"""
+
+    def __init__(self, key: str, base_url: str, timeout: int):
+        self.completions = Completions(key, base_url, timeout)
+
+
+class OpenAI:
+    """
+    Drop-in replacement for openai.OpenAI.
+
+    Every completion is cryptographically attested via SwiftAPI.
+    No attestation, no output.
+
+    Usage:
+        from swiftapi import OpenAI
+
+        client = OpenAI(swiftapi_key="swiftapi_live_...")
+        r = client.chat.completions.create(
+            model="gpt-4o-mini",
+            messages=[{"role": "user", "content": "Hello"}]
+        )
+        print(r.choices[0].message.content)
+    """
+
+    def __init__(
+        self,
+        swiftapi_key: str = None,
+        api_key: str = None,
+        base_url: str = "https://swiftapi.ai",
+        timeout: int = 60,
+        **kwargs,
+    ):
+        key = swiftapi_key or api_key
+        if not key:
+            raise AuthenticationError("swiftapi_key is required")
+        if not key.startswith("swiftapi_live_"):
+            raise AuthenticationError("Invalid key format: must start with 'swiftapi_live_'")
+
+        self.chat = _ChatNamespace(key, base_url, timeout)

{swiftapi_python-1.0.2 → swiftapi_python-1.1.0}/swiftapi/utils.py

@@ -30,18 +30,29 @@ class Colors:
         RED = GREEN = YELLOW = BLUE = MAGENTA = CYAN = WHITE = RESET = BOLD = ""
 
 
-# Unicode symbols
+# Unicode symbols - Windows-safe fallbacks
 class Symbols:
     """Unicode symbols for SwiftAPI output."""
 
-    LOCK = "\U0001F512"        # Locked
-    UNLOCK = "\U0001F513"      # Unlocked
-    CHECK = "\u2713"           # Checkmark
-    CROSS = "\u2717"           # X mark
-    SHIELD = "\U0001F6E1"      # Shield
-    KEY = "\U0001F511"         # Key
-    WARNING = "\u26A0"         # Warning
-    LIGHTNING = "\u26A1"       # Lightning bolt
+    if sys.platform == 'win32':
+        # Windows console can't encode emoji - use ASCII fallbacks
+        LOCK = "[DENIED]"
+        UNLOCK = "[UNLOCKED]"
+        CHECK = "[OK]"
+        CROSS = "[X]"
+        SHIELD = "[VERIFIED]"
+        KEY = "[KEY]"
+        WARNING = "[!]"
+        LIGHTNING = "[*]"
+    else:
+        LOCK = "\U0001F512"        # Locked
+        UNLOCK = "\U0001F513"      # Unlocked
+        CHECK = "\u2713"           # Checkmark
+        CROSS = "\u2717"           # X mark
+        SHIELD = "\U0001F6E1"      # Shield
+        KEY = "\U0001F511"         # Key
+        WARNING = "\u26A0"         # Warning
+        LIGHTNING = "\u26A1"       # Lightning bolt
 
 
 def print_approved(action_type: str, intent: str):

{swiftapi_python-1.0.2 → swiftapi_python-1.1.0}/swiftapi/verifier.py

@@ -93,8 +93,11 @@ def _reconstruct_signed_payload(attestation: Dict[str, Any]) -> bytes:
     The server signs the attestation BEFORE adding signature/signing_mode fields.
     We must reconstruct that exact payload.
     """
-    # Copy attestation and remove signature fields (they weren't in the signed payload)
-    signed_fields = {k: v for k, v in attestation.items() if k not in ("signature", "signing_mode")}
+    # Copy attestation and remove fields that weren't in the signed payload.
+    # signature/signing_mode are added after signing.
+    # action_data/denial_reason are added by /attest after signing.
+    _unsigned = ("signature", "signing_mode", "action_data", "denial_reason")
+    signed_fields = {k: v for k, v in attestation.items() if k not in _unsigned}
 
     # Deterministic JSON serialization (must match server exactly)
     payload_str = json.dumps(signed_fields, sort_keys=True, separators=(",", ":"))

{swiftapi_python-1.0.2 → swiftapi_python-1.1.0}/swiftapi_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: swiftapi-python
-Version: 1.0.2
+Version: 1.1.0
 Summary: SwiftAPI Python SDK - AI Action Verification Gateway
 Author-email: Rayan Pal <rayan@swiftapi.ai>
 License-Expression: MIT

{swiftapi_python-1.0.2 → swiftapi_python-1.1.0}/swiftapi_python.egg-info/SOURCES.txt

@@ -4,6 +4,7 @@ swiftapi/__init__.py
 swiftapi/client.py
 swiftapi/enforcement.py
 swiftapi/exceptions.py
+swiftapi/openai.py
 swiftapi/utils.py
 swiftapi/verifier.py
 swiftapi_python.egg-info/PKG-INFO