cerone 1.0.0__tar.gz

cerone-1.0.0/LICENSE

@@ -0,0 +1,51 @@
+Cerone SDK Commercial License
+Version 1.0
+
+Copyright (c) 2026 Anant Dhavale and Homer Semantics. All rights reserved.
+
+This license governs use of the Cerone Software Development Kit ("SDK") and any associated source code, binaries, examples, and documentation made available by Homer Semantics ("Licensor").
+
+1. Grant of License
+Subject to compliance with this License, Licensor grants you a limited, non-exclusive, non-transferable, revocable license to:
+(a) use the SDK solely to develop, test, and operate integrations with Licensor's Cerone services;
+(b) reproduce and distribute the SDK only as embedded within your application in object form, where end users cannot reasonably extract the SDK as a standalone developer tool.
+
+2. Ownership and Intellectual Property
+The SDK is licensed, not sold. Licensor retains all right, title, and interest in and to the SDK, including all intellectual property rights, trade secrets, and derivative works.
+
+3. Restrictions
+You may not, and may not permit others to:
+(a) sell, sublicense, rent, lease, or provide the SDK as a standalone product or service;
+(b) modify, create derivative works of, or redistribute the SDK source code, except with Licensor's prior written permission;
+(c) remove, alter, or obscure any copyright, trademark, or proprietary notices;
+(d) use the SDK or Cerone services to build, train, benchmark, validate, or improve any competing product or service, including competitive analysis intended for publication or commercialization;
+(e) reverse engineer, decompile, disassemble, translate, decode, or otherwise attempt to derive source code, underlying ideas, algorithms, model behavior, scoring logic, thresholds, prompts, or non-public APIs, except to the limited extent such restriction is expressly prohibited by applicable law;
+(f) attempt model extraction, prompt extraction, dataset extraction, or systematic output analysis intended to replicate Cerone functionality;
+(g) attempt to discover or reconstruct non-public service internals, infrastructure, security controls, or backend implementation details through unauthorized means, including probing, scraping, fuzzing, or penetration activity without prior written authorization from Licensor;
+(h) circumvent or attempt to circumvent usage limits, authentication controls, billing controls, access restrictions, anti-abuse controls, or monitoring controls.
+
+4. Service Terms and Quotas
+Use of the Cerone service APIs is subject to separate service terms, usage quotas, and pricing published by Licensor. Licensor may suspend or terminate API access for abuse, non-payment, security risk, or license breach. Current introductory quota is described in the Terms of Service and may change from time to time.
+
+5. Confidentiality
+Any non-public technical information, performance information, keys, or implementation details disclosed by Licensor are confidential and must not be disclosed to third parties.
+
+6. Feedback
+If you provide feedback, suggestions, or improvement ideas, you grant Licensor a perpetual, irrevocable, worldwide, royalty-free right to use them without restriction or compensation.
+
+7. Disclaimer
+THE SDK IS PROVIDED "AS IS" WITHOUT WARRANTIES OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+
+8. Limitation of Liability
+TO THE MAXIMUM EXTENT PERMITTED BY LAW, LICENSOR WILL NOT BE LIABLE FOR ANY INDIRECT, INCIDENTAL, SPECIAL, CONSEQUENTIAL, EXEMPLARY, OR PUNITIVE DAMAGES, OR ANY LOSS OF DATA, PROFITS, OR REVENUE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. LICENSOR'S AGGREGATE LIABILITY FOR ALL CLAIMS RELATING TO THE SDK WILL NOT EXCEED USD $100.
+
+9. Termination
+This License is effective until terminated. It terminates automatically if you breach any term. Upon termination, you must cease use of the SDK and destroy all copies in your possession or control.
+
+10. Governing Law
+This License is governed by the laws of Western Australia, without regard to conflict of laws principles. Any dispute shall be subject to the exclusive jurisdiction of the courts of Western Australia.
+
+11. Contact
+Licensing requests: info@homersemantics.com , anantdhavale@gmail.com
+
+By using the SDK, you agree to this License.

cerone-1.0.0/MANIFEST.in

@@ -0,0 +1,8 @@
+include README.md
+include LICENSE
+include TERMS_OF_SERVICE.md
+recursive-include cerone *.py
+recursive-include tests *.py
+prune private
+global-exclude __pycache__
+global-exclude *.py[cod]

cerone-1.0.0/PKG-INFO

@@ -0,0 +1,168 @@
+Metadata-Version: 2.4
+Name: cerone
+Version: 1.0.0
+Summary: Zero Trust Security for AI Agents
+Home-page: https://github.com/AnantDhavale/cerone
+Author: Anant Dhavale for Homer Semantics
+Author-email: Homer Semantics <info@homersemantics.com>
+License: Cerone SDK Commercial License
+        Version 1.0
+        
+        Copyright (c) 2026 Anant Dhavale and Homer Semantics. All rights reserved.
+        
+        This license governs use of the Cerone Software Development Kit ("SDK") and any associated source code, binaries, examples, and documentation made available by Homer Semantics ("Licensor").
+        
+        1. Grant of License
+        Subject to compliance with this License, Licensor grants you a limited, non-exclusive, non-transferable, revocable license to:
+        (a) use the SDK solely to develop, test, and operate integrations with Licensor's Cerone services;
+        (b) reproduce and distribute the SDK only as embedded within your application in object form, where end users cannot reasonably extract the SDK as a standalone developer tool.
+        
+        2. Ownership and Intellectual Property
+        The SDK is licensed, not sold. Licensor retains all right, title, and interest in and to the SDK, including all intellectual property rights, trade secrets, and derivative works.
+        
+        3. Restrictions
+        You may not, and may not permit others to:
+        (a) sell, sublicense, rent, lease, or provide the SDK as a standalone product or service;
+        (b) modify, create derivative works of, or redistribute the SDK source code, except with Licensor's prior written permission;
+        (c) remove, alter, or obscure any copyright, trademark, or proprietary notices;
+        (d) use the SDK or Cerone services to build, train, benchmark, validate, or improve any competing product or service, including competitive analysis intended for publication or commercialization;
+        (e) reverse engineer, decompile, disassemble, translate, decode, or otherwise attempt to derive source code, underlying ideas, algorithms, model behavior, scoring logic, thresholds, prompts, or non-public APIs, except to the limited extent such restriction is expressly prohibited by applicable law;
+        (f) attempt model extraction, prompt extraction, dataset extraction, or systematic output analysis intended to replicate Cerone functionality;
+        (g) attempt to discover or reconstruct non-public service internals, infrastructure, security controls, or backend implementation details through unauthorized means, including probing, scraping, fuzzing, or penetration activity without prior written authorization from Licensor;
+        (h) circumvent or attempt to circumvent usage limits, authentication controls, billing controls, access restrictions, anti-abuse controls, or monitoring controls.
+        
+        4. Service Terms and Quotas
+        Use of the Cerone service APIs is subject to separate service terms, usage quotas, and pricing published by Licensor. Licensor may suspend or terminate API access for abuse, non-payment, security risk, or license breach. Current introductory quota is described in the Terms of Service and may change from time to time.
+        
+        5. Confidentiality
+        Any non-public technical information, performance information, keys, or implementation details disclosed by Licensor are confidential and must not be disclosed to third parties.
+        
+        6. Feedback
+        If you provide feedback, suggestions, or improvement ideas, you grant Licensor a perpetual, irrevocable, worldwide, royalty-free right to use them without restriction or compensation.
+        
+        7. Disclaimer
+        THE SDK IS PROVIDED "AS IS" WITHOUT WARRANTIES OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+        
+        8. Limitation of Liability
+        TO THE MAXIMUM EXTENT PERMITTED BY LAW, LICENSOR WILL NOT BE LIABLE FOR ANY INDIRECT, INCIDENTAL, SPECIAL, CONSEQUENTIAL, EXEMPLARY, OR PUNITIVE DAMAGES, OR ANY LOSS OF DATA, PROFITS, OR REVENUE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. LICENSOR'S AGGREGATE LIABILITY FOR ALL CLAIMS RELATING TO THE SDK WILL NOT EXCEED USD $100.
+        
+        9. Termination
+        This License is effective until terminated. It terminates automatically if you breach any term. Upon termination, you must cease use of the SDK and destroy all copies in your possession or control.
+        
+        10. Governing Law
+        This License is governed by the laws of Western Australia, without regard to conflict of laws principles. Any dispute shall be subject to the exclusive jurisdiction of the courts of Western Australia.
+        
+        11. Contact
+        Licensing requests: info@homersemantics.com , anantdhavale@gmail.com
+        
+        By using the SDK, you agree to this License.
+        
+Project-URL: Homepage, https://aztp.homersemantics.com
+Project-URL: Repository, https://github.com/AnantDhavale/cerone
+Project-URL: Bug Tracker, https://github.com/AnantDhavale/cerone/issues
+Keywords: ai,agents,security,zero-trust,validation,llm
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: Other/Proprietary License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+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 :: Security
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.28
+Provides-Extra: async
+Requires-Dist: aiohttp>=3.8; extra == "async"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21; extra == "dev"
+Requires-Dist: aiohttp>=3.8; extra == "dev"
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+
+# Cerone Python SDK (Beta)
+
+Zero Trust security and production governance for AI agents. 
+Cryptographic identity and run-time validation for AI agents in production.
+
+AI agents are being deployed into production systems that handle real decisions, real data, and real consequences, yet most teams have no 
+runtime control over what those agents actually do. Cerone fixes that.
+
+Cerone enforces cryptographic identity, semantic intent validation, and continuous trust scoring on every agent action; ensuring agents only 
+do what they were authorized to do, and nothing else. Deploying AI agents in production without this layer of protection is an unacceptable 
+operational and security risk.
+
+The SDK is currently in early-access beta for selected teams building production AI systems that require accountability, auditability, and 
+control.
+
+## Install
+
+```bash
+pip install cerone
+```
+
+## Access (Beta)
+
+API access is currently managed through early access:
+
+- Request access: https://aztp.homersemantics.com/
+- Receive approval and API credentials
+- Review terms in `TERMS_OF_SERVICE.md`
+
+## Quick Start
+
+```python
+from cerone import CeroneClient
+import os
+
+client = CeroneClient(api_key=os.getenv("CERONE_API_KEY"))
+
+# Create agent
+agent = client.create_agent(
+    purpose="Email classifier",
+    capabilities=["read_email", "move_email", "send_reply"]
+)
+
+# Validate action before executing
+response = client.validate(
+    agent_id=agent.agent_id,
+    action="move_email",
+    parameters={"email_id": "123", "folder": "spam"}
+)
+
+if response.result.value == "approved":
+    mailbox.move_email("123", "spam")
+else:
+    print(f"Action rejected: {response.violations}")
+```
+
+## What the SDK Provides
+
+- Authenticated client access to Cerone services
+- Agent registration and identity-bound operations
+- Sync and async validation calls
+- Batch validation support
+- Governance-oriented telemetry surfaces
+
+## Usage Terms
+
+Usage limits and commercial terms are defined in `TERMS_OF_SERVICE.md`.
+
+Current free trial: up to 25 validations in the first 5 days.
+
+## License
+
+Proprietary commercial license. See `LICENSE`.
+
+## Contact
+anantdhavale@gmail.com
+info@homersemantics.com
+```

cerone-1.0.0/README.md

@@ -0,0 +1,79 @@
+
+# Cerone Python SDK (Beta)
+
+Zero Trust security and production governance for AI agents. 
+Cryptographic identity and run-time validation for AI agents in production.
+
+AI agents are being deployed into production systems that handle real decisions, real data, and real consequences, yet most teams have no 
+runtime control over what those agents actually do. Cerone fixes that.
+
+Cerone enforces cryptographic identity, semantic intent validation, and continuous trust scoring on every agent action; ensuring agents only 
+do what they were authorized to do, and nothing else. Deploying AI agents in production without this layer of protection is an unacceptable 
+operational and security risk.
+
+The SDK is currently in early-access beta for selected teams building production AI systems that require accountability, auditability, and 
+control.
+
+## Install
+
+```bash
+pip install cerone
+```
+
+## Access (Beta)
+
+API access is currently managed through early access:
+
+- Request access: https://aztp.homersemantics.com/
+- Receive approval and API credentials
+- Review terms in `TERMS_OF_SERVICE.md`
+
+## Quick Start
+
+```python
+from cerone import CeroneClient
+import os
+
+client = CeroneClient(api_key=os.getenv("CERONE_API_KEY"))
+
+# Create agent
+agent = client.create_agent(
+    purpose="Email classifier",
+    capabilities=["read_email", "move_email", "send_reply"]
+)
+
+# Validate action before executing
+response = client.validate(
+    agent_id=agent.agent_id,
+    action="move_email",
+    parameters={"email_id": "123", "folder": "spam"}
+)
+
+if response.result.value == "approved":
+    mailbox.move_email("123", "spam")
+else:
+    print(f"Action rejected: {response.violations}")
+```
+
+## What the SDK Provides
+
+- Authenticated client access to Cerone services
+- Agent registration and identity-bound operations
+- Sync and async validation calls
+- Batch validation support
+- Governance-oriented telemetry surfaces
+
+## Usage Terms
+
+Usage limits and commercial terms are defined in `TERMS_OF_SERVICE.md`.
+
+Current free trial: up to 25 validations in the first 5 days.
+
+## License
+
+Proprietary commercial license. See `LICENSE`.
+
+## Contact
+anantdhavale@gmail.com
+info@homersemantics.com
+```

cerone-1.0.0/TERMS_OF_SERVICE.md

@@ -0,0 +1,75 @@
+# Cerone API Terms of Service
+
+Effective date: March 5, 2026
+
+These Terms of Service ("Terms") govern access to and use of the Cerone APIs, SDK, website, and related services (collectively, the "Services") provided by Homer Semantics ("we", "us", "our"). By creating an account, using an API key, installing the SDK, or otherwise using the Services, you agree to these Terms.
+## Beta Service Notice
+
+The Services are currently offered as a beta version. Beta services may contain bugs, errors, or instabilities and are provided for evaluation and early-access purposes only. Features, APIs, quotas, and pricing are subject to change without notice during the beta period. Homer Semantics and Anant Dhavale make no commitment to maintain beta features in future releases. By using the Services during beta, you acknowledge and accept these limitations and agree not to rely on the Services for mission-critical or production workloads without appropriate independent safeguards.
+## 1. Eligibility and Account Responsibilities
+
+You must be legally able to enter into these Terms. You are responsible for all activity under your account and API keys. You must keep credentials secure and notify us promptly of unauthorized use.
+
+## 2. License and Service Access
+
+Your use of the SDK is subject to the Cerone SDK Commercial License in the `LICENSE` file. We grant you a limited, revocable, non-exclusive right to access and use the Services in accordance with these Terms, your plan limits, and applicable law.
+
+## 3. Acceptable Use and Restrictions
+
+You may not, and may not permit others to:
+
+1. Reverse engineer, decompile, disassemble, decode, or otherwise attempt to derive non-public source code, algorithms, models, scoring logic, prompts, or internal APIs, except to the limited extent prohibited by applicable law.
+2. Use the Services or SDK to build, benchmark, validate, or improve a competing product or service, including competitive publications intended for commercialization.
+3. Attempt model, prompt, or dataset extraction, or systematic output analysis intended to replicate Cerone functionality.
+4. Circumvent plan limits, usage quotas, authentication, billing, anti-abuse controls, monitoring controls, or any access restrictions.
+5. Probe, scrape, fuzz, or penetration-test the Services without our prior written authorization.
+6. Use the Services in a way that violates law, infringes third-party rights, or materially degrades service reliability or security.
+
+## 4. Plans, Quotas, and Billing
+
+Free and paid plans, quotas, and pricing are described on our website or order form and may be updated from time to time. Exceeding usage limits may result in throttling, overage charges, suspension, or requirement to upgrade. Fees are non-refundable except where required by law or expressly stated.
+
+## Free Tier and Trial Usage
+
+The Cerone free tier includes up to 25 validations during the first 5 days from account activation ("Trial Period").
+
+After the Trial Period ends, continued API usage may require an active paid plan or may be subject to reduced or zero quota, at Cerone's discretion unless otherwise stated in a signed commercial agreement.
+
+Unused trial validations do not roll over. Cerone may modify, suspend, or discontinue free-tier/trial offerings at any time.
+
+## 5. Data Handling
+
+You are responsible for ensuring you have rights to submit data to the Services and for configuring your own redaction and data governance controls. We may process submitted data to provide, secure, and improve the Services consistent with our privacy commitments and legal obligations, including India's Digital Personal Data Protection Act (DPDPA 2023).
+
+## 6. Confidentiality
+
+Non-public technical, security, pricing, and product information we provide is confidential and must not be disclosed to third parties without our written permission.
+
+## 7. Feedback
+
+If you provide feedback, suggestions, or ideas, you grant us a perpetual, irrevocable, worldwide, royalty-free right to use them without restriction.
+
+## 8. Suspension and Termination
+
+We may suspend or terminate access immediately for suspected abuse, security risk, non-payment, legal risk, or breach of these Terms or the SDK license. On termination, your right to use the Services ceases immediately.
+
+## 9. Disclaimers
+
+THE SERVICES ARE PROVIDED "AS IS" AND "AS AVAILABLE" WITHOUT WARRANTIES OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+
+## 10. Limitation of Liability
+
+TO THE MAXIMUM EXTENT PERMITTED BY LAW, HOMER SEMANTICS and ANANT DHAVALE WILL NOT BE LIABLE FOR ANY INDIRECT, INCIDENTAL, SPECIAL, CONSEQUENTIAL, EXEMPLARY, OR PUNITIVE DAMAGES, OR ANY LOSS OF DATA, PROFITS, OR REVENUE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. OUR AGGREGATE LIABILITY FOR ALL CLAIMS ARISING OUT OF OR RELATED TO THE SERVICES WILL NOT EXCEED THE GREATER OF (A) USD $100 OR (B) FEES PAID BY YOU TO US IN THE THREE (3) MONTHS PRECEDING THE EVENT GIVING RISE TO LIABILITY.
+
+## 11. Governing Law and Venue
+
+These Terms are governed by the laws of India, without regard to conflict-of-laws principles. Any dispute arising out of or relating to these Terms shall be subject to the exclusive jurisdiction of the courts of Pune, Maharashtra, India. Notwithstanding the foregoing, we may elect, at our sole discretion, to bring any dispute in the courts of the jurisdiction where you are domiciled or incorporated.
+
+## 12. Changes to Terms
+
+We may update these Terms from time to time. Updated Terms become effective when posted. Continued use after the effective date constitutes acceptance of the updated Terms.
+
+## 13. Contact
+
+Questions / Support: info@homersemantics.com anantdhavale@gmail.com
+copyright © Anant Dhavale 2026

cerone-1.0.0/cerone/__init__.py

@@ -0,0 +1,527 @@
+"""
+Cerone Python SDK
+Zero Trust Security for AI Agents
+
+Installation:
+    pip install cerone
+
+Usage:
+    from cerone import CeroneClient
+
+    client = CeroneClient(api_key="your_api_key")
+    result = client.validate(agent_id="agt_123", action="trade_execute", parameters={...})
+"""
+
+import asyncio
+import hashlib
+import json
+import logging
+import time
+from collections import OrderedDict
+from dataclasses import dataclass
+from enum import Enum
+from functools import wraps
+from typing import Any, Callable, Dict, List, Optional, TypeVar, cast
+
+import requests
+
+try:
+    import aiohttp
+
+    _AIOHTTP_AVAILABLE = True
+    _AIOHTTP_CLIENT_ERROR = aiohttp.ClientError
+except ModuleNotFoundError:
+    aiohttp = None
+    _AIOHTTP_AVAILABLE = False
+
+    class _AiohttpClientError(Exception):
+        pass
+
+    _AIOHTTP_CLIENT_ERROR = _AiohttpClientError
+
+# F23: version set to 0.2.0 (product is early-access beta, not stable 1.x)
+__version__ = "0.2.0"
+__author__ = "Homer Semantics"
+EARLY_ACCESS_URL = "https://aztp.homersemantics.com/"
+
+logger = logging.getLogger(__name__)
+F = TypeVar("F", bound=Callable[..., Any])
+
+# F18: maximum entries in the in-process validation cache (prevents unbounded growth)
+_CACHE_MAX_SIZE = 1000
+
+
+class ValidationResult(Enum):
+    """Validation result enum."""
+    APPROVED = "approved"
+    REJECTED = "rejected"
+    ERROR    = "error"
+
+
+@dataclass
+class CeroneResponse:
+    """Response from Cerone validation."""
+    result: ValidationResult
+    semantic_alignment: float
+    trust_score: float
+    violations: List[str]
+    agent_id: str
+    action: str
+    timestamp: str
+    latency_ms: int
+
+
+@dataclass
+class AgentCertificate:
+    """Agent identity certificate."""
+    agent_id: str
+    purpose: str
+    capabilities: List[str]
+    trust_score: float
+    signature: str
+    created_at: str
+
+
+class CeroneException(Exception):
+    """Base exception for Cerone SDK."""
+
+
+class AuthenticationError(CeroneException):
+    """Raised when API key is invalid."""
+
+
+class ValidationError(CeroneException):
+    """Raised when validation fails."""
+
+
+class RateLimitError(CeroneException):
+    """Raised when rate limit is exceeded."""
+
+
+class _ClientRequestError(ValidationError):
+    """Raised for non-retryable 4xx request errors."""
+
+
+class _ServerError(ValidationError):
+    """Raised for retryable 5xx server errors."""
+
+
+class CeroneClient:
+    """Cerone API client for validating AI agent actions."""
+
+    _IDEMPOTENT_METHODS = {"GET", "HEAD", "OPTIONS"}
+
+    def __init__(
+        self,
+        api_key: str,
+        base_url: str = "https://api.homersemantics.com",
+        timeout: int = 30,
+        max_retries: int = 3,
+        enable_cache: bool = False,
+        retry_non_idempotent: bool = False,
+    ):
+        """
+        Initialize Cerone client.
+
+        Args:
+            api_key: Your Cerone API key.
+            base_url: API endpoint (default: production).
+            timeout: Request timeout in seconds.
+            max_retries: Number of retry attempts for eligible requests.
+            enable_cache: Enable local caching of high-trust validations.
+                          Cache is bounded to 1,000 entries (LRU eviction).
+            retry_non_idempotent: Retry POST/PUT/PATCH/DELETE on transport
+                errors. Defaults to False to avoid duplicate side effects.
+        """
+        self.api_key = api_key
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+        self.max_retries = max(0, max_retries)
+        self.enable_cache = enable_cache
+        self.retry_non_idempotent = retry_non_idempotent
+
+        # F18: bounded LRU cache — plain dict grows unboundedly in long-running
+        # processes; OrderedDict with a size cap gives O(1) eviction.
+        self._cache: Optional[OrderedDict] = OrderedDict() if enable_cache else None
+
+        self._session = requests.Session()
+        self._session.headers.update(
+            {
+                "X-API-Key": api_key,
+                "Content-Type": "application/json",
+                "User-Agent": f"cerone-python-sdk/{__version__}",
+            }
+        )
+
+        self._async_session: Optional[Any] = None
+
+    # ------------------------------------------------------------------
+    # Certificate / agent management
+    # ------------------------------------------------------------------
+
+    def create_agent(
+        self,
+        purpose: str,
+        capabilities: Optional[List[str]] = None,
+    ) -> AgentCertificate:
+        """Create a new agent with cryptographic identity."""
+        payload = {"purpose": purpose, "capabilities": capabilities or []}
+        response = self._request("POST", "/v1/certificates", json=payload)
+
+        return AgentCertificate(
+            agent_id=response["agent_id"],
+            purpose=purpose,
+            capabilities=capabilities or [],
+            trust_score=response["trust_score"],
+            signature=response["signature"],
+            created_at=response["created_at"],
+        )
+
+    # ------------------------------------------------------------------
+    # Validation
+    # ------------------------------------------------------------------
+
+    def validate(
+        self,
+        agent_id: str,
+        action: str,
+        parameters: Dict[str, Any],
+    ) -> CeroneResponse:
+        """Validate an agent action in real-time."""
+        if self._cache is not None:
+            cache_key = self._cache_key(agent_id, action, parameters)
+            cached = self._cache.get(cache_key)
+            if cached and time.time() - cached["timestamp"] < 300:
+                if cached["trust_score"] > 0.95:
+                    logger.debug("Cache hit for %s", cache_key)
+                    # Move to end (most recently used)
+                    self._cache.move_to_end(cache_key)
+                    return cast(CeroneResponse, cached["response"])
+
+        start_time = time.time()
+        payload = {"agent_id": agent_id, "action": action, "parameters": parameters}
+        response = self._request("POST", "/v1/validate", json=payload)
+        latency_ms = int((time.time() - start_time) * 1000)
+
+        cerone_response = CeroneResponse(
+            result=ValidationResult(response["result"]),
+            semantic_alignment=response["semantic_alignment"],
+            trust_score=response["trust_score"],
+            violations=response.get("violations", []),
+            agent_id=agent_id,
+            action=action,
+            timestamp=response["timestamp"],
+            latency_ms=latency_ms,
+        )
+
+        if (
+            self._cache is not None
+            and cerone_response.result == ValidationResult.APPROVED
+            and cerone_response.trust_score > 0.95
+        ):
+            cache_key = self._cache_key(agent_id, action, parameters)
+            self._cache[cache_key] = {
+                "response": cerone_response,
+                "trust_score": cerone_response.trust_score,
+                "timestamp": time.time(),
+            }
+            self._cache.move_to_end(cache_key)
+            # F18: evict oldest entries if cache is full
+            while len(self._cache) > _CACHE_MAX_SIZE:
+                self._cache.popitem(last=False)
+
+        return cerone_response
+
+    async def validate_async(
+        self,
+        agent_id: str,
+        action: str,
+        parameters: Dict[str, Any],
+    ) -> CeroneResponse:
+        """Async version of validate() for high-throughput scenarios."""
+        if not _AIOHTTP_AVAILABLE:
+            raise ValidationError(
+                "aiohttp is required for async methods. "
+                "Install with: pip install aiohttp"
+            )
+
+        start_time = time.time()
+        payload = {"agent_id": agent_id, "action": action, "parameters": parameters}
+        data = await self._request_async("POST", "/v1/validate", json=payload)
+        latency_ms = int((time.time() - start_time) * 1000)
+
+        return CeroneResponse(
+            result=ValidationResult(data["result"]),
+            semantic_alignment=data["semantic_alignment"],
+            trust_score=data["trust_score"],
+            violations=data.get("violations", []),
+            agent_id=agent_id,
+            action=action,
+            timestamp=data["timestamp"],
+            latency_ms=latency_ms,
+        )
+
+    def validate_batch(self, validations: List[Dict[str, Any]]) -> List[CeroneResponse]:
+        """
+        Validate multiple actions in a single request.
+
+        Each dict in ``validations`` must contain:
+            agent_id   (str)
+            action     (dict with ``tool`` and ``parameters`` keys)
+        """
+        # F3: build properly shaped ValidationRequest objects for the backend
+        requests_payload = []
+        for v in validations:
+            requests_payload.append({
+                "agent_id": v["agent_id"],
+                "action": v["action"],   # must be {"tool": str, "parameters": dict}
+            })
+
+        response = self._request(
+            "POST", "/v1/validate/batch", json={"validations": requests_payload}
+        )
+
+        return [
+            CeroneResponse(
+                result=ValidationResult(r.get("result", "error")),
+                semantic_alignment=r.get("semantic_alignment", 0.0),
+                trust_score=r.get("trust_score", 0.0),
+                violations=r.get("violations", []),
+                agent_id=r.get("agent_id", ""),
+                action=r.get("action", {}).get("tool", "") if isinstance(r.get("action"), dict) else str(r.get("action", "")),
+                timestamp=r.get("timestamp", ""),
+                latency_ms=r.get("latency_ms", 0),
+            )
+            for r in response["results"]
+        ]
+
+    # ------------------------------------------------------------------
+    # Trust / audit
+    # ------------------------------------------------------------------
+
+    def get_trust_score(self, agent_id: str) -> Dict[str, Any]:
+        """Get current trust score and history for an agent."""
+        return self._request("GET", f"/v1/trust/{agent_id}")
+
+    def get_audit_log(
+        self,
+        agent_id: str,
+        limit: int = 100,
+        offset: int = 0,
+    ) -> List[Dict[str, Any]]:
+        """
+        Retrieve audit log events for an agent.
+
+        Returns a list of event dicts.  Each dict contains at minimum:
+            timestamp, agent_id, action, result, change_reason
+        """
+        # F4: backend returns {"events": [...], ...} — read the correct key
+        params = {"limit": limit, "offset": offset}
+        response = self._request("GET", f"/v1/audit/agent/{agent_id}", params=params)
+        return response["events"]
+
+    # ------------------------------------------------------------------
+    # Health / lifecycle
+    # ------------------------------------------------------------------
+
+    def health_check(self) -> Dict[str, Any]:
+        """Check API health status."""
+        try:
+            response = requests.get(f"{self.base_url}/health", timeout=5)
+            return response.json()
+        except Exception as exc:
+            return {"status": "error", "message": str(exc)}
+
+    def close(self) -> None:
+        """Close the underlying synchronous HTTP session."""
+        self._session.close()
+
+    async def aclose(self) -> None:
+        """Close the underlying asynchronous HTTP session if initialized."""
+        if self._async_session is not None and not self._async_session.closed:
+            await self._async_session.close()
+
+    # ------------------------------------------------------------------
+    # Internal helpers
+    # ------------------------------------------------------------------
+
+    def _cache_key(self, agent_id: str, action: str, parameters: Dict[str, Any]) -> str:
+        serialized = json.dumps(parameters, sort_keys=True, default=str, separators=(",", ":"))
+        digest = hashlib.sha256(serialized.encode("utf-8")).hexdigest()
+        return f"{agent_id}:{action}:{digest}"
+
+    def _can_retry(self, method: str) -> bool:
+        return method.upper() in self._IDEMPOTENT_METHODS or self.retry_non_idempotent
+
+    @staticmethod
+    def _raise_for_status(status_code: int, body_text: str) -> None:
+        if 200 <= status_code < 300:
+            return
+        if status_code == 401:
+            raise AuthenticationError(
+                f"Invalid or missing API key. Request early access at {EARLY_ACCESS_URL}"
+            )
+        if status_code == 429:
+            raise RateLimitError(
+                f"Rate limit exceeded. Upgrade your plan at {EARLY_ACCESS_URL}"
+            )
+        if status_code >= 500:
+            raise _ServerError(f"Server error: {status_code}")
+        raise _ClientRequestError(f"Request failed: {status_code} - {body_text}")
+
+    def _request(self, method: str, endpoint: str, **kwargs: Any) -> Dict[str, Any]:
+        """Internal request with bounded retries."""
+        url = f"{self.base_url}{endpoint}"
+        can_retry = self._can_retry(method)
+        attempts = (self.max_retries + 1) if can_retry else 1
+
+        for attempt in range(attempts):
+            try:
+                response = self._session.request(method, url, timeout=self.timeout, **kwargs)
+                self._raise_for_status(response.status_code, response.text)
+                try:
+                    return response.json()
+                except ValueError as exc:
+                    raise ValidationError("Invalid JSON response from server") from exc
+            except (AuthenticationError, RateLimitError, _ClientRequestError):
+                raise
+            except _ServerError:
+                if attempt < attempts - 1:
+                    wait = 2 ** attempt
+                    logger.warning("Server error, retrying in %ss…", wait)
+                    time.sleep(wait)
+                    continue
+                raise
+            except requests.exceptions.Timeout:
+                if attempt < attempts - 1:
+                    logger.warning("Request timeout, retrying…")
+                    continue
+                raise ValidationError("Request timeout")
+            except requests.exceptions.RequestException as exc:
+                if attempt < attempts - 1:
+                    logger.warning("Request failed: %s, retrying…", exc)
+                    continue
+                raise ValidationError(f"Request failed: {exc}")
+
+        raise ValidationError("Max retries exceeded")
+
+    async def _get_async_session(self) -> Any:
+        if not _AIOHTTP_AVAILABLE:
+            raise ValidationError(
+                "aiohttp is required for async methods. "
+                "Install with: pip install aiohttp"
+            )
+        if self._async_session is None or self._async_session.closed:
+            self._async_session = aiohttp.ClientSession(
+                headers=dict(self._session.headers),
+                timeout=aiohttp.ClientTimeout(total=self.timeout),
+            )
+        return self._async_session
+
+    async def _request_async(self, method: str, endpoint: str, **kwargs: Any) -> Dict[str, Any]:
+        """Async request helper with bounded retries."""
+        url = f"{self.base_url}{endpoint}"
+        can_retry = self._can_retry(method)
+        attempts = (self.max_retries + 1) if can_retry else 1
+
+        for attempt in range(attempts):
+            try:
+                session = await self._get_async_session()
+                async with session.request(method, url, **kwargs) as response:
+                    body_text = await response.text()
+                    self._raise_for_status(response.status, body_text)
+                    try:
+                        return json.loads(body_text)
+                    except json.JSONDecodeError as exc:
+                        raise ValidationError("Invalid JSON response from server") from exc
+            except (AuthenticationError, RateLimitError, _ClientRequestError):
+                raise
+            except _ServerError:
+                if attempt < attempts - 1:
+                    wait = 2 ** attempt
+                    logger.warning("Async server error, retrying in %ss…", wait)
+                    await asyncio.sleep(wait)
+                    continue
+                raise
+            except asyncio.TimeoutError:
+                if attempt < attempts - 1:
+                    logger.warning("Async timeout, retrying…")
+                    continue
+                raise ValidationError("Request timeout")
+            except _AIOHTTP_CLIENT_ERROR as exc:
+                if attempt < attempts - 1:
+                    logger.warning("Async request failed: %s, retrying…", exc)
+                    continue
+                raise ValidationError(f"Request failed: {exc}")
+
+        raise ValidationError("Max retries exceeded")
+
+    # ------------------------------------------------------------------
+    # Context manager support
+    # ------------------------------------------------------------------
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()
+        if self._async_session is not None and not self._async_session.closed:
+            logger.warning(
+                "Async session still open. "
+                "Use 'async with CeroneClient(...)' or await client.aclose()."
+            )
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        await self.aclose()
+        self.close()
+
+
+class AgentWrapper:
+    """Wrapper that automatically validates all agent actions via a decorator."""
+
+    def __init__(self, cerone_client: CeroneClient, agent_id: str):
+        self.client = cerone_client
+        self.agent_id = agent_id
+
+    def validate_action(self, func: F) -> F:
+        """Decorator that validates a function call through Cerone before executing it."""
+
+        @wraps(func)
+        def wrapper(*args: Any, **kwargs: Any):
+            action = func.__name__
+            parameters = {"args": args, "kwargs": kwargs}
+
+            result = self.client.validate(
+                agent_id=self.agent_id,
+                action=action,
+                parameters=parameters,
+            )
+
+            if result.result == ValidationResult.APPROVED:
+                logger.info(
+                    "Action '%s' approved (alignment: %.2f)",
+                    action,
+                    result.semantic_alignment,
+                )
+                return func(*args, **kwargs)
+
+            logger.warning("Action '%s' blocked: %s", action, result.violations)
+            raise PermissionError(f"Cerone blocked action: {', '.join(result.violations)}")
+
+        return cast(F, wrapper)
+
+
+__all__ = [
+    "CeroneClient",
+    "AgentWrapper",
+    "CeroneResponse",
+    "AgentCertificate",
+    "ValidationResult",
+    "CeroneException",
+    "AuthenticationError",
+    "ValidationError",
+    "RateLimitError",
+]

cerone-1.0.0/cerone.egg-info/PKG-INFO

@@ -0,0 +1,168 @@
+Metadata-Version: 2.4
+Name: cerone
+Version: 1.0.0
+Summary: Zero Trust Security for AI Agents
+Home-page: https://github.com/AnantDhavale/cerone
+Author: Anant Dhavale for Homer Semantics
+Author-email: Homer Semantics <info@homersemantics.com>
+License: Cerone SDK Commercial License
+        Version 1.0
+        
+        Copyright (c) 2026 Anant Dhavale and Homer Semantics. All rights reserved.
+        
+        This license governs use of the Cerone Software Development Kit ("SDK") and any associated source code, binaries, examples, and documentation made available by Homer Semantics ("Licensor").
+        
+        1. Grant of License
+        Subject to compliance with this License, Licensor grants you a limited, non-exclusive, non-transferable, revocable license to:
+        (a) use the SDK solely to develop, test, and operate integrations with Licensor's Cerone services;
+        (b) reproduce and distribute the SDK only as embedded within your application in object form, where end users cannot reasonably extract the SDK as a standalone developer tool.
+        
+        2. Ownership and Intellectual Property
+        The SDK is licensed, not sold. Licensor retains all right, title, and interest in and to the SDK, including all intellectual property rights, trade secrets, and derivative works.
+        
+        3. Restrictions
+        You may not, and may not permit others to:
+        (a) sell, sublicense, rent, lease, or provide the SDK as a standalone product or service;
+        (b) modify, create derivative works of, or redistribute the SDK source code, except with Licensor's prior written permission;
+        (c) remove, alter, or obscure any copyright, trademark, or proprietary notices;
+        (d) use the SDK or Cerone services to build, train, benchmark, validate, or improve any competing product or service, including competitive analysis intended for publication or commercialization;
+        (e) reverse engineer, decompile, disassemble, translate, decode, or otherwise attempt to derive source code, underlying ideas, algorithms, model behavior, scoring logic, thresholds, prompts, or non-public APIs, except to the limited extent such restriction is expressly prohibited by applicable law;
+        (f) attempt model extraction, prompt extraction, dataset extraction, or systematic output analysis intended to replicate Cerone functionality;
+        (g) attempt to discover or reconstruct non-public service internals, infrastructure, security controls, or backend implementation details through unauthorized means, including probing, scraping, fuzzing, or penetration activity without prior written authorization from Licensor;
+        (h) circumvent or attempt to circumvent usage limits, authentication controls, billing controls, access restrictions, anti-abuse controls, or monitoring controls.
+        
+        4. Service Terms and Quotas
+        Use of the Cerone service APIs is subject to separate service terms, usage quotas, and pricing published by Licensor. Licensor may suspend or terminate API access for abuse, non-payment, security risk, or license breach. Current introductory quota is described in the Terms of Service and may change from time to time.
+        
+        5. Confidentiality
+        Any non-public technical information, performance information, keys, or implementation details disclosed by Licensor are confidential and must not be disclosed to third parties.
+        
+        6. Feedback
+        If you provide feedback, suggestions, or improvement ideas, you grant Licensor a perpetual, irrevocable, worldwide, royalty-free right to use them without restriction or compensation.
+        
+        7. Disclaimer
+        THE SDK IS PROVIDED "AS IS" WITHOUT WARRANTIES OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+        
+        8. Limitation of Liability
+        TO THE MAXIMUM EXTENT PERMITTED BY LAW, LICENSOR WILL NOT BE LIABLE FOR ANY INDIRECT, INCIDENTAL, SPECIAL, CONSEQUENTIAL, EXEMPLARY, OR PUNITIVE DAMAGES, OR ANY LOSS OF DATA, PROFITS, OR REVENUE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. LICENSOR'S AGGREGATE LIABILITY FOR ALL CLAIMS RELATING TO THE SDK WILL NOT EXCEED USD $100.
+        
+        9. Termination
+        This License is effective until terminated. It terminates automatically if you breach any term. Upon termination, you must cease use of the SDK and destroy all copies in your possession or control.
+        
+        10. Governing Law
+        This License is governed by the laws of Western Australia, without regard to conflict of laws principles. Any dispute shall be subject to the exclusive jurisdiction of the courts of Western Australia.
+        
+        11. Contact
+        Licensing requests: info@homersemantics.com , anantdhavale@gmail.com
+        
+        By using the SDK, you agree to this License.
+        
+Project-URL: Homepage, https://aztp.homersemantics.com
+Project-URL: Repository, https://github.com/AnantDhavale/cerone
+Project-URL: Bug Tracker, https://github.com/AnantDhavale/cerone/issues
+Keywords: ai,agents,security,zero-trust,validation,llm
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: Other/Proprietary License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+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 :: Security
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.28
+Provides-Extra: async
+Requires-Dist: aiohttp>=3.8; extra == "async"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21; extra == "dev"
+Requires-Dist: aiohttp>=3.8; extra == "dev"
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+
+# Cerone Python SDK (Beta)
+
+Zero Trust security and production governance for AI agents. 
+Cryptographic identity and run-time validation for AI agents in production.
+
+AI agents are being deployed into production systems that handle real decisions, real data, and real consequences, yet most teams have no 
+runtime control over what those agents actually do. Cerone fixes that.
+
+Cerone enforces cryptographic identity, semantic intent validation, and continuous trust scoring on every agent action; ensuring agents only 
+do what they were authorized to do, and nothing else. Deploying AI agents in production without this layer of protection is an unacceptable 
+operational and security risk.
+
+The SDK is currently in early-access beta for selected teams building production AI systems that require accountability, auditability, and 
+control.
+
+## Install
+
+```bash
+pip install cerone
+```
+
+## Access (Beta)
+
+API access is currently managed through early access:
+
+- Request access: https://aztp.homersemantics.com/
+- Receive approval and API credentials
+- Review terms in `TERMS_OF_SERVICE.md`
+
+## Quick Start
+
+```python
+from cerone import CeroneClient
+import os
+
+client = CeroneClient(api_key=os.getenv("CERONE_API_KEY"))
+
+# Create agent
+agent = client.create_agent(
+    purpose="Email classifier",
+    capabilities=["read_email", "move_email", "send_reply"]
+)
+
+# Validate action before executing
+response = client.validate(
+    agent_id=agent.agent_id,
+    action="move_email",
+    parameters={"email_id": "123", "folder": "spam"}
+)
+
+if response.result.value == "approved":
+    mailbox.move_email("123", "spam")
+else:
+    print(f"Action rejected: {response.violations}")
+```
+
+## What the SDK Provides
+
+- Authenticated client access to Cerone services
+- Agent registration and identity-bound operations
+- Sync and async validation calls
+- Batch validation support
+- Governance-oriented telemetry surfaces
+
+## Usage Terms
+
+Usage limits and commercial terms are defined in `TERMS_OF_SERVICE.md`.
+
+Current free trial: up to 25 validations in the first 5 days.
+
+## License
+
+Proprietary commercial license. See `LICENSE`.
+
+## Contact
+anantdhavale@gmail.com
+info@homersemantics.com
+```

cerone-1.0.0/cerone.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+MANIFEST.in
+README.md
+TERMS_OF_SERVICE.md
+pyproject.toml
+setup.py
+cerone/__init__.py
+cerone.egg-info/PKG-INFO
+cerone.egg-info/SOURCES.txt
+cerone.egg-info/dependency_links.txt
+cerone.egg-info/requires.txt
+cerone.egg-info/top_level.txt

cerone-1.0.0/cerone.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

cerone-1.0.0/cerone.egg-info/requires.txt

@@ -0,0 +1,9 @@
+requests>=2.28
+
+[async]
+aiohttp>=3.8
+
+[dev]
+pytest>=7.0
+pytest-asyncio>=0.21
+aiohttp>=3.8

cerone-1.0.0/cerone.egg-info/top_level.txt

@@ -0,0 +1 @@
+cerone

cerone-1.0.0/pyproject.toml

@@ -0,0 +1,51 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "cerone"
+version = "1.0.0"
+description = "Zero Trust Security for AI Agents"
+readme = "README.md"
+requires-python = ">=3.8"
+license = { file = "LICENSE" }
+authors = [
+    { name = "Homer Semantics", email = "info@homersemantics.com" }
+]
+keywords = ["ai", "agents", "security", "zero-trust", "validation", "llm"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: Other/Proprietary License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Security",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+
+dependencies = [
+    "requests>=2.28",
+]
+
+[project.optional-dependencies]
+async = [
+    "aiohttp>=3.8",
+]
+dev = [
+    "pytest>=7.0",
+    "pytest-asyncio>=0.21",
+    "aiohttp>=3.8",
+]
+
+[project.urls]
+Homepage    = "https://aztp.homersemantics.com"
+Repository  = "https://github.com/AnantDhavale/cerone"
+"Bug Tracker" = "https://github.com/AnantDhavale/cerone/issues"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["cerone*"]

cerone-1.0.0/setup.cfg

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

cerone-1.0.0/setup.py

@@ -0,0 +1,60 @@
+"""Setup configuration for Cerone Python SDK."""
+
+import os
+from pathlib import Path
+
+from setuptools import find_packages, setup
+
+ROOT = Path(__file__).parent
+README = ROOT / "README.md"
+os.chdir(ROOT)
+
+setup(
+    name="cerone",
+    version="1.0.0",
+    author="Anant Dhavale for Homer Semantics",
+    author_email="info@homersemantics.com",
+    description="Zero Trust Security for AI Agents",
+    license="Proprietary - see LICENSE file",
+    long_description=README.read_text(encoding="utf-8"),
+    long_description_content_type="text/markdown",
+    url="https://github.com/AnantDhavale/cerone",
+    project_urls={
+        "Documentation": "https://aztp.homersemantics.com/",
+        "Bug Tracker": "https://github.com/AnantDhavale/cerone/issues",
+        "Homepage": "https://aztp.homersemantics.com/",
+    },
+    packages=["cerone"],
+    include_package_data=True,
+    classifiers=[
+        "Development Status :: 4 - Beta",
+        "Intended Audience :: Developers",
+        "Topic :: Software Development :: Libraries :: Python Modules",
+        "Topic :: Security",
+        "Topic :: Scientific/Engineering :: Artificial Intelligence",
+        "License :: Other/Proprietary License",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+        "Programming Language :: Python :: 3.12",
+    ],
+    python_requires=">=3.8",
+    install_requires=[
+        "requests>=2.28.0",
+    ],
+    extras_require={
+        "async": [
+            "aiohttp>=3.8.0",
+        ],
+        "dev": [
+            "pytest>=7.0.0",
+            "pytest-asyncio>=0.21.0",
+            "black>=23.0.0",
+            "flake8>=6.0.0",
+            "mypy>=1.0.0",
+        ],
+    },
+    keywords="ai agent security zero-trust governance semantic-validation",
+)