swiftapi-python 1.1.1__tar.gz → 1.1.2__tar.gz

{swiftapi_python-1.1.1 → swiftapi_python-1.1.2}/PKG-INFO

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

{swiftapi_python-1.1.1 → swiftapi_python-1.1.2}/pyproject.toml

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

{swiftapi_python-1.1.1 → swiftapi_python-1.1.2}/swiftapi/__init__.py

@@ -29,7 +29,7 @@ Usage:
         db.update(user_id, data)
 """
 
-__version__ = "1.1.1"
+__version__ = "1.1.2"
 __author__ = "Rayan Pal"
 
 # Core exports

{swiftapi_python-1.1.1 → swiftapi_python-1.1.2}/swiftapi/openai.py

@@ -3,19 +3,19 @@ SwiftAPI Attested OpenAI - Drop-in replacement.
 
     # Before (vibe coding):
     from openai import OpenAI
-    client = OpenAI()
+    client = OpenAI(api_key="sk-...")
 
     # After (attested):
     from swiftapi import OpenAI
-    client = OpenAI(swiftapi_key="swiftapi_live_...")
+    client = OpenAI(swiftapi_key="swiftapi_live_...", openai_key="sk-...")
 
 Same interface. Same return type. Every completion is cryptographically attested.
-No attestation, no output.
+No attestation, no output. SwiftAPI governs. OpenAI executes. You bring both keys.
 """
 
 import json
 import requests
-from typing import List, Dict, Union, Optional, Any
+from typing import List, Dict, Optional, Any
 
 from .exceptions import SwiftAPIError, AuthenticationError, NetworkError
 
@@ -65,16 +65,12 @@ class ChatCompletion:
 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("/")
+    def __init__(self, swiftapi_key: str, openai_key: str, authority_url: str, timeout: int):
+        self._swiftapi_key = swiftapi_key
+        self._openai_key = openai_key
+        self._authority_url = authority_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,
@@ -89,10 +85,13 @@ class Completions:
         Create an attested chat completion.
 
         Same interface as openai.chat.completions.create().
-        Attestation is handled transparently. If any gate fails, content is empty string.
+        Step 1: Attest with SwiftAPI (governance).
+        Step 2: Call OpenAI directly with your key (execution).
+
+        If governance denies, content is empty string. Void.
 
         Args:
-            model: Model name (e.g. "gpt-4o-mini")
+            model: Model name (e.g. "gpt-4o")
             messages: List of message dicts with role and content
             temperature: Sampling temperature
             max_completion_tokens: Max tokens in response
@@ -101,18 +100,25 @@ class Completions:
         Returns:
             ChatCompletion with .choices[0].message.content
         """
+        effective_max = max_tokens or max_completion_tokens
+
         payload = {
             "model": model,
             "messages": messages,
             "temperature": temperature,
-            "max_completion_tokens": max_tokens or max_completion_tokens,
+            "max_completion_tokens": effective_max,
         }
 
-        # Step 1: Attest
+        # Step 1: Attest with SwiftAPI — governance check
         try:
             attest_resp = self._session.post(
-                f"{self._base_url}/attest",
+                f"{self._authority_url}/attest",
                 json={"action_type": "chat_completion", "action_data": payload},
+                headers={
+                    "X-SwiftAPI-Authority": self._swiftapi_key,
+                    "Content-Type": "application/json",
+                    "User-Agent": "swiftapi-python/1.1.1",
+                },
                 timeout=self._timeout,
             )
         except requests.exceptions.RequestException as e:
@@ -130,25 +136,36 @@ class Completions:
         if not attestation.get("approved"):
             return ChatCompletion(content="", model=model)
 
-        # Step 2: Forward to /chat/vibe with attestation
+        # Step 2: Call OpenAI directly — user's own key, user's own credits
+        openai_payload = {
+            "model": model,
+            "messages": messages,
+            "temperature": temperature,
+            "max_completion_tokens": effective_max,
+        }
+        openai_payload.update(kwargs)
+
         try:
-            vibe_resp = self._session.post(
-                f"{self._base_url}/chat/vibe",
-                json=payload,
-                headers={"X-SwiftAPI-Attestation": json.dumps(attestation)},
+            openai_resp = self._session.post(
+                "https://api.openai.com/v1/chat/completions",
+                json=openai_payload,
+                headers={
+                    "Authorization": f"Bearer {self._openai_key}",
+                    "Content-Type": "application/json",
+                    "User-Agent": "swiftapi-python/1.1.1",
+                },
                 timeout=self._timeout,
             )
         except requests.exceptions.RequestException as e:
-            raise NetworkError(f"Chat request failed: {e}")
+            raise NetworkError(f"OpenAI 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]}")
+        if openai_resp.status_code == 401:
+            raise AuthenticationError("Invalid OpenAI API key")
+        if openai_resp.status_code != 200:
+            raise SwiftAPIError(f"OpenAI error: {openai_resp.text[:200]}")
 
-        content = vibe_resp.json()
-        if content is None:
-            content = ""
+        data = openai_resp.json()
+        content = data.get("choices", [{}])[0].get("message", {}).get("content", "")
 
         return ChatCompletion(
             content=content,
@@ -161,8 +178,8 @@ class Completions:
 class _ChatNamespace:
     """Namespace for client.chat.completions"""
 
-    def __init__(self, key: str, base_url: str, timeout: int):
-        self.completions = Completions(key, base_url, timeout)
+    def __init__(self, swiftapi_key: str, openai_key: str, authority_url: str, timeout: int):
+        self.completions = Completions(swiftapi_key, openai_key, authority_url, timeout)
 
 
 class OpenAI:
@@ -170,14 +187,17 @@ class OpenAI:
     Drop-in replacement for openai.OpenAI.
 
     Every completion is cryptographically attested via SwiftAPI.
-    No attestation, no output.
+    SwiftAPI governs. OpenAI executes. You bring both keys.
 
     Usage:
         from swiftapi import OpenAI
 
-        client = OpenAI(swiftapi_key="swiftapi_live_...")
+        client = OpenAI(
+            swiftapi_key="swiftapi_live_...",
+            openai_key="sk-..."
+        )
         r = client.chat.completions.create(
-            model="gpt-4o-mini",
+            model="gpt-4o",
             messages=[{"role": "user", "content": "Hello"}]
         )
         print(r.choices[0].message.content)
@@ -186,15 +206,19 @@ class OpenAI:
     def __init__(
         self,
         swiftapi_key: str = None,
+        openai_key: str = None,
         api_key: str = None,
-        base_url: str = "https://swiftapi.ai",
+        authority_url: str = "https://swiftapi.ai",
         timeout: int = 60,
         **kwargs,
     ):
-        key = swiftapi_key or api_key
-        if not key:
+        if not swiftapi_key:
             raise AuthenticationError("swiftapi_key is required")
-        if not key.startswith("swiftapi_live_"):
+        if not swiftapi_key.startswith("swiftapi_live_"):
             raise AuthenticationError("Invalid key format: must start with 'swiftapi_live_'")
 
-        self.chat = _ChatNamespace(key, base_url, timeout)
+        oai_key = openai_key or api_key
+        if not oai_key:
+            raise AuthenticationError("openai_key is required (your OpenAI API key)")
+
+        self.chat = _ChatNamespace(swiftapi_key, oai_key, authority_url, timeout)

{swiftapi_python-1.1.1 → swiftapi_python-1.1.2}/swiftapi_python.egg-info/PKG-INFO

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