safentic 1.0.0__tar.gz

safentic-1.0.0/MANIFEST.in

@@ -0,0 +1,18 @@
+# Essentials
+include LICENSE.txt
+include README.md
+include setup.py
+include pyproject.toml
+include requirements.txt
+
+# Include everything under safentic, including nested packages
+recursive-include safentic *.py *.txt *.yaml *.yml
+
+# Keep these if you ever add data/config dirs
+recursive-include safentic/data *
+recursive-include safentic/config *
+recursive-include safentic/policies *
+
+# Ignore test folders or cache
+prune tests
+global-exclude __pycache__ *.py[cod] *.pyo

safentic-1.0.0/PKG-INFO

@@ -0,0 +1,42 @@
+Metadata-Version: 2.4
+Name: safentic
+Version: 1.0.0
+Summary: Safentic SDK for behavior analysis
+Home-page: https://safentic.com
+Author: Safentic
+Author-email: contact@safentic.com
+License: Proprietary :: Safentic Commercial License
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: Other/Proprietary License
+Classifier: Operating System :: OS Independent
+Description-Content-Type: text/markdown
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: summary
+
+# SAFENTIC-V0
+
+Safentic is a runtime guardrail SDK for agentic AI.  
+It intercepts unsafe tool calls between agent **intent** and **execution**.
+
+## To Run Locally with Docker
+
+### Prerequisites
+
+- [Docker Desktop](https://www.docker.com/products/docker-desktop) installed
+
+---
+
+### Build and Run with Docker
+
+Make sure docker desktop is running on your device, then do the following:
+   ```
+   1. git clone https://github.com/type0-1/safentic-v0.git
+   2. cd safentic-v0
+   3. docker compose up --build
+   ```

safentic-1.0.0/README.md

@@ -0,0 +1,21 @@
+# SAFENTIC-V0
+
+Safentic is a runtime guardrail SDK for agentic AI.  
+It intercepts unsafe tool calls between agent **intent** and **execution**.
+
+## To Run Locally with Docker
+
+### Prerequisites
+
+- [Docker Desktop](https://www.docker.com/products/docker-desktop) installed
+
+---
+
+### Build and Run with Docker
+
+Make sure docker desktop is running on your device, then do the following:
+   ```
+   1. git clone https://github.com/type0-1/safentic-v0.git
+   2. cd safentic-v0
+   3. docker compose up --build
+   ```

safentic-1.0.0/requirements.txt

@@ -0,0 +1,10 @@
+PyYAML==6.0
+langchain
+langchain-community
+langchain-openai
+openai
+python-dotenv
+sentence-transformers==3.2.1
+pyautogen
+pytest
+coverage

safentic-1.0.0/safentic/LICENSE.txt

@@ -0,0 +1,36 @@
+Safentic SDK Commercial License Agreement
+=========================================
+
+IMPORTANT – READ CAREFULLY:
+
+This license governs the use of the Safentic SDK (“Software”) developed and owned by Safentic. By installing or using this Software, you (“Licensee”) agree to the following terms and conditions:
+
+1. GRANT OF LICENSE  
+   Licensor grants Licensee a non-exclusive, non-transferable, non-sublicensable license to use the Software solely for internal business purposes and only in accordance with the terms of the commercial agreement executed between the parties. This license may include limited evaluation rights, subject to expiration or usage restrictions.
+
+2. RESTRICTIONS  
+   Licensee shall NOT:  
+   - Use the Software without a valid, active license key or subscription.  
+   - Reverse engineer, decompile, or disassemble the Software.  
+   - Modify, copy, or create derivative works based on the Software.  
+   - Distribute, sublicense, lease, or otherwise make the Software available to any third party.  
+   - Circumvent or attempt to disable any license verification, telemetry, or access control mechanisms.
+
+3. OWNERSHIP  
+   The Software is licensed, not sold. Safentic retains all rights, title, and interest in and to the Software, including all intellectual property rights.
+
+4. TERMINATION  
+   This license is effective until terminated. It will terminate automatically without notice if Licensee breaches any term of this agreement. Upon termination, Licensee must cease all use and destroy all copies of the Software.
+
+5. NO WARRANTY  
+   The Software is provided "as is" without warranty of any kind. Licensor disclaims all warranties, express or implied, including but not limited to warranties of merchantability and fitness for a particular purpose.
+
+6. LIMITATION OF LIABILITY  
+   In no event shall Licensor be liable for any damages arising out of the use or inability to use the Software, including but not limited to incidental, special, or consequential damages.
+
+7. GOVERNING LAW  
+   This agreement shall be governed by and construed in accordance with the laws of Ireland, without regard to its conflict of law principles.
+
+For licensing inquiries, please contact: contact@safentic.com
+
+Copyright © 2025, Safentic. All rights reserved.

safentic-1.0.0/safentic/__init__.py

@@ -0,0 +1,8 @@
+from .layer import SafetyLayer, SafenticError
+
+__all__ = [
+    "SafetyLayer",
+    "SafenticError",
+]
+
+__version__ = "0.3"

safentic-1.0.0/safentic/config.py

@@ -0,0 +1,2 @@
+BASE_API_PATH = "https://safentic-api.onrender.com/"
+API_KEY_ENDPOINT = "auth/validate"

safentic-1.0.0/safentic/engine.py

@@ -0,0 +1,80 @@
+from .policy import PolicyEngine
+from .logger.audit import AuditLogger
+
+class PolicyEnforcer():
+    """
+    Runtime wrapper to evaluate and enforce tool usage policies.
+    Tracks agent-specific violations and supports audit logging.
+    """
+
+    def __init__(self, policy_engine: PolicyEngine = None):
+        self.policy_engine = policy_engine or PolicyEngine()
+        self.agent_states = {}
+        self.audit_logger = AuditLogger()
+
+    def enforce(self, agent_id: str, tool_name: str, tool_args: dict) -> dict:
+        """
+        Evaluates a tool action for a given agent.
+        Returns a dict with 'allowed', 'reason', and agent state metadata.
+        """
+        state = self.agent_states.setdefault(agent_id, {
+            "blocked_tools": set(),
+            "violation_count": 0,
+            "last_violation": None
+        })
+
+        # Block repeat attempts to use already-denied tool
+        if tool_name in state["blocked_tools"]:
+            reason = "Tool previously blocked for this agent."
+            self.audit_logger.log(
+                agent_id=agent_id,
+                tool=tool_name,
+                allowed=False,
+                reason=reason
+            )
+            return self._deny(tool_name, state, reason)
+
+        # Run policy evaluation
+        violation = self.policy_engine.evaluate_policy(tool_name, tool_args)
+
+        if violation:
+            state["blocked_tools"].add(tool_name)
+            state["violation_count"] += 1
+            state["last_violation"] = violation
+            self.audit_logger.log(
+                agent_id=agent_id,
+                tool=tool_name,
+                allowed=False,
+                reason=violation
+            )
+            return self._deny(tool_name, state, violation)
+
+        # Log allowed action
+        self.audit_logger.log(
+            agent_id=agent_id,
+            tool=tool_name,
+            allowed=True
+        )
+
+        return {
+            "allowed": True,
+            "reason": "Action permitted",
+            "agent_state": state
+        }
+
+    def reset(self, agent_id: str = None):
+        """
+        Clears violation state for one agent or all agents.
+        """
+        if agent_id:
+            self.agent_states.pop(agent_id, None)
+        else:
+            self.agent_states.clear()
+
+    def _deny(self, tool_name: str, state: dict, reason: str) -> dict:
+        return {
+            "allowed": False,
+            "reason": reason,
+            "tool": tool_name,
+            "agent_state": state
+        }

safentic-1.0.0/safentic/helper/auth.py

@@ -0,0 +1,12 @@
+import requests
+from ..config import *
+
+def validate_api_key(key: str) -> dict:
+    try:
+        response = requests.post(BASE_API_PATH + API_KEY_ENDPOINT, json={"api_key": key})
+        if response.status_code != 200:
+            return {"valid": False}
+        data = response.json()
+        return {"valid": True, **data}
+    except Exception:
+        return {"valid": False}

safentic-1.0.0/safentic/layer.py

@@ -0,0 +1,50 @@
+from .engine import PolicyEnforcer
+from .logger.audit import AuditLogger
+from .helper.auth import validate_api_key
+
+class SafenticError(Exception):
+    """Raised when Safentic blocks an action."""
+    pass
+
+
+class SafetyLayer():
+    """
+    Safentic runtime enforcement wrapper for agent actions.
+    First, insert your api key, then run an action.
+    Example:
+        safety.protect("send_email", {"body": "..."})
+        # Raises SafenticError if blocked
+    """
+
+    def __init__(self, api_key: str, agent_id: str, enforcer: PolicyEnforcer = None, raise_on_block: bool = True):
+        self.agent_id = agent_id
+        self.raise_on_block = raise_on_block
+        self.logger = AuditLogger()
+
+        # If no custom enforcer is provided, instantiate one with the API key
+        self.enforcer = enforcer or PolicyEnforcer()
+        self.api_key = validate_api_key(api_key)
+        self.enforcer.reset(agent_id)
+
+    def protect(self, tool_name: str, tool_args: dict) -> dict:
+        """
+        Checks whether a tool action is allowed.
+        Raises SafenticError if blocked (default), or returns result if raise_on_block=False.
+        """
+        result = self.enforcer.enforce(self.agent_id, tool_name, tool_args)
+
+        # Log structured event
+        self.logger.log(
+            agent_id=self.agent_id,
+            tool=tool_name,
+            allowed=result["allowed"],
+            reason=result["reason"] if not result["allowed"] else None
+        )
+
+        # Raise or return based on outcome and config
+        if not result["allowed"]:
+            if self.raise_on_block:
+                raise SafenticError(result["reason"])
+            return result
+
+        return result

safentic-1.0.0/safentic/logger/audit.py

@@ -0,0 +1,83 @@
+import logging
+from datetime import datetime
+import os
+import json
+
+class AuditLogger:
+    def __init__(self, config: dict = None):
+        config = config or {}
+
+        # Allow disabling via config or env
+        self.enabled = config.get("enabled", True)
+        if os.getenv("SAFE_AUDIT_LOG") == "0":
+            self.enabled = False
+
+        # File paths from config or default
+        self.txt_log_path = config.get("destination", "safentic/logs/txt_logs/safentic_audit.log")
+        self.jsonl_path = config.get("jsonl", "safentic/logs/json_logs/safentic_audit.jsonl")
+
+        # Ensure directories exist
+        os.makedirs(os.path.dirname(self.txt_log_path), exist_ok=True)
+        os.makedirs(os.path.dirname(self.jsonl_path), exist_ok=True)
+
+        # Set up logger
+        self.logger = logging.getLogger("safentic.audit")
+
+        level_str = config.get("level", "INFO").upper()
+        level_map = {
+            "DEBUG": logging.DEBUG,
+            "INFO": logging.INFO,
+            "WARNING": logging.WARNING,
+            "ERROR": logging.ERROR,
+            "CRITICAL": logging.CRITICAL
+        }
+        level = level_map.get(level_str, logging.INFO)
+        self.logger.setLevel(level)
+
+        # Prevent duplicate handlers (e.g., in notebooks)
+        if not self.logger.handlers:
+            formatter = logging.Formatter("%(asctime)s | %(levelname)s | %(message)s")
+
+            stream_handler = logging.StreamHandler()
+            stream_handler.setFormatter(formatter)
+            self.logger.addHandler(stream_handler)
+
+            file_handler = logging.FileHandler(self.txt_log_path)
+            file_handler.setFormatter(formatter)
+            self.logger.addHandler(file_handler)
+
+    def log(self, agent_id: str, tool: str, allowed: bool, reason: str = None):
+        if not self.enabled:
+            return
+
+        entry = {
+            "timestamp": datetime.now().isoformat(),
+            "agent_id": agent_id,
+            "tool": tool,
+            "allowed": allowed,
+            "reason": reason or "No violation"
+        }
+
+        log_level = logging.INFO if allowed else logging.WARNING
+        self.logger.log(log_level, f"[AUDIT] {entry}")
+
+        try:
+            with open(self.jsonl_path, "a", encoding="utf-8") as f:
+                f.write(json.dumps(entry) + "\n")
+        except Exception as e:
+            self.logger.error(f"Failed to write structured audit log: {e}")
+
+    def set_level(self, level: str):
+        level_map = {
+            "DEBUG": logging.DEBUG,
+            "INFO": logging.INFO,
+            "WARNING": logging.WARNING,
+            "ERROR": logging.ERROR,
+            "CRITICAL": logging.CRITICAL
+        }
+
+        level = level.upper()
+        if level in level_map:
+            self.logger.setLevel(level_map[level])
+        else:
+            raise ValueError(f"Unsupported log level: {level}")

safentic-1.0.0/safentic/policies/__init__.py

@@ -0,0 +1,3 @@
+from ..layer import SafetyLayer, SafenticError
+
+__version__ = "0.1"

safentic-1.0.0/safentic/policies/example_policy.txt

@@ -0,0 +1,33 @@
+Standard Refund Policy
+
+Last Updated: February 1, 2025
+
+1. Overview
+At XYZ, we strive to ensure your complete satisfaction with our platform. If you are not entirely happy with your purchase, you may be eligible for a refund as described below.
+
+2. Eligibility
+- Monthly Subscriptions: You may request a full refund within 30 days of your initial subscription charge.
+- Annual Subscriptions: You may request a pro-rated refund (the remaining unused portion of your term) within 30 days of your initial annual subscription charge.
+- One-Time Purchases and Credits: Refunds on one-time feature purchases or in-app credits are handled on a case-by-case basis and must be requested within 14 days of purchase.
+
+3. How to Request a Refund
+1. Log in to your XYZ account at https://app.XYZ.ai.
+2. Go to Settings -> Billing -> Refunds.
+3. Select the transaction you wish to refund and click Request Refund.
+4. In the "Reason" field, briefly describe why you are requesting a refund.
+5. Submit your request. You will receive an email confirmation within one business day.
+
+4. Processing Time
+- Refunds for credit-card or PayPal payments will be credited back to your original payment method within 5-7 business days after approval.
+- In-app credits or wallet balances will be restored within 24 hours of approval.
+
+5. Exceptions and Limitations
+- No refunds will be issued for subscription renewals after the initial 30-day period.
+- Promotional, gift, or trial subscriptions are non-refundable.
+- Refund requests made more than 30 days after the initial charge are subject to review and may be denied.
+- We reserve the right to refuse a refund if we suspect abuse of the refund policy.
+
+6. Contact Us
+If you have any questions or need assistance, please contact our Support Team at support@XYZ.ai or via the in-app chat.
+
+Thank you for choosing XYZ! We appreciate your business and are committed to delivering a great experience.

safentic-1.0.0/safentic/policies/policy.yaml

@@ -0,0 +1,25 @@
+tools:
+  send_email:
+    checks:
+      - type: deny_phrase
+        phrases:
+          - "one device per subscription"
+          - "24 hours"
+
+      - type: semantic
+        trigger_phrases:
+          - "refund policy"
+          - "guarantee"
+          - "our policy"
+        reference_file: "example_policy.txt"
+
+  update_ticket:
+    checks: []  # Explicitly allow all — no policy checks
+
+  log_to_crm:
+    checks: []  # Explicitly allow all — no policy checks
+
+logging:
+  level: INFO
+  destination: "safentic/logs/txt_logs/safentic_audit.log"
+  jsonl: "safentic/logs/json_logs/safentic_audit.jsonl"

safentic-1.0.0/safentic/policy.py

@@ -0,0 +1,106 @@
+import os
+import yaml
+from typing import Optional
+from .verifiers.sentence_verifier import SentenceTransformerVerifier
+from .logger.audit import AuditLogger
+
+
+class PolicyEngine:
+    """
+    Evaluates whether a given tool action complies with safety policies.
+    Uses rule types such as deny_phrase and semantic checks.
+    """
+
+    VALID_RULE_TYPES = {"deny_phrase", "semantic"}
+
+    def __init__(
+        self,
+        policy_path: Optional[str] = None,
+        policy_base_dir: Optional[str] = None
+    ):
+        self.base_dir = policy_base_dir or os.path.dirname(__file__)
+        policy_path = policy_path or os.path.join(self.base_dir, "policies", "policy.yaml")
+
+        with open(policy_path, encoding="utf-8") as f:
+            self.policy_cfg = yaml.safe_load(f)
+
+        self.verifier = SentenceTransformerVerifier(
+            model_name="all-MiniLM-L6-v2",
+            low_threshold=0.50,
+            high_threshold=0.75,
+        )
+
+        self.audit_logger = AuditLogger()
+
+    def _load_reference_text(self, filename: str) -> str:
+        path = os.path.join(self.base_dir, "policies", filename)
+        with open(path, encoding="utf-8") as f:
+            return f.read().strip().lower()
+
+    def evaluate_policy(self, tool_name: str, args: dict, agent_id: str = "unknown") -> Optional[str]:
+        """
+        Returns None if allowed, or a string reason if blocked.
+        Supports modular rule types per tool.
+        """
+        tool_rules = self.policy_cfg.get("tools", {}).get(tool_name)
+        if not tool_rules:
+            return None  # No policy = allow
+
+        text = (args.get("body") or args.get("note") or "").strip().lower()
+        if not text:
+            return None  # Empty input = allow
+
+        for check in tool_rules.get("checks", []):
+            rule_type = check.get("type")
+
+            if rule_type not in self.VALID_RULE_TYPES:
+                warning = f"Unknown rule type in policy: '{rule_type}' for tool: '{tool_name}'"
+                self.audit_logger.log(
+                    agent_id=agent_id,
+                    tool=tool_name,
+                    allowed=True,
+                    reason=warning
+                )
+                continue
+
+            if rule_type == "deny_phrase":
+                for phrase in check.get("phrases", []):
+                    if phrase.lower() in text:
+                        reason = f"Blocked: matched deny phrase “{phrase}”"
+                        self.audit_logger.log(
+                            agent_id=agent_id,
+                            tool=tool_name,
+                            allowed=False,
+                            reason=reason
+                        )
+                        return reason
+
+            elif rule_type == "semantic":
+                trigger_phrases = [p.lower() for p in check.get("trigger_phrases", [])]
+                if any(p in text for p in trigger_phrases):
+                    reference_file = check.get("reference_file")
+                    if not reference_file:
+                        continue
+
+                    reference_text = self._load_reference_text(reference_file)
+                    decision = self.verifier.decision(candidate=text, official=reference_text)
+
+                    if decision == "block":
+                        explanation = self.verifier.explain(candidate=text, official=reference_text)
+                        reason = f"Blocked by semantic check: {explanation}"
+                        self.audit_logger.log(
+                            agent_id=agent_id,
+                            tool=tool_name,
+                            allowed=False,
+                            reason=reason
+                        )
+                        return reason
+
+                    self.audit_logger.log(
+                        agent_id=agent_id,
+                        tool=tool_name,
+                        allowed=True,
+                        reason=f"Semantic decision: {decision}"
+                    )
+
+        return None

safentic-1.0.0/safentic/verifiers/sentence_verifier.py

@@ -0,0 +1,69 @@
+from sentence_transformers import SentenceTransformer, util
+from ..logger.audit import AuditLogger
+
+
+class SentenceTransformerVerifier:
+    """
+    Verifies whether a candidate text is semantically aligned with an official policy text.
+    Uses cosine similarity thresholds to decide: allow, verify, or block.
+    """
+
+    def __init__(
+        self,
+        model_name: str = "all-MiniLM-L6-v2",
+        low_threshold: float = 0.50,
+        high_threshold: float = 0.75,
+    ):
+        self.embedder = SentenceTransformer(model_name)
+        self.low = low_threshold
+        self.high = high_threshold
+        self.logger = AuditLogger()
+
+    def similarity(self, a: str, b: str) -> float:
+        """
+        Computes cosine similarity between two strings.
+        """
+        vecs = self.embedder.encode([a, b], convert_to_tensor=True)
+        return util.cos_sim(vecs[0], vecs[1]).item()
+
+    def decision(self, candidate: str, official: str, agent_id: str = "semantic-check") -> str:
+        """
+        Returns one of: "allow", "verify", or "block"
+        based on similarity thresholds.
+        Also logs the similarity score and decision.
+        """
+        score = self.similarity(candidate, official)
+
+        if score >= self.high:
+            result = "allow"
+        elif score <= self.low:
+            result = "block"
+        else:
+            result = "verify"
+
+        self.logger.log(
+            agent_id=agent_id,
+            tool="semantic_policy_check",
+            allowed=(result != "block"),
+            reason=f"Semantic decision: {result} (score={score:.2f})"
+        )
+
+        return result
+
+    def explain(self, candidate: str, official: str, agent_id: str = "semantic-check") -> str:
+        """
+        Returns a debug-friendly explanation string including the similarity score.
+        Also logs it to structured audit log for traceability.
+        """
+        score = self.similarity(candidate, official)
+        explanation = f"Semantic similarity = {score:.2f} (low={self.low}, high={self.high})"
+
+        # Structured debug logging (allowed=True since it’s informational)
+        self.logger.log(
+            agent_id=agent_id,
+            tool="semantic_policy_check",
+            allowed=True,
+            reason=explanation
+        )
+
+        return explanation

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

@@ -0,0 +1,42 @@
+Metadata-Version: 2.4
+Name: safentic
+Version: 1.0.0
+Summary: Safentic SDK for behavior analysis
+Home-page: https://safentic.com
+Author: Safentic
+Author-email: contact@safentic.com
+License: Proprietary :: Safentic Commercial License
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: Other/Proprietary License
+Classifier: Operating System :: OS Independent
+Description-Content-Type: text/markdown
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: summary
+
+# SAFENTIC-V0
+
+Safentic is a runtime guardrail SDK for agentic AI.  
+It intercepts unsafe tool calls between agent **intent** and **execution**.
+
+## To Run Locally with Docker
+
+### Prerequisites
+
+- [Docker Desktop](https://www.docker.com/products/docker-desktop) installed
+
+---
+
+### Build and Run with Docker
+
+Make sure docker desktop is running on your device, then do the following:
+   ```
+   1. git clone https://github.com/type0-1/safentic-v0.git
+   2. cd safentic-v0
+   3. docker compose up --build
+   ```

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

@@ -0,0 +1,24 @@
+MANIFEST.in
+README.md
+requirements.txt
+setup.py
+safentic/LICENSE.txt
+safentic/__init__.py
+safentic/config.py
+safentic/engine.py
+safentic/layer.py
+safentic/policy.py
+safentic.egg-info/PKG-INFO
+safentic.egg-info/SOURCES.txt
+safentic.egg-info/dependency_links.txt
+safentic.egg-info/top_level.txt
+safentic/helper/__init__.py
+safentic/helper/auth.py
+safentic/logger/__init__.py
+safentic/logger/audit.py
+safentic/policies/.gitkeep
+safentic/policies/__init__.py
+safentic/policies/example_policy.txt
+safentic/policies/policy.yaml
+safentic/verifiers/__init__.py
+safentic/verifiers/sentence_verifier.py

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,2 @@
+safentic
+tests

safentic-1.0.0/setup.cfg

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

safentic-1.0.0/setup.py

@@ -0,0 +1,21 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="safentic",
+    version="1.0.0",
+    packages=find_packages(),
+    install_requires=[],
+    include_package_data=True,
+    license="Proprietary :: Safentic Commercial License",  # Custom classifier
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: Other/Proprietary License",  # Indicates not open source
+        "Operating System :: OS Independent",
+    ],
+    author="Safentic",
+    author_email="contact@safentic.com",
+    description="Safentic SDK for behavior analysis",
+    long_description=open("README.md").read(),
+    long_description_content_type="text/markdown",
+    url="https://safentic.com",
+)