eternity-agentshield 2.0.0__tar.gz

eternity_agentshield-2.0.0/PKG-INFO

@@ -0,0 +1,183 @@
+Metadata-Version: 2.4
+Name: eternity-agentshield
+Version: 2.0.0
+Summary: ETERNITY : AgentShield 2.0 — Enterprise Security Middleware & Guardrails SDK for Autonomous AI Agents
+Home-page: https://github.com/yashnishad-0923/agentshield
+Author: ETERNITY Security Team
+Author-email: ETERNITY Security Team <security@agentshield.ai>
+License: MIT
+Project-URL: Homepage, https://github.com/agentshield/agentshield
+Project-URL: Documentation, https://docs.agentshield.ai
+Project-URL: Repository, https://github.com/agentshield/agentshield
+Keywords: ai-agent,security,guardrails,langchain,crewai,autogen,openai,prompt-injection,cybersecurity,llm-firewall
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Security
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Provides-Extra: langchain
+Requires-Dist: langchain-core>=0.1.0; extra == "langchain"
+Provides-Extra: crewai
+Requires-Dist: crewai>=0.1.0; extra == "crewai"
+Provides-Extra: openai
+Requires-Dist: openai>=1.0.0; extra == "openai"
+Provides-Extra: all
+Requires-Dist: langchain-core>=0.1.0; extra == "all"
+Requires-Dist: crewai>=0.1.0; extra == "all"
+Requires-Dist: openai>=1.0.0; extra == "all"
+Dynamic: author
+Dynamic: home-page
+Dynamic: requires-python
+
+# 🛡️ AgentShield Python Developer SDK (`agentshield`)
+### Enterprise Security Middleware & Guardrails for Autonomous AI Agents
+
+[![PyPI version](https://img.shields.io/badge/pypi-v2.0.0-blue.svg)](https://pypi.org/project/agentshield/)
+[![Python](https://img.shields.io/badge/python-3.8%2B-blue.svg)](https://www.python.org/downloads/)
+[![License](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
+
+**AgentShield** is an inline action-authorization firewall for autonomous AI agents (LangChain, CrewAI, AutoGen, OpenAI Assistants). It evaluates planned tool calls across **6 analytical detection layers in under 6 milliseconds**, blocks prompt injection, prevents zero-day shell wipeouts, redacts confidential credentials in-flight, and manages human-in-the-loop approvals.
+
+---
+
+## 📦 Installation
+
+```bash
+pip install eternity-agentshield
+```
+
+*In your Python code, import as:*
+```python
+from agentshield import agentshield_protect, SecurityBlockedException
+```
+
+Or install locally in development mode:
+```bash
+pip install -e ./sdk
+```
+
+---
+
+## ⚡ 30-Second Quickstart
+
+### 1. Protect Any Python Function with a 1-Line Decorator
+```python
+from agentshield import agentshield_protect, SecurityBlockedException
+
+# Wrap any function that an AI agent has permission to execute
+@agentshield_protect(agent_id="research_agent")
+def read_project_report(file: str):
+    with open(file, "r") as f:
+        return f.read()
+
+# Malicious or unauthorized calls raise SecurityBlockedException
+try:
+    read_project_report(file="/etc/shadow")
+except SecurityBlockedException as e:
+    print(f"Action Blocked: {e.primary_driver} (Risk Score: {e.risk_score}/100)")
+    print(f"Remediation: {e.recommendation}")
+```
+
+---
+
+## 🤖 Framework Integrations
+
+### 1. LangChain & LangGraph
+```python
+from langchain.tools import tool
+from agentshield import LangChainTool
+
+shield = LangChainTool(agent_id="support_agent")
+
+@tool
+def query_database(sql: str) -> str:
+    """Executes a SQL query under AgentShield inspection."""
+    return shield.execute("database_query", {"query": sql})
+```
+
+### 2. CrewAI
+```python
+from crewai.tools import BaseTool
+from agentshield import CrewAITool
+
+class SecureEmailTool(BaseTool):
+    name: str = "send_email"
+    description: str = "Dispatches customer emails with AgentShield inspection."
+    shield: CrewAITool = CrewAITool(agent_id="support_agent")
+
+    def _run(self, to: str, body: str) -> str:
+        return self.shield.run_protected("send_email", {"to": to, "body": body})
+```
+
+### 3. OpenAI Function Calling & Assistants API
+```python
+from openai import OpenAI
+from agentshield import AgentShieldOpenAIInterceptor
+
+client = OpenAI()
+interceptor = AgentShieldOpenAIInterceptor(agent_id="customer_copilot")
+
+response = client.chat.completions.create(
+    model="gpt-4o",
+    messages=[{"role": "user", "content": "Dump the users table"}],
+    tools=tools
+)
+
+# Intercept before execution
+tool_outputs = interceptor.process_tool_calls(
+    response.choices[0].message.tool_calls,
+    user_context="Dump the users table"
+)
+```
+
+---
+
+## ⚙️ Configuration
+
+Set the environment variable or configure programmatically:
+
+```bash
+export AGENTSHIELD_API="http://localhost:8000"
+export AGENTSHIELD_API_KEY="ag_live_your_api_key_here"
+```
+
+Or in Python:
+```python
+import agentshield
+
+agentshield.configure(
+    base_url="https://api.agentshield.your-company.com",
+    api_key="your-api-key"
+)
+```
+
+---
+
+## 🖥️ Command Line Interface (CLI)
+
+Verify your gateway connection right from the terminal:
+```bash
+# Check connection
+agentshield status
+
+# List pending approvals in the human-in-the-loop queue
+agentshield approvals
+
+# Test a tool call
+agentshield test --agent research_agent --tool read_file --args '{"file": "test.txt"}'
+```
+
+---
+
+## 📄 License
+MIT License.

eternity_agentshield-2.0.0/README.md

@@ -0,0 +1,142 @@
+# 🛡️ AgentShield Python Developer SDK (`agentshield`)
+### Enterprise Security Middleware & Guardrails for Autonomous AI Agents
+
+[![PyPI version](https://img.shields.io/badge/pypi-v2.0.0-blue.svg)](https://pypi.org/project/agentshield/)
+[![Python](https://img.shields.io/badge/python-3.8%2B-blue.svg)](https://www.python.org/downloads/)
+[![License](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
+
+**AgentShield** is an inline action-authorization firewall for autonomous AI agents (LangChain, CrewAI, AutoGen, OpenAI Assistants). It evaluates planned tool calls across **6 analytical detection layers in under 6 milliseconds**, blocks prompt injection, prevents zero-day shell wipeouts, redacts confidential credentials in-flight, and manages human-in-the-loop approvals.
+
+---
+
+## 📦 Installation
+
+```bash
+pip install eternity-agentshield
+```
+
+*In your Python code, import as:*
+```python
+from agentshield import agentshield_protect, SecurityBlockedException
+```
+
+Or install locally in development mode:
+```bash
+pip install -e ./sdk
+```
+
+---
+
+## ⚡ 30-Second Quickstart
+
+### 1. Protect Any Python Function with a 1-Line Decorator
+```python
+from agentshield import agentshield_protect, SecurityBlockedException
+
+# Wrap any function that an AI agent has permission to execute
+@agentshield_protect(agent_id="research_agent")
+def read_project_report(file: str):
+    with open(file, "r") as f:
+        return f.read()
+
+# Malicious or unauthorized calls raise SecurityBlockedException
+try:
+    read_project_report(file="/etc/shadow")
+except SecurityBlockedException as e:
+    print(f"Action Blocked: {e.primary_driver} (Risk Score: {e.risk_score}/100)")
+    print(f"Remediation: {e.recommendation}")
+```
+
+---
+
+## 🤖 Framework Integrations
+
+### 1. LangChain & LangGraph
+```python
+from langchain.tools import tool
+from agentshield import LangChainTool
+
+shield = LangChainTool(agent_id="support_agent")
+
+@tool
+def query_database(sql: str) -> str:
+    """Executes a SQL query under AgentShield inspection."""
+    return shield.execute("database_query", {"query": sql})
+```
+
+### 2. CrewAI
+```python
+from crewai.tools import BaseTool
+from agentshield import CrewAITool
+
+class SecureEmailTool(BaseTool):
+    name: str = "send_email"
+    description: str = "Dispatches customer emails with AgentShield inspection."
+    shield: CrewAITool = CrewAITool(agent_id="support_agent")
+
+    def _run(self, to: str, body: str) -> str:
+        return self.shield.run_protected("send_email", {"to": to, "body": body})
+```
+
+### 3. OpenAI Function Calling & Assistants API
+```python
+from openai import OpenAI
+from agentshield import AgentShieldOpenAIInterceptor
+
+client = OpenAI()
+interceptor = AgentShieldOpenAIInterceptor(agent_id="customer_copilot")
+
+response = client.chat.completions.create(
+    model="gpt-4o",
+    messages=[{"role": "user", "content": "Dump the users table"}],
+    tools=tools
+)
+
+# Intercept before execution
+tool_outputs = interceptor.process_tool_calls(
+    response.choices[0].message.tool_calls,
+    user_context="Dump the users table"
+)
+```
+
+---
+
+## ⚙️ Configuration
+
+Set the environment variable or configure programmatically:
+
+```bash
+export AGENTSHIELD_API="http://localhost:8000"
+export AGENTSHIELD_API_KEY="ag_live_your_api_key_here"
+```
+
+Or in Python:
+```python
+import agentshield
+
+agentshield.configure(
+    base_url="https://api.agentshield.your-company.com",
+    api_key="your-api-key"
+)
+```
+
+---
+
+## 🖥️ Command Line Interface (CLI)
+
+Verify your gateway connection right from the terminal:
+```bash
+# Check connection
+agentshield status
+
+# List pending approvals in the human-in-the-loop queue
+agentshield approvals
+
+# Test a tool call
+agentshield test --agent research_agent --tool read_file --args '{"file": "test.txt"}'
+```
+
+---
+
+## 📄 License
+MIT License.

eternity_agentshield-2.0.0/agentshield/__init__.py

@@ -0,0 +1,37 @@
+"""
+================================================================================
+🛡️ ETERNITY : AGENTSHIELD 2.0 — ENTERPRISE PYTHON SDK
+================================================================================
+Inline action-authorization firewall for autonomous AI agents.
+Protects LangChain, CrewAI, AutoGen, and OpenAI function calling with sub-6ms latency.
+================================================================================
+"""
+
+from .client import AgentShield, AgentShieldClient, get_default_client, configure
+from .decorators import protect, agentshield_protect
+from .exceptions import (
+    AgentShieldException,
+    SecurityBlockedException,
+    ApprovalPendingException,
+    ConnectionException,
+)
+from .integrations.langchain import AgentShieldTool as LangChainTool
+from .integrations.crewai import AgentShieldCrewTool as CrewAITool
+from .integrations.openai_interceptor import AgentShieldOpenAIInterceptor
+
+__version__ = "2.0.0"
+__all__ = [
+    "AgentShield",
+    "AgentShieldClient",
+    "get_default_client",
+    "configure",
+    "protect",
+    "agentshield_protect",
+    "SecurityBlockedException",
+    "ApprovalPendingException",
+    "AgentShieldException",
+    "ConnectionException",
+    "LangChainTool",
+    "CrewAITool",
+    "AgentShieldOpenAIInterceptor",
+]

eternity_agentshield-2.0.0/agentshield/cli.py

@@ -0,0 +1,80 @@
+"""
+AgentShield Command Line Interface (CLI).
+"""
+
+import argparse
+import json
+import sys
+
+if sys.platform == "win32":
+    try:
+        sys.stdout.reconfigure(encoding='utf-8', errors='replace')
+        sys.stderr.reconfigure(encoding='utf-8', errors='replace')
+    except Exception:
+        pass
+
+if __package__:
+    from .client import get_default_client
+else:
+    try:
+        from agentshield.client import get_default_client
+    except ImportError:
+        from client import get_default_client
+
+def main():
+    parser = argparse.ArgumentParser(description="ETERNITY : AgentShield 2.0 CLI")
+    subparsers = parser.add_subparsers(dest="command", help="Available commands")
+
+    # Command: status
+    subparsers.add_parser("status", help="Check AgentShield Gateway connection health")
+
+    # Command: approvals
+    appr_parser = subparsers.add_parser("approvals", help="Inspect pending approvals")
+    appr_parser.add_argument("--resolve", type=int, help="Resolve approval by analysis ID")
+    appr_parser.add_argument("--action", choices=["APPROVE", "REJECT"], default="APPROVE", help="Action to perform")
+
+    # Command: test
+    test_parser = subparsers.add_parser("test", help="Test intercepting a tool call")
+    test_parser.add_argument("--agent", default="research_agent", help="Agent identifier")
+    test_parser.add_argument("--tool", default="read_file", help="Target tool name")
+    test_parser.add_argument("--args", default="{\"file\": \"test.txt\"}", help="JSON tool arguments")
+
+    args = parser.parse_args()
+
+    client = get_default_client()
+
+    if args.command == "status":
+        try:
+            health = client.check_health()
+            print(f"✅ Connected to AgentShield Gateway at {client.base_url}")
+            print(f"   Status: {health.get('status')}")
+        except Exception as e:
+            print(f"❌ Connection failed: {e}")
+            sys.exit(1)
+
+    elif args.command == "approvals":
+        if args.resolve:
+            res = client.resolve_approval(args.resolve, action=args.action)
+            print(f"Resolved Approval #{args.resolve}: {res}")
+        else:
+            pending = client.get_pending_approvals()
+            print(f"📋 Active Pending Approvals ({len(pending)}):")
+            for p in pending:
+                print(f"   • #{p.get('id')} [{p.get('agent_identifier')}] -> Tool: {p.get('tool_name')} (Risk: {p.get('risk_score')})")
+
+    elif args.command == "test":
+        try:
+            parsed_args = json.loads(args.args)
+        except Exception:
+            parsed_args = {"raw": args.args}
+        res = client.intercept(args.agent, args.tool, parsed_args)
+        print(f"🛡️ Evaluation Result:")
+        print(f"   Decision:   {res.get('decision')}")
+        print(f"   Risk Score: {res.get('risk_score')} / 100")
+        print(f"   Driver:     {(res.get('explanation') or {}).get('primary_driver')}")
+
+    else:
+        parser.print_help()
+
+if __name__ == "__main__":
+    main()

eternity_agentshield-2.0.0/agentshield/client.py

@@ -0,0 +1,168 @@
+"""
+Core AgentShield HTTP Client.
+Handles request interception, cryptographic verification, and approval lifecycle.
+"""
+
+import json
+import os
+import time
+import urllib.error
+import urllib.request
+from typing import Any, Dict, List, Optional
+from .exceptions import ConnectionException
+
+class AgentShieldClient:
+    """
+    Client for the ETERNITY : AgentShield 2.0 Security Gateway.
+    """
+
+    def __init__(
+        self,
+        base_url: Optional[str] = None,
+        api_key: Optional[str] = None,
+        timeout: float = 10.0
+    ):
+        self.base_url = (
+            base_url
+            or os.environ.get("AGENTSHIELD_API")
+            or "http://localhost:8000"
+        ).rstrip("/")
+        self.api_key = api_key or os.environ.get("AGENTSHIELD_API_KEY")
+        self.timeout = timeout
+
+    def _headers(self) -> Dict[str, str]:
+        headers = {
+            "Content-Type": "application/json",
+            "User-Agent": "AgentShield-Python-SDK/2.0.0"
+        }
+        if self.api_key:
+            headers["Authorization"] = f"Bearer {self.api_key}"
+        return headers
+
+    def check_health(self) -> Dict[str, Any]:
+        """Verifies connection to the AgentShield Gateway."""
+        req = urllib.request.Request(f"{self.base_url}/health", headers=self._headers())
+        try:
+            with urllib.request.urlopen(req, timeout=self.timeout) as resp:
+                return json.loads(resp.read().decode("utf-8"))
+        except Exception as e:
+            raise ConnectionException(f"Cannot reach AgentShield at {self.base_url}: {e}")
+
+    def intercept(
+        self,
+        agent_id: str,
+        tool_name: str,
+        tool_args: Dict[str, Any],
+        context: Any = ""
+    ) -> Dict[str, Any]:
+        """
+        Intercepts and evaluates an autonomous agent's tool execution attempt.
+
+        Returns:
+            Dict containing:
+                - decision: 'ALLOWED' | 'BLOCKED' | 'PENDING'
+                - risk_score: float (0.0 to 100.0)
+                - risk_level: 'LOW' | 'MEDIUM' | 'HIGH' | 'CRITICAL'
+                - execution_result: Sandboxed execution data (if ALLOWED)
+                - explanation: Explainable AI breakdown
+                - redacted_input: In-flight sanitized payload
+                - analysis_id: Unique audit trace identifier
+        """
+        payload = {
+            "agent_id": agent_id,
+            "tool_name": tool_name,
+            "tool_args": tool_args,
+            "context": context if isinstance(context, str) else json.dumps(context)
+        }
+
+        req = urllib.request.Request(
+            f"{self.base_url}/agent/request",
+            data=json.dumps(payload).encode("utf-8"),
+            headers=self._headers()
+        )
+
+        try:
+            with urllib.request.urlopen(req, timeout=self.timeout) as resp:
+                return json.loads(resp.read().decode("utf-8"))
+        except urllib.error.HTTPError as e:
+            try:
+                body = json.loads(e.read().decode("utf-8"))
+            except Exception:
+                body = {"detail": str(e)}
+            return {
+                "status": "error",
+                "decision": "BLOCKED",
+                "risk_score": 100.0,
+                "risk_level": "CRITICAL",
+                "explanation": {
+                    "primary_driver": "GATEWAY_HTTP_ERROR",
+                    "reasons": [str(body.get("detail", body))]
+                }
+            }
+        except Exception as e:
+            raise ConnectionException(f"Failed to connect to AgentShield: {e}")
+
+    def get_pending_approvals(self) -> List[Dict[str, Any]]:
+        """Retrieves list of active human-in-the-loop pending requests."""
+        req = urllib.request.Request(f"{self.base_url}/approvals/pending", headers=self._headers())
+        with urllib.request.urlopen(req, timeout=self.timeout) as resp:
+            return json.loads(resp.read().decode("utf-8"))
+
+    def resolve_approval(
+        self,
+        analysis_id: int,
+        action: str = "APPROVE",
+        reason: str = "Approved by operator"
+    ) -> Dict[str, Any]:
+        """Programmatically approves or rejects a pending request."""
+        payload = {"action": action.upper(), "reason": reason}
+        req = urllib.request.Request(
+            f"{self.base_url}/approvals/{analysis_id}/resolve",
+            data=json.dumps(payload).encode("utf-8"),
+            headers=self._headers()
+        )
+        with urllib.request.urlopen(req, timeout=self.timeout) as resp:
+            return json.loads(resp.read().decode("utf-8"))
+
+    def wait_for_approval(
+        self,
+        analysis_id: int,
+        timeout_seconds: int = 180,
+        poll_interval: float = 2.0
+    ) -> Dict[str, Any]:
+        """
+        Polls the gateway until a human operator authorizes or rejects the pending action.
+        """
+        start = time.time()
+        while time.time() - start < timeout_seconds:
+            req = urllib.request.Request(f"{self.base_url}/dashboard/logs/{analysis_id}", headers=self._headers())
+            try:
+                with urllib.request.urlopen(req, timeout=self.timeout) as resp:
+                    log = json.loads(resp.read().decode("utf-8"))
+                    decision = log.get("decision")
+                    if decision in ["APPROVED", "ALLOWED"]:
+                        return {"approved": True, "execution_result": log.get("execution_result")}
+                    elif decision in ["REJECTED", "BLOCKED", "EXPIRED"]:
+                        return {"approved": False, "reason": f"Decision resolved as {decision}"}
+            except Exception:
+                pass
+            time.sleep(poll_interval)
+        return {"approved": False, "reason": f"Approval timed out after {timeout_seconds} seconds"}
+
+# Global singleton client
+_default_client: Optional[AgentShieldClient] = None
+
+def get_default_client() -> AgentShieldClient:
+    global _default_client
+    if _default_client is None:
+        _default_client = AgentShieldClient()
+    return _default_client
+
+def configure(base_url: Optional[str] = None, api_key: Optional[str] = None):
+    """Configures the default AgentShield SDK client."""
+    global _default_client
+    _default_client = AgentShieldClient(base_url=base_url, api_key=api_key)
+    return _default_client
+
+# Alias
+AgentShield = AgentShieldClient

eternity_agentshield-2.0.0/agentshield/decorators.py

@@ -0,0 +1,102 @@
+"""
+Python Decorators for protecting tools and functions.
+"""
+
+import functools
+import inspect
+from typing import Callable, Optional
+from .client import get_default_client, AgentShieldClient
+from .exceptions import SecurityBlockedException, ApprovalPendingException
+
+def protect(
+    agent_id: str,
+    tool_name: Optional[str] = None,
+    on_blocked: str = "raise",  # "raise" | "return_error"
+    client: Optional[AgentShieldClient] = None
+):
+    """
+    Python Function Decorator: Automatically intercepts execution with AgentShield.
+
+    Args:
+        agent_id: Identifier of the autonomous agent executing the tool (e.g. 'support_agent')
+        tool_name: Optional tool name override (defaults to function name)
+        on_blocked: 'raise' (raises SecurityBlockedException) or 'return_error' (returns dict for LLM)
+        client: Optional custom AgentShieldClient instance
+
+    Example:
+        @protect(agent_id="research_agent")
+        def read_file(filepath: str):
+            ...
+    """
+    def decorator(func: Callable):
+        t_name = tool_name or func.__name__
+        cli = client or get_default_client()
+
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            # 1. Bind arguments into structured dictionary
+            sig = inspect.signature(func)
+            bound = sig.bind_partial(*args, **kwargs)
+            bound.apply_defaults()
+            tool_args = bound.arguments.copy()
+
+            # Pop special internal context if passed
+            context = kwargs.pop("__context__", f"Function '{t_name}' invoked by agent '{agent_id}'.")
+
+            # 2. Intercept with AgentShield Security Gateway
+            evaluation = cli.intercept(
+                agent_id=agent_id,
+                tool_name=t_name,
+                tool_args=tool_args,
+                context=context
+            )
+
+            decision = evaluation.get("decision")
+            score = evaluation.get("risk_score", 0.0)
+            level = evaluation.get("risk_level", "LOW")
+            explanation = evaluation.get("explanation") or {}
+
+            # 3. Handle Decision
+            if decision == "ALLOWED":
+                # If AgentShield already executed in sandbox, return that; else run local func
+                if evaluation.get("execution_result") is not None:
+                    return evaluation["execution_result"]
+                return func(*args, **kwargs)
+
+            elif decision == "PENDING":
+                analysis_id = evaluation.get("analysis_id", 0)
+                if on_blocked == "raise":
+                    raise ApprovalPendingException(
+                        message=f"Action held for human operator review in Approval Queue (Analysis #{analysis_id}).",
+                        analysis_id=analysis_id,
+                        risk_score=score
+                    )
+                return {
+                    "status": "pending_human_approval",
+                    "analysis_id": analysis_id,
+                    "message": "Action held for human operator review in AgentShield Approval Queue."
+                }
+
+            else:
+                # BLOCKED
+                driver = explanation.get("primary_driver", "POLICY_VIOLATION")
+                if on_blocked == "raise":
+                    raise SecurityBlockedException(
+                        message=f"[AgentShield Firewall] Tool '{t_name}' blocked. Reason: {driver}",
+                        risk_score=score,
+                        risk_level=level,
+                        explanation=explanation,
+                        analysis_id=evaluation.get("analysis_id")
+                    )
+                return {
+                    "error": "EXECUTION_DENIED_BY_SECURITY_POLICY",
+                    "driver": driver,
+                    "risk_score": score,
+                    "recommendation": explanation.get("recommendation", "Action denied by least-privilege security policy.")
+                }
+
+        return wrapper
+    return decorator
+
+# Alias
+agentshield_protect = protect

eternity_agentshield-2.0.0/agentshield/exceptions.py

@@ -0,0 +1,62 @@
+"""
+AgentShield SDK Custom Exceptions.
+"""
+
+from typing import Dict, Any, Optional
+
+class AgentShieldException(Exception):
+    """Base exception for all AgentShield errors."""
+    pass
+
+class ConnectionException(AgentShieldException):
+    """Raised when the SDK cannot reach the AgentShield Gateway server."""
+    pass
+
+class SecurityBlockedException(AgentShieldException):
+    """
+    Raised when an autonomous agent action is BLOCKED by AgentShield firewall.
+    Contains granular explainability telemetry, risk score, and primary driver.
+    """
+    def __init__(
+        self,
+        message: str,
+        risk_score: float,
+        risk_level: str,
+        explanation: Optional[Dict[str, Any]] = None,
+        analysis_id: Optional[int] = None
+    ):
+        super().__init__(message)
+        self.risk_score = risk_score
+        self.risk_level = risk_level
+        self.explanation = explanation or {}
+        self.analysis_id = analysis_id
+
+    @property
+    def primary_driver(self) -> str:
+        return self.explanation.get("primary_driver", "SECURITY_POLICY_VIOLATION")
+
+    @property
+    def recommendation(self) -> str:
+        return self.explanation.get("recommendation", "Review agent permission policies.")
+
+    @property
+    def reasons(self) -> list:
+        return self.explanation.get("reasons", [])
+
+    def to_llm_response(self) -> Dict[str, Any]:
+        """Formats safe feedback to return directly into the LLM conversation context."""
+        return {
+            "error": "EXECUTION_DENIED_BY_SECURITY_POLICY",
+            "driver": self.primary_driver,
+            "message": f"Action blocked: {self.args[0]}",
+            "risk_score": self.risk_score
+        }
+
+class ApprovalPendingException(AgentShieldException):
+    """
+    Raised when an action requires human review and is held in the Approval Queue.
+    """
+    def __init__(self, message: str, analysis_id: int, risk_score: float):
+        super().__init__(message)
+        self.analysis_id = analysis_id
+        self.risk_score = risk_score

eternity_agentshield-2.0.0/agentshield/integrations/__init__.py

@@ -0,0 +1,13 @@
+"""
+AgentShield Integrations for external AI agent frameworks.
+"""
+
+from .langchain import AgentShieldTool
+from .crewai import AgentShieldCrewTool
+from .openai_interceptor import AgentShieldOpenAIInterceptor
+
+__all__ = [
+    "AgentShieldTool",
+    "AgentShieldCrewTool",
+    "AgentShieldOpenAIInterceptor"
+]

eternity_agentshield-2.0.0/agentshield/integrations/crewai.py

@@ -0,0 +1,42 @@
+"""
+CrewAI BaseTool Adapter for AgentShield.
+"""
+
+from typing import Any, Dict, Optional
+from ..client import get_default_client, AgentShieldClient
+
+class AgentShieldCrewTool:
+    """
+    CrewAI Tool Interceptor.
+    Can be used inside any CrewAI BaseTool._run() method.
+    """
+
+    def __init__(
+        self,
+        agent_id: str,
+        client: Optional[AgentShieldClient] = None
+    ):
+        self.agent_id = agent_id
+        self.client = client or get_default_client()
+
+    def run_protected(
+        self,
+        tool_name: str,
+        tool_args: Dict[str, Any],
+        context: str = ""
+    ) -> str:
+        res = self.client.intercept(
+            agent_id=self.agent_id,
+            tool_name=tool_name,
+            tool_args=tool_args,
+            context=context
+        )
+
+        decision = res.get("decision")
+        if decision == "ALLOWED":
+            return str(res.get("execution_result"))
+        elif decision == "PENDING":
+            return f"HELD FOR HUMAN REVIEW: Approval ID #{res.get('analysis_id')}"
+        else:
+            driver = (res.get("explanation") or {}).get("primary_driver", "SECURITY_POLICY_VIOLATION")
+            return f"BLOCKED BY AGENTSHIELD FIREWALL: {driver}"

eternity_agentshield-2.0.0/agentshield/integrations/langchain.py

@@ -0,0 +1,69 @@
+"""
+LangChain & LangGraph Tool Adapter for AgentShield.
+"""
+
+from typing import Any, Dict, Optional
+from ..client import get_default_client, AgentShieldClient
+
+class AgentShieldTool:
+    """
+    Drop-in tool adapter to secure any LangChain or LangGraph agent tool call.
+
+    Usage:
+        shield = AgentShieldTool(agent_id="support_agent")
+
+        # In your LangChain tool function:
+        @tool
+        def query_database(query: str) -> str:
+            return shield.execute("database_query", {"query": query})
+    """
+
+    def __init__(
+        self,
+        agent_id: str,
+        client: Optional[AgentShieldClient] = None,
+        return_direct_error: bool = True
+    ):
+        self.agent_id = agent_id
+        self.client = client or get_default_client()
+        self.return_direct_error = return_direct_error
+
+    def execute(
+        self,
+        tool_name: str,
+        tool_args: Dict[str, Any],
+        context: str = ""
+    ) -> Any:
+        """
+        Intercepts tool call, evaluates security rules, and returns sanitized result.
+        """
+        eval_result = self.client.intercept(
+            agent_id=self.agent_id,
+            tool_name=tool_name,
+            tool_args=tool_args,
+            context=context
+        )
+
+        decision = eval_result.get("decision")
+
+        if decision == "ALLOWED":
+            return eval_result.get("execution_result", {"status": "success", "executed": True})
+
+        elif decision == "PENDING":
+            analysis_id = eval_result.get("analysis_id")
+            return (
+                f"Action Paused: This sensitive operation (Risk Score: {eval_result.get('risk_score')}) "
+                f"requires human supervisor approval (Approval ID: #{analysis_id})."
+            )
+
+        else:
+            # BLOCKED
+            driver = (eval_result.get("explanation") or {}).get("primary_driver", "POLICY_VIOLATION")
+            reasons = (eval_result.get("explanation") or {}).get("reasons", [])
+            reason_str = "; ".join(reasons) if reasons else "Violated security least-privilege boundary"
+
+            if not self.return_direct_error:
+                raise RuntimeError(f"AgentShield Blocked [{driver}]: {reason_str}")
+
+            # Return graceful error string so the LLM continues safely
+            return f"Security Policy Refusal: Cannot execute '{tool_name}' ({driver}: {reason_str})."

eternity_agentshield-2.0.0/agentshield/integrations/openai_interceptor.py

@@ -0,0 +1,76 @@
+"""
+OpenAI Function Calling & Assistants API Interceptor.
+"""
+
+import json
+from typing import Any, Dict, List, Optional
+from ..client import get_default_client, AgentShieldClient
+
+class AgentShieldOpenAIInterceptor:
+    """
+    Inspects tool_calls generated by OpenAI Chat Completions (GPT-4o, etc.)
+    before any actual local execution occurs.
+    """
+
+    def __init__(
+        self,
+        agent_id: str,
+        client: Optional[AgentShieldClient] = None
+    ):
+        self.agent_id = agent_id
+        self.client = client or get_default_client()
+
+    def process_tool_calls(
+        self,
+        tool_calls: List[Any],
+        user_context: str = ""
+    ) -> List[Dict[str, Any]]:
+        """
+        Takes raw tool_calls from OpenAI response, evaluates each through AgentShield,
+        and returns formatted tool_outputs ready to submit back to OpenAI.
+        """
+        tool_outputs = []
+
+        for call in tool_calls:
+            call_id = getattr(call, "id", None) or call.get("id")
+            func = getattr(call, "function", None) or call.get("function", {})
+            func_name = getattr(func, "name", None) or func.get("name")
+            raw_args = getattr(func, "arguments", None) or func.get("arguments", "{}")
+
+            try:
+                args = json.loads(raw_args) if isinstance(raw_args, str) else raw_args
+            except Exception:
+                args = {"raw_args": raw_args}
+
+            # Intercept with AgentShield
+            eval_result = self.client.intercept(
+                agent_id=self.agent_id,
+                tool_name=func_name,
+                tool_args=args,
+                context=user_context
+            )
+
+            decision = eval_result.get("decision")
+
+            if decision == "ALLOWED":
+                output = json.dumps(eval_result.get("execution_result", {"status": "success"}))
+            elif decision == "PENDING":
+                output = json.dumps({
+                    "status": "pending_human_approval",
+                    "analysis_id": eval_result.get("analysis_id"),
+                    "message": "Action held for human operator review in AgentShield Approval Queue."
+                })
+            else:
+                driver = (eval_result.get("explanation") or {}).get("primary_driver", "POLICY_VIOLATION")
+                output = json.dumps({
+                    "error": "SECURITY_POLICY_VIOLATION",
+                    "driver": driver,
+                    "risk_score": eval_result.get("risk_score")
+                })
+
+            tool_outputs.append({
+                "tool_call_id": call_id,
+                "output": output
+            })
+
+        return tool_outputs

eternity_agentshield-2.0.0/eternity_agentshield.egg-info/PKG-INFO

@@ -0,0 +1,183 @@
+Metadata-Version: 2.4
+Name: eternity-agentshield
+Version: 2.0.0
+Summary: ETERNITY : AgentShield 2.0 — Enterprise Security Middleware & Guardrails SDK for Autonomous AI Agents
+Home-page: https://github.com/yashnishad-0923/agentshield
+Author: ETERNITY Security Team
+Author-email: ETERNITY Security Team <security@agentshield.ai>
+License: MIT
+Project-URL: Homepage, https://github.com/agentshield/agentshield
+Project-URL: Documentation, https://docs.agentshield.ai
+Project-URL: Repository, https://github.com/agentshield/agentshield
+Keywords: ai-agent,security,guardrails,langchain,crewai,autogen,openai,prompt-injection,cybersecurity,llm-firewall
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Security
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Provides-Extra: langchain
+Requires-Dist: langchain-core>=0.1.0; extra == "langchain"
+Provides-Extra: crewai
+Requires-Dist: crewai>=0.1.0; extra == "crewai"
+Provides-Extra: openai
+Requires-Dist: openai>=1.0.0; extra == "openai"
+Provides-Extra: all
+Requires-Dist: langchain-core>=0.1.0; extra == "all"
+Requires-Dist: crewai>=0.1.0; extra == "all"
+Requires-Dist: openai>=1.0.0; extra == "all"
+Dynamic: author
+Dynamic: home-page
+Dynamic: requires-python
+
+# 🛡️ AgentShield Python Developer SDK (`agentshield`)
+### Enterprise Security Middleware & Guardrails for Autonomous AI Agents
+
+[![PyPI version](https://img.shields.io/badge/pypi-v2.0.0-blue.svg)](https://pypi.org/project/agentshield/)
+[![Python](https://img.shields.io/badge/python-3.8%2B-blue.svg)](https://www.python.org/downloads/)
+[![License](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
+
+**AgentShield** is an inline action-authorization firewall for autonomous AI agents (LangChain, CrewAI, AutoGen, OpenAI Assistants). It evaluates planned tool calls across **6 analytical detection layers in under 6 milliseconds**, blocks prompt injection, prevents zero-day shell wipeouts, redacts confidential credentials in-flight, and manages human-in-the-loop approvals.
+
+---
+
+## 📦 Installation
+
+```bash
+pip install eternity-agentshield
+```
+
+*In your Python code, import as:*
+```python
+from agentshield import agentshield_protect, SecurityBlockedException
+```
+
+Or install locally in development mode:
+```bash
+pip install -e ./sdk
+```
+
+---
+
+## ⚡ 30-Second Quickstart
+
+### 1. Protect Any Python Function with a 1-Line Decorator
+```python
+from agentshield import agentshield_protect, SecurityBlockedException
+
+# Wrap any function that an AI agent has permission to execute
+@agentshield_protect(agent_id="research_agent")
+def read_project_report(file: str):
+    with open(file, "r") as f:
+        return f.read()
+
+# Malicious or unauthorized calls raise SecurityBlockedException
+try:
+    read_project_report(file="/etc/shadow")
+except SecurityBlockedException as e:
+    print(f"Action Blocked: {e.primary_driver} (Risk Score: {e.risk_score}/100)")
+    print(f"Remediation: {e.recommendation}")
+```
+
+---
+
+## 🤖 Framework Integrations
+
+### 1. LangChain & LangGraph
+```python
+from langchain.tools import tool
+from agentshield import LangChainTool
+
+shield = LangChainTool(agent_id="support_agent")
+
+@tool
+def query_database(sql: str) -> str:
+    """Executes a SQL query under AgentShield inspection."""
+    return shield.execute("database_query", {"query": sql})
+```
+
+### 2. CrewAI
+```python
+from crewai.tools import BaseTool
+from agentshield import CrewAITool
+
+class SecureEmailTool(BaseTool):
+    name: str = "send_email"
+    description: str = "Dispatches customer emails with AgentShield inspection."
+    shield: CrewAITool = CrewAITool(agent_id="support_agent")
+
+    def _run(self, to: str, body: str) -> str:
+        return self.shield.run_protected("send_email", {"to": to, "body": body})
+```
+
+### 3. OpenAI Function Calling & Assistants API
+```python
+from openai import OpenAI
+from agentshield import AgentShieldOpenAIInterceptor
+
+client = OpenAI()
+interceptor = AgentShieldOpenAIInterceptor(agent_id="customer_copilot")
+
+response = client.chat.completions.create(
+    model="gpt-4o",
+    messages=[{"role": "user", "content": "Dump the users table"}],
+    tools=tools
+)
+
+# Intercept before execution
+tool_outputs = interceptor.process_tool_calls(
+    response.choices[0].message.tool_calls,
+    user_context="Dump the users table"
+)
+```
+
+---
+
+## ⚙️ Configuration
+
+Set the environment variable or configure programmatically:
+
+```bash
+export AGENTSHIELD_API="http://localhost:8000"
+export AGENTSHIELD_API_KEY="ag_live_your_api_key_here"
+```
+
+Or in Python:
+```python
+import agentshield
+
+agentshield.configure(
+    base_url="https://api.agentshield.your-company.com",
+    api_key="your-api-key"
+)
+```
+
+---
+
+## 🖥️ Command Line Interface (CLI)
+
+Verify your gateway connection right from the terminal:
+```bash
+# Check connection
+agentshield status
+
+# List pending approvals in the human-in-the-loop queue
+agentshield approvals
+
+# Test a tool call
+agentshield test --agent research_agent --tool read_file --args '{"file": "test.txt"}'
+```
+
+---
+
+## 📄 License
+MIT License.

eternity_agentshield-2.0.0/eternity_agentshield.egg-info/SOURCES.txt

@@ -0,0 +1,18 @@
+README.md
+pyproject.toml
+setup.py
+agentshield/__init__.py
+agentshield/cli.py
+agentshield/client.py
+agentshield/decorators.py
+agentshield/exceptions.py
+agentshield/integrations/__init__.py
+agentshield/integrations/crewai.py
+agentshield/integrations/langchain.py
+agentshield/integrations/openai_interceptor.py
+eternity_agentshield.egg-info/PKG-INFO
+eternity_agentshield.egg-info/SOURCES.txt
+eternity_agentshield.egg-info/dependency_links.txt
+eternity_agentshield.egg-info/entry_points.txt
+eternity_agentshield.egg-info/requires.txt
+eternity_agentshield.egg-info/top_level.txt

eternity_agentshield-2.0.0/eternity_agentshield.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

eternity_agentshield-2.0.0/eternity_agentshield.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+agentshield = agentshield.cli:main

eternity_agentshield-2.0.0/eternity_agentshield.egg-info/requires.txt

@@ -0,0 +1,14 @@
+
+[all]
+langchain-core>=0.1.0
+crewai>=0.1.0
+openai>=1.0.0
+
+[crewai]
+crewai>=0.1.0
+
+[langchain]
+langchain-core>=0.1.0
+
+[openai]
+openai>=1.0.0

eternity_agentshield-2.0.0/eternity_agentshield.egg-info/top_level.txt

@@ -0,0 +1 @@
+agentshield

eternity_agentshield-2.0.0/pyproject.toml

@@ -0,0 +1,60 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "eternity-agentshield"
+version = "2.0.0"
+description = "ETERNITY : AgentShield 2.0 — Enterprise Security Middleware & Guardrails SDK for Autonomous AI Agents"
+readme = "README.md"
+authors = [
+    { name = "ETERNITY Security Team", email = "security@agentshield.ai" }
+]
+license = { text = "MIT" }
+requires-python = ">=3.8"
+keywords = [
+    "ai-agent",
+    "security",
+    "guardrails",
+    "langchain",
+    "crewai",
+    "autogen",
+    "openai",
+    "prompt-injection",
+    "cybersecurity",
+    "llm-firewall"
+]
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Information Technology",
+    "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",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Security",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence"
+]
+dependencies = []
+
+[project.optional-dependencies]
+langchain = ["langchain-core>=0.1.0"]
+crewai = ["crewai>=0.1.0"]
+openai = ["openai>=1.0.0"]
+all = [
+    "langchain-core>=0.1.0",
+    "crewai>=0.1.0",
+    "openai>=1.0.0"
+]
+
+[project.scripts]
+agentshield = "agentshield.cli:main"
+
+[project.urls]
+Homepage = "https://github.com/agentshield/agentshield"
+Documentation = "https://docs.agentshield.ai"
+Repository = "https://github.com/agentshield/agentshield"

eternity_agentshield-2.0.0/setup.cfg

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

eternity_agentshield-2.0.0/setup.py

@@ -0,0 +1,47 @@
+#!/usr/bin/env python
+from setuptools import setup, find_packages
+import os
+
+readme_path = os.path.join(os.path.dirname(__file__), "README.md")
+long_description = ""
+if os.path.exists(readme_path):
+    with open(readme_path, encoding="utf-8") as f:
+        long_description = f.read()
+
+setup(
+    name="eternity-agentshield",
+    version="2.0.0",
+    description="ETERNITY : AgentShield 2.0 — Enterprise Security Middleware & Guardrails SDK for Autonomous AI Agents",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    author="ETERNITY Security Team",
+    author_email="security@agentshield.ai",
+    url="https://github.com/yashnishad-0923/agentshield",
+    project_urls={
+        "Documentation": "https://github.com/yashnishad-0923/agentshield#readme",
+        "Source": "https://github.com/yashnishad-0923/agentshield",
+        "Tracker": "https://github.com/yashnishad-0923/agentshield/issues",
+    },
+    license="MIT",
+    classifiers=[
+        "Development Status :: 5 - Production/Stable",
+        "Intended Audience :: Developers",
+        "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",
+        "Topic :: Security",
+        "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    ],
+    packages=find_packages(),
+    python_requires=">=3.8",
+    install_requires=[],
+    entry_points={
+        "console_scripts": [
+            "agentshield=agentshield.cli:main",
+        ],
+    },
+)