nexus6-sdk 0.1.0__tar.gz

nexus6_sdk-0.1.0/PKG-INFO

@@ -0,0 +1,110 @@
+Metadata-Version: 2.4
+Name: nexus6-sdk
+Version: 0.1.0
+Summary: Nexus6 AI Identity SDK — universal identity verification for AI agents
+Author: Nexus6
+License: MIT
+Project-URL: Homepage, https://github.com/Marsssssssssssdsss/nexus6-sdk
+Project-URL: Documentation, https://nexus-7xp6n.ondigitalocean.app
+Project-URL: Source, https://github.com/Marsssssssssssdsss/nexus6-sdk
+Keywords: ai,identity,verification,authentication,agent
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Security
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.24.0
+Requires-Dist: starlette>=0.27.0
+
+# Nexus6 Python SDK
+
+Universal AI identity verification in 3 lines of code.
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## Installation
+
+```bash
+pip install nexus6-sdk
+```
+
+## Quick Start
+
+### For AI Agents
+
+```python
+from nexus6_sdk import Nexus6Client
+
+client = Nexus6Client()
+
+result = client.register(
+    name="My AI Agent",
+    title="Customer Support Bot",
+    ai_type="assistant",
+    description="Handles tier-1 customer queries",
+    developer_email="dev@mycompany.com",
+    developer_name="Your Name"
+)
+
+print(result)
+# {'success': True, 'agent_id': 'ai_xxx', 'api_key': 'nxs6_xxx'}
+
+verified = client.verify(result["api_key"])
+print(verified)
+# {'verified': True, 'id': 'ai_xxx', 'name': 'My AI Agent'}
+```
+
+### For Platforms (FastAPI)
+
+```python
+from fastapi import FastAPI
+from nexus6_sdk.middleware import Nexus6Middleware
+
+app = FastAPI()
+app.add_middleware(Nexus6Middleware)
+
+# That's it. Any request with X-API-Key header will be auto-verified.
+```
+
+### For Flask
+
+```python
+from flask import Flask, request, jsonify
+from nexus6_sdk import Nexus6Client
+
+app = Flask(__name__)
+nexus6 = Nexus6Client()
+
+@app.before_request
+def verify_ai():
+    api_key = request.headers.get("X-API-Key")
+    if api_key:
+        result = nexus6.verify(api_key)
+        if not result.get("verified"):
+            return jsonify({"error": "Invalid identity"}), 401
+
+@app.route("/api/chat", methods=["POST"])
+def chat():
+    return jsonify({"message": "Hello from verified AI!"})
+```
+
+## API Reference
+
+### Nexus6Client
+
+| Method | Description |
+|--------|-------------|
+| `verify(api_key)` | Verify an AI identity |
+| `register(name, ...)` | Register a new AI identity |
+| `create_token(api_key)` | Create a one-time identity token |
+
+## License
+
+MIT

nexus6_sdk-0.1.0/README.md

@@ -0,0 +1,85 @@
+# Nexus6 Python SDK
+
+Universal AI identity verification in 3 lines of code.
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## Installation
+
+```bash
+pip install nexus6-sdk
+```
+
+## Quick Start
+
+### For AI Agents
+
+```python
+from nexus6_sdk import Nexus6Client
+
+client = Nexus6Client()
+
+result = client.register(
+    name="My AI Agent",
+    title="Customer Support Bot",
+    ai_type="assistant",
+    description="Handles tier-1 customer queries",
+    developer_email="dev@mycompany.com",
+    developer_name="Your Name"
+)
+
+print(result)
+# {'success': True, 'agent_id': 'ai_xxx', 'api_key': 'nxs6_xxx'}
+
+verified = client.verify(result["api_key"])
+print(verified)
+# {'verified': True, 'id': 'ai_xxx', 'name': 'My AI Agent'}
+```
+
+### For Platforms (FastAPI)
+
+```python
+from fastapi import FastAPI
+from nexus6_sdk.middleware import Nexus6Middleware
+
+app = FastAPI()
+app.add_middleware(Nexus6Middleware)
+
+# That's it. Any request with X-API-Key header will be auto-verified.
+```
+
+### For Flask
+
+```python
+from flask import Flask, request, jsonify
+from nexus6_sdk import Nexus6Client
+
+app = Flask(__name__)
+nexus6 = Nexus6Client()
+
+@app.before_request
+def verify_ai():
+    api_key = request.headers.get("X-API-Key")
+    if api_key:
+        result = nexus6.verify(api_key)
+        if not result.get("verified"):
+            return jsonify({"error": "Invalid identity"}), 401
+
+@app.route("/api/chat", methods=["POST"])
+def chat():
+    return jsonify({"message": "Hello from verified AI!"})
+```
+
+## API Reference
+
+### Nexus6Client
+
+| Method | Description |
+|--------|-------------|
+| `verify(api_key)` | Verify an AI identity |
+| `register(name, ...)` | Register a new AI identity |
+| `create_token(api_key)` | Create a one-time identity token |
+
+## License
+
+MIT

nexus6_sdk-0.1.0/nexus6_sdk/__init__.py

@@ -0,0 +1,24 @@
+"""
+nexus6_sdk — Nexus6 AI Identity SDK for Python.
+
+5-minute integration for AI agents and platforms.
+
+Usage:
+    # AI Agent side
+    from nexus6_sdk import Nexus6Client
+    client = Nexus6Client(api_key="nxs6_xxx")
+    identity = client.verify()
+
+    # Platform side (FastAPI middleware)
+    from nexus6_sdk.middleware import Nexus6Middleware
+    app.add_middleware(Nexus6Middleware, api_key="nxs6_xxx")
+"""
+
+__version__ = "0.1.0"
+__author__ = "Nexus6"
+__license__ = "MIT"
+
+from .client import Nexus6Client
+from .middleware import Nexus6Middleware
+
+__all__ = ["Nexus6Client", "Nexus6Middleware"]

nexus6_sdk-0.1.0/nexus6_sdk/client.py

@@ -0,0 +1,87 @@
+"""Nexus6 Client — AI identity registration and verification."""
+
+import httpx
+from typing import Optional, Dict, Any
+
+DEFAULT_BASE_URL = "https://nexus-7xp6n.ondigitalocean.app"
+
+
+class Nexus6Client:
+    """Client for Nexus6 AI Identity system.
+    
+    Usage:
+        client = Nexus6Client(api_key="nxs6_xxx")
+        identity = client.verify()
+        
+        # Or register a new identity
+        result = client.register(name="My AI Agent")
+    """
+    
+    def __init__(self, api_key: Optional[str] = None, base_url: str = DEFAULT_BASE_URL):
+        self.api_key = api_key
+        self.base_url = base_url.rstrip("/")
+    
+    def verify(self, api_key: Optional[str] = None) -> Dict[str, Any]:
+        """Verify an AI identity by API key.
+        
+        Returns:
+            {"verified": True, "id": "ai_xxx", "name": "...", ...}
+            or {"verified": False, "error": "..."}
+        """
+        key = api_key or self.api_key
+        if not key:
+            return {"verified": False, "error": "No API key provided. Pass api_key or set it in client."}
+        
+        try:
+            with httpx.Client(timeout=10) as http:
+                resp = http.post(
+                    f"{self.base_url}/api/v1/identity/verify",
+                    json={"api_key": key}
+                )
+                return resp.json()
+        except Exception as e:
+            return {"verified": False, "error": f"Verification failed: {str(e)}"}
+    
+    def register(self, name: str, **kwargs) -> Dict[str, Any]:
+        """Register a new AI identity.
+        
+        Args:
+            name: AI agent name
+            **kwargs: optional fields (title, description, developer_email, etc.)
+        
+        Returns:
+            {"success": True, "agent_id": "...", "api_key": "nxs6_xxx", ...}
+        """
+        payload = {"name": name, **kwargs}
+        try:
+            with httpx.Client(timeout=10) as http:
+                resp = http.post(
+                    f"{self.base_url}/api/ai/register",
+                    json=payload
+                )
+                result = resp.json()
+                if result.get("success") and "api_key" in result:
+                    self.api_key = result["api_key"]
+                return result
+        except Exception as e:
+            return {"success": False, "error": f"Registration failed: {str(e)}"}
+    
+    def create_token(self, api_key: Optional[str] = None) -> Dict[str, Any]:
+        """Create a one-time identity token (expires in 5 min).
+        
+        Returns:
+            {"token": "idt_xxx", "expires_in": 300, "usage": "single-use"}
+        """
+        key = api_key or self.api_key
+        if not key:
+            return {"error": "No API key provided"}
+        
+        try:
+            with httpx.Client(timeout=10) as http:
+                resp = http.post(
+                    f"{self.base_url}/api/v1/identity/token",
+                    headers={"X-API-Key": key}
+                )
+                return resp.json()
+        except Exception as e:
+            return {"error": f"Token creation failed: {str(e)}"}

nexus6_sdk-0.1.0/nexus6_sdk/middleware.py

@@ -0,0 +1,85 @@
+"""Nexus6 Middleware — drop-in AI identity verification for FastAPI/Starlette."""
+
+from starlette.middleware.base import BaseHTTPMiddleware
+from starlette.requests import Request
+from starlette.responses import JSONResponse
+import httpx
+from typing import Optional, List, Callable
+
+DEFAULT_BASE_URL = "https://nexus-7xp6n.ondigitalocean.app"
+
+
+class Nexus6Middleware(BaseHTTPMiddleware):
+    """FastAPI middleware that automatically verifies AI identity on incoming requests.
+    
+    Usage:
+        from fastapi import FastAPI
+        from nexus6 import Nexus6Middleware
+        
+        app = FastAPI()
+        app.add_middleware(Nexus6Middleware)
+        
+        # Or with custom config:
+        app.add_middleware(
+            Nexus6Middleware,
+            exclude_paths=["/health", "/docs", "/openapi.json"],
+            on_verified=lambda req, identity: print(f"Verified: {identity['name']}"),
+        )
+    
+    How it works:
+        1. Checks for X-API-Key header in incoming requests
+        2. If present, calls Nexus6 verification endpoint
+        3. If verified, stores identity in request.state.ai_identity and continues
+        4. If not verified, returns 401 Unauthorized
+    """
+    
+    def __init__(
+        self,
+        app,
+        base_url: str = DEFAULT_BASE_URL,
+        exclude_paths: Optional[List[str]] = None,
+        on_verified: Optional[Callable] = None,
+        header_name: str = "X-API-Key",
+    ):
+        super().__init__(app)
+        self.base_url = base_url.rstrip("/")
+        self.exclude_paths = exclude_paths or ["/health", "/docs", "/openapi.json", "/favicon.ico"]
+        self.on_verified = on_verified
+        self.header_name = header_name
+    
+    async def dispatch(self, request: Request, call_next):
+        path = request.url.path
+        
+        if any(path.startswith(p) for p in self.exclude_paths):
+            return await call_next(request)
+        
+        api_key = request.headers.get(self.header_name)
+        
+        if not api_key:
+            return await call_next(request)
+        
+        verified = await self._verify(api_key)
+        
+        if not verified.get("verified"):
+            return JSONResponse(
+                status_code=401,
+                content={"error": "Invalid AI identity", "details": verified.get("error", "")}
+            )
+        
+        request.state.ai_identity = verified
+        
+        if self.on_verified:
+            self.on_verified(request, verified)
+        
+        return await call_next(request)
+    
+    async def _verify(self, api_key: str) -> dict:
+        try:
+            async with httpx.AsyncClient(timeout=10) as http:
+                resp = await http.post(
+                    f"{self.base_url}/api/v1/identity/verify",
+                    json={"api_key": api_key}
+                )
+                return resp.json()
+        except Exception:
+            return {"verified": False, "error": "Verification service unavailable"}

nexus6_sdk-0.1.0/nexus6_sdk.egg-info/PKG-INFO

@@ -0,0 +1,110 @@
+Metadata-Version: 2.4
+Name: nexus6-sdk
+Version: 0.1.0
+Summary: Nexus6 AI Identity SDK — universal identity verification for AI agents
+Author: Nexus6
+License: MIT
+Project-URL: Homepage, https://github.com/Marsssssssssssdsss/nexus6-sdk
+Project-URL: Documentation, https://nexus-7xp6n.ondigitalocean.app
+Project-URL: Source, https://github.com/Marsssssssssssdsss/nexus6-sdk
+Keywords: ai,identity,verification,authentication,agent
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Security
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.24.0
+Requires-Dist: starlette>=0.27.0
+
+# Nexus6 Python SDK
+
+Universal AI identity verification in 3 lines of code.
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## Installation
+
+```bash
+pip install nexus6-sdk
+```
+
+## Quick Start
+
+### For AI Agents
+
+```python
+from nexus6_sdk import Nexus6Client
+
+client = Nexus6Client()
+
+result = client.register(
+    name="My AI Agent",
+    title="Customer Support Bot",
+    ai_type="assistant",
+    description="Handles tier-1 customer queries",
+    developer_email="dev@mycompany.com",
+    developer_name="Your Name"
+)
+
+print(result)
+# {'success': True, 'agent_id': 'ai_xxx', 'api_key': 'nxs6_xxx'}
+
+verified = client.verify(result["api_key"])
+print(verified)
+# {'verified': True, 'id': 'ai_xxx', 'name': 'My AI Agent'}
+```
+
+### For Platforms (FastAPI)
+
+```python
+from fastapi import FastAPI
+from nexus6_sdk.middleware import Nexus6Middleware
+
+app = FastAPI()
+app.add_middleware(Nexus6Middleware)
+
+# That's it. Any request with X-API-Key header will be auto-verified.
+```
+
+### For Flask
+
+```python
+from flask import Flask, request, jsonify
+from nexus6_sdk import Nexus6Client
+
+app = Flask(__name__)
+nexus6 = Nexus6Client()
+
+@app.before_request
+def verify_ai():
+    api_key = request.headers.get("X-API-Key")
+    if api_key:
+        result = nexus6.verify(api_key)
+        if not result.get("verified"):
+            return jsonify({"error": "Invalid identity"}), 401
+
+@app.route("/api/chat", methods=["POST"])
+def chat():
+    return jsonify({"message": "Hello from verified AI!"})
+```
+
+## API Reference
+
+### Nexus6Client
+
+| Method | Description |
+|--------|-------------|
+| `verify(api_key)` | Verify an AI identity |
+| `register(name, ...)` | Register a new AI identity |
+| `create_token(api_key)` | Create a one-time identity token |
+
+## License
+
+MIT

nexus6_sdk-0.1.0/nexus6_sdk.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+README.md
+pyproject.toml
+nexus6_sdk/__init__.py
+nexus6_sdk/client.py
+nexus6_sdk/middleware.py
+nexus6_sdk.egg-info/PKG-INFO
+nexus6_sdk.egg-info/SOURCES.txt
+nexus6_sdk.egg-info/dependency_links.txt
+nexus6_sdk.egg-info/requires.txt
+nexus6_sdk.egg-info/top_level.txt

nexus6_sdk-0.1.0/nexus6_sdk.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

nexus6_sdk-0.1.0/nexus6_sdk.egg-info/requires.txt

@@ -0,0 +1,2 @@
+httpx>=0.24.0
+starlette>=0.27.0

nexus6_sdk-0.1.0/nexus6_sdk.egg-info/top_level.txt

@@ -0,0 +1 @@
+nexus6_sdk

nexus6_sdk-0.1.0/pyproject.toml

@@ -0,0 +1,37 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "nexus6-sdk"
+version = "0.1.0"
+description = "Nexus6 AI Identity SDK — universal identity verification for AI agents"
+readme = "README.md"
+license = {text = "MIT"}
+authors = [{name = "Nexus6"}]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Topic :: Security",
+]
+keywords = ["ai", "identity", "verification", "authentication", "agent"]
+requires-python = ">=3.9"
+dependencies = [
+    "httpx>=0.24.0",
+    "starlette>=0.27.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/Marsssssssssssdsss/nexus6-sdk"
+Documentation = "https://nexus-7xp6n.ondigitalocean.app"
+Source = "https://github.com/Marsssssssssssdsss/nexus6-sdk"
+
+[tool.setuptools.packages.find]
+include = ["nexus6_sdk*"]

nexus6_sdk-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+