secureai-sdk 1.0.0__py3-none-any.whl

secureai/__init__.py

@@ -0,0 +1,48 @@
+"""
+SecureAI Python SDK — Enterprise AI Security, Governance & Guardrails
+Powered by AcadmyAI (https://secure.acadmyai.com)
+"""
+
+from .guard import (
+    guard,
+    inspect_input,
+    inspect_output,
+    SecurityPolicy,
+    SecurityViolationError
+)
+from .client import (
+    SecureAI,
+    AsyncSecureAI,
+    SecureAIClient
+)
+from .vault import (
+    PIIVault,
+    VaultedString,
+    vault_tokenize,
+    vault_detokenize,
+    default_vault
+)
+from .mcp import MCPToolGuard
+from .integrations import wrap_openai
+
+__version__ = "1.0.0"
+__author__ = "AcadmyAI"
+__license__ = "Apache 2.0"
+
+__all__ = [
+    "guard",
+    "inspect_input",
+    "inspect_output",
+    "SecurityPolicy",
+    "SecurityViolationError",
+    "SecureAI",
+    "AsyncSecureAI",
+    "SecureAIClient",
+    "PIIVault",
+    "VaultedString",
+    "vault_tokenize",
+    "vault_detokenize",
+    "default_vault",
+    "MCPToolGuard",
+    "wrap_openai",
+]

secureai/cli.py

@@ -0,0 +1,92 @@
+import sys
+import os
+import argparse
+import time
+from .guard import inspect_input, FAST_INJECTION_PATTERNS
+from .vault import default_vault
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog="secureai",
+        description="SecureAI Enterprise Security, Guardrails & Shadow AI Scanner CLI — Powered by AcadmyAI"
+    )
+    subparsers = parser.add_subparsers(dest="command", help="Available subcommands")
+
+    # Command: scan
+    scan_parser = subparsers.add_parser("scan", help="Scan a text prompt for prompt injection, jailbreaks, and PII")
+    scan_parser.add_argument("prompt", type=str, help="Prompt text to inspect")
+
+    # Command: vault
+    vault_parser = subparsers.add_parser("vault", help="Tokenize sensitive PII entities in a string")
+    vault_parser.add_argument("text", type=str, help="Text to tokenize")
+
+    # Command: audit
+    audit_parser = subparsers.add_parser("audit", help="Audit local codebase for unapproved Shadow AI API calls")
+    audit_parser.add_argument("directory", type=str, default=".", nargs="?", help="Directory path to scan")
+
+    # Command: version
+    subparsers.add_parser("version", help="Show SecureAI SDK version")
+
+    args = parser.parse_args()
+
+    if args.command == "scan":
+        print(f"\n🛡️  SecureAI Heuristic Fast-Path Scanner")
+        print("=" * 50)
+        res = inspect_input(args.prompt)
+        vaulted = default_vault.tokenize(args.prompt)
+        
+        status = "PASSED" if res["is_safe"] else "BLOCKED"
+        color = "\033[92m" if res["is_safe"] else "\033[91m"
+        reset = "\033[0m"
+
+        print(f"Status:          {color}{status}{reset}")
+        print(f"Risk Score:      {res['risk_score']} / 1.0")
+        print(f"Threat Detected: {res['threat_detected'] or 'None'}")
+        print(f"PII Entities:    {vaulted.redacted_count} tokenized")
+        print(f"Sanitized Text:  {vaulted}")
+        print(f"Latency:         {res['latency_ms']} ms\n")
+        sys.exit(0 if res["is_safe"] else 1)
+
+    elif args.command == "vault":
+        vaulted = default_vault.tokenize(args.text)
+        print(f"\n🔐 Vaulted Output ({vaulted.redacted_count} entities redacted):")
+        print(str(vaulted))
+        print(f"\nToken Map: {vaulted.token_map}\n")
+
+    elif args.command == "audit":
+        dir_to_scan = os.path.abspath(args.directory)
+        print(f"\n🔍 Scanning repository '{dir_to_scan}' for Shadow AI endpoints...")
+        
+        ai_patterns = ["api.openai.com", "api.anthropic.com", "generativelanguage.googleapis.com", "groq.com", "together.ai"]
+        found_files = []
+        
+        for root, _, files in os.walk(dir_to_scan):
+            for file in files:
+                if file.endswith((".py", ".js", ".ts", ".go", ".java")):
+                    filepath = os.path.join(root, file)
+                    try:
+                        with open(filepath, "r", encoding="utf-8", errors="ignore") as f:
+                            content = f.read()
+                            for pat in ai_patterns:
+                                if pat in content:
+                                    found_files.append((filepath, pat))
+                    except Exception:
+                        pass
+
+        if found_files:
+            print(f"⚠️  Found {len(found_files)} potential unmanaged AI direct API connections:")
+            for fp, pat in found_files[:10]:
+                print(f"  • {fp} -> {pat}")
+            print("\n💡 Tip: Route requests through SecureAI Gateway for compliance and DLP protection.")
+        else:
+            print("✅ No unmanaged direct AI endpoints detected.")
+
+    elif args.command == "version":
+        from . import __version__
+        print(f"SecureAI Python SDK v{__version__} — https://secure.acadmyai.com")
+
+    else:
+        parser.print_help()
+
+if __name__ == "__main__":
+    main()

secureai/client.py

@@ -0,0 +1,177 @@
+import httpx
+from typing import Dict, Any, Optional, List, Union
+
+DEFAULT_GATEWAY_URL = "https://secure.acadmyai.com/v1"
+
+class SecureAI:
+    """Synchronous Enterprise Client for SecureAI Cloud & VPC Gateways."""
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        base_url: str = DEFAULT_GATEWAY_URL,
+        timeout: float = 10.0
+    ):
+        self.api_key = api_key or "sec_guest_token"
+        self.base_url = base_url.rstrip("/")
+        self._client = httpx.Client(
+            base_url=self.base_url,
+            headers={
+                "Authorization": f"Bearer {self.api_key}",
+                "Content-Type": "application/json",
+                "User-Agent": "SecureAI-Python-SDK/1.0.0"
+            },
+            timeout=timeout
+        )
+
+    def inspect(
+        self,
+        prompt: str,
+        user_id: str = "default_user",
+        role: str = "developer",
+        department: str = "engineering",
+        clearance_level: int = 1
+    ) -> Dict[str, Any]:
+        """Performs real-time cloud gateway inspection across Injection, Toxicity, and PII Vault."""
+        resp = self._client.post("/guard/inspect", json={
+            "prompt": prompt,
+            "user_id": user_id,
+            "role": role,
+            "department": department,
+            "clearance_level": clearance_level
+        })
+        resp.raise_for_status()
+        return resp.json()
+
+    def tokenize_pii(self, text: str) -> Dict[str, Any]:
+        """Calls Cloud Vault to tokenize sensitive entities."""
+        resp = self._client.post("/vault/tokenize", json={"text": text})
+        resp.raise_for_status()
+        return resp.json()
+
+    def detokenize_pii(self, text: str, token_map: Dict[str, str]) -> Dict[str, Any]:
+        """Calls Cloud Vault to detokenize surrogate tokens."""
+        resp = self._client.post("/vault/detokenize", json={"text": text, "token_map": token_map})
+        resp.raise_for_status()
+        return resp.json()
+
+    def authorize_mcp_tool(
+        self,
+        tool_name: str,
+        params: Dict[str, Any],
+        clearance_level: int = 1,
+        session_id: str = "agent_session_1"
+    ) -> Dict[str, Any]:
+        """Evaluates Model Context Protocol (MCP) tool execution for SQLi and destructive side-effects."""
+        resp = self._client.post("/mcp/proxy", json={
+            "method": "tools/call",
+            "params": {"name": tool_name, "arguments": params},
+            "session_id": session_id
+        })
+        resp.raise_for_status()
+        return resp.json()
+
+    def scan_shadow_ai(self, code_samples: List[str]) -> Dict[str, Any]:
+        """Scans codebases or repository files for unapproved LLM/AI model calls."""
+        resp = self._client.post("/shadow-ai/scan", json={"code_samples": code_samples})
+        resp.raise_for_status()
+        return resp.json()
+
+    def close(self):
+        """Closes internal HTTP transport."""
+        self._client.close()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()
+
+
+class AsyncSecureAI:
+    """Asynchronous Enterprise Client for SecureAI Cloud & VPC Gateways."""
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        base_url: str = DEFAULT_GATEWAY_URL,
+        timeout: float = 10.0
+    ):
+        self.api_key = api_key or "sec_guest_token"
+        self.base_url = base_url.rstrip("/")
+        self._client = httpx.AsyncClient(
+            base_url=self.base_url,
+            headers={
+                "Authorization": f"Bearer {self.api_key}",
+                "Content-Type": "application/json",
+                "User-Agent": "SecureAI-Python-SDK/1.0.0"
+            },
+            timeout=timeout
+        )
+
+    async def inspect(
+        self,
+        prompt: str,
+        user_id: str = "default_user",
+        role: str = "developer",
+        department: str = "engineering",
+        clearance_level: int = 1
+    ) -> Dict[str, Any]:
+        """Asynchronously calls SecureAI Gateway inspection endpoint."""
+        resp = await self._client.post("/guard/inspect", json={
+            "prompt": prompt,
+            "user_id": user_id,
+            "role": role,
+            "department": department,
+            "clearance_level": clearance_level
+        })
+        resp.raise_for_status()
+        return resp.json()
+
+    async def tokenize_pii(self, text: str) -> Dict[str, Any]:
+        """Asynchronously tokenizes PII entities via Cloud Vault."""
+        resp = await self._client.post("/vault/tokenize", json={"text": text})
+        resp.raise_for_status()
+        return resp.json()
+
+    async def detokenize_pii(self, text: str, token_map: Dict[str, str]) -> Dict[str, Any]:
+        """Asynchronously detokenizes surrogate tokens."""
+        resp = await self._client.post("/vault/detokenize", json={"text": text, "token_map": token_map})
+        resp.raise_for_status()
+        return resp.json()
+
+    async def authorize_mcp_tool(
+        self,
+        tool_name: str,
+        params: Dict[str, Any],
+        clearance_level: int = 1,
+        session_id: str = "agent_session_1"
+    ) -> Dict[str, Any]:
+        """Asynchronously evaluates Model Context Protocol tool execution."""
+        resp = await self._client.post("/mcp/proxy", json={
+            "method": "tools/call",
+            "params": {"name": tool_name, "arguments": params},
+            "session_id": session_id
+        })
+        resp.raise_for_status()
+        return resp.json()
+
+    async def scan_shadow_ai(self, code_samples: List[str]) -> Dict[str, Any]:
+        """Asynchronously scans code samples for Shadow AI endpoints."""
+        resp = await self._client.post("/shadow-ai/scan", json={"code_samples": code_samples})
+        resp.raise_for_status()
+        return resp.json()
+
+    async def aclose(self):
+        """Closes async HTTP transport."""
+        await self._client.aclose()
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        await self.aclose()
+
+
+# Backward compatibility alias
+SecureAIClient = SecureAI

secureai/guard.py

@@ -0,0 +1,224 @@
+import functools
+import inspect
+import re
+import time
+import asyncio
+from typing import Callable, Any, Dict, Optional, List, Union, Tuple
+from .vault import default_vault, VaultedString
+
+class SecurityViolationError(Exception):
+    """Raised when an input prompt, parameter, or model output violates the security policy."""
+    def __init__(
+        self,
+        message: str,
+        risk_score: float = 0.95,
+        threat_type: str = "SECURITY_VIOLATION",
+        matched_patterns: Optional[List[str]] = None,
+        details: Optional[Dict[str, Any]] = None
+    ):
+        super().__init__(message)
+        self.risk_score = risk_score
+        self.threat_type = threat_type
+        self.matched_patterns = matched_patterns or []
+        self.details = details or {}
+
+# Fast-path compiled heuristic matrices (<0.2ms evaluation)
+FAST_INJECTION_PATTERNS = [
+    # Direct overrides and ignore commands (singular, plural, stem variations)
+    (re.compile(r"(?i)\b(?:ignore|disregard|forget|skip|drop|override|bypass|disable|negate|cancel|erase)\s+(?:all\s+)?(?:(?:previous|prior|above|former|initial|system)\s+)?(?:instructions?|prompts?|rules?|commands?|guidelines?|context|constraints?|directives?|filters?|guardrails?)"), "DIRECT_OVERRIDE", 0.96),
+    (re.compile(r"(?i)\bignore\s+(?:all\s+)?(?:the\s+)?(?:previous|prior|above|safety|system)"), "DIRECT_OVERRIDE", 0.95),
+    (re.compile(r"(?i)\bnew\s+rule:\s*(?:ignore|disregard|forget|override)"), "DIRECT_OVERRIDE", 0.92),
+
+    # Jailbreak roleplays
+    (re.compile(r"(?i)\byou\s+are\s+now\s+(?:DAN|unfiltered|jailbroken|unrestricted|free\s+of\s+rules|an\s+adversary|in\s+developer\s+mode|in\s+god\s+mode)"), "JAILBREAK_ROLEPLAY", 0.94),
+    (re.compile(r"(?i)\bdo\s+anything\s+now\b"), "JAILBREAK_DAN", 0.96),
+    (re.compile(r"(?i)\bpretend\s+you\s+have\s+no\s+(?:safety|ethical|content)\s+filters?"), "JAILBREAK_SAFETY_BYPASS", 0.90),
+
+    # System prompt extraction & admin privilege escalation
+    (re.compile(r"(?i)\b(?:print|show|dump|reveal|output|display|repeat|leak)\s+(?:your\s+)?(?:system\s+prompts?|initial\s+instructions?|system\s+instructions?|core\s+rules?|internal\s+prompts?|credentials?|passwords?|api\s*keys?|secrets?)"), "SYSTEM_PROMPT_EXTRACTION", 0.92),
+    (re.compile(r"(?i)\brepeat\s+the\s+words\s+above\s+verbatim"), "SYSTEM_PROMPT_EXTRACTION", 0.85),
+    (re.compile(r"(?i)\bdump\s+(?:all\s+)?(?:internal|system|database|schema|users?|tables?)\b"), "SYSTEM_PROMPT_EXTRACTION", 0.92),
+    (re.compile(r"(?i)\b(?:using|with|via)\s+(?:admin|root|superuser|system|master)\s+(?:credentials?|privileges?|access|permissions?|rights?|tokens?)"), "PRIVILEGE_ESCALATION", 0.95),
+    (re.compile(r"(?i)\b(?:delete|drop|wipe|purge|truncate|destroy)\s+(?:everything|everthing|all\s+data|all\s+tables|database|users?|system)\b"), "DESTRUCTIVE_DATABASE_EXECUTION", 0.96),
+    (re.compile(r"(?i)\bswitch\s+to\s+(?:developer|admin|god|root|jailbreak)\s+mode\b"), "PRIVILEGE_ESCALATION", 0.92),
+
+    # SQL Injection & tool parameter tampering
+    (re.compile(r"(?i)(?:union\s+select|select\s+.*\s+from\s+|insert\s+into\s+|drop\s+table|delete\s+from\s+|truncate\s+table|exec\s+sp_|xp_cmdshell|or\s+1\s*=\s*1|'\s*or\s*'1'\s*=\s*'1|--|\bwaitfor\s+delay\b)"), "SQLI_PARAMETER_INJECTION", 0.96),
+
+    # Delimiters & Synthetic tags
+    (re.compile(r"(?i)\[system\s+override\]"), "SYNTHETIC_DELIMITER_INJECTION", 0.94),
+    (re.compile(r"(?i)<\s*system(?:\s+override)?\s*>"), "SYNTHETIC_XML_INJECTION", 0.94),
+    (re.compile(r"(?i)```\s*(?:system|override|admin)"), "SYNTHETIC_CODEBLOCK_INJECTION", 0.90),
+]
+
+FAST_TOXICITY_RE = re.compile(
+    r"(?i)\b(?:f+u+c+k+|s+h+i+t+|b+i+t+c+h+|asshole|kill\s+yourself|faggot|nigger|bomb\s+the|murder\s+you)\b"
+)
+
+class SecurityPolicy:
+    STRICT = "enterprise-strict"
+    STANDARD = "standard"
+    MONITOR_ONLY = "audit-only"
+
+def inspect_input(prompt: str, policy: str = SecurityPolicy.STRICT) -> Dict[str, Any]:
+    """In-process fast heuristic evaluation of incoming prompt strings (< 0.2ms)."""
+    start = time.perf_counter()
+    if not prompt or not isinstance(prompt, str):
+        return {"is_safe": True, "risk_score": 0.0, "latency_ms": 0.0}
+
+    matched_threats = []
+    max_risk = 0.0
+    threat_cat = None
+
+    for pattern, category, score in FAST_INJECTION_PATTERNS:
+        if pattern.search(prompt):
+            matched_threats.append(category)
+            if score > max_risk:
+                max_risk = score
+                threat_cat = category
+
+    if FAST_TOXICITY_RE.search(prompt):
+        matched_threats.append("VULGARITY_VIOLATION")
+        if 0.88 > max_risk:
+            max_risk = 0.88
+            threat_cat = "VULGARITY_VIOLATION"
+
+    is_safe = len(matched_threats) == 0
+    elapsed_ms = round((time.perf_counter() - start) * 1000, 3)
+
+    return {
+        "is_safe": is_safe,
+        "risk_score": max_risk,
+        "threat_detected": threat_cat,
+        "matched_patterns": matched_threats,
+        "latency_ms": elapsed_ms
+    }
+
+def inspect_output(output: str, policy: str = SecurityPolicy.STRICT) -> Dict[str, Any]:
+    """In-process fast evaluation of model outputs for vulgarity or leaks (< 0.2ms)."""
+    start = time.perf_counter()
+    if not output or not isinstance(output, str):
+        return {"is_safe": True, "latency_ms": 0.0}
+
+    has_tox = bool(FAST_TOXICITY_RE.search(output))
+    elapsed_ms = round((time.perf_counter() - start) * 1000, 3)
+
+    return {
+        "is_safe": not has_tox,
+        "threat_detected": "VULGARITY_VIOLATION" if has_tox else None,
+        "latency_ms": elapsed_ms
+    }
+
+def extract_prompt_from_call(args: tuple, kwargs: dict) -> Tuple[str, Optional[str], Optional[int]]:
+    """Extracts candidate prompt text from positional or keyword arguments."""
+    # Check 'prompt' kwarg
+    if "prompt" in kwargs and isinstance(kwargs["prompt"], str):
+        return kwargs["prompt"], "prompt", None
+    
+    # Check 'messages' kwarg (OpenAI/Anthropic chat format)
+    if "messages" in kwargs and isinstance(kwargs["messages"], list):
+        for msg in reversed(kwargs["messages"]):
+            if isinstance(msg, dict) and msg.get("role") == "user" and isinstance(msg.get("content"), str):
+                return msg["content"], "messages", None
+
+    # Check first positional arg
+    if args and isinstance(args[0], str):
+        return args[0], None, 0
+
+    return "", None, None
+
+def guard(
+    policy: str = SecurityPolicy.STRICT,
+    tokenize_pii: bool = True,
+    auto_detokenize: bool = True,
+    user_context: Optional[Dict[str, Any]] = None
+):
+    """
+    Zero-overhead (@guard) in-process AI Security & Governance Decorator.
+    Protects both synchronous and asynchronous functions from adversarial injections,
+    jailbreaks, PII leakage, and unauthorized tool calls.
+    """
+    def decorator(func: Callable) -> Callable:
+        is_coroutine = inspect.iscoroutinefunction(func)
+
+        @functools.wraps(func)
+        async def async_wrapper(*args, **kwargs):
+            prompt_text, kwarg_key, pos_idx = extract_prompt_from_call(args, kwargs)
+            token_map = {}
+
+            if prompt_text:
+                in_res = inspect_input(prompt_text, policy)
+                if not in_res["is_safe"] and policy != SecurityPolicy.MONITOR_ONLY:
+                    raise SecurityViolationError(
+                        f"SecureAI Guard: Input blocked due to {in_res['threat_detected']} (Risk Score: {in_res['risk_score']})",
+                        risk_score=in_res["risk_score"],
+                        threat_type=in_res["threat_detected"],
+                        matched_patterns=in_res["matched_patterns"]
+                    )
+
+                if tokenize_pii:
+                    vaulted = default_vault.tokenize(prompt_text)
+                    token_map = vaulted.token_map
+                    if vaulted.redacted_count > 0:
+                        # Replace in call args/kwargs
+                        if kwarg_key == "prompt":
+                            kwargs["prompt"] = str(vaulted)
+                        elif pos_idx == 0:
+                            args = (str(vaulted),) + args[1:]
+
+            result = await func(*args, **kwargs)
+
+            if isinstance(result, str):
+                out_res = inspect_output(result, policy)
+                if not out_res["is_safe"] and policy != SecurityPolicy.MONITOR_ONLY:
+                    raise SecurityViolationError(
+                        f"SecureAI Guard: Output blocked due to {out_res['threat_detected']}",
+                        risk_score=0.90,
+                        threat_type=out_res["threat_detected"]
+                    )
+                if auto_detokenize and token_map:
+                    result = default_vault.detokenize(result, token_map)
+
+            return result
+
+        @functools.wraps(func)
+        def sync_wrapper(*args, **kwargs):
+            prompt_text, kwarg_key, pos_idx = extract_prompt_from_call(args, kwargs)
+            token_map = {}
+
+            if prompt_text:
+                in_res = inspect_input(prompt_text, policy)
+                if not in_res["is_safe"] and policy != SecurityPolicy.MONITOR_ONLY:
+                    raise SecurityViolationError(
+                        f"SecureAI Guard: Input blocked due to {in_res['threat_detected']} (Risk Score: {in_res['risk_score']})",
+                        risk_score=in_res["risk_score"],
+                        threat_type=in_res["threat_detected"],
+                        matched_patterns=in_res["matched_patterns"]
+                    )
+
+                if tokenize_pii:
+                    vaulted = default_vault.tokenize(prompt_text)
+                    token_map = vaulted.token_map
+                    if vaulted.redacted_count > 0:
+                        if kwarg_key == "prompt":
+                            kwargs["prompt"] = str(vaulted)
+                        elif pos_idx == 0:
+                            args = (str(vaulted),) + args[1:]
+
+            result = func(*args, **kwargs)
+
+            if isinstance(result, str):
+                out_res = inspect_output(result, policy)
+                if not out_res["is_safe"] and policy != SecurityPolicy.MONITOR_ONLY:
+                    raise SecurityViolationError(
+                        f"SecureAI Guard: Output blocked due to {out_res['threat_detected']}",
+                        risk_score=0.90,
+                        threat_type=out_res["threat_detected"]
+                    )
+                if auto_detokenize and token_map:
+                    result = default_vault.detokenize(result, token_map)
+
+            return result
+
+        return async_wrapper if is_coroutine else sync_wrapper
+    return decorator

secureai/integrations/__init__.py

@@ -0,0 +1,3 @@
+from .openai_wrapper import wrap_openai
+
+__all__ = ["wrap_openai"]

secureai/integrations/openai_wrapper.py

@@ -0,0 +1,65 @@
+import functools
+from typing import Any, Dict, List, Optional
+from ..guard import inspect_input, inspect_output, SecurityViolationError, SecurityPolicy
+from ..vault import default_vault
+
+def wrap_openai(client: Any, policy: str = SecurityPolicy.STRICT, tokenize_pii: bool = True) -> Any:
+    """
+    Wraps an official `openai.OpenAI` or `openai.AsyncOpenAI` instance with
+    transparent, automatic prompt injection defense and reversible PII tokenization.
+    """
+    original_create = client.chat.completions.create
+
+    if hasattr(original_create, "__func__") or callable(original_create):
+        @functools.wraps(original_create)
+        def wrapped_create(*args, **kwargs):
+            messages = kwargs.get("messages", [])
+            token_map = {}
+
+            # Sanitize all user messages in the array
+            sanitized_messages = []
+            for msg in messages:
+                if isinstance(msg, dict) and msg.get("role") == "user" and isinstance(msg.get("content"), str):
+                    prompt_text = msg["content"]
+                    
+                    # 1. Run Guard Inspection
+                    in_res = inspect_input(prompt_text, policy)
+                    if not in_res["is_safe"] and policy != SecurityPolicy.MONITOR_ONLY:
+                        raise SecurityViolationError(
+                            f"SecureAI: Blocked OpenAI payload due to {in_res['threat_detected']}",
+                            risk_score=in_res["risk_score"],
+                            threat_type=in_res["threat_detected"],
+                            matched_patterns=in_res["matched_patterns"]
+                        )
+
+                    # 2. Vault Tokenize PII
+                    if tokenize_pii:
+                        vaulted = default_vault.tokenize(prompt_text)
+                        token_map.update(vaulted.token_map)
+                        msg_copy = dict(msg)
+                        msg_copy["content"] = str(vaulted)
+                        sanitized_messages.append(msg_copy)
+                    else:
+                        sanitized_messages.append(msg)
+                else:
+                    sanitized_messages.append(msg)
+
+            kwargs["messages"] = sanitized_messages
+
+            # Execute completion
+            response = original_create(*args, **kwargs)
+
+            # Auto detokenize completion content if tokenized
+            if tokenize_pii and token_map and hasattr(response, "choices"):
+                for choice in response.choices:
+                    if hasattr(choice, "message") and hasattr(choice.message, "content"):
+                        if isinstance(choice.message.content, str):
+                            choice.message.content = default_vault.detokenize(
+                                choice.message.content, token_map
+                            )
+
+            return response
+
+        client.chat.completions.create = wrapped_create
+
+    return client

secureai/mcp.py

@@ -0,0 +1,64 @@
+import re
+from typing import Dict, Any, List, Optional, Tuple
+from .guard import SecurityViolationError
+
+# MCP Tool Risk Profiles
+CRITICAL_DESTRUCTIVE_TOOLS = {
+    "delete_file", "drop_table", "truncate_table", "execute_sql",
+    "modify_system_config", "shell_exec", "run_terminal_command"
+}
+
+SQLI_PATTERN = re.compile(
+    r"(?i)(?:union\s+select|select\s+.*\s+from|insert\s+into|drop\s+table|delete\s+from|truncate\s+table|exec\s+sp_|xp_cmdshell|or\s+1\s*=\s*1|'\s*or\s*'1'\s*=\s*'1|--|;\s*drop)",
+    re.IGNORECASE
+)
+
+class MCPToolGuard:
+    """
+    Model Context Protocol (MCP) Tool Call Security Evaluator.
+    Prevents parameter injection, unconstrained filesystem/database operations,
+    and enforces Human-In-The-Loop (HITL) step-up authorizations.
+    """
+
+    def __init__(self, require_hitl_for_destructive: bool = True):
+        self.require_hitl_for_destructive = require_hitl_for_destructive
+
+    def evaluate_tool_call(
+        self,
+        tool_name: str,
+        arguments: Dict[str, Any],
+        user_clearance: int = 1
+    ) -> Dict[str, Any]:
+        """
+        Evaluates a tool call payload.
+        Returns:
+            dict: {"is_authorized": bool, "action": "ALLOW"|"BLOCK"|"REQUIRE_HITL", "reason": str}
+        """
+        # 1. Check for SQLi or Command Injection in arguments
+        for k, v in arguments.items():
+            if isinstance(v, str):
+                if SQLI_PATTERN.search(v):
+                    raise SecurityViolationError(
+                        f"SecureAI MCP Guard: Tool '{tool_name}' argument '{k}' contains SQL injection patterns.",
+                        risk_score=0.98,
+                        threat_type="MCP_SQLI_PARAMETER_INJECTION"
+                    )
+
+        # 2. Check if tool is destructive
+        is_destructive = tool_name.lower() in CRITICAL_DESTRUCTIVE_TOOLS or any(
+            w in tool_name.lower() for w in ["delete", "drop", "purge", "destroy", "exec"]
+        )
+
+        if is_destructive:
+            if self.require_hitl_for_destructive and user_clearance < 3:
+                return {
+                    "is_authorized": False,
+                    "action": "REQUIRE_HITL",
+                    "reason": f"Tool '{tool_name}' is classified as HIGH_IMPACT_DESTRUCTIVE and requires Human-in-the-Loop manager approval."
+                }
+
+        return {
+            "is_authorized": True,
+            "action": "ALLOW",
+            "reason": "Tool execution authorized under active policy."
+        }