correctover 2.1.0__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.1.0 → correctover-2.2.0}/setup.cfg

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

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.1.0/LICENSE

@@ -1,7 +0,0 @@
-CORRECTOVER SDK — PROPRIETARY COMMERCIAL LICENSE
-Copyright (c) 2024-2026 Correctover Team. All rights reserved.
-
-This software is NOT open source. It is distributed as compiled
-bytecode only. Redistribution requires a valid commercial license.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND.

correctover-2.1.0/MANIFEST.in

@@ -1,2 +0,0 @@
-recursive-include correctover *.pyc
-recursive-include correctover/benchmark *.pyc

correctover-2.1.0/PKG-INFO

@@ -1,49 +0,0 @@
-Metadata-Version: 2.1
-Name: correctover
-Version: 2.1.0
-Summary: Correctover — Failure is not fatal. Protocol-level contract validation with automatic verified failover for LLM APIs.
-Home-page: https://correctover.com
-Author: Correctover Team
-Author-email: Correctover Team <team@correctover.com>
-Maintainer-email: Correctover Team <team@correctover.com>
-License: Proprietary Commercial License — see LICENSE
-Project-URL: Homepage, https://correctover.com
-Project-URL: Documentation, https://correctover.com/docs
-Project-URL: Changelog, https://correctover.com/docs/changelog
-Project-URL: Bug Tracker, https://correctover.com/support
-Keywords: llm,self-healing,failover,circuit-breaker,api-resilience,openai,anthropic,deepseek,contract-validation,correctover,ai-gateway,semantic-verification
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: Intended Audience :: Developers
-Classifier: License :: Other/Proprietary License
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Python: >=3.12
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: httpx>=0.24.0
-Requires-Dist: aiohttp>=3.8.0
-
-# Correctover SDK
-
-**Failure is not fatal.** Protocol-level contract validation with automatic verified failover for LLM APIs.
-
-## Install
-
-```bash
-pip install correctover
-```
-
-## Quick Start
-
-```python
-import correctover
-result = correctover.run("Hello!")
-print(result)
-```
-
-## License
-
-Proprietary Commercial License. See LICENSE file.

correctover-2.1.0/README.md

@@ -1,21 +0,0 @@
-# Correctover SDK
-
-**Failure is not fatal.** Protocol-level contract validation with automatic verified failover for LLM APIs.
-
-## Install
-
-```bash
-pip install correctover
-```
-
-## Quick Start
-
-```python
-import correctover
-result = correctover.run("Hello!")
-print(result)
-```
-
-## License
-
-Proprietary Commercial License. See LICENSE file.