correctover 2.0.2__tar.gz → 2.2.0__tar.gz

correctover-2.2.0/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.4
+Name: correctover
+Version: 2.2.0
+Summary: Correctover - AI Agent Runtime Assurance. CCS standard + GuardrailProvider + MCP Security Scanner.
+Author-email: Guigui Wang <wangguigui@correctover.com>
+License: Proprietary Commercial License
+Project-URL: Homepage, https://correctover.com
+Project-URL: CCS Standard, https://correctover.com/ccs
+Project-URL: GitHub, https://github.com/Correctover
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: pydantic>=1.10

correctover-2.2.0/pyproject.toml

@@ -0,0 +1,21 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "correctover"
+version = "2.2.0"
+authors = [{name="Guigui Wang", email="wangguigui@correctover.com"}]
+description = "Correctover - AI Agent Runtime Assurance. CCS standard + GuardrailProvider + MCP Security Scanner."
+readme = "README.md"
+license = {text = "Proprietary Commercial License"}
+requires-python = ">=3.8"
+dependencies = ["pydantic>=1.10"]
+
+[project.urls]
+Homepage = "https://correctover.com"
+"CCS Standard" = "https://correctover.com/ccs"
+GitHub = "https://github.com/Correctover"
+
+[tool.setuptools.packages.find]
+where = ["src"]

correctover-2.2.0/src/correctover/__init__.py

@@ -0,0 +1,22 @@
+"""Correctover v2.2.0 - AI Agent Runtime Assurance"""
+__version__ = "2.2.0"
+__author__ = "Guigui Wang"
+__email__ = "wangguigui@correctover.com"
+from .validator import CCSValidator, ValidationResult
+from .guardrail import (
+    GuardrailDecisionV1, ActionEnvelopeV1, ToolCallContext,
+    GuardrailProvider, AllowAllGuardrailProvider, DenyAllGuardrailProvider,
+    ToolListGuardrailProvider, CKGGuardrailProvider, EnvProtectionProvider,
+    CompositeGuardrailProvider, AuditTrail, GuardrailContext,
+    make_guardrail_hook, detect_missing_guardrail, compute_decision_id,
+    canonical_json, MCPSecurityValidator,
+)
+__all__ = [
+    "CCSValidator","ValidationResult",
+    "GuardrailDecisionV1","ActionEnvelopeV1","ToolCallContext",
+    "GuardrailProvider","AllowAllGuardrailProvider","DenyAllGuardrailProvider",
+    "ToolListGuardrailProvider","CKGGuardrailProvider","EnvProtectionProvider",
+    "CompositeGuardrailProvider","AuditTrail","GuardrailContext",
+    "make_guardrail_hook","detect_missing_guardrail","compute_decision_id",
+    "canonical_json","MCPSecurityValidator",
+]

correctover-2.2.0/src/correctover/guardrail.py

@@ -0,0 +1,211 @@
+"""
+correctover.guardrail - Framework-agnostic runtime security guardrail system.
+CCS reference implementation.
+"""
+import hashlib, json, time
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from typing import Any, Callable, Dict, List, Optional, Set
+
+def canonical_json(obj):
+    return json.dumps(obj, sort_keys=True, separators=(",",":"), default=str)
+
+def compute_decision_id(claims, expires_at=None):
+    preimage = claims.copy()
+    if expires_at is not None:
+        preimage["_expires_at"] = expires_at
+    return hashlib.sha256(canonical_json(preimage).encode("utf-8")).hexdigest()
+
+@dataclass(frozen=True)
+class GuardrailDecisionV1:
+    decision_id: str
+    authorized: bool
+    claims: Dict[str, Any]
+    expires_at: Optional[float] = None
+    def is_expired(self):
+        if self.expires_at is None: return False
+        return time.time() > self.expires_at
+    def verify_integrity(self):
+        return self.decision_id == compute_decision_id(self.claims, self.expires_at)
+    def to_dict(self):
+        return {"decision_id":self.decision_id,"authorized":self.authorized,"claims":self.claims,"expires_at":self.expires_at}
+
+@dataclass(frozen=True)
+class ActionEnvelopeV1:
+    decision_id: str
+    tool_result_digest: str
+    executed_at: float
+    duration_ms: float
+    @staticmethod
+    def digest_result(result):
+        raw = canonical_json(result) if result is not None else ""
+        return hashlib.sha256(raw.encode("utf-8")).hexdigest()
+    def to_dict(self):
+        return {"decision_id":self.decision_id,"tool_result_digest":self.tool_result_digest,"executed_at":self.executed_at,"duration_ms":self.duration_ms}
+
+@dataclass
+class ToolCallContext:
+    tool_name: str
+    tool_args: Dict[str, Any] = field(default_factory=dict)
+    agent_id: str = "unknown"
+    metadata: Dict[str, Any] = field(default_factory=dict)
+
+class GuardrailProvider(ABC):
+    @abstractmethod
+    def authorize(self, context: ToolCallContext) -> GuardrailDecisionV1: ...
+
+class AllowAllGuardrailProvider(GuardrailProvider):
+    def authorize(self, context):
+        claims = {"provider":"AllowAllGuardrailProvider","tool_name":context.tool_name,"agent_id":context.agent_id}
+        return GuardrailDecisionV1(decision_id=compute_decision_id(claims), authorized=True, claims=claims)
+
+class DenyAllGuardrailProvider(GuardrailProvider):
+    def authorize(self, context):
+        claims = {"provider":"DenyAllGuardrailProvider","tool_name":context.tool_name,"reason":"deny-all safety lock active"}
+        return GuardrailDecisionV1(decision_id=compute_decision_id(claims), authorized=False, claims=claims)
+
+class ToolListGuardrailProvider(GuardrailProvider):
+    def __init__(self, allowed_tools=None, denied_tools=None):
+        self.allowed_tools = allowed_tools
+        self.denied_tools = denied_tools or set()
+    def authorize(self, context):
+        claims = {"provider":"ToolListGuardrailProvider","tool_name":context.tool_name,"agent_id":context.agent_id}
+        if self.allowed_tools is not None:
+            authorized = context.tool_name in self.allowed_tools
+            claims["policy"] = "allowlist"
+            claims["allowed_tools"] = sorted(self.allowed_tools)
+        elif context.tool_name in self.denied_tools:
+            authorized = False
+            claims["policy"] = "denylist"
+            claims["denied_tools"] = sorted(self.denied_tools)
+        else:
+            authorized = True
+            claims["policy"] = "default-allow"
+        return GuardrailDecisionV1(decision_id=compute_decision_id(claims), authorized=authorized, claims=claims)
+
+class CKGGuardrailProvider(GuardrailProvider):
+    def __init__(self):
+        self._constraints = []
+    def add_constraint(self, predicate, **kwargs):
+        self._constraints.append({"predicate":predicate, **kwargs})
+        return self
+    def authorize(self, context):
+        claims = {"provider":"CKGGuardrailProvider","tool_name":context.tool_name,"agent_id":context.agent_id}
+        satisfied, failed_predicate = True, None
+        for c in self._constraints:
+            p = c["predicate"]
+            if p=="tool_name_in" and context.tool_name not in c["tools"]: satisfied,failed_predicate=False,p
+            elif p=="tool_name_not_in" and context.tool_name in c["tools"]: satisfied,failed_predicate=False,p
+            elif p=="agent_id_in" and context.agent_id not in c["agents"]: satisfied,failed_predicate=False,p
+            elif p=="param_matches" and context.tool_args.get(c["name"])!=c["value"]: satisfied,failed_predicate=False,p
+            elif p=="has_param" and c["name"] not in context.tool_args: satisfied,failed_predicate=False,p
+            elif p=="no_param" and c["name"] in context.tool_args: satisfied,failed_predicate=False,p
+        if not satisfied: claims["failed_predicate"]=failed_predicate
+        claims["constraints_count"]=len(self._constraints)
+        return GuardrailDecisionV1(decision_id=compute_decision_id(claims), authorized=satisfied, claims=claims)
+
+class EnvProtectionProvider(GuardrailProvider):
+    DANGEROUS_PATTERNS = {
+        "env_vars":["API_KEY","API_SECRET","SECRET_KEY","PRIVATE_KEY","ACCESS_TOKEN","AUTH_TOKEN","DB_PASSWORD","DATABASE_URL","AWS_SECRET","AWS_ACCESS_KEY","GITHUB_TOKEN","OPENAI_API_KEY","ANTHROPIC_API_KEY"],
+        "env_commands":["os.environ","process.env","getenv","env ","printenv","echo $","${"],
+        "file_paths":[".env",".env.local",".env.production","credentials.json","service-account.json"],
+    }
+    def __init__(self, extra_patterns=None):
+        self.extra_patterns = extra_patterns or []
+    def authorize(self, context):
+        claims = {"provider":"EnvProtectionProvider","tool_name":context.tool_name,"agent_id":context.agent_id}
+        args_str = canonical_json(context.tool_args).lower()
+        matched = [f"{cat}:{p}" for cat,pats in self.DANGEROUS_PATTERNS.items() for p in pats if p.lower() in args_str]
+        matched += [f"custom:{p}" for p in self.extra_patterns if p.lower() in args_str]
+        if matched:
+            claims["matched_patterns"]=matched
+            claims["reason"]="Environment variable access attempt detected"
+            return GuardrailDecisionV1(decision_id=compute_decision_id(claims), authorized=False, claims=claims)
+        claims["reason"]="No environment variable access detected"
+        return GuardrailDecisionV1(decision_id=compute_decision_id(claims), authorized=True, claims=claims)
+
+class CompositeGuardrailProvider(GuardrailProvider):
+    def __init__(self, providers, mode="AND"):
+        if mode not in ("AND","OR"): raise ValueError(f"mode must be AND or OR, got {mode}")
+        self.providers = providers
+        self.mode = mode
+    def authorize(self, context):
+        results = [p.authorize(context) for p in self.providers]
+        authorized = all(d.authorized for d in results) if self.mode=="AND" else any(d.authorized for d in results)
+        claims = {"provider":"CompositeGuardrailProvider","mode":self.mode,"tool_name":context.tool_name,"agent_id":context.agent_id,"sub_decisions":[d.decision_id for d in results],"sub_providers":[d.claims.get("provider","unknown") for d in results]}
+        return GuardrailDecisionV1(decision_id=compute_decision_id(claims), authorized=authorized, claims=claims)
+
+class AuditTrail:
+    def __init__(self):
+        self._decisions = {}
+        self._envelopes = {}
+    def record_decision(self, decision): self._decisions[decision.decision_id] = decision
+    def record_envelope(self, envelope): self._envelopes[envelope.decision_id] = envelope
+    def get_decision(self, did): return self._decisions.get(did)
+    def get_envelope(self, did): return self._envelopes.get(did)
+    def get_all_decisions(self): return list(self._decisions.values())
+    def get_all_envelopes(self): return list(self._envelopes.values())
+    def clear(self): self._decisions.clear(); self._envelopes.clear()
+    @property
+    def decision_count(self): return len(self._decisions)
+    @property
+    def envelope_count(self): return len(self._envelopes)
+    def verify_all(self): return all(d.verify_integrity() for d in self._decisions.values())
+    def export(self): return {"decisions":[d.to_dict() for d in self._decisions.values()],"envelopes":[e.to_dict() for e in self._envelopes.values()],"verified":self.verify_all()}
+
+class GuardrailContext:
+    def __init__(self, provider, trail=None, on_deny=None):
+        self.provider = provider; self.trail = trail or AuditTrail(); self.on_deny = on_deny
+    def authorize(self, context):
+        decision = self.provider.authorize(context)
+        self.trail.record_decision(decision)
+        if not decision.authorized and self.on_deny: self.on_deny(decision)
+        return decision
+    def after_tool_call(self, decision, result, start_time):
+        duration_ms = (time.time()-start_time)*1000
+        envelope = ActionEnvelopeV1(decision_id=decision.decision_id, tool_result_digest=ActionEnvelopeV1.digest_result(result), executed_at=time.time(), duration_ms=duration_ms)
+        self.trail.record_envelope(envelope)
+        return envelope
+
+def make_guardrail_hook(provider, trail=None, on_deny=None):
+    ctx = GuardrailContext(provider=provider, trail=trail, on_deny=on_deny)
+    def _hook(tool_name, tool_args=None, agent_id="unknown", **kwargs):
+        context = ToolCallContext(tool_name=tool_name, tool_args=tool_args or {}, agent_id=agent_id, metadata=kwargs)
+        decision = ctx.authorize(context)
+        if not decision.authorized: return False
+        return None
+    _hook._guardrail_context = ctx
+    return _hook
+
+def detect_missing_guardrail(agents):
+    findings = []
+    for agent in agents:
+        agent_name = getattr(agent,"role",getattr(agent,"name",getattr(agent,"id","unknown")))
+        has_hooks = getattr(agent,"_before_tool_call_hooks",None) or getattr(agent,"before_tool_call",None) or getattr(agent,"_guardrails",None) or getattr(agent,"guardrail_provider",None)
+        if not has_hooks:
+            findings.append({"severity":"CRITICAL","pattern":"AS-GUARDRAIL-MISS-001","agent":agent_name,"message":f"Agent '{agent_name}' has no registered GuardrailProvider","remediation":"Register a GuardrailProvider via make_guardrail_hook()","ccs_ref":"https://correctover.com/ccs"})
+    return findings
+
+class MCPSecurityValidator:
+    DANGEROUS_COMMANDS = ["rm -rf","curl | sh","wget | bash","eval(","exec(","os.system","subprocess.call"]
+    SENSITIVE_ENV_PATTERNS = ["API_KEY","SECRET","TOKEN","PASSWORD","PRIVATE_KEY","CREDENTIALS","AUTH"]
+    @staticmethod
+    def validate_tool_definition(tool_def):
+        issues = []
+        impl = str(tool_def.get("implementation",""))
+        for cmd in MCPSecurityValidator.DANGEROUS_COMMANDS:
+            if cmd in impl: issues.append({"severity":"CRITICAL","type":"command_injection","pattern":cmd,"cve_ref":"CVE-2026-42271"})
+        env_section = str(tool_def.get("env",{}))
+        for pattern in MCPSecurityValidator.SENSITIVE_ENV_PATTERNS:
+            if pattern.upper() in env_section.upper(): issues.append({"severity":"HIGH","type":"env_exposure","pattern":pattern,"cve_ref":"CVE-2026-12957"})
+        return {"safe":len(issues)==0,"issues":issues,"tool_name":tool_def.get("name","unknown")}
+    @staticmethod
+    def validate_mcp_config(config):
+        issues = []
+        transport = config.get("transport","stdio")
+        if transport == "stdio":
+            env = config.get("env",{})
+            if env: issues.append({"severity":"HIGH","type":"stdio_env_exposure","message":"stdio transport with env variables","cve_ref":"CVE-2026-12957","remediation":"Use env_isolation or switch to sse/http transport"})
+        for tool in config.get("tools",[]):
+            issues.extend(MCPSecurityValidator.validate_tool_definition(tool)["issues"])
+        return {"safe":len(issues)==0,"issues":issues,"config_name":config.get("name","unknown")}

correctover-2.2.0/src/correctover/validator.py

@@ -0,0 +1,37 @@
+from typing import Dict, List, Any, Optional
+from pydantic import BaseModel, Field
+from datetime import datetime
+import hashlib, hmac, json
+
+class ValidationResult(BaseModel):
+    is_valid: bool
+    errors: List[str] = Field(default_factory=list)
+    warnings: List[str] = Field(default_factory=list)
+    validated_at: str = Field(default_factory=lambda: datetime.utcnow().isoformat())
+    trace_id: Optional[str] = None
+
+class CCSValidator:
+    def __init__(self, required_fields=None, supported_fields=None, forbidden_fields=None, enable_integrity=False, integrity_key=None):
+        self.required_fields = set(required_fields or [])
+        self.supported_fields = set(supported_fields or [])
+        self.forbidden_fields = set(forbidden_fields or [])
+        self.enable_integrity = enable_integrity
+        self.integrity_key = integrity_key or "default-key"
+    def validate(self, output, trace_id=None):
+        errors, warnings = [], []
+        for f in self.required_fields:
+            if f not in output: errors.append(f"Missing required field: {f}")
+        for f in self.forbidden_fields:
+            if f in output: errors.append(f"Forbidden field present: {f}")
+        unexpected = set(output.keys()) - self.required_fields - self.supported_fields - self.forbidden_fields
+        for f in unexpected: warnings.append(f"Unexpected field: {f}")
+        if self.enable_integrity:
+            stored_hash = output.get("integrity_hash")
+            computed = self._compute_integrity(output)
+            if stored_hash is None: warnings.append("No integrity hash in output")
+            elif stored_hash != computed: errors.append("Integrity hash mismatch")
+        return ValidationResult(is_valid=len(errors)==0, errors=errors, warnings=warnings, trace_id=trace_id)
+    def _compute_integrity(self, output):
+        data = {k:v for k,v in output.items() if k != "integrity_hash"}
+        canonical = json.dumps(data, sort_keys=True, separators=(",",":"))
+        return hmac.new(self.integrity_key.encode(), canonical.encode(), hashlib.sha256).hexdigest()

correctover-2.2.0/src/correctover.egg-info/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.4
+Name: correctover
+Version: 2.2.0
+Summary: Correctover - AI Agent Runtime Assurance. CCS standard + GuardrailProvider + MCP Security Scanner.
+Author-email: Guigui Wang <wangguigui@correctover.com>
+License: Proprietary Commercial License
+Project-URL: Homepage, https://correctover.com
+Project-URL: CCS Standard, https://correctover.com/ccs
+Project-URL: GitHub, https://github.com/Correctover
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: pydantic>=1.10

correctover-2.2.0/src/correctover.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+pyproject.toml
+src/correctover/__init__.py
+src/correctover/guardrail.py
+src/correctover/validator.py
+src/correctover.egg-info/PKG-INFO
+src/correctover.egg-info/SOURCES.txt
+src/correctover.egg-info/dependency_links.txt
+src/correctover.egg-info/requires.txt
+src/correctover.egg-info/top_level.txt

correctover-2.2.0/src/correctover.egg-info/requires.txt

@@ -0,0 +1 @@
+pydantic>=1.10

correctover-2.0.2/LICENSE

@@ -1,8 +0,0 @@
-Proprietary Commercial License
-
-Copyright (c) 2026 Guigui Wang
-
-This software is proprietary and confidential. Unauthorized copying, 
-distribution, or use is strictly prohibited.
-
-For licensing inquiries, contact: wangguigui@correctover.com

correctover-2.0.2/PKG-INFO

@@ -1,94 +0,0 @@
-Metadata-Version: 2.4
-Name: correctover
-Version: 2.0.2
-Summary: CCS v1.0 - Conformance Protocol for Agentic Runtime Systems
-Home-page: https://correctover.github.io
-Author: Guigui Wang
-Author-email: wangguigui@correctover.com
-Project-URL: Bug Tracker, https://github.com/Correctover/standards/issues
-Project-URL: Documentation, https://correctover.github.io
-Project-URL: Source, https://github.com/Correctover/standards
-Project-URL: DOI, https://doi.org/10.5281/zenodo.21234580
-Keywords: llm,validation,conformance,compliance,hipaa,gdpr,soc2,agent,mcp
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: Intended Audience :: Developers
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-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: Operating System :: OS Independent
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: pydantic>=2.0.0
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: home-page
-Dynamic: keywords
-Dynamic: license-file
-Dynamic: project-url
-Dynamic: requires-dist
-Dynamic: requires-python
-Dynamic: summary
-
-# Correctover - CCS v1.0
-
-**Conformance Protocol for Agentic Runtime Systems**
-
-DOI: [10.5281/zenodo.21234580](https://doi.org/10.5281/zenodo.21234580)
-
-## Overview
-
-Correctover implements the CCS v1.0 standard for validating LLM outputs in agentic systems. It provides provider-agnostic, framework-agnostic conformance verification.
-
-## Quick Start
-
-```python
-from correctover import CCSValidator
-
-validator = CCSValidator(
-    required_fields=["decision", "confidence", "trace_id"],
-    supported_fields=["reasoning", "metadata"],
-    forbidden_fields=["pii", "credentials"]
-)
-
-result = validator.validate({
-    "decision": "approve",
-    "confidence": 0.95,
-    "trace_id": "abc-123"
-})
-
-print(f"Valid: {result.is_valid}")
-```
-
-## Components
-
-- **CCS-Core**: Schema validation (Required/Supported/Forbidden)
-- **CCS-Compliance**: HIPAA, GDPR, SOC2 mapping
-- **CCS-Cost-Flow-Analysis**: Token budget enforcement
-- **CCS-Integrity**: HMAC-based output binding
-- **CCS-Audit**: Comprehensive audit logging
-
-## Integration
-
-Framework adapters available:
-- LangChain
-- CrewAI
-- AutoGen
-- LlamaIndex
-
-## License
-
-Proprietary Commercial License — see LICENSE file
-
-## Resources
-
-- Website: https://correctover.github.io
-- Specification: https://github.com/Correctover/standards
-- DOI: https://doi.org/10.5281/zenodo.21234580

correctover-2.0.2/README.md

@@ -1,55 +0,0 @@
-# Correctover - CCS v1.0
-
-**Conformance Protocol for Agentic Runtime Systems**
-
-DOI: [10.5281/zenodo.21234580](https://doi.org/10.5281/zenodo.21234580)
-
-## Overview
-
-Correctover implements the CCS v1.0 standard for validating LLM outputs in agentic systems. It provides provider-agnostic, framework-agnostic conformance verification.
-
-## Quick Start
-
-```python
-from correctover import CCSValidator
-
-validator = CCSValidator(
-    required_fields=["decision", "confidence", "trace_id"],
-    supported_fields=["reasoning", "metadata"],
-    forbidden_fields=["pii", "credentials"]
-)
-
-result = validator.validate({
-    "decision": "approve",
-    "confidence": 0.95,
-    "trace_id": "abc-123"
-})
-
-print(f"Valid: {result.is_valid}")
-```
-
-## Components
-
-- **CCS-Core**: Schema validation (Required/Supported/Forbidden)
-- **CCS-Compliance**: HIPAA, GDPR, SOC2 mapping
-- **CCS-Cost-Flow-Analysis**: Token budget enforcement
-- **CCS-Integrity**: HMAC-based output binding
-- **CCS-Audit**: Comprehensive audit logging
-
-## Integration
-
-Framework adapters available:
-- LangChain
-- CrewAI
-- AutoGen
-- LlamaIndex
-
-## License
-
-Proprietary Commercial License — see LICENSE file
-
-## Resources
-
-- Website: https://correctover.github.io
-- Specification: https://github.com/Correctover/standards
-- DOI: https://doi.org/10.5281/zenodo.21234580

correctover-2.0.2/correctover/__init__.py

@@ -1,12 +0,0 @@
-"""
-Correctover - CCS v1.0
-Conformance Protocol for Agentic Runtime Systems
-"""
-
-__version__ = "2.0.2"
-__author__ = "Guigui Wang"
-__email__ = "wangguigui@correctover.com"
-
-from .validator import CCSValidator, ValidationResult
-
-__all__ = ["CCSValidator", "ValidationResult"]

correctover-2.0.2/correctover/validator.py

@@ -1,98 +0,0 @@
-"""
-CCS v1.0 Validator
-Validates LLM outputs against Required/Supported/Forbidden schemas
-"""
-
-from typing import Dict, List, Any, Optional
-from pydantic import BaseModel, Field
-from datetime import datetime
-import hashlib
-import hmac
-import json
-
-
-class ValidationResult(BaseModel):
-    """Result of CCS validation"""
-    is_valid: bool
-    errors: List[str] = Field(default_factory=list)
-    warnings: List[str] = Field(default_factory=list)
-    validated_at: str = Field(default_factory=lambda: datetime.utcnow().isoformat())
-    trace_id: Optional[str] = None
-
-
-class CCSValidator:
-    """
-    CCS v1.0 Validator
-    
-    Validates LLM outputs against Required/Supported/Forbidden schemas.
-    """
-    
-    def __init__(
-        self,
-        required_fields: List[str] = None,
-        supported_fields: List[str] = None,
-        forbidden_fields: List[str] = None,
-        enable_integrity: bool = False,
-        integrity_key: str = None
-    ):
-        self.required_fields = set(required_fields or [])
-        self.supported_fields = set(supported_fields or [])
-        self.forbidden_fields = set(forbidden_fields or [])
-        self.enable_integrity = enable_integrity
-        self.integrity_key = integrity_key or "default-key"
-        
-    def validate(self, output: Dict[str, Any], trace_id: str = None) -> ValidationResult:
-        """Validate LLM output against CCS schema"""
-        errors = []
-        warnings = []
-        
-        for field in self.required_fields:
-            if field not in output:
-                errors.append(f"Missing required field: {field}")
-        
-        for field in self.forbidden_fields:
-            if field in output:
-                errors.append(f"Forbidden field present: {field}")
-        
-        output_fields = set(output.keys())
-        all_allowed = self.required_fields | self.supported_fields
-        unexpected = output_fields - all_allowed - self.forbidden_fields
-        for field in unexpected:
-            warnings.append(f"Unexpected field: {field}")
-        
-        if self.enable_integrity:
-            stored_hash = output.get("integrity_hash")
-            computed_hash = self._compute_integrity(output)
-            
-            if stored_hash is None:
-                warnings.append("No integrity hash in output")
-            elif stored_hash != computed_hash:
-                errors.append("Integrity hash mismatch")
-        
-        return ValidationResult(
-            is_valid=len(errors) == 0,
-            errors=errors,
-            warnings=warnings,
-            trace_id=trace_id
-        )
-    
-    def _compute_integrity(self, output: Dict[str, Any]) -> str:
-        """Compute HMAC-based integrity hash using JSON serialization"""
-        # Exclude integrity_hash from computation
-        filtered = {k: v for k, v in output.items() if k != "integrity_hash"}
-        # Use JSON serialization (sorted keys, no extra spaces)
-        data_str = json.dumps(filtered, sort_keys=True, separators=(',', ':'))
-        
-        signature = hmac.new(
-            self.integrity_key.encode(),
-            data_str.encode(),
-            hashlib.sha256
-        ).hexdigest()
-        
-        return signature
-    
-    def add_integrity_hash(self, output: Dict[str, Any]) -> Dict[str, Any]:
-        """Add integrity hash to output"""
-        output_copy = output.copy()
-        output_copy["integrity_hash"] = self._compute_integrity(output_copy)
-        return output_copy

correctover-2.0.2/correctover.egg-info/PKG-INFO

@@ -1,94 +0,0 @@
-Metadata-Version: 2.4
-Name: correctover
-Version: 2.0.2
-Summary: CCS v1.0 - Conformance Protocol for Agentic Runtime Systems
-Home-page: https://correctover.github.io
-Author: Guigui Wang
-Author-email: wangguigui@correctover.com
-Project-URL: Bug Tracker, https://github.com/Correctover/standards/issues
-Project-URL: Documentation, https://correctover.github.io
-Project-URL: Source, https://github.com/Correctover/standards
-Project-URL: DOI, https://doi.org/10.5281/zenodo.21234580
-Keywords: llm,validation,conformance,compliance,hipaa,gdpr,soc2,agent,mcp
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: Intended Audience :: Developers
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-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: Operating System :: OS Independent
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: pydantic>=2.0.0
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: home-page
-Dynamic: keywords
-Dynamic: license-file
-Dynamic: project-url
-Dynamic: requires-dist
-Dynamic: requires-python
-Dynamic: summary
-
-# Correctover - CCS v1.0
-
-**Conformance Protocol for Agentic Runtime Systems**
-
-DOI: [10.5281/zenodo.21234580](https://doi.org/10.5281/zenodo.21234580)
-
-## Overview
-
-Correctover implements the CCS v1.0 standard for validating LLM outputs in agentic systems. It provides provider-agnostic, framework-agnostic conformance verification.
-
-## Quick Start
-
-```python
-from correctover import CCSValidator
-
-validator = CCSValidator(
-    required_fields=["decision", "confidence", "trace_id"],
-    supported_fields=["reasoning", "metadata"],
-    forbidden_fields=["pii", "credentials"]
-)
-
-result = validator.validate({
-    "decision": "approve",
-    "confidence": 0.95,
-    "trace_id": "abc-123"
-})
-
-print(f"Valid: {result.is_valid}")
-```
-
-## Components
-
-- **CCS-Core**: Schema validation (Required/Supported/Forbidden)
-- **CCS-Compliance**: HIPAA, GDPR, SOC2 mapping
-- **CCS-Cost-Flow-Analysis**: Token budget enforcement
-- **CCS-Integrity**: HMAC-based output binding
-- **CCS-Audit**: Comprehensive audit logging
-
-## Integration
-
-Framework adapters available:
-- LangChain
-- CrewAI
-- AutoGen
-- LlamaIndex
-
-## License
-
-Proprietary Commercial License — see LICENSE file
-
-## Resources
-
-- Website: https://correctover.github.io
-- Specification: https://github.com/Correctover/standards
-- DOI: https://doi.org/10.5281/zenodo.21234580

correctover-2.0.2/correctover.egg-info/SOURCES.txt

@@ -1,10 +0,0 @@
-LICENSE
-README.md
-setup.py
-correctover/__init__.py
-correctover/validator.py
-correctover.egg-info/PKG-INFO
-correctover.egg-info/SOURCES.txt
-correctover.egg-info/dependency_links.txt
-correctover.egg-info/requires.txt
-correctover.egg-info/top_level.txt

correctover-2.0.2/correctover.egg-info/requires.txt

@@ -1 +0,0 @@
-pydantic>=2.0.0

correctover-2.0.2/setup.py

@@ -1,39 +0,0 @@
-from setuptools import setup, find_packages
-
-with open("README.md", "r", encoding="utf-8") as fh:
-    long_description = fh.read()
-
-setup(
-    name="correctover",
-    version="2.0.2",
-    author="Guigui Wang",
-    author_email="wangguigui@correctover.com",
-    description="CCS v1.0 - Conformance Protocol for Agentic Runtime Systems",
-    long_description=long_description,
-    long_description_content_type="text/markdown",
-    url="https://correctover.github.io",
-    project_urls={
-        "Bug Tracker": "https://github.com/Correctover/standards/issues",
-        "Documentation": "https://correctover.github.io",
-        "Source": "https://github.com/Correctover/standards",
-        "DOI": "https://doi.org/10.5281/zenodo.21234580",
-    },
-    packages=find_packages(),
-    classifiers=[
-        "Development Status :: 5 - Production/Stable",
-        "Intended Audience :: Developers",
-        "Topic :: Software Development :: Libraries :: Python Modules",
-        "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",
-        "Operating System :: OS Independent",
-    ],
-    python_requires=">=3.8",
-    install_requires=[
-        "pydantic>=2.0.0",
-    ],
-    keywords="llm, validation, conformance, compliance, hipaa, gdpr, soc2, agent, mcp",
-)