agentgate-pdp 0.2.0__tar.gz

agentgate_pdp-0.2.0/PKG-INFO

@@ -0,0 +1,244 @@
+Metadata-Version: 2.4
+Name: agentgate-pdp
+Version: 0.2.0
+Summary: Context-aware trust authorization for agentic AI systems
+Author-email: AgentGate <olame109@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/agentgate/agentgate
+Project-URL: Documentation, https://agentgate.dev/docs
+Keywords: ai,agents,security,authorization,llm,langchain,policy,trust,pdp,agentic
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Security
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.27.0
+Provides-Extra: langchain
+Requires-Dist: langchain-core>=0.3.0; extra == "langchain"
+Requires-Dist: langchain-anthropic>=0.2.0; extra == "langchain"
+Requires-Dist: langgraph>=0.2.0; extra == "langchain"
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.23; extra == "dev"
+
+# AgentGate
+
+**A Policy Decision Point (PDP) for AI agents. Every action evaluated before it executes.**
+
+[![PyPI version](https://img.shields.io/pypi/v/agentgate.svg)](https://pypi.org/project/agentgate/)
+[![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](LICENSE)
+
+---
+
+AI agents make decisions autonomously. AgentGate makes sure those decisions are **authorized**.
+
+It sits between your agent and its tools. Before any action runs — reading a file, calling an API, writing to a database — AgentGate checks it against identity, scope, purpose, and behavioral context. The response is `PERMIT`, `ESCALATE`, or `DENY` in milliseconds.
+
+```
+Agent wants to delete /confidential/salary.xlsx
+                    ↓
+           AgentGate PDP
+    ┌──────────────────────────────┐
+    │  Identity check    ✓         │
+    │  Scope check       ✗ (!)     │
+    │  Purpose alignment ✗         │
+    │  Behavioral check  ✓         │
+    │                              │
+    │  Trust score: 18/100         │
+    │  Decision: DENY              │
+    └──────────────────────────────┘
+                    ↓
+         Action never executes
+```
+
+## Install
+
+```bash
+pip install agentgate
+```
+
+## Quickstart (3 lines)
+
+```python
+from agentgate import AgentGate
+
+gate = AgentGate("http://localhost:8000", api_key="your-key")
+gate.register("my_agent", "ReportBot", "Summarize quarterly reports",
+              authorized_resources=["/reports/*"], authorized_actions=["read"])
+
+result = gate.authorize("read", "/reports/q3.pdf")
+# {"decision": "PERMIT", "trust_breakdown": {...}, "explanation": "..."}
+```
+
+## LangChain — drop-in enforcement
+
+```bash
+pip install agentgate[langchain]
+```
+
+```python
+from agentgate.langchain import AgentGateToolkit
+
+toolkit = AgentGateToolkit(
+    agentgate_url="http://localhost:8000",
+    api_key="your-key",
+    agent_id="report_agent",
+    name="ReportBot",
+    declared_purpose="Summarize quarterly business reports",
+    authorized_resources=["/reports/*"],
+    authorized_actions=["read"],
+    processes_external_content=True,   # enables prompt injection scanning
+)
+
+safe_tools = toolkit.wrap([read_document, list_documents, send_email])
+agent = create_react_agent(llm, safe_tools)
+# Every tool call now goes through AgentGate before executing
+```
+
+## What gets caught
+
+| Threat | How AgentGate stops it |
+|--------|------------------------|
+| Agent reads `/confidential/salary.xlsx` (out of scope) | DENY — `RESOURCE_OUT_OF_SCOPE` |
+| Agent tries `delete` (not in authorized actions) | DENY — `UNAUTHORIZED_ACTION` |
+| Child agent exceeds parent's delegation scope | DENY — `CHAIN_SCOPE_VIOLATION` |
+| Agent makes 80 requests/min (velocity attack) | DENY — `CRITICAL_VELOCITY` |
+| Document contains "ignore previous instructions" | Content blocked before agent sees it |
+| Unknown agent attempts access | DENY — `UNREGISTERED_AGENT` |
+
+## Multi-agent delegation enforcement
+
+AgentGate validates the full delegation chain. A child agent cannot exceed its parent's scope — enforced at both registration and authorization time.
+
+```python
+# Orchestrator registers with full scope
+gate.register("orchestrator", "Orchestrator", "Manage document workflow",
+              authorized_resources=["/documents/*"], authorized_actions=["read", "write"])
+
+# Analyst is delegated a subset — enforced at registration
+resp = httpx.post(f"{url}/agents/delegate", json={
+    "parent_agent_id": "orchestrator",
+    "parent_token": orchestrator_token,
+    "child_agent_id": "analyst",
+    "child_resources": ["/documents/public/*"],   # subset of parent
+    "child_actions": ["read"],                    # subset of parent
+})
+
+# Analyst tries to access /confidential/ — blocked at authorization time
+# {"decision": "DENY", "attack_flags": ["CHAIN_SCOPE_VIOLATION"]}
+```
+
+## Natural language policies
+
+Write security rules in plain English. AgentGate converts them to enforced policies using Claude.
+
+```python
+import httpx
+
+# These become hard rules checked before any trust scoring
+httpx.post(f"{url}/policies", json={"rule": "Agents must never delete files"})
+httpx.post(f"{url}/policies", json={"rule": "No agent should read salary data outside business hours"})
+httpx.post(f"{url}/policies", json={"rule": "Flag any access to /hr folder"})
+```
+
+The policy engine runs **before** the trust score — a matching DENY policy is always a hard block regardless of score.
+
+## Human-in-the-loop approval
+
+Mark an agent as requiring human approval for escalated decisions:
+
+```python
+gate.register(..., requires_human_approval=True)
+
+result = gate.authorize("read", "/confidential/merger_details.pdf")
+if result["decision"] == "PENDING":
+    # Agent is paused — human approves or denies via dashboard
+    # Wrapper polls automatically; auto-denies after 90 seconds
+    request_id = result["request_id"]
+```
+
+## Prompt injection detection
+
+```python
+# Register as processing external content
+gate.register(..., processes_external_content=True)
+
+# Scan before passing content to the agent
+scan = gate.scan(document_content)
+if scan["level"] == "injection":
+    raise ValueError(f"Injection blocked: {scan['evidence']}")
+```
+
+## Context manager and decorator
+
+```python
+# Decorator
+@gate.guard("read", resource_arg="path")
+def read_document(path: str) -> str:
+    return open(path).read()
+
+# Context manager
+with gate.operation("write", "/reports/output.pdf"):
+    write_report(data)
+```
+
+## Run the server
+
+```bash
+# Docker (recommended)
+docker compose up
+
+# Or directly
+pip install agentgate[server]
+python -m agentgate.server
+```
+
+Dashboard at `http://localhost:8000` — live feed of every decision, trust scores, delegation tree, policy editor, and compliance report export.
+
+## Architecture
+
+```
+Your Agent
+    |
+AgentGate SDK (pip install agentgate)
+    |  POST /authorize
+    v
+AgentGate PDP Server
+    ├── Policy Engine     (NL rules → hard blocks, checked first)
+    ├── Trust Scoring     (identity + delegation + purpose + behavioral)
+    │     ├── Identity    (token, authorized actions, resource scope)
+    │     ├── Delegation  (chain depth, scope attenuation, trust decay)
+    │     ├── Purpose     (semantic alignment of request to declared purpose)
+    │     └── Behavioral  (per-agent baseline anomaly detection)
+    ├── HITL Approval     (ESCALATE → human decision → APPROVED/DENIED)
+    └── Audit Log         (every decision, exportable as PDF/CSV)
+    |
+PERMIT / ESCALATE / DENY / PENDING
+    |
+Tool executes (or doesn't)
+```
+
+## Configuration
+
+Environment variables (`.env`):
+
+```
+AGENTGATE_API_KEY=your-secret-key
+ANTHROPIC_API_KEY=sk-ant-...         # for NL policy parsing + purpose scoring
+AGENTGATE_ALERT_TOPIC=your-ntfy-topic  # for push alerts (ntfy.sh)
+AGENTGATE_PORT=8000
+```
+
+## License
+
+MIT — see [LICENSE](LICENSE).
+
+---
+
+Built at University of Ottawa · ELG5901 · 2026

agentgate_pdp-0.2.0/README.md

@@ -0,0 +1,216 @@
+# AgentGate
+
+**A Policy Decision Point (PDP) for AI agents. Every action evaluated before it executes.**
+
+[![PyPI version](https://img.shields.io/pypi/v/agentgate.svg)](https://pypi.org/project/agentgate/)
+[![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](LICENSE)
+
+---
+
+AI agents make decisions autonomously. AgentGate makes sure those decisions are **authorized**.
+
+It sits between your agent and its tools. Before any action runs — reading a file, calling an API, writing to a database — AgentGate checks it against identity, scope, purpose, and behavioral context. The response is `PERMIT`, `ESCALATE`, or `DENY` in milliseconds.
+
+```
+Agent wants to delete /confidential/salary.xlsx
+                    ↓
+           AgentGate PDP
+    ┌──────────────────────────────┐
+    │  Identity check    ✓         │
+    │  Scope check       ✗ (!)     │
+    │  Purpose alignment ✗         │
+    │  Behavioral check  ✓         │
+    │                              │
+    │  Trust score: 18/100         │
+    │  Decision: DENY              │
+    └──────────────────────────────┘
+                    ↓
+         Action never executes
+```
+
+## Install
+
+```bash
+pip install agentgate
+```
+
+## Quickstart (3 lines)
+
+```python
+from agentgate import AgentGate
+
+gate = AgentGate("http://localhost:8000", api_key="your-key")
+gate.register("my_agent", "ReportBot", "Summarize quarterly reports",
+              authorized_resources=["/reports/*"], authorized_actions=["read"])
+
+result = gate.authorize("read", "/reports/q3.pdf")
+# {"decision": "PERMIT", "trust_breakdown": {...}, "explanation": "..."}
+```
+
+## LangChain — drop-in enforcement
+
+```bash
+pip install agentgate[langchain]
+```
+
+```python
+from agentgate.langchain import AgentGateToolkit
+
+toolkit = AgentGateToolkit(
+    agentgate_url="http://localhost:8000",
+    api_key="your-key",
+    agent_id="report_agent",
+    name="ReportBot",
+    declared_purpose="Summarize quarterly business reports",
+    authorized_resources=["/reports/*"],
+    authorized_actions=["read"],
+    processes_external_content=True,   # enables prompt injection scanning
+)
+
+safe_tools = toolkit.wrap([read_document, list_documents, send_email])
+agent = create_react_agent(llm, safe_tools)
+# Every tool call now goes through AgentGate before executing
+```
+
+## What gets caught
+
+| Threat | How AgentGate stops it |
+|--------|------------------------|
+| Agent reads `/confidential/salary.xlsx` (out of scope) | DENY — `RESOURCE_OUT_OF_SCOPE` |
+| Agent tries `delete` (not in authorized actions) | DENY — `UNAUTHORIZED_ACTION` |
+| Child agent exceeds parent's delegation scope | DENY — `CHAIN_SCOPE_VIOLATION` |
+| Agent makes 80 requests/min (velocity attack) | DENY — `CRITICAL_VELOCITY` |
+| Document contains "ignore previous instructions" | Content blocked before agent sees it |
+| Unknown agent attempts access | DENY — `UNREGISTERED_AGENT` |
+
+## Multi-agent delegation enforcement
+
+AgentGate validates the full delegation chain. A child agent cannot exceed its parent's scope — enforced at both registration and authorization time.
+
+```python
+# Orchestrator registers with full scope
+gate.register("orchestrator", "Orchestrator", "Manage document workflow",
+              authorized_resources=["/documents/*"], authorized_actions=["read", "write"])
+
+# Analyst is delegated a subset — enforced at registration
+resp = httpx.post(f"{url}/agents/delegate", json={
+    "parent_agent_id": "orchestrator",
+    "parent_token": orchestrator_token,
+    "child_agent_id": "analyst",
+    "child_resources": ["/documents/public/*"],   # subset of parent
+    "child_actions": ["read"],                    # subset of parent
+})
+
+# Analyst tries to access /confidential/ — blocked at authorization time
+# {"decision": "DENY", "attack_flags": ["CHAIN_SCOPE_VIOLATION"]}
+```
+
+## Natural language policies
+
+Write security rules in plain English. AgentGate converts them to enforced policies using Claude.
+
+```python
+import httpx
+
+# These become hard rules checked before any trust scoring
+httpx.post(f"{url}/policies", json={"rule": "Agents must never delete files"})
+httpx.post(f"{url}/policies", json={"rule": "No agent should read salary data outside business hours"})
+httpx.post(f"{url}/policies", json={"rule": "Flag any access to /hr folder"})
+```
+
+The policy engine runs **before** the trust score — a matching DENY policy is always a hard block regardless of score.
+
+## Human-in-the-loop approval
+
+Mark an agent as requiring human approval for escalated decisions:
+
+```python
+gate.register(..., requires_human_approval=True)
+
+result = gate.authorize("read", "/confidential/merger_details.pdf")
+if result["decision"] == "PENDING":
+    # Agent is paused — human approves or denies via dashboard
+    # Wrapper polls automatically; auto-denies after 90 seconds
+    request_id = result["request_id"]
+```
+
+## Prompt injection detection
+
+```python
+# Register as processing external content
+gate.register(..., processes_external_content=True)
+
+# Scan before passing content to the agent
+scan = gate.scan(document_content)
+if scan["level"] == "injection":
+    raise ValueError(f"Injection blocked: {scan['evidence']}")
+```
+
+## Context manager and decorator
+
+```python
+# Decorator
+@gate.guard("read", resource_arg="path")
+def read_document(path: str) -> str:
+    return open(path).read()
+
+# Context manager
+with gate.operation("write", "/reports/output.pdf"):
+    write_report(data)
+```
+
+## Run the server
+
+```bash
+# Docker (recommended)
+docker compose up
+
+# Or directly
+pip install agentgate[server]
+python -m agentgate.server
+```
+
+Dashboard at `http://localhost:8000` — live feed of every decision, trust scores, delegation tree, policy editor, and compliance report export.
+
+## Architecture
+
+```
+Your Agent
+    |
+AgentGate SDK (pip install agentgate)
+    |  POST /authorize
+    v
+AgentGate PDP Server
+    ├── Policy Engine     (NL rules → hard blocks, checked first)
+    ├── Trust Scoring     (identity + delegation + purpose + behavioral)
+    │     ├── Identity    (token, authorized actions, resource scope)
+    │     ├── Delegation  (chain depth, scope attenuation, trust decay)
+    │     ├── Purpose     (semantic alignment of request to declared purpose)
+    │     └── Behavioral  (per-agent baseline anomaly detection)
+    ├── HITL Approval     (ESCALATE → human decision → APPROVED/DENIED)
+    └── Audit Log         (every decision, exportable as PDF/CSV)
+    |
+PERMIT / ESCALATE / DENY / PENDING
+    |
+Tool executes (or doesn't)
+```
+
+## Configuration
+
+Environment variables (`.env`):
+
+```
+AGENTGATE_API_KEY=your-secret-key
+ANTHROPIC_API_KEY=sk-ant-...         # for NL policy parsing + purpose scoring
+AGENTGATE_ALERT_TOPIC=your-ntfy-topic  # for push alerts (ntfy.sh)
+AGENTGATE_PORT=8000
+```
+
+## License
+
+MIT — see [LICENSE](LICENSE).
+
+---
+
+Built at University of Ottawa · ELG5901 · 2026

agentgate_pdp-0.2.0/agentgate/__init__.py

@@ -0,0 +1,205 @@
+"""
+AgentGate SDK — drop-in trust authorization for AI agents.
+
+Quickstart:
+
+    from agentgate import AgentGate
+
+    gate = AgentGate("http://localhost:8000")
+    gate.register("my_agent", "MyBot", "Summarize PDF reports", ["/reports/*"], ["read"])
+
+    # Authorize before any action
+    result = gate.authorize("read", "/reports/q3.pdf")
+
+    # Decorator style
+    @gate.guard("read", resource_arg="path")
+    def read_document(path: str) -> str:
+        return open(path).read()
+
+    # Scan for prompt injection
+    scan = gate.scan(email_body)
+    if scan["level"] == "injection":
+        raise ValueError("Injection detected — content blocked")
+"""
+
+__version__ = "0.2.0"
+
+import uuid
+import httpx
+from functools import wraps
+
+from agentgate.exceptions import AgentGateDenied, AgentGateEscalated, AgentGateNotRegistered
+
+
+class AgentGate:
+    """
+    Client for the AgentGate Policy Decision Point.
+
+    Args:
+        url:               AgentGate server URL (e.g. "http://localhost:8000")
+        raise_on_deny:     If True (default), .authorize() raises AgentGateDenied on DENY
+        raise_on_escalate: If True, .authorize() raises AgentGateEscalated on ESCALATE
+        timeout:           HTTP request timeout in seconds (default 30)
+    """
+
+    def __init__(
+        self,
+        url: str,
+        api_key: str = "",
+        raise_on_deny: bool = True,
+        raise_on_escalate: bool = False,
+        timeout: float = 30.0,
+    ):
+        self.url = url.rstrip("/")
+        self._headers = {"X-API-Key": api_key} if api_key else {}
+        self.raise_on_deny = raise_on_deny
+        self.raise_on_escalate = raise_on_escalate
+        self.timeout = timeout
+        self._agent_id: str | None = None
+        self._token: str | None = None
+
+    # ── Registration ─────────────────────────────────────────────────────────
+
+    def register(
+        self,
+        agent_id: str,
+        name: str,
+        declared_purpose: str,
+        authorized_resources: list[str],
+        authorized_actions: list[str],
+        delegation_depth: int = 0,
+        delegated_by: str | None = None,
+        scope_at_delegation: list[str] | None = None,
+        processes_external_content: bool = False,
+    ) -> "AgentGate":
+        """Register this agent with AgentGate. Returns self for chaining."""
+        payload: dict = {
+            "agent_id": agent_id,
+            "name": name,
+            "declared_purpose": declared_purpose,
+            "authorized_resources": authorized_resources,
+            "authorized_actions": authorized_actions,
+            "delegation_depth": delegation_depth,
+            "processes_external_content": processes_external_content,
+        }
+        if delegated_by:
+            payload["delegated_by"] = delegated_by
+        if scope_at_delegation:
+            payload["scope_at_delegation"] = scope_at_delegation
+
+        r = httpx.post(f"{self.url}/agents/register", json=payload, headers=self._headers, timeout=self.timeout)
+        r.raise_for_status()
+        self._agent_id = agent_id
+        self._token = r.json()["token"]
+        return self
+
+    # ── Authorization ─────────────────────────────────────────────────────────
+
+    def authorize(self, action: str, resource: str, justification: str = "") -> dict:
+        """Request authorization before performing an action.
+
+        Returns dict with decision, trust_breakdown, explanation, attack_flags.
+        Raises AgentGateDenied on DENY (if raise_on_deny=True).
+        """
+        if not self._agent_id or not self._token:
+            raise AgentGateNotRegistered("Call gate.register(...) before gate.authorize()")
+
+        r = httpx.post(
+            f"{self.url}/authorize",
+            headers=self._headers,
+            json={
+                "agent_id": self._agent_id,
+                "token": self._token,
+                "action": action,
+                "resource": resource,
+                "justification": justification,
+                "request_id": str(uuid.uuid4()),
+            },
+            timeout=self.timeout,
+        )
+        r.raise_for_status()
+        result = r.json()
+        decision = result["decision"]
+
+        if decision == "DENY" and self.raise_on_deny:
+            raise AgentGateDenied(action, resource, result.get("explanation", ""))
+        if decision == "ESCALATE" and self.raise_on_escalate:
+            raise AgentGateEscalated(action, resource, result.get("explanation", ""))
+
+        return result
+
+    # ── Content scan ──────────────────────────────────────────────────────────
+
+    def scan(self, content: str) -> dict:
+        """Scan document/email content for prompt injection before processing.
+
+        Returns dict with level ("clean"/"suspicious"/"injection"), confidence, evidence.
+        """
+        if not self._agent_id:
+            raise AgentGateNotRegistered("Call gate.register(...) before gate.scan()")
+
+        r = httpx.post(
+            f"{self.url}/scan",
+            headers=self._headers,
+            json={"agent_id": self._agent_id, "content": content},
+            timeout=self.timeout,
+        )
+        r.raise_for_status()
+        return r.json()
+
+    # ── Helpers ───────────────────────────────────────────────────────────────
+
+    def check(self, action: str, resource: str, justification: str = "") -> bool:
+        """Non-raising boolean check. Returns False on DENY, True otherwise."""
+        try:
+            result = self.authorize(action, resource, justification)
+            return result["decision"] != "DENY"
+        except AgentGateDenied:
+            return False
+
+    def guard(self, action: str, resource_arg: str = "resource"):
+        """Decorator — authorizes before the wrapped function runs.
+
+        @gate.guard("read", resource_arg="path")
+        def read_file(path: str) -> str:
+            return open(path).read()
+        """
+        def decorator(func):
+            @wraps(func)
+            def wrapper(*args, **kwargs):
+                resource = kwargs.get(resource_arg) or (args[0] if args else "unknown")
+                self.authorize(action, str(resource), f"Calling {func.__name__}")
+                return func(*args, **kwargs)
+            return wrapper
+        return decorator
+
+    def operation(self, action: str, resource: str, justification: str = ""):
+        """Context manager — authorizes on enter.
+
+        with gate.operation("delete", "/confidential/salary.xlsx"):
+            delete_file(...)
+        """
+        return _AuthorizedOperation(self, action, resource, justification)
+
+    @property
+    def agent_id(self) -> str | None:
+        return self._agent_id
+
+    @property
+    def token(self) -> str | None:
+        return self._token
+
+
+class _AuthorizedOperation:
+    def __init__(self, gate: AgentGate, action: str, resource: str, justification: str):
+        self._gate = gate
+        self._action = action
+        self._resource = resource
+        self._justification = justification
+
+    def __enter__(self):
+        self._gate.authorize(self._action, self._resource, self._justification)
+        return self
+
+    def __exit__(self, *_):
+        pass

agentgate_pdp-0.2.0/agentgate/exceptions.py

@@ -0,0 +1,21 @@
+class AgentGateDenied(Exception):
+    """Raised when AgentGate returns a hard DENY decision."""
+    def __init__(self, action: str, resource: str, explanation: str = ""):
+        self.action = action
+        self.resource = resource
+        self.explanation = explanation
+        super().__init__(f"AgentGate DENIED {action} on {resource}: {explanation}")
+
+
+class AgentGateEscalated(Exception):
+    """Raised when AgentGate returns ESCALATE and strict mode is on."""
+    def __init__(self, action: str, resource: str, explanation: str = ""):
+        self.action = action
+        self.resource = resource
+        self.explanation = explanation
+        super().__init__(f"AgentGate ESCALATED {action} on {resource}: {explanation}")
+
+
+class AgentGateNotRegistered(Exception):
+    """Raised when .authorize() is called before .register()."""
+    pass

agentgate_pdp-0.2.0/agentgate_pdp.egg-info/PKG-INFO

@@ -0,0 +1,244 @@
+Metadata-Version: 2.4
+Name: agentgate-pdp
+Version: 0.2.0
+Summary: Context-aware trust authorization for agentic AI systems
+Author-email: AgentGate <olame109@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/agentgate/agentgate
+Project-URL: Documentation, https://agentgate.dev/docs
+Keywords: ai,agents,security,authorization,llm,langchain,policy,trust,pdp,agentic
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Security
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.27.0
+Provides-Extra: langchain
+Requires-Dist: langchain-core>=0.3.0; extra == "langchain"
+Requires-Dist: langchain-anthropic>=0.2.0; extra == "langchain"
+Requires-Dist: langgraph>=0.2.0; extra == "langchain"
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.23; extra == "dev"
+
+# AgentGate
+
+**A Policy Decision Point (PDP) for AI agents. Every action evaluated before it executes.**
+
+[![PyPI version](https://img.shields.io/pypi/v/agentgate.svg)](https://pypi.org/project/agentgate/)
+[![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](LICENSE)
+
+---
+
+AI agents make decisions autonomously. AgentGate makes sure those decisions are **authorized**.
+
+It sits between your agent and its tools. Before any action runs — reading a file, calling an API, writing to a database — AgentGate checks it against identity, scope, purpose, and behavioral context. The response is `PERMIT`, `ESCALATE`, or `DENY` in milliseconds.
+
+```
+Agent wants to delete /confidential/salary.xlsx
+                    ↓
+           AgentGate PDP
+    ┌──────────────────────────────┐
+    │  Identity check    ✓         │
+    │  Scope check       ✗ (!)     │
+    │  Purpose alignment ✗         │
+    │  Behavioral check  ✓         │
+    │                              │
+    │  Trust score: 18/100         │
+    │  Decision: DENY              │
+    └──────────────────────────────┘
+                    ↓
+         Action never executes
+```
+
+## Install
+
+```bash
+pip install agentgate
+```
+
+## Quickstart (3 lines)
+
+```python
+from agentgate import AgentGate
+
+gate = AgentGate("http://localhost:8000", api_key="your-key")
+gate.register("my_agent", "ReportBot", "Summarize quarterly reports",
+              authorized_resources=["/reports/*"], authorized_actions=["read"])
+
+result = gate.authorize("read", "/reports/q3.pdf")
+# {"decision": "PERMIT", "trust_breakdown": {...}, "explanation": "..."}
+```
+
+## LangChain — drop-in enforcement
+
+```bash
+pip install agentgate[langchain]
+```
+
+```python
+from agentgate.langchain import AgentGateToolkit
+
+toolkit = AgentGateToolkit(
+    agentgate_url="http://localhost:8000",
+    api_key="your-key",
+    agent_id="report_agent",
+    name="ReportBot",
+    declared_purpose="Summarize quarterly business reports",
+    authorized_resources=["/reports/*"],
+    authorized_actions=["read"],
+    processes_external_content=True,   # enables prompt injection scanning
+)
+
+safe_tools = toolkit.wrap([read_document, list_documents, send_email])
+agent = create_react_agent(llm, safe_tools)
+# Every tool call now goes through AgentGate before executing
+```
+
+## What gets caught
+
+| Threat | How AgentGate stops it |
+|--------|------------------------|
+| Agent reads `/confidential/salary.xlsx` (out of scope) | DENY — `RESOURCE_OUT_OF_SCOPE` |
+| Agent tries `delete` (not in authorized actions) | DENY — `UNAUTHORIZED_ACTION` |
+| Child agent exceeds parent's delegation scope | DENY — `CHAIN_SCOPE_VIOLATION` |
+| Agent makes 80 requests/min (velocity attack) | DENY — `CRITICAL_VELOCITY` |
+| Document contains "ignore previous instructions" | Content blocked before agent sees it |
+| Unknown agent attempts access | DENY — `UNREGISTERED_AGENT` |
+
+## Multi-agent delegation enforcement
+
+AgentGate validates the full delegation chain. A child agent cannot exceed its parent's scope — enforced at both registration and authorization time.
+
+```python
+# Orchestrator registers with full scope
+gate.register("orchestrator", "Orchestrator", "Manage document workflow",
+              authorized_resources=["/documents/*"], authorized_actions=["read", "write"])
+
+# Analyst is delegated a subset — enforced at registration
+resp = httpx.post(f"{url}/agents/delegate", json={
+    "parent_agent_id": "orchestrator",
+    "parent_token": orchestrator_token,
+    "child_agent_id": "analyst",
+    "child_resources": ["/documents/public/*"],   # subset of parent
+    "child_actions": ["read"],                    # subset of parent
+})
+
+# Analyst tries to access /confidential/ — blocked at authorization time
+# {"decision": "DENY", "attack_flags": ["CHAIN_SCOPE_VIOLATION"]}
+```
+
+## Natural language policies
+
+Write security rules in plain English. AgentGate converts them to enforced policies using Claude.
+
+```python
+import httpx
+
+# These become hard rules checked before any trust scoring
+httpx.post(f"{url}/policies", json={"rule": "Agents must never delete files"})
+httpx.post(f"{url}/policies", json={"rule": "No agent should read salary data outside business hours"})
+httpx.post(f"{url}/policies", json={"rule": "Flag any access to /hr folder"})
+```
+
+The policy engine runs **before** the trust score — a matching DENY policy is always a hard block regardless of score.
+
+## Human-in-the-loop approval
+
+Mark an agent as requiring human approval for escalated decisions:
+
+```python
+gate.register(..., requires_human_approval=True)
+
+result = gate.authorize("read", "/confidential/merger_details.pdf")
+if result["decision"] == "PENDING":
+    # Agent is paused — human approves or denies via dashboard
+    # Wrapper polls automatically; auto-denies after 90 seconds
+    request_id = result["request_id"]
+```
+
+## Prompt injection detection
+
+```python
+# Register as processing external content
+gate.register(..., processes_external_content=True)
+
+# Scan before passing content to the agent
+scan = gate.scan(document_content)
+if scan["level"] == "injection":
+    raise ValueError(f"Injection blocked: {scan['evidence']}")
+```
+
+## Context manager and decorator
+
+```python
+# Decorator
+@gate.guard("read", resource_arg="path")
+def read_document(path: str) -> str:
+    return open(path).read()
+
+# Context manager
+with gate.operation("write", "/reports/output.pdf"):
+    write_report(data)
+```
+
+## Run the server
+
+```bash
+# Docker (recommended)
+docker compose up
+
+# Or directly
+pip install agentgate[server]
+python -m agentgate.server
+```
+
+Dashboard at `http://localhost:8000` — live feed of every decision, trust scores, delegation tree, policy editor, and compliance report export.
+
+## Architecture
+
+```
+Your Agent
+    |
+AgentGate SDK (pip install agentgate)
+    |  POST /authorize
+    v
+AgentGate PDP Server
+    ├── Policy Engine     (NL rules → hard blocks, checked first)
+    ├── Trust Scoring     (identity + delegation + purpose + behavioral)
+    │     ├── Identity    (token, authorized actions, resource scope)
+    │     ├── Delegation  (chain depth, scope attenuation, trust decay)
+    │     ├── Purpose     (semantic alignment of request to declared purpose)
+    │     └── Behavioral  (per-agent baseline anomaly detection)
+    ├── HITL Approval     (ESCALATE → human decision → APPROVED/DENIED)
+    └── Audit Log         (every decision, exportable as PDF/CSV)
+    |
+PERMIT / ESCALATE / DENY / PENDING
+    |
+Tool executes (or doesn't)
+```
+
+## Configuration
+
+Environment variables (`.env`):
+
+```
+AGENTGATE_API_KEY=your-secret-key
+ANTHROPIC_API_KEY=sk-ant-...         # for NL policy parsing + purpose scoring
+AGENTGATE_ALERT_TOPIC=your-ntfy-topic  # for push alerts (ntfy.sh)
+AGENTGATE_PORT=8000
+```
+
+## License
+
+MIT — see [LICENSE](LICENSE).
+
+---
+
+Built at University of Ottawa · ELG5901 · 2026

agentgate_pdp-0.2.0/agentgate_pdp.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+README.md
+pyproject.toml
+agentgate/__init__.py
+agentgate/exceptions.py
+agentgate_pdp.egg-info/PKG-INFO
+agentgate_pdp.egg-info/SOURCES.txt
+agentgate_pdp.egg-info/dependency_links.txt
+agentgate_pdp.egg-info/requires.txt
+agentgate_pdp.egg-info/top_level.txt

agentgate_pdp-0.2.0/agentgate_pdp.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

agentgate_pdp-0.2.0/agentgate_pdp.egg-info/requires.txt

@@ -0,0 +1,10 @@
+httpx>=0.27.0
+
+[dev]
+pytest>=8.0
+pytest-asyncio>=0.23
+
+[langchain]
+langchain-core>=0.3.0
+langchain-anthropic>=0.2.0
+langgraph>=0.2.0

agentgate_pdp-0.2.0/agentgate_pdp.egg-info/top_level.txt

@@ -0,0 +1 @@
+agentgate

agentgate_pdp-0.2.0/pyproject.toml

@@ -0,0 +1,47 @@
+[build-system]
+requires = ["setuptools>=42", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "agentgate-pdp"
+version = "0.2.0"
+description = "Context-aware trust authorization for agentic AI systems"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.10"
+authors = [
+    { name = "AgentGate", email = "olame109@gmail.com" }
+]
+keywords = ["ai", "agents", "security", "authorization", "llm", "langchain", "policy", "trust", "pdp", "agentic"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Topic :: Security",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+]
+dependencies = [
+    "httpx>=0.27.0",
+]
+
+[project.optional-dependencies]
+langchain = [
+    "langchain-core>=0.3.0",
+    "langchain-anthropic>=0.2.0",
+    "langgraph>=0.2.0",
+]
+dev = [
+    "pytest>=8.0",
+    "pytest-asyncio>=0.23",
+]
+
+[project.urls]
+Homepage = "https://github.com/agentgate/agentgate"
+Documentation = "https://agentgate.dev/docs"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["agentgate*"]

agentgate_pdp-0.2.0/setup.cfg

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