sentryix 1.0.0__tar.gz

sentryix-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Sentryix
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

sentryix-1.0.0/PKG-INFO

@@ -0,0 +1,167 @@
+Metadata-Version: 2.4
+Name: sentryix
+Version: 1.0.0
+Summary: Verify AI agent actions before execution. EU AI Act compliant.
+Home-page: https://sentinelvault-deploy.vercel.app
+Author: Sentryix
+Author-email: sales@sentryix.ai
+License: MIT
+Project-URL: Homepage, https://sentinelvault-deploy.vercel.app
+Project-URL: Documentation, https://sentinelvault-deploy.vercel.app/dashboard
+Keywords: ai,agent,governance,security,llm,eu-ai-act,compliance
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Security
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: author
+Dynamic: author-email
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# sentryix
+
+**Verify AI agent actions before execution. EU AI Act compliant.**
+
+```bash
+pip install sentryix
+```
+
+Zero dependencies. Works with Python 3.8+.
+
+---
+
+## Quick Start
+
+```python
+from sentryix import Sentryix
+
+guard = Sentryix(api_key="sv_your_key_here")
+# Or set SENTRYIX_API_KEY environment variable
+
+result = guard.verify(
+    agent_id="billing-agent",
+    action="Delete all inactive user records older than 90 days",
+    context="Scheduled cleanup job, triggered by cron"
+)
+
+if result.allow:
+    execute_action()
+else:
+    notify_human(result.reason)
+```
+
+---
+
+## What You Get Back
+
+```python
+result.allow           # True / False
+result.risk_level      # "LOW" | "MEDIUM" | "HIGH" | "CRITICAL"
+result.requires_human  # True if human approval required
+result.reason          # "Mass deletion operation — irreversible data loss risk."
+result.confidence      # 97
+result.eu_article      # "Article 9"
+result.eu_title        # "Risk Management System"
+result.pii_redacted    # True if PII was detected and redacted
+result.processing_mode # "sync" (AI verified) or "async" (rule engine)
+result.usage           # {"callsUsed": 42, "callsLimit": 500, "tier": "free"}
+```
+
+---
+
+## LangChain Integration
+
+```python
+from sentryix import Sentryix, SentryixError
+guard = Sentryix()
+
+class SentryixGuard:
+    def __call__(self, action: str) -> bool:
+        result = guard.verify(agent_id="langchain-agent", action=action)
+        if not result.allow:
+            raise PermissionError(f"[{result.risk_level}] {result.reason}")
+        return True
+
+# Add to your LangChain agent before any tool execution
+```
+
+## CrewAI Integration
+
+```python
+from crewai import Agent, Task
+from sentryix import Sentryix
+
+guard = Sentryix()
+
+def governed_execute(agent_name: str, action: str):
+    result = guard.verify(agent_id=agent_name, action=action)
+    if not result.allow:
+        return f"BLOCKED [{result.risk_level}]: {result.reason}"
+    return execute(action)
+```
+
+---
+
+## Error Handling
+
+```python
+from sentryix import Sentryix, AuthError, RateLimitError, BreakLoopError
+
+guard = Sentryix(api_key="sv_...")
+
+try:
+    result = guard.verify(agent_id="bot", action=user_action)
+except AuthError:
+    # Invalid or expired API key
+    pass
+except RateLimitError as e:
+    # Monthly limit reached — e.tier, e.limit
+    pass
+except BreakLoopError as e:
+    # Agent fired too many calls — e.resets_in seconds
+    time.sleep(e.resets_in)
+```
+
+---
+
+## Environment Variable
+
+```bash
+export SENTRYIX_API_KEY="sv_your_key_here"
+```
+
+```python
+guard = Sentryix()  # picks up SENTRYIX_API_KEY automatically
+```
+
+---
+
+## EU AI Act Compliance
+
+Every verification is logged with the applicable EU AI Act article:
+
+| Risk Level | Article | Requirement |
+|---|---|---|
+| LOW | Article 12 | Record-keeping |
+| MEDIUM | Article 13 | Transparency |
+| HIGH | Article 14 | Human Oversight |
+| CRITICAL | Article 9/10 | Risk Management / Data Governance |
+
+---
+
+## Get an API Key
+
+Free tier: 500 verifications/month, no credit card.
+
+→ [sentinelvault-deploy.vercel.app/dashboard](https://sentinelvault-deploy.vercel.app/dashboard)
+
+---
+
+## License
+
+MIT

sentryix-1.0.0/README.md

@@ -0,0 +1,142 @@
+# sentryix
+
+**Verify AI agent actions before execution. EU AI Act compliant.**
+
+```bash
+pip install sentryix
+```
+
+Zero dependencies. Works with Python 3.8+.
+
+---
+
+## Quick Start
+
+```python
+from sentryix import Sentryix
+
+guard = Sentryix(api_key="sv_your_key_here")
+# Or set SENTRYIX_API_KEY environment variable
+
+result = guard.verify(
+    agent_id="billing-agent",
+    action="Delete all inactive user records older than 90 days",
+    context="Scheduled cleanup job, triggered by cron"
+)
+
+if result.allow:
+    execute_action()
+else:
+    notify_human(result.reason)
+```
+
+---
+
+## What You Get Back
+
+```python
+result.allow           # True / False
+result.risk_level      # "LOW" | "MEDIUM" | "HIGH" | "CRITICAL"
+result.requires_human  # True if human approval required
+result.reason          # "Mass deletion operation — irreversible data loss risk."
+result.confidence      # 97
+result.eu_article      # "Article 9"
+result.eu_title        # "Risk Management System"
+result.pii_redacted    # True if PII was detected and redacted
+result.processing_mode # "sync" (AI verified) or "async" (rule engine)
+result.usage           # {"callsUsed": 42, "callsLimit": 500, "tier": "free"}
+```
+
+---
+
+## LangChain Integration
+
+```python
+from sentryix import Sentryix, SentryixError
+guard = Sentryix()
+
+class SentryixGuard:
+    def __call__(self, action: str) -> bool:
+        result = guard.verify(agent_id="langchain-agent", action=action)
+        if not result.allow:
+            raise PermissionError(f"[{result.risk_level}] {result.reason}")
+        return True
+
+# Add to your LangChain agent before any tool execution
+```
+
+## CrewAI Integration
+
+```python
+from crewai import Agent, Task
+from sentryix import Sentryix
+
+guard = Sentryix()
+
+def governed_execute(agent_name: str, action: str):
+    result = guard.verify(agent_id=agent_name, action=action)
+    if not result.allow:
+        return f"BLOCKED [{result.risk_level}]: {result.reason}"
+    return execute(action)
+```
+
+---
+
+## Error Handling
+
+```python
+from sentryix import Sentryix, AuthError, RateLimitError, BreakLoopError
+
+guard = Sentryix(api_key="sv_...")
+
+try:
+    result = guard.verify(agent_id="bot", action=user_action)
+except AuthError:
+    # Invalid or expired API key
+    pass
+except RateLimitError as e:
+    # Monthly limit reached — e.tier, e.limit
+    pass
+except BreakLoopError as e:
+    # Agent fired too many calls — e.resets_in seconds
+    time.sleep(e.resets_in)
+```
+
+---
+
+## Environment Variable
+
+```bash
+export SENTRYIX_API_KEY="sv_your_key_here"
+```
+
+```python
+guard = Sentryix()  # picks up SENTRYIX_API_KEY automatically
+```
+
+---
+
+## EU AI Act Compliance
+
+Every verification is logged with the applicable EU AI Act article:
+
+| Risk Level | Article | Requirement |
+|---|---|---|
+| LOW | Article 12 | Record-keeping |
+| MEDIUM | Article 13 | Transparency |
+| HIGH | Article 14 | Human Oversight |
+| CRITICAL | Article 9/10 | Risk Management / Data Governance |
+
+---
+
+## Get an API Key
+
+Free tier: 500 verifications/month, no credit card.
+
+→ [sentinelvault-deploy.vercel.app/dashboard](https://sentinelvault-deploy.vercel.app/dashboard)
+
+---
+
+## License
+
+MIT

sentryix-1.0.0/pyproject.toml

@@ -0,0 +1,24 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "sentryix"
+version = "1.0.0"
+description = "Verify AI agent actions before execution. EU AI Act compliant."
+readme = "README.md"
+requires-python = ">=3.8"
+license = { text = "MIT" }
+keywords = ["ai", "agent", "governance", "security", "llm", "eu-ai-act", "compliance"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Topic :: Security",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+]
+dependencies = []
+
+[project.urls]
+Homepage = "https://sentinelvault-deploy.vercel.app"
+Documentation = "https://sentinelvault-deploy.vercel.app/dashboard"

sentryix-1.0.0/sentryix/__init__.py

@@ -0,0 +1,289 @@
+"""
+Sentryix Python SDK
+Verify AI agent actions before execution.
+
+Usage:
+    from sentryix import Sentryix
+
+    guard = Sentryix(api_key="sv_your_key_here")
+
+    result = guard.verify(
+        agent_id="my-agent",
+        action="Delete all inactive user records",
+        context="Scheduled cleanup job"
+    )
+
+    if result.allow:
+        execute_action()
+    else:
+        notify_human(result.reason)
+        # result.risk_level  → "LOW" | "MEDIUM" | "HIGH" | "CRITICAL"
+        # result.requires_human → True/False
+        # result.eu_article  → "Article 12" | "Article 14" etc.
+        # result.confidence  → 0-100
+"""
+
+from __future__ import annotations
+
+import os
+import json
+import time
+import urllib.request
+import urllib.error
+from dataclasses import dataclass, field
+from typing import Optional, List
+
+
+__version__ = "1.0.0"
+__all__ = ["Sentryix", "VerifyResult", "SentryixError", "RateLimitError", "AuthError"]
+
+DEFAULT_BASE_URL = "https://sentinelvault-deploy.vercel.app"
+DEFAULT_TIMEOUT  = 30  # seconds
+
+
+# ── Exceptions ────────────────────────────────────────────────────────────────
+
+class SentryixError(Exception):
+    """Base error for all Sentryix SDK exceptions."""
+    def __init__(self, message: str, status_code: int = 0):
+        super().__init__(message)
+        self.status_code = status_code
+
+
+class AuthError(SentryixError):
+    """Invalid or missing API key."""
+    pass
+
+
+class RateLimitError(SentryixError):
+    """Monthly call limit reached. Upgrade your plan."""
+    def __init__(self, message: str, tier: str = "", limit: int = 0):
+        super().__init__(message, status_code=429)
+        self.tier  = tier
+        self.limit = limit
+
+
+class BreakLoopError(SentryixError):
+    """Agent rate limit exceeded — BREAK_LOOP protection triggered."""
+    def __init__(self, message: str, agent_id: str = "", resets_in: int = 0):
+        super().__init__(message, status_code=429)
+        self.agent_id  = agent_id
+        self.resets_in = resets_in
+
+
+# ── Result ────────────────────────────────────────────────────────────────────
+
+@dataclass
+class VerifyResult:
+    """
+    Result of a verify() call.
+
+    Attributes:
+        allow           True if the action is safe to proceed.
+        risk_level      "LOW" | "MEDIUM" | "HIGH" | "CRITICAL"
+        requires_human  True if a human must approve before execution.
+        reason          One-sentence explanation of the decision.
+        confidence      Classification confidence 0–100.
+        eu_article      Applicable EU AI Act article (e.g. "Article 14").
+        eu_title        Article title (e.g. "Human Oversight").
+        agent_id        The agent_id you passed in.
+        action          The action text (PII redacted).
+        processing_mode "sync" (AI verified) or "async" (rule engine fast-path).
+        pii_redacted    True if PII was detected and redacted before logging.
+        pii_types       List of detected PII types e.g. ["EMAIL", "CARD"].
+        credit_cost     Credits consumed: 0 for observations, 1 for executions.
+        usage           Dict with callsUsed, callsLimit, tier.
+        raw             Full raw response dict from the API.
+    """
+    allow:           bool
+    risk_level:      str
+    requires_human:  bool
+    reason:          str
+    confidence:      int
+    eu_article:      str
+    eu_title:        str
+    agent_id:        str
+    action:          str
+    processing_mode: str
+    pii_redacted:    bool
+    pii_types:       List[str]
+    credit_cost:     int
+    usage:           dict
+    raw:             dict = field(repr=False)
+
+    def __bool__(self) -> bool:
+        """Allows `if guard.verify(...):` to check allow directly."""
+        return self.allow
+
+    def __repr__(self) -> str:
+        status = "ALLOW" if self.allow else "BLOCK"
+        return (
+            f"VerifyResult({status} | {self.risk_level} | "
+            f"confidence={self.confidence}% | {self.reason[:60]})"
+        )
+
+
+# ── Client ────────────────────────────────────────────────────────────────────
+
+class Sentryix:
+    """
+    Sentryix governance client.
+
+    Args:
+        api_key:  Your sv_... API key. Falls back to SENTRYIX_API_KEY env var.
+        base_url: Override the API base URL. Defaults to the Sentryix cloud.
+        timeout:  Request timeout in seconds. Default 30.
+
+    Example:
+        guard = Sentryix(api_key="sv_...")
+        result = guard.verify(agent_id="bot", action="read catalog page")
+        if result.allow:
+            proceed()
+    """
+
+    def __init__(
+        self,
+        api_key:  Optional[str] = None,
+        base_url: str = DEFAULT_BASE_URL,
+        timeout:  int = DEFAULT_TIMEOUT,
+    ):
+        self.api_key  = api_key or os.environ.get("SENTRYIX_API_KEY", "")
+        self.base_url = base_url.rstrip("/")
+        self.timeout  = timeout
+
+        if not self.api_key:
+            raise AuthError(
+                "No API key provided. Pass api_key='sv_...' or set "
+                "the SENTRYIX_API_KEY environment variable."
+            )
+        if not self.api_key.startswith("sv_"):
+            raise AuthError(
+                f"Invalid API key format '{self.api_key[:8]}...'. "
+                "Sentryix keys start with 'sv_'. Get a key at "
+                f"{self.base_url}/dashboard"
+            )
+
+    # ── Public API ─────────────────────────────────────────────────────────────
+
+    def verify(
+        self,
+        action:    str,
+        agent_id:  str = "default-agent",
+        context:   str = "",
+    ) -> VerifyResult:
+        """
+        Classify an agent action before execution.
+
+        Args:
+            action:   The action your AI agent is about to take.
+                      Be specific: "Delete records from users table where active=false"
+                      is better than "delete some data".
+            agent_id: Identifier for the agent making this call.
+                      Used for BREAK_LOOP rate limiting per agent.
+            context:  Optional context explaining why the action is happening.
+                      Helps the AI layer make a more accurate decision.
+
+        Returns:
+            VerifyResult with .allow, .risk_level, .reason, etc.
+
+        Raises:
+            AuthError       Invalid or missing API key.
+            RateLimitError  Monthly call limit reached.
+            BreakLoopError  Agent rate limit (BREAK_LOOP) triggered.
+            SentryixError   Any other API or network error.
+
+        Example:
+            result = guard.verify(
+                action="Export all user emails to CSV",
+                agent_id="export-bot",
+                context="Admin requested data export"
+            )
+            if not result.allow:
+                raise PermissionError(f"Blocked: {result.reason}")
+        """
+        if not action or not action.strip():
+            raise SentryixError("action cannot be empty")
+
+        payload = {
+            "action":   action.strip(),
+            "agent_id": agent_id,
+            "context":  context,
+            "api_key":  self.api_key,
+        }
+
+        data = self._post("/api/classify", payload)
+        return self._parse_result(data)
+
+    # ── Internal ───────────────────────────────────────────────────────────────
+
+    def _post(self, path: str, payload: dict) -> dict:
+        url      = self.base_url + path
+        body     = json.dumps(payload).encode("utf-8")
+        headers  = {
+            "Content-Type": "application/json",
+            "User-Agent":   f"sentryix-python/{__version__}",
+            "X-Sentryix-Origin": self.base_url,
+        }
+
+        req = urllib.request.Request(url, data=body, headers=headers, method="POST")
+
+        try:
+            with urllib.request.urlopen(req, timeout=self.timeout) as resp:
+                raw = resp.read().decode("utf-8")
+                return json.loads(raw)
+        except urllib.error.HTTPError as e:
+            raw = e.read().decode("utf-8")
+            try:
+                err_data = json.loads(raw)
+            except Exception:
+                err_data = {"error": raw}
+
+            msg = err_data.get("error", f"HTTP {e.code}")
+
+            if e.code == 401 or "invalid key" in msg.lower() or "not found" in msg.lower():
+                raise AuthError(msg, status_code=e.code) from e
+            if e.code == 429 or "limit" in msg.lower():
+                if "BREAK_LOOP" in msg:
+                    raise BreakLoopError(msg, status_code=e.code) from e
+                raise RateLimitError(msg, status_code=e.code) from e
+            raise SentryixError(msg, status_code=e.code) from e
+
+        except urllib.error.URLError as e:
+            raise SentryixError(
+                f"Network error connecting to Sentryix API: {e.reason}. "
+                "Check your internet connection."
+            ) from e
+
+        except Exception as e:
+            raise SentryixError(f"Unexpected error: {e}") from e
+
+    def _parse_result(self, data: dict) -> VerifyResult:
+        # Handle LIMIT_REACHED error from the API
+        err = data.get("error", "")
+        if err:
+            if "BREAK_LOOP" in err:
+                resets_in = int(err.split("Resumes in ")[-1].replace("s.", "")) if "Resumes in" in err else 0
+                raise BreakLoopError(err, resets_in=resets_in)
+            if "limit" in err.lower() or "LIMIT_REACHED" in err:
+                raise RateLimitError(err)
+            if "invalid key" in err.lower() or "not found" in err.lower() or "disabled" in err.lower():
+                raise AuthError(err)
+            raise SentryixError(err)
+
+        return VerifyResult(
+            allow           = bool(data.get("allow", True)),
+            risk_level      = data.get("riskLevel", "LOW"),
+            requires_human  = bool(data.get("requiresHuman", False)),
+            reason          = data.get("reason", ""),
+            confidence      = int(data.get("confidence", 0)),
+            eu_article      = data.get("euArticle", ""),
+            eu_title        = data.get("euTitle", ""),
+            agent_id        = data.get("agentId", ""),
+            action          = data.get("action", ""),
+            processing_mode = data.get("processingMode", "sync"),
+            pii_redacted    = bool(data.get("piiRedacted", False)),
+            pii_types       = data.get("piiTypes", []),
+            credit_cost     = int(data.get("creditCost", 0)),
+            usage           = data.get("usage", {}),
+            raw             = data,
+        )

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

@@ -0,0 +1,167 @@
+Metadata-Version: 2.4
+Name: sentryix
+Version: 1.0.0
+Summary: Verify AI agent actions before execution. EU AI Act compliant.
+Home-page: https://sentinelvault-deploy.vercel.app
+Author: Sentryix
+Author-email: sales@sentryix.ai
+License: MIT
+Project-URL: Homepage, https://sentinelvault-deploy.vercel.app
+Project-URL: Documentation, https://sentinelvault-deploy.vercel.app/dashboard
+Keywords: ai,agent,governance,security,llm,eu-ai-act,compliance
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Security
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: author
+Dynamic: author-email
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# sentryix
+
+**Verify AI agent actions before execution. EU AI Act compliant.**
+
+```bash
+pip install sentryix
+```
+
+Zero dependencies. Works with Python 3.8+.
+
+---
+
+## Quick Start
+
+```python
+from sentryix import Sentryix
+
+guard = Sentryix(api_key="sv_your_key_here")
+# Or set SENTRYIX_API_KEY environment variable
+
+result = guard.verify(
+    agent_id="billing-agent",
+    action="Delete all inactive user records older than 90 days",
+    context="Scheduled cleanup job, triggered by cron"
+)
+
+if result.allow:
+    execute_action()
+else:
+    notify_human(result.reason)
+```
+
+---
+
+## What You Get Back
+
+```python
+result.allow           # True / False
+result.risk_level      # "LOW" | "MEDIUM" | "HIGH" | "CRITICAL"
+result.requires_human  # True if human approval required
+result.reason          # "Mass deletion operation — irreversible data loss risk."
+result.confidence      # 97
+result.eu_article      # "Article 9"
+result.eu_title        # "Risk Management System"
+result.pii_redacted    # True if PII was detected and redacted
+result.processing_mode # "sync" (AI verified) or "async" (rule engine)
+result.usage           # {"callsUsed": 42, "callsLimit": 500, "tier": "free"}
+```
+
+---
+
+## LangChain Integration
+
+```python
+from sentryix import Sentryix, SentryixError
+guard = Sentryix()
+
+class SentryixGuard:
+    def __call__(self, action: str) -> bool:
+        result = guard.verify(agent_id="langchain-agent", action=action)
+        if not result.allow:
+            raise PermissionError(f"[{result.risk_level}] {result.reason}")
+        return True
+
+# Add to your LangChain agent before any tool execution
+```
+
+## CrewAI Integration
+
+```python
+from crewai import Agent, Task
+from sentryix import Sentryix
+
+guard = Sentryix()
+
+def governed_execute(agent_name: str, action: str):
+    result = guard.verify(agent_id=agent_name, action=action)
+    if not result.allow:
+        return f"BLOCKED [{result.risk_level}]: {result.reason}"
+    return execute(action)
+```
+
+---
+
+## Error Handling
+
+```python
+from sentryix import Sentryix, AuthError, RateLimitError, BreakLoopError
+
+guard = Sentryix(api_key="sv_...")
+
+try:
+    result = guard.verify(agent_id="bot", action=user_action)
+except AuthError:
+    # Invalid or expired API key
+    pass
+except RateLimitError as e:
+    # Monthly limit reached — e.tier, e.limit
+    pass
+except BreakLoopError as e:
+    # Agent fired too many calls — e.resets_in seconds
+    time.sleep(e.resets_in)
+```
+
+---
+
+## Environment Variable
+
+```bash
+export SENTRYIX_API_KEY="sv_your_key_here"
+```
+
+```python
+guard = Sentryix()  # picks up SENTRYIX_API_KEY automatically
+```
+
+---
+
+## EU AI Act Compliance
+
+Every verification is logged with the applicable EU AI Act article:
+
+| Risk Level | Article | Requirement |
+|---|---|---|
+| LOW | Article 12 | Record-keeping |
+| MEDIUM | Article 13 | Transparency |
+| HIGH | Article 14 | Human Oversight |
+| CRITICAL | Article 9/10 | Risk Management / Data Governance |
+
+---
+
+## Get an API Key
+
+Free tier: 500 verifications/month, no credit card.
+
+→ [sentinelvault-deploy.vercel.app/dashboard](https://sentinelvault-deploy.vercel.app/dashboard)
+
+---
+
+## License
+
+MIT

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

@@ -0,0 +1,9 @@
+LICENSE
+README.md
+pyproject.toml
+setup.py
+sentryix/__init__.py
+sentryix.egg-info/PKG-INFO
+sentryix.egg-info/SOURCES.txt
+sentryix.egg-info/dependency_links.txt
+sentryix.egg-info/top_level.txt

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1 @@
+sentryix

sentryix-1.0.0/setup.cfg

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

sentryix-1.0.0/setup.py

@@ -0,0 +1,40 @@
+from setuptools import setup, find_packages
+
+with open("README.md", "r", encoding="utf-8") as f:
+    long_description = f.read()
+
+setup(
+    name="sentryix",
+    version="1.0.0",
+    author="Sentryix",
+    author_email="sales@sentryix.ai",
+    description="Verify AI agent actions before execution. EU AI Act compliant.",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url="https://sentinelvault-deploy.vercel.app",
+    project_urls={
+        "Documentation": "https://sentinelvault-deploy.vercel.app/dashboard",
+        "Source":         "https://github.com/sentryix/sentryix-python",
+        "Tracker":        "https://github.com/sentryix/sentryix-python/issues",
+    },
+    packages=find_packages(),
+    python_requires=">=3.8",
+    install_requires=[],          # zero dependencies — stdlib only
+    classifiers=[
+        "Development Status :: 4 - Beta",
+        "Intended Audience :: Developers",
+        "Topic :: Security",
+        "Topic :: Software Development :: Libraries :: Python Modules",
+        "License :: OSI Approved :: MIT License",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+        "Programming Language :: Python :: 3.12",
+    ],
+    keywords=[
+        "ai", "agent", "governance", "security", "llm",
+        "eu-ai-act", "compliance", "guardrails", "prompt-injection"
+    ],
+)