verilink-aiverify-plugin 1.0.0__py3-none-any.whl

verilink_aiverify_plugin-1.0.0.dist-info/METADATA

@@ -0,0 +1,71 @@
+Metadata-Version: 2.4
+Name: verilink-aiverify-plugin
+Version: 1.0.0
+Summary: VeriLinkOS Active Governance Integration for AI Verify
+License: Apache-2.0
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: httpx<0.28.0,>=0.23.0
+Requires-Dist: pydantic<3.0.0,>=1.10.0
+Requires-Dist: python-dotenv<2.1.0,>=0.19.0
+Requires-Dist: tenacity<9.1.0,>=8.0.0
+Dynamic: license-file
+Dynamic: requires-python
+
+# VeriLinkOS AI Verify Plugin
+
+[![PyPI version](https://badge.fury.io/py/verilink-aiverify-plugin.svg)](https://badge.fury.io/py/verilink-aiverify-plugin)
+[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
+
+## Overview
+
+VeriLinkOS AI Verify Plugin integrates active governance capabilities from VeriLinkOS into the AI Verify testing framework.
+
+### Features
+
+- ✅ Active Governance: Real-time policy enforcement during AI tests
+- ✅ VAP Receipts: Cryptographic evidence for compliance audits
+- ✅ AI-BOM Verification: Ensure model integrity and provenance
+- ✅ Trust Tokens: JIT authentication for each test run
+- ✅ Predictive Enforcement: ML-based risk prediction
+
+## Installation
+
+```bash
+pip install verilink-aiverify-plugin
+```
+
+## Configuration
+Set environment variables:
+
+```bash
+export VERILINK_API_URL=https://api.verilink.os
+export VERILINK_API_KEY=your_api_key
+export VERILINK_AGENT_ID=your_agent_id
+export VERILINK_ORG_ID=your_org_id
+```
+
+## Quick Start
+```python
+import asyncio
+from verilink_plugin import VeriLinkGovernancePlugin
+
+async def test_model():
+    plugin = VeriLinkGovernancePlugin()
+    
+    result = await plugin.run_test(
+        {"model_id": "model-001", "dataset": "test-data"},
+        lambda config: {"passed": True, "artifacts": {}}
+    )
+    
+    print(f"Passed: {result.passed}")
+    print(f"Receipt: {result.receipt_id}")
+    
+    await plugin.cleanup()
+
+asyncio.run(test_model())
+```
+
+## License
+Apache 2.0

verilink_aiverify_plugin-1.0.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+verilink_aiverify_plugin-1.0.0.dist-info/licenses/LICENSE,sha256=KSuq6JK0zk6CXmYDZDZ6lMUEUDkTMJR9nYL6ZeNZ4vs,623
+verilink_plugin/__init__.py,sha256=_KCUidBhREjwW7uDAarqd_VKN0vPXnvKKWlV-oF8IQs,425
+verilink_plugin/client.py,sha256=yH3bmfgKHx74flDw_ppo4sUQnsYOMjXzkOi3DOoFook,3814
+verilink_plugin/exceptions.py,sha256=ooqhDs-mXrZMSPBHK7mkzQAtF7sJPPSxR0I4CPsXu_c,695
+verilink_plugin/models.py,sha256=FAkAq9rllHLaKhLHHaZa6lEuI-8opM8UA6L4Ai5cv2U,2356
+verilink_plugin/plugin.py,sha256=N3VkLot2kHNWTJvoTR_k4sKw5QYuNobR2OROeetXDmM,7467
+verilink_plugin/utils.py,sha256=Sx_xkHy0yswoc5LG85ZBrcjtzhB7cDq6dtksjSlQYs4,1029
+verilink_aiverify_plugin-1.0.0.dist-info/METADATA,sha256=PRsnDvLJQit1Lzsg9cZRVZmlBjaGJs5BFcbkiW96kjk,1958
+verilink_aiverify_plugin-1.0.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+verilink_aiverify_plugin-1.0.0.dist-info/entry_points.txt,sha256=k8KmFSB6n70QiWSHuE0UitCeZOm0O4VJSp7XM3J2zXk,81
+verilink_aiverify_plugin-1.0.0.dist-info/top_level.txt,sha256=jmMWUkgIaXjFsUH1J2rYnAaIqI3gRxNgRtnM23k1uFs,16
+verilink_aiverify_plugin-1.0.0.dist-info/RECORD,,

verilink_aiverify_plugin-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

verilink_aiverify_plugin-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[aiverify.plugins]
+verilink_os = verilink_plugin.plugin:VeriLinkGovernancePlugin

verilink_aiverify_plugin-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,17 @@
+Apache License
+Version 2.0, January 2004
+http://www.apache.org/licenses/
+
+Copyright 2024 Rajinder Jhol
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

verilink_aiverify_plugin-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+verilink_plugin

verilink_plugin/__init__.py

@@ -0,0 +1,18 @@
+"""
+VeriLinkOS AI Verify Plugin
+"""
+from .plugin import VeriLinkGovernancePlugin
+from .client import VeriLinkClient
+from .models import VeriLinkConfig, VeriLinkTestResult, VeriLinkEnforcementMode
+from .exceptions import VeriLinkError
+
+__version__ = "1.0.0"
+
+__all__ = [
+    "VeriLinkGovernancePlugin",
+    "VeriLinkClient",
+    "VeriLinkConfig",
+    "VeriLinkTestResult",
+    "VeriLinkEnforcementMode",
+    "VeriLinkError"
+]

verilink_plugin/client.py

@@ -0,0 +1,102 @@
+"""
+HTTP client for VeriLinkOS API
+"""
+
+import logging
+import time
+from typing import Dict, Any, Optional
+import httpx
+from tenacity import retry, stop_after_attempt, wait_exponential, retry_if_exception_type
+
+from .models import VeriLinkConfig
+from .exceptions import (
+    VeriLinkConnectionError,
+    VeriLinkAuthError,
+    VeriLinkTimeoutError
+)
+
+logger = logging.getLogger("verilink_plugin")
+
+class VeriLinkClient:
+    """Core API client for VeriLinkOS"""
+    
+    def __init__(self, config: VeriLinkConfig):
+        self.config = config
+        self.headers = {
+            "X-VeriLink-API-Key": config.api_key,
+            "X-VeriLink-Agent-ID": config.agent_id,
+            "Content-Type": "application/json",
+            "User-Agent": "VeriLink-AIVerify-Plugin/1.0.0"
+        }
+        self.client = httpx.AsyncClient(
+            base_url=config.api_url,
+            headers=self.headers,
+            timeout=config.timeout
+        )
+
+    async def verilink_health_check(self) -> bool:
+        """Check if VeriLinkOS API is healthy"""
+        try:
+            response = await self.client.get("/health")
+            return response.status_code == 200
+        except Exception as e:
+            logger.error(f"VeriLink health check failed: {str(e)}")
+            return False
+
+    @retry(
+        stop=stop_after_attempt(3),
+        wait=wait_exponential(multiplier=1, min=2, max=10),
+        retry=retry_if_exception_type((httpx.RequestError, VeriLinkTimeoutError))
+    )
+    async def _verilink_request(self, method: str, endpoint: str, data: Optional[Dict] = None) -> Dict:
+        """Make a request to VeriLinkOS API with retry logic"""
+        try:
+            response = await self.client.request(method, endpoint, json=data)
+            
+            if response.status_code == 401:
+                raise VeriLinkAuthError("Invalid VeriLink API credentials")
+            
+            response.raise_for_status()
+            return response.json()
+            
+        except httpx.TimeoutException:
+            raise VeriLinkTimeoutError(f"Request to {endpoint} timed out")
+        except httpx.HTTPStatusError as e:
+            raise VeriLinkConnectionError(f"API Error {e.response.status_code}: {e.response.text}")
+        except Exception as e:
+            raise VeriLinkConnectionError(f"Unexpected connection error: {str(e)}")
+
+    async def verilink_get_token(self) -> str:
+        """Retrieve a short-lived JIT Trust Token"""
+        res = await self._verilink_request("POST", "/v1/auth/token", {
+            "org_id": self.config.organization_id,
+            "agent_id": self.config.agent_id
+        })
+        return res["trust_token"]
+
+    async def verilink_verify_aibom(self, aibom_data: Dict) -> Dict:
+        """Validate Model Integrity via AI-BOM verification"""
+        return await self._verilink_request("POST", "/v1/governance/verify-aibom", aibom_data)
+
+    async def verilink_generate_receipt(self, test_evidence: Dict) -> Dict:
+        """Generate a VAP Receipt"""
+        return await self._verilink_request("POST", "/v1/governance/receipt", {
+            "evidence": test_evidence,
+            "timestamp": time.time(),
+            "batch": True
+        })
+
+    async def verilink_verify_receipt(self, receipt_id: str) -> Dict:
+        """Verify an existing receipt"""
+        return await self._verilink_request("GET", f"/v1/governance/receipt/{receipt_id}/verify")
+
+    async def verilink_predict_outcome(self, config_fingerprint: str) -> float:
+        """Predict failure probability"""
+        res = await self._verilink_request("POST", "/v1/analytics/predict", {
+            "fingerprint": config_fingerprint
+        })
+        return res.get("failure_probability", 0.0)
+
+    async def close(self):
+        """Close the HTTP client"""
+        await self.client.aclose()

verilink_plugin/exceptions.py

@@ -0,0 +1,27 @@
+"""
+Custom exceptions for VeriLinkOS plugin
+"""
+
+class VeriLinkError(Exception):
+    """Base exception for all VeriLink plugin errors."""
+    pass
+
+class VeriLinkConnectionError(VeriLinkError):
+    """Raised when the plugin cannot connect to VeriLinkOS API."""
+    pass
+
+class VeriLinkAuthError(VeriLinkError):
+    """Raised on authentication failures."""
+    pass
+
+class VeriLinkValidationError(VeriLinkError):
+    """Raised when configuration or payload validation fails."""
+    pass
+
+class VeriLinkTimeoutError(VeriLinkError):
+    """Raised when a VeriLinkOS operation times out."""
+    pass
+
+class VeriLinkConfigError(VeriLinkError):
+    """Raised when configuration is invalid."""
+    pass

verilink_plugin/models.py

@@ -0,0 +1,63 @@
+"""
+Data models for VeriLinkOS plugin
+"""
+
+from typing import Dict, Any, Optional
+from pydantic import BaseModel, Field, validator
+from enum import Enum
+import uuid
+
+class VeriLinkEnforcementMode(str, Enum):
+    """Enforcement modes for governance"""
+    BLOCK = "block"
+    WARN = "warn"
+    LOG = "log"
+    OBSERVE = "observe"
+
+class VeriLinkConfig(BaseModel):
+    """Configuration for VeriLinkOS plugin"""
+    api_url: str = Field(..., description="VeriLinkOS API URL")
+    api_key: str = Field(..., description="VeriLinkOS API key")
+    agent_id: str = Field(..., description="Agent identifier")
+    organization_id: str = Field(..., description="Organization identifier")
+    enforce_mode: VeriLinkEnforcementMode = Field(
+        default=VeriLinkEnforcementMode.BLOCK,
+        description="Enforcement mode"
+    )
+    timeout: int = Field(default=30, description="Request timeout in seconds")
+    max_retries: int = Field(default=3, description="Maximum retry attempts")
+    use_cache: bool = Field(default=True, description="Enable caching")
+    cache_ttl: int = Field(default=300, description="Cache TTL in seconds")
+    predictive_enabled: bool = Field(default=True, description="Enable predictive enforcement")
+    jurisdiction: str = Field(default="SG", description="Legal jurisdiction")
+
+    @validator("api_url")
+    def validate_url(cls, v):
+        if not v.startswith(("http://", "https://")):
+            raise ValueError("VERILINK_API_URL must start with http:// or https://")
+        return v
+
+class VeriLinkTestResult(BaseModel):
+    """Result of a test with VeriLinkOS governance"""
+    passed: bool
+    error: Optional[str] = None
+    details: Dict[str, Any] = Field(default_factory=dict)
+    artifacts: Dict[str, Any] = Field(default_factory=dict)
+    receipt_id: Optional[str] = None
+    verification_url: Optional[str] = None
+    merkle_root: Optional[str] = None
+    prediction_score: Optional[float] = None
+    governance_status: str = "evaluated"
+
+    def to_dict(self) -> Dict[str, Any]:
+        return self.dict(exclude_none=True)
+
+class VeriLinkReceipt(BaseModel):
+    """VAP Receipt model"""
+    receipt_id: str = Field(default_factory=lambda: str(uuid.uuid4()))
+    test_id: str
+    timestamp: float
+    signature: str
+    evidence_hash: str
+    merkle_root: Optional[str] = None
+    verification_url: Optional[str] = None

verilink_plugin/plugin.py

@@ -0,0 +1,181 @@
+"""
+Main VeriLinkOS Governance Plugin for AI Verify
+"""
+
+import logging
+import asyncio
+import hashlib
+import json
+from typing import Dict, Any, Optional, Callable
+
+from .models import VeriLinkConfig, VeriLinkTestResult, VeriLinkEnforcementMode
+from .client import VeriLinkClient
+from .exceptions import VeriLinkAuthError
+
+logger = logging.getLogger("verilink_plugin")
+
+class VeriLinkGovernancePlugin:
+    """Main integration plugin for AI Verify"""
+    
+    PLUGIN_ID = "verilink_os_governance"
+    PLUGIN_VERSION = "1.0.0"
+    
+    def __init__(self, config_dict: Optional[Dict] = None):
+        self.config = VeriLinkConfig(**(config_dict or {}))
+        self.client = VeriLinkClient(self.config)
+        self._aibom_cache: Dict[str, Any] = {}
+        self._initialized = False
+    
+    async def verilink_setup(self):
+        """Initialize the plugin and check connectivity"""
+        try:
+            if await self.client.verilink_health_check():
+                self._initialized = True
+                logger.info("VeriLinkOS connection established")
+            else:
+                logger.warning("VeriLinkOS API unreachable. Operating in fail-safe mode.")
+                self._initialized = False
+        except Exception as e:
+            logger.error(f"VeriLink setup failed: {str(e)}")
+            self._initialized = False
+    
+    async def run_test(self, test_config: Dict[str, Any], test_func: Callable) -> VeriLinkTestResult:
+        """Run an AI test with VeriLinkOS governance"""
+        try:
+            if not self._initialized:
+                await self.verilink_setup()
+            
+            # 1. Predictive enforcement
+            if self.config.predictive_enabled:
+                prediction = await self._verilink_predict_risk(test_config)
+                if prediction > 0.8 and self.config.enforce_mode == VeriLinkEnforcementMode.BLOCK:
+                    return VeriLinkTestResult(
+                        passed=False, 
+                        error="Predictive block: high risk detected",
+                        prediction_score=prediction,
+                        governance_status="blocked"
+                    )
+            
+            # 2. Get trust token
+            try:
+                await self.client.verilink_get_token()
+                logger.info("VeriLink trust token acquired")
+            except Exception as e:
+                if self.config.enforce_mode == VeriLinkEnforcementMode.BLOCK:
+                    return VeriLinkTestResult(
+                        passed=False,
+                        error=f"Authentication failed: {str(e)}",
+                        governance_status="blocked"
+                    )
+                return self._fail_open_result(str(e))
+            
+            # 3. Verify AI-BOM
+            try:
+                aibom_status = await self._verilink_check_aibom(test_config)
+                if not aibom_status.get("valid") and self.config.enforce_mode == VeriLinkEnforcementMode.BLOCK:
+                    return VeriLinkTestResult(
+                        passed=False,
+                        error="AI-BOM Verification Failed: Model not registered or tampered",
+                        governance_status="blocked"
+                    )
+            except Exception as e:
+                if self.config.enforce_mode == VeriLinkEnforcementMode.BLOCK:
+                    return VeriLinkTestResult(
+                        passed=False,
+                        error=f"AI-BOM verification error: {str(e)}",
+                        governance_status="blocked"
+                    )
+                logger.warning(f"AI-BOM verification degraded: {e}")
+            
+            # 4. Run the actual test
+            test_start_time = asyncio.get_event_loop().time()
+            test_raw_result = await test_func(test_config)
+            test_duration = asyncio.get_event_loop().time() - test_start_time
+            
+            # 5. Generate VAP receipt
+            evidence = {
+                "test_config": test_config,
+                "raw_result": test_raw_result,
+                "duration": test_duration,
+                "timestamp": asyncio.get_event_loop().time()
+            }
+            receipt_data = await self.client.verilink_generate_receipt(evidence)
+            
+            # 6. Verify the receipt
+            verification = await self.client.verilink_verify_receipt(receipt_data["receipt_id"])
+            is_verified = verification.get("verified", False)
+            
+            return VeriLinkTestResult(
+                passed=test_raw_result.get("passed", False),
+                receipt_id=receipt_data["receipt_id"],
+                verification_url=f"{self.config.api_url}/verify/{receipt_data['receipt_id']}",
+                merkle_root=receipt_data.get("merkle_root"),
+                details={
+                    "receipt_verified": is_verified,
+                    "duration": test_duration,
+                    "governance_mode": self.config.enforce_mode.value
+                },
+                artifacts=test_raw_result.get("artifacts", {}),
+                governance_status="approved" if is_verified else "pending"
+            )
+            
+        except VeriLinkAuthError as e:
+            if self.config.enforce_mode == VeriLinkEnforcementMode.BLOCK:
+                raise
+            return self._fail_open_result(str(e))
+            
+        except Exception as e:
+            logger.error(f"VeriLink plugin error: {e}", exc_info=True)
+            if self.config.enforce_mode == VeriLinkEnforcementMode.BLOCK:
+                return VeriLinkTestResult(
+                    passed=False,
+                    error=str(e),
+                    governance_status="blocked"
+                )
+            return self._fail_open_result(str(e))
+    
+    async def _verilink_check_aibom(self, test_config: Dict) -> Dict:
+        """Check AI-BOM with caching"""
+        model_id = test_config.get("model_id", "default")
+        
+        if self.config.use_cache and model_id in self._aibom_cache:
+            logger.debug(f"AI-BOM cache hit for {model_id}")
+            return self._aibom_cache[model_id]
+        
+        res = await self.client.verilink_verify_aibom({"model_id": model_id})
+        
+        if self.config.use_cache:
+            self._aibom_cache[model_id] = res
+        
+        return res
+    
+    async def _verilink_predict_risk(self, test_config: Dict) -> float:
+        """Predict failure probability"""
+        fingerprint = hashlib.sha256(
+            json.dumps(test_config, sort_keys=True).encode()
+        ).hexdigest()
+        
+        return await self.client.verilink_predict_outcome(fingerprint)
+    
+    def _fail_open_result(self, error_msg: str) -> VeriLinkTestResult:
+        """Return fail-open result (pass with warning)"""
+        logger.warning(f"VeriLink fail-open: {error_msg}")
+        return VeriLinkTestResult(
+            passed=True,
+            error=error_msg,
+            governance_status="degraded",
+            details={"mode": "fail_open"}
+        )
+    
+    def get_metadata(self) -> Dict[str, str]:
+        """Return plugin metadata for AI Verify"""
+        return {
+            "name": "VeriLinkOS Governance Plugin",
+            "version": self.PLUGIN_VERSION,
+            "entry_point": "verilink_os",
+            "description": "Active governance integration for AI Verify"
+        }
+    
+    async def cleanup(self):
+        """Clean up resources"""
+        await self.client.close()

verilink_plugin/utils.py

@@ -0,0 +1,31 @@
+"""
+Utility functions for VeriLinkOS plugin
+"""
+
+import logging
+import hashlib
+import json
+from typing import Dict, Any
+
+def verilink_setup_logger(name: str = "verilink_plugin") -> logging.Logger:
+    """Setup and return a logger for the plugin"""
+    logger = logging.getLogger(name)
+    if not logger.handlers:
+        handler = logging.StreamHandler()
+        formatter = logging.Formatter(
+            '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+        )
+        handler.setFormatter(formatter)
+        logger.addHandler(handler)
+    return logger
+
+def verilink_calculate_evidence_hash(data: Dict[str, Any]) -> str:
+    """Computes a deterministic SHA256 hash of the evidence data."""
+    encoded = json.dumps(data, sort_keys=True).encode()
+    return hashlib.sha256(encoded).hexdigest()
+
+def verilink_validate_config(url: str, key: str) -> bool:
+    """Basic validation for VeriLink API connectivity parameters."""
+    if not url.startswith(("http://", "https://")):
+        return False
+    return len(key) > 8