agentguard-tech 0.1.0__tar.gz

agentguard_tech-0.1.0/LICENSE

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

agentguard_tech-0.1.0/PKG-INFO

@@ -0,0 +1,245 @@
+Metadata-Version: 2.4
+Name: agentguard-tech
+Version: 0.1.0
+Summary: Runtime security for AI agents — policy engine, audit trail, and kill switch
+Author-email: AgentGuard <hello@agentguard.tech>
+License: MIT
+Project-URL: Homepage, https://agentguard.tech
+Project-URL: Documentation, https://agentguard.tech
+Project-URL: Repository, https://github.com/koshaji/agentguard
+Project-URL: Demo, https://demo.agentguard.tech
+Keywords: ai,agents,security,governance,policy,langchain,openai
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Security
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# agentguard
+
+**Runtime security for AI agents** — policy engine, audit trail, and kill switch.
+
+[![PyPI version](https://img.shields.io/pypi/v/agentguard)](https://pypi.org/project/agentguard/)
+[![Python versions](https://img.shields.io/pypi/pyversions/agentguard)](https://pypi.org/project/agentguard/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+
+## Overview
+
+AgentGuard gives AI agents production-grade guardrails:
+
+- 🛡️ **Policy evaluation** — check every tool call before execution
+- 📋 **Audit trail** — tamper-evident hash chain of every action
+- 🔴 **Kill switch** — instantly halt all agents
+- 🔍 **Audit verification** — cryptographically verify the audit chain
+- ⚡ **Zero dependencies** — pure Python stdlib, works anywhere
+
+---
+
+## Installation
+
+```bash
+pip install agentguard
+```
+
+Requires Python 3.8+. No external dependencies.
+
+---
+
+## Quick Start
+
+```python
+from agentguard import AgentGuard
+
+guard = AgentGuard(api_key="ag_your_api_key")
+
+# Evaluate an agent action before executing it
+decision = guard.evaluate(
+    tool="send_email",
+    params={"to": "user@example.com", "subject": "Hello"}
+)
+
+if decision["result"] == "allow":
+    print("Action allowed, risk score:", decision["riskScore"])
+    # proceed with tool execution
+elif decision["result"] == "block":
+    print("Action blocked:", decision["reason"])
+elif decision["result"] == "require_approval":
+    print("Waiting for human approval...")
+elif decision["result"] == "monitor":
+    print("Action monitored (allowed but logged):", decision["reason"])
+```
+
+---
+
+## API Reference
+
+### `AgentGuard(api_key, base_url=...)`
+
+Create a client instance.
+
+```python
+guard = AgentGuard(
+    api_key="ag_your_api_key",
+    base_url="https://api.agentguard.tech"  # optional, default shown
+)
+```
+
+---
+
+### `evaluate(tool, params=None) → dict`
+
+Evaluate a tool call against your policy. Call this **before** every tool execution.
+
+```python
+decision = guard.evaluate("read_file", {"path": "/data/report.csv"})
+# Returns:
+# {
+#   "result": "allow",          # allow | block | monitor | require_approval
+#   "riskScore": 5,             # 0-1000
+#   "reason": "Matched allow-read rule",
+#   "durationMs": 1.2,
+#   "matchedRuleId": "allow-read"  # optional
+# }
+```
+
+**Integration pattern:**
+
+```python
+def safe_tool_call(tool_name, tool_func, **params):
+    decision = guard.evaluate(tool_name, params)
+    if decision["result"] in ("allow", "monitor"):
+        return tool_func(**params)
+    elif decision["result"] == "block":
+        raise PermissionError(f"Blocked by policy: {decision['reason']}")
+    elif decision["result"] == "require_approval":
+        raise PermissionError("Awaiting human approval")
+```
+
+---
+
+### `get_usage() → dict`
+
+Get usage statistics for your tenant.
+
+```python
+usage = guard.get_usage()
+print(usage)
+# {
+#   "requestsToday": 142,
+#   "requestsThisMonth": 3891,
+#   "plan": "pro",
+#   "limits": { "requestsPerDay": 10000 }
+# }
+```
+
+---
+
+### `get_audit(limit=50, offset=0) → dict`
+
+Get audit trail events with pagination.
+
+```python
+audit = guard.get_audit(limit=100, offset=0)
+for event in audit["events"]:
+    print(f"{event['timestamp']} | {event['tool']} | {event['decision']}")
+```
+
+---
+
+### `kill_switch(active) → dict`
+
+Activate or deactivate the global kill switch.
+
+```python
+# Emergency halt — stop all agents immediately
+guard.kill_switch(True)
+
+# Resume operations
+guard.kill_switch(False)
+```
+
+---
+
+### `verify_audit() → dict`
+
+Verify the cryptographic integrity of the audit hash chain.
+
+```python
+result = guard.verify_audit()
+if result["valid"]:
+    print("Audit chain is intact")
+else:
+    print(f"Chain broken at event index: {result['invalidAt']}")
+```
+
+---
+
+## Complete Example — LangChain-style Agent
+
+```python
+from agentguard import AgentGuard
+
+guard = AgentGuard(api_key="ag_your_api_key")
+
+def run_tool(name: str, func, **params):
+    """Execute a tool with AgentGuard policy enforcement."""
+    decision = guard.evaluate(name, params)
+    
+    result = decision["result"]
+    if result == "block":
+        raise PermissionError(f"Policy blocked {name}: {decision['reason']}")
+    if result == "require_approval":
+        raise PermissionError(f"Human approval required for {name}")
+    
+    # "allow" or "monitor" — proceed
+    return func(**params)
+
+
+# Your tools
+def send_email(to: str, subject: str, body: str) -> str:
+    # ... send the email
+    return f"Email sent to {to}"
+
+def read_file(path: str) -> str:
+    with open(path) as f:
+        return f.read()
+
+
+# Use with policy enforcement
+content = run_tool("read_file", read_file, path="/data/report.csv")
+run_tool("send_email", send_email, to="boss@company.com", subject="Report", body=content)
+```
+
+---
+
+## Error Handling
+
+```python
+from agentguard import AgentGuard
+
+guard = AgentGuard(api_key="ag_your_key")
+
+try:
+    decision = guard.evaluate("dangerous_tool", {"target": "production_db"})
+except RuntimeError as e:
+    print(f"API error: {e}")
+    # RuntimeError: AgentGuard API error: 401 Unauthorized
+```
+
+---
+
+## Links
+
+- 🌐 [agentguard.tech](https://agentguard.tech)
+- 🎮 [Live Demo](https://demo.agentguard.tech)
+- 📦 [GitHub](https://github.com/koshaji/agentguard)
+- 📘 [npm SDK](https://www.npmjs.com/package/@agentguard/sdk)
+
+## License
+
+MIT

agentguard_tech-0.1.0/README.md

@@ -0,0 +1,223 @@
+# agentguard
+
+**Runtime security for AI agents** — policy engine, audit trail, and kill switch.
+
+[![PyPI version](https://img.shields.io/pypi/v/agentguard)](https://pypi.org/project/agentguard/)
+[![Python versions](https://img.shields.io/pypi/pyversions/agentguard)](https://pypi.org/project/agentguard/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+
+## Overview
+
+AgentGuard gives AI agents production-grade guardrails:
+
+- 🛡️ **Policy evaluation** — check every tool call before execution
+- 📋 **Audit trail** — tamper-evident hash chain of every action
+- 🔴 **Kill switch** — instantly halt all agents
+- 🔍 **Audit verification** — cryptographically verify the audit chain
+- ⚡ **Zero dependencies** — pure Python stdlib, works anywhere
+
+---
+
+## Installation
+
+```bash
+pip install agentguard
+```
+
+Requires Python 3.8+. No external dependencies.
+
+---
+
+## Quick Start
+
+```python
+from agentguard import AgentGuard
+
+guard = AgentGuard(api_key="ag_your_api_key")
+
+# Evaluate an agent action before executing it
+decision = guard.evaluate(
+    tool="send_email",
+    params={"to": "user@example.com", "subject": "Hello"}
+)
+
+if decision["result"] == "allow":
+    print("Action allowed, risk score:", decision["riskScore"])
+    # proceed with tool execution
+elif decision["result"] == "block":
+    print("Action blocked:", decision["reason"])
+elif decision["result"] == "require_approval":
+    print("Waiting for human approval...")
+elif decision["result"] == "monitor":
+    print("Action monitored (allowed but logged):", decision["reason"])
+```
+
+---
+
+## API Reference
+
+### `AgentGuard(api_key, base_url=...)`
+
+Create a client instance.
+
+```python
+guard = AgentGuard(
+    api_key="ag_your_api_key",
+    base_url="https://api.agentguard.tech"  # optional, default shown
+)
+```
+
+---
+
+### `evaluate(tool, params=None) → dict`
+
+Evaluate a tool call against your policy. Call this **before** every tool execution.
+
+```python
+decision = guard.evaluate("read_file", {"path": "/data/report.csv"})
+# Returns:
+# {
+#   "result": "allow",          # allow | block | monitor | require_approval
+#   "riskScore": 5,             # 0-1000
+#   "reason": "Matched allow-read rule",
+#   "durationMs": 1.2,
+#   "matchedRuleId": "allow-read"  # optional
+# }
+```
+
+**Integration pattern:**
+
+```python
+def safe_tool_call(tool_name, tool_func, **params):
+    decision = guard.evaluate(tool_name, params)
+    if decision["result"] in ("allow", "monitor"):
+        return tool_func(**params)
+    elif decision["result"] == "block":
+        raise PermissionError(f"Blocked by policy: {decision['reason']}")
+    elif decision["result"] == "require_approval":
+        raise PermissionError("Awaiting human approval")
+```
+
+---
+
+### `get_usage() → dict`
+
+Get usage statistics for your tenant.
+
+```python
+usage = guard.get_usage()
+print(usage)
+# {
+#   "requestsToday": 142,
+#   "requestsThisMonth": 3891,
+#   "plan": "pro",
+#   "limits": { "requestsPerDay": 10000 }
+# }
+```
+
+---
+
+### `get_audit(limit=50, offset=0) → dict`
+
+Get audit trail events with pagination.
+
+```python
+audit = guard.get_audit(limit=100, offset=0)
+for event in audit["events"]:
+    print(f"{event['timestamp']} | {event['tool']} | {event['decision']}")
+```
+
+---
+
+### `kill_switch(active) → dict`
+
+Activate or deactivate the global kill switch.
+
+```python
+# Emergency halt — stop all agents immediately
+guard.kill_switch(True)
+
+# Resume operations
+guard.kill_switch(False)
+```
+
+---
+
+### `verify_audit() → dict`
+
+Verify the cryptographic integrity of the audit hash chain.
+
+```python
+result = guard.verify_audit()
+if result["valid"]:
+    print("Audit chain is intact")
+else:
+    print(f"Chain broken at event index: {result['invalidAt']}")
+```
+
+---
+
+## Complete Example — LangChain-style Agent
+
+```python
+from agentguard import AgentGuard
+
+guard = AgentGuard(api_key="ag_your_api_key")
+
+def run_tool(name: str, func, **params):
+    """Execute a tool with AgentGuard policy enforcement."""
+    decision = guard.evaluate(name, params)
+    
+    result = decision["result"]
+    if result == "block":
+        raise PermissionError(f"Policy blocked {name}: {decision['reason']}")
+    if result == "require_approval":
+        raise PermissionError(f"Human approval required for {name}")
+    
+    # "allow" or "monitor" — proceed
+    return func(**params)
+
+
+# Your tools
+def send_email(to: str, subject: str, body: str) -> str:
+    # ... send the email
+    return f"Email sent to {to}"
+
+def read_file(path: str) -> str:
+    with open(path) as f:
+        return f.read()
+
+
+# Use with policy enforcement
+content = run_tool("read_file", read_file, path="/data/report.csv")
+run_tool("send_email", send_email, to="boss@company.com", subject="Report", body=content)
+```
+
+---
+
+## Error Handling
+
+```python
+from agentguard import AgentGuard
+
+guard = AgentGuard(api_key="ag_your_key")
+
+try:
+    decision = guard.evaluate("dangerous_tool", {"target": "production_db"})
+except RuntimeError as e:
+    print(f"API error: {e}")
+    # RuntimeError: AgentGuard API error: 401 Unauthorized
+```
+
+---
+
+## Links
+
+- 🌐 [agentguard.tech](https://agentguard.tech)
+- 🎮 [Live Demo](https://demo.agentguard.tech)
+- 📦 [GitHub](https://github.com/koshaji/agentguard)
+- 📘 [npm SDK](https://www.npmjs.com/package/@agentguard/sdk)
+
+## License
+
+MIT

agentguard_tech-0.1.0/agentguard/__init__.py

@@ -0,0 +1,5 @@
+"""AgentGuard — Runtime security for AI agents."""
+from .client import AgentGuard
+
+__version__ = "0.1.0"
+__all__ = ["AgentGuard"]

agentguard_tech-0.1.0/agentguard/client.py

@@ -0,0 +1,79 @@
+"""AgentGuard Python SDK — Runtime security for AI agents."""
+import json
+from typing import Any, Optional
+from urllib.request import Request, urlopen
+from urllib.error import HTTPError
+
+
+class AgentGuard:
+    """Client for the AgentGuard API."""
+
+    def __init__(self, api_key: str, base_url: str = "https://api.agentguard.tech"):
+        self.api_key = api_key
+        self.base_url = base_url.rstrip("/")
+
+    def _request(self, method: str, path: str, body: Optional[dict] = None) -> dict:
+        url = f"{self.base_url}{path}"
+        headers = {
+            "X-API-Key": self.api_key,
+            "Content-Type": "application/json",
+        }
+        data = json.dumps(body).encode() if body else None
+        req = Request(url, data=data, headers=headers, method=method)
+        try:
+            with urlopen(req) as resp:
+                return json.loads(resp.read().decode())
+        except HTTPError as e:
+            raise RuntimeError(f"AgentGuard API error: {e.code} {e.read().decode()}") from e
+
+    def evaluate(self, tool: str, params: Optional[dict] = None) -> dict:
+        """Evaluate an agent action against the policy engine.
+
+        Args:
+            tool: Name of the tool being called (e.g. "send_email", "read_file")
+            params: Optional dict of parameters passed to the tool
+
+        Returns:
+            dict with keys: result, riskScore, reason, durationMs, matchedRuleId (optional)
+            result is one of: "allow", "block", "monitor", "require_approval"
+        """
+        return self._request("POST", "/api/v1/evaluate", {"tool": tool, "params": params or {}})
+
+    def get_usage(self) -> dict:
+        """Get usage statistics for your tenant.
+
+        Returns:
+            dict with usage data including request counts and limits
+        """
+        return self._request("GET", "/api/v1/usage")
+
+    def get_audit(self, limit: int = 50, offset: int = 0) -> dict:
+        """Get audit trail events.
+
+        Args:
+            limit: Maximum number of events to return (default 50)
+            offset: Pagination offset (default 0)
+
+        Returns:
+            dict with 'events' list and pagination metadata
+        """
+        return self._request("GET", f"/api/v1/audit?limit={limit}&offset={offset}")
+
+    def kill_switch(self, active: bool) -> dict:
+        """Activate or deactivate the kill switch.
+
+        Args:
+            active: True to halt all agents, False to resume operations
+
+        Returns:
+            dict with confirmation of the kill switch state
+        """
+        return self._request("POST", "/api/v1/killswitch", {"active": active})
+
+    def verify_audit(self) -> dict:
+        """Verify audit trail hash chain integrity.
+
+        Returns:
+            dict with 'valid' boolean and optional 'invalidAt' index
+        """
+        return self._request("GET", "/api/v1/audit/verify")

agentguard_tech-0.1.0/agentguard_tech.egg-info/PKG-INFO

@@ -0,0 +1,245 @@
+Metadata-Version: 2.4
+Name: agentguard-tech
+Version: 0.1.0
+Summary: Runtime security for AI agents — policy engine, audit trail, and kill switch
+Author-email: AgentGuard <hello@agentguard.tech>
+License: MIT
+Project-URL: Homepage, https://agentguard.tech
+Project-URL: Documentation, https://agentguard.tech
+Project-URL: Repository, https://github.com/koshaji/agentguard
+Project-URL: Demo, https://demo.agentguard.tech
+Keywords: ai,agents,security,governance,policy,langchain,openai
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Security
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# agentguard
+
+**Runtime security for AI agents** — policy engine, audit trail, and kill switch.
+
+[![PyPI version](https://img.shields.io/pypi/v/agentguard)](https://pypi.org/project/agentguard/)
+[![Python versions](https://img.shields.io/pypi/pyversions/agentguard)](https://pypi.org/project/agentguard/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+
+## Overview
+
+AgentGuard gives AI agents production-grade guardrails:
+
+- 🛡️ **Policy evaluation** — check every tool call before execution
+- 📋 **Audit trail** — tamper-evident hash chain of every action
+- 🔴 **Kill switch** — instantly halt all agents
+- 🔍 **Audit verification** — cryptographically verify the audit chain
+- ⚡ **Zero dependencies** — pure Python stdlib, works anywhere
+
+---
+
+## Installation
+
+```bash
+pip install agentguard
+```
+
+Requires Python 3.8+. No external dependencies.
+
+---
+
+## Quick Start
+
+```python
+from agentguard import AgentGuard
+
+guard = AgentGuard(api_key="ag_your_api_key")
+
+# Evaluate an agent action before executing it
+decision = guard.evaluate(
+    tool="send_email",
+    params={"to": "user@example.com", "subject": "Hello"}
+)
+
+if decision["result"] == "allow":
+    print("Action allowed, risk score:", decision["riskScore"])
+    # proceed with tool execution
+elif decision["result"] == "block":
+    print("Action blocked:", decision["reason"])
+elif decision["result"] == "require_approval":
+    print("Waiting for human approval...")
+elif decision["result"] == "monitor":
+    print("Action monitored (allowed but logged):", decision["reason"])
+```
+
+---
+
+## API Reference
+
+### `AgentGuard(api_key, base_url=...)`
+
+Create a client instance.
+
+```python
+guard = AgentGuard(
+    api_key="ag_your_api_key",
+    base_url="https://api.agentguard.tech"  # optional, default shown
+)
+```
+
+---
+
+### `evaluate(tool, params=None) → dict`
+
+Evaluate a tool call against your policy. Call this **before** every tool execution.
+
+```python
+decision = guard.evaluate("read_file", {"path": "/data/report.csv"})
+# Returns:
+# {
+#   "result": "allow",          # allow | block | monitor | require_approval
+#   "riskScore": 5,             # 0-1000
+#   "reason": "Matched allow-read rule",
+#   "durationMs": 1.2,
+#   "matchedRuleId": "allow-read"  # optional
+# }
+```
+
+**Integration pattern:**
+
+```python
+def safe_tool_call(tool_name, tool_func, **params):
+    decision = guard.evaluate(tool_name, params)
+    if decision["result"] in ("allow", "monitor"):
+        return tool_func(**params)
+    elif decision["result"] == "block":
+        raise PermissionError(f"Blocked by policy: {decision['reason']}")
+    elif decision["result"] == "require_approval":
+        raise PermissionError("Awaiting human approval")
+```
+
+---
+
+### `get_usage() → dict`
+
+Get usage statistics for your tenant.
+
+```python
+usage = guard.get_usage()
+print(usage)
+# {
+#   "requestsToday": 142,
+#   "requestsThisMonth": 3891,
+#   "plan": "pro",
+#   "limits": { "requestsPerDay": 10000 }
+# }
+```
+
+---
+
+### `get_audit(limit=50, offset=0) → dict`
+
+Get audit trail events with pagination.
+
+```python
+audit = guard.get_audit(limit=100, offset=0)
+for event in audit["events"]:
+    print(f"{event['timestamp']} | {event['tool']} | {event['decision']}")
+```
+
+---
+
+### `kill_switch(active) → dict`
+
+Activate or deactivate the global kill switch.
+
+```python
+# Emergency halt — stop all agents immediately
+guard.kill_switch(True)
+
+# Resume operations
+guard.kill_switch(False)
+```
+
+---
+
+### `verify_audit() → dict`
+
+Verify the cryptographic integrity of the audit hash chain.
+
+```python
+result = guard.verify_audit()
+if result["valid"]:
+    print("Audit chain is intact")
+else:
+    print(f"Chain broken at event index: {result['invalidAt']}")
+```
+
+---
+
+## Complete Example — LangChain-style Agent
+
+```python
+from agentguard import AgentGuard
+
+guard = AgentGuard(api_key="ag_your_api_key")
+
+def run_tool(name: str, func, **params):
+    """Execute a tool with AgentGuard policy enforcement."""
+    decision = guard.evaluate(name, params)
+    
+    result = decision["result"]
+    if result == "block":
+        raise PermissionError(f"Policy blocked {name}: {decision['reason']}")
+    if result == "require_approval":
+        raise PermissionError(f"Human approval required for {name}")
+    
+    # "allow" or "monitor" — proceed
+    return func(**params)
+
+
+# Your tools
+def send_email(to: str, subject: str, body: str) -> str:
+    # ... send the email
+    return f"Email sent to {to}"
+
+def read_file(path: str) -> str:
+    with open(path) as f:
+        return f.read()
+
+
+# Use with policy enforcement
+content = run_tool("read_file", read_file, path="/data/report.csv")
+run_tool("send_email", send_email, to="boss@company.com", subject="Report", body=content)
+```
+
+---
+
+## Error Handling
+
+```python
+from agentguard import AgentGuard
+
+guard = AgentGuard(api_key="ag_your_key")
+
+try:
+    decision = guard.evaluate("dangerous_tool", {"target": "production_db"})
+except RuntimeError as e:
+    print(f"API error: {e}")
+    # RuntimeError: AgentGuard API error: 401 Unauthorized
+```
+
+---
+
+## Links
+
+- 🌐 [agentguard.tech](https://agentguard.tech)
+- 🎮 [Live Demo](https://demo.agentguard.tech)
+- 📦 [GitHub](https://github.com/koshaji/agentguard)
+- 📘 [npm SDK](https://www.npmjs.com/package/@agentguard/sdk)
+
+## License
+
+MIT

agentguard_tech-0.1.0/agentguard_tech.egg-info/SOURCES.txt

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

agentguard_tech-0.1.0/agentguard_tech.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

agentguard_tech-0.1.0/agentguard_tech.egg-info/top_level.txt

@@ -0,0 +1 @@
+agentguard

agentguard_tech-0.1.0/pyproject.toml

@@ -0,0 +1,27 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "agentguard-tech"
+version = "0.1.0"
+description = "Runtime security for AI agents — policy engine, audit trail, and kill switch"
+readme = "README.md"
+license = {text = "MIT"}
+requires-python = ">=3.8"
+authors = [{name = "AgentGuard", email = "hello@agentguard.tech"}]
+keywords = ["ai", "agents", "security", "governance", "policy", "langchain", "openai"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Topic :: Security",
+    "Topic :: Software Development :: Libraries",
+]
+
+[project.urls]
+Homepage = "https://agentguard.tech"
+Documentation = "https://agentguard.tech"
+Repository = "https://github.com/koshaji/agentguard"
+Demo = "https://demo.agentguard.tech"

agentguard_tech-0.1.0/setup.cfg

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