agentguardproxy 0.2.0__tar.gz → 0.2.2__tar.gz

{agentguardproxy-0.2.0 → agentguardproxy-0.2.2}/PKG-INFO

@@ -1,142 +1,145 @@
-Metadata-Version: 2.4
-Name: agentguardproxy
-Version: 0.2.0
-Summary: Python SDK for AgentGuard — the firewall for AI agents
-Author: AgentGuard Contributors
-License-Expression: Apache-2.0
-Project-URL: Homepage, https://github.com/Caua-ferraz/AgentGuard
-Project-URL: Repository, https://github.com/Caua-ferraz/AgentGuard
-Project-URL: Documentation, https://github.com/Caua-ferraz/AgentGuard/blob/master/docs/SETUP.md
-Project-URL: Issues, https://github.com/Caua-ferraz/AgentGuard/issues
-Keywords: ai,agents,firewall,policy,guardrails,safety
-Classifier: Development Status :: 3 - Alpha
-Classifier: Intended Audience :: Developers
-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 :: Software Development :: Libraries
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-Provides-Extra: langchain
-Requires-Dist: langchain>=0.1.0; extra == "langchain"
-Provides-Extra: crewai
-Requires-Dist: crewai>=0.1.0; extra == "crewai"
-Provides-Extra: browser-use
-Requires-Dist: browser-use>=0.1.0; extra == "browser-use"
-Provides-Extra: mcp
-Provides-Extra: all
-Requires-Dist: langchain>=0.1.0; extra == "all"
-Requires-Dist: crewai>=0.1.0; extra == "all"
-Requires-Dist: browser-use>=0.1.0; extra == "all"
-
-# AgentGuard Python SDK
-
-Lightweight Python client for [AgentGuard](https://github.com/Caua-ferraz/AgentGuard) — the firewall for AI agents.
-
-## Install
-
-```bash
-pip install agentguard
-
-# With framework adapters
-pip install agentguard[langchain]
-pip install agentguard[crewai]
-pip install agentguard[browser-use]
-pip install agentguard[all]
-```
-
-## Quick Start
-
-```python
-from agentguard import Guard
-
-guard = Guard("http://localhost:8080", agent_id="my-agent")
-
-# Check before executing
-result = guard.check("shell", command="rm -rf ./old_data")
-
-if result.allowed:
-    execute(command)
-elif result.needs_approval:
-    print(f"Approve at: {result.approval_url}")
-else:
-    print(f"Blocked: {result.reason}")
-```
-
-## Framework Adapters
-
-### LangChain
-
-```python
-from agentguard.adapters.langchain import GuardedToolkit
-
-toolkit = GuardedToolkit(
-    tools=my_tools,
-    guard_url="http://localhost:8080",
-    agent_id="langchain-agent",
-)
-
-agent = create_react_agent(llm, toolkit.tools, prompt)
-```
-
-### CrewAI
-
-```python
-from agentguard.adapters.crewai import guard_crew_tools
-
-guarded_tools = guard_crew_tools(
-    tools=my_crew_tools,
-    guard_url="http://localhost:8080",
-    agent_id="crew-agent",
-)
-```
-
-### browser-use
-
-```python
-from agentguard.adapters.browseruse import GuardedBrowser
-
-browser = GuardedBrowser(guard_url="http://localhost:8080")
-
-result = browser.check_navigation("https://example.com")
-if result.allowed:
-    await page.goto("https://example.com")
-```
-
-### MCP
-
-```python
-from agentguard.adapters.mcp import GuardedMCPServer
-
-server = GuardedMCPServer(guard_url="http://localhost:8080")
-server.add_tool("my_tool", "Description", handler=my_handler)
-server.run()  # Starts stdio MCP server
-```
-
-## API Reference
-
-### `Guard(base_url, agent_id="")`
-- `check(scope, *, action, command, path, domain, url, meta)` — Check an action against policy
-- `approve(approval_id)` — Approve a pending action
-- `deny(approval_id)` — Deny a pending action
-- `wait_for_approval(approval_id, timeout=300)` — Block until resolved
-
-### `CheckResult`
-- `.allowed` — True if action is permitted
-- `.denied` — True if action is blocked
-- `.needs_approval` — True if human approval required
-- `.decision` — Raw decision string
-- `.reason` — Explanation
-- `.approval_url` — URL to approve (when applicable)
-
-### `@guarded(scope, guard=None)` decorator
-Wraps a function so it's checked before execution.
-
-## License
-
-Apache 2.0
+Metadata-Version: 2.4
+Name: agentguardproxy
+Version: 0.2.2
+Summary: Python SDK for AgentGuard — the firewall for AI agents
+Author: AgentGuard Contributors
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/Caua-ferraz/AgentGuard
+Project-URL: Repository, https://github.com/Caua-ferraz/AgentGuard
+Project-URL: Documentation, https://github.com/Caua-ferraz/AgentGuard/blob/master/docs/SETUP.md
+Project-URL: Issues, https://github.com/Caua-ferraz/AgentGuard/issues
+Keywords: ai,agents,firewall,policy,guardrails,safety
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+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 :: Software Development :: Libraries
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Provides-Extra: langchain
+Requires-Dist: langchain>=0.1.0; extra == "langchain"
+Provides-Extra: crewai
+Requires-Dist: crewai>=0.1.0; extra == "crewai"
+Provides-Extra: browser-use
+Requires-Dist: browser-use>=0.1.0; extra == "browser-use"
+Provides-Extra: mcp
+Provides-Extra: all
+Requires-Dist: langchain>=0.1.0; extra == "all"
+Requires-Dist: crewai>=0.1.0; extra == "all"
+Requires-Dist: browser-use>=0.1.0; extra == "all"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0; extra == "dev"
+
+# AgentGuard Python SDK
+
+Lightweight Python client for [AgentGuard](https://github.com/Caua-ferraz/AgentGuard) — the firewall for AI agents.
+
+## Install
+
+```bash
+pip install agentguardproxy
+
+# With framework adapters
+pip install agentguardproxy[langchain]
+pip install agentguardproxy[crewai]
+pip install agentguardproxy[browser-use]
+pip install agentguardproxy[all]
+```
+
+## Quick Start
+
+```python
+from agentguard import Guard
+
+guard = Guard("http://localhost:8080", agent_id="my-agent")
+
+# Check before executing
+result = guard.check("shell", command="rm -rf ./old_data")
+
+if result.allowed:
+    execute(command)
+elif result.needs_approval:
+    print(f"Approve at: {result.approval_url}")
+else:
+    print(f"Blocked: {result.reason}")
+```
+
+## Framework Adapters
+
+### LangChain
+
+```python
+from agentguard.adapters.langchain import GuardedToolkit
+
+toolkit = GuardedToolkit(
+    tools=my_tools,
+    guard_url="http://localhost:8080",
+    agent_id="langchain-agent",
+)
+
+agent = create_react_agent(llm, toolkit.tools, prompt)
+```
+
+### CrewAI
+
+```python
+from agentguard.adapters.crewai import guard_crew_tools
+
+guarded_tools = guard_crew_tools(
+    tools=my_crew_tools,
+    guard_url="http://localhost:8080",
+    agent_id="crew-agent",
+)
+```
+
+### browser-use
+
+```python
+from agentguard.adapters.browseruse import GuardedBrowser
+
+browser = GuardedBrowser(guard_url="http://localhost:8080")
+
+result = browser.check_navigation("https://example.com")
+if result.allowed:
+    await page.goto("https://example.com")
+```
+
+### MCP
+
+```python
+from agentguard.adapters.mcp import GuardedMCPServer
+
+server = GuardedMCPServer(guard_url="http://localhost:8080")
+server.add_tool("my_tool", "Description", handler=my_handler)
+server.run()  # Starts stdio MCP server
+```
+
+## API Reference
+
+### `Guard(base_url, agent_id="")`
+- `check(scope, *, action, command, path, domain, url, meta)` — Check an action against policy
+- `approve(approval_id)` — Approve a pending action
+- `deny(approval_id)` — Deny a pending action
+- `wait_for_approval(approval_id, timeout=300)` — Block until resolved
+
+### `CheckResult`
+- `.allowed` — True if action is permitted
+- `.denied` — True if action is blocked
+- `.needs_approval` — True if human approval required
+- `.decision` — Raw decision string
+- `.reason` — Explanation
+- `.approval_url` — URL to approve (when applicable)
+
+### `@guarded(scope, guard=None)` decorator
+Wraps a function so it's checked before execution.
+
+## License
+
+Apache 2.0

{agentguardproxy-0.2.0 → agentguardproxy-0.2.2}/README.md

@@ -5,13 +5,13 @@ Lightweight Python client for [AgentGuard](https://github.com/Caua-ferraz/AgentG
 ## Install
 
 ```bash
-pip install agentguard
+pip install agentguardproxy
 
 # With framework adapters
-pip install agentguard[langchain]
-pip install agentguard[crewai]
-pip install agentguard[browser-use]
-pip install agentguard[all]
+pip install agentguardproxy[langchain]
+pip install agentguardproxy[crewai]
+pip install agentguardproxy[browser-use]
+pip install agentguardproxy[all]
 ```
 
 ## Quick Start

{agentguardproxy-0.2.0 → agentguardproxy-0.2.2}/agentguard/__init__.py

@@ -17,12 +17,31 @@ Usage:
         print(f"Blocked: {result.reason}")
 """
 
+import functools
 import json
+import os
 import time
 from dataclasses import dataclass, field
 from typing import Optional
 from urllib import request, error
 
+# --- Defaults and constants ---
+DEFAULT_BASE_URL = "http://localhost:8080"
+DEFAULT_TIMEOUT = 5           # seconds, for individual HTTP calls
+DEFAULT_APPROVAL_TIMEOUT = 300  # seconds, for wait_for_approval
+DEFAULT_POLL_INTERVAL = 2       # seconds
+
+# Decision values (must match the Go backend)
+DECISION_ALLOW = "ALLOW"
+DECISION_DENY = "DENY"
+DECISION_REQUIRE_APPROVAL = "REQUIRE_APPROVAL"
+
+# API endpoint paths
+ENDPOINT_CHECK = "/v1/check"
+ENDPOINT_APPROVE = "/v1/approve/"
+ENDPOINT_DENY = "/v1/deny/"
+ENDPOINT_STATUS = "/v1/status/"
+
 
 @dataclass
 class CheckResult:
@@ -35,23 +54,24 @@ class CheckResult:
 
     @property
     def allowed(self) -> bool:
-        return self.decision == "ALLOW"
+        return self.decision == DECISION_ALLOW
 
     @property
     def denied(self) -> bool:
-        return self.decision == "DENY"
+        return self.decision == DECISION_DENY
 
     @property
     def needs_approval(self) -> bool:
-        return self.decision == "REQUIRE_APPROVAL"
+        return self.decision == DECISION_REQUIRE_APPROVAL
 
 
 class Guard:
     """Client for the AgentGuard proxy."""
 
-    def __init__(self, base_url: str = "http://localhost:8080", agent_id: str = ""):
-        self.base_url = base_url.rstrip("/")
+    def __init__(self, base_url: str = "", agent_id: str = "", timeout: int = DEFAULT_TIMEOUT):
+        self.base_url = (base_url or os.environ.get("AGENTGUARD_URL", DEFAULT_BASE_URL)).rstrip("/")
         self.agent_id = agent_id
+        self.timeout = timeout
 
     def check(
         self,
@@ -97,17 +117,17 @@ class Guard:
 
         data = json.dumps(payload).encode("utf-8")
         req = request.Request(
-            f"{self.base_url}/v1/check",
+            f"{self.base_url}{ENDPOINT_CHECK}",
             data=data,
             headers={"Content-Type": "application/json"},
             method="POST",
         )
 
         try:
-            with request.urlopen(req, timeout=5) as resp:
+            with request.urlopen(req, timeout=self.timeout) as resp:
                 body = json.loads(resp.read())
                 return CheckResult(
-                    decision=body.get("decision", "DENY"),
+                    decision=body.get("decision", DECISION_DENY),
                     reason=body.get("reason", ""),
                     matched_rule=body.get("matched_rule", ""),
                     approval_id=body.get("approval_id", ""),
@@ -116,18 +136,18 @@ class Guard:
         except error.URLError as e:
             # If AgentGuard is unreachable, default to deny (fail closed)
             return CheckResult(
-                decision="DENY",
+                decision=DECISION_DENY,
                 reason=f"AgentGuard unreachable: {e}",
             )
 
     def approve(self, approval_id: str) -> bool:
         """Approve a pending action."""
         req = request.Request(
-            f"{self.base_url}/v1/approve/{approval_id}",
+            f"{self.base_url}{ENDPOINT_APPROVE}{approval_id}",
             method="POST",
         )
         try:
-            with request.urlopen(req, timeout=5):
+            with request.urlopen(req, timeout=self.timeout):
                 return True
         except error.URLError:
             return False
@@ -135,28 +155,36 @@ class Guard:
     def deny(self, approval_id: str) -> bool:
         """Deny a pending action."""
         req = request.Request(
-            f"{self.base_url}/v1/deny/{approval_id}",
+            f"{self.base_url}{ENDPOINT_DENY}{approval_id}",
             method="POST",
         )
         try:
-            with request.urlopen(req, timeout=5):
+            with request.urlopen(req, timeout=self.timeout):
                 return True
         except error.URLError:
             return False
 
-    def wait_for_approval(self, approval_id: str, timeout: int = 300, poll_interval: int = 2) -> CheckResult:
+    def wait_for_approval(
+        self,
+        approval_id: str,
+        timeout: int = DEFAULT_APPROVAL_TIMEOUT,
+        poll_interval: int = DEFAULT_POLL_INTERVAL,
+    ) -> CheckResult:
         """Block until a pending action is approved or denied (or timeout)."""
         deadline = time.time() + timeout
         while time.time() < deadline:
             # Poll the status endpoint for resolution
             req = request.Request(
-                f"{self.base_url}/v1/status/{approval_id}",
+                f"{self.base_url}{ENDPOINT_STATUS}{approval_id}",
                 method="GET",
             )
             try:
-                with request.urlopen(req, timeout=5) as resp:
+                with request.urlopen(req, timeout=self.timeout) as resp:
                     body = json.loads(resp.read())
-                    if body.get("status") == "resolved" and body.get("decision") in ("ALLOW", "DENY"):
+                    if body.get("status") == "resolved" and body.get("decision") in (
+                        DECISION_ALLOW,
+                        DECISION_DENY,
+                    ):
                         return CheckResult(
                             decision=body["decision"],
                             reason=body.get("reason", "resolved"),
@@ -165,7 +193,7 @@ class Guard:
                 pass
             time.sleep(poll_interval)
 
-        return CheckResult(decision="DENY", reason="Approval timed out")
+        return CheckResult(decision=DECISION_DENY, reason="Approval timed out")
 
 
 # Convenience decorator for guarding functions
@@ -180,6 +208,7 @@ def guarded(scope: str, guard: Optional[Guard] = None, **check_kwargs):
             os.system(cmd)
     """
     def decorator(func):
+        @functools.wraps(func)
         def wrapper(*args, **kwargs):
             g = guard or Guard()
             # Try to extract meaningful info from args

{agentguardproxy-0.2.0 → agentguardproxy-0.2.2}/agentguard/adapters/browseruse.py

@@ -20,7 +20,7 @@ Usage:
 
 from typing import Any, Optional
 from urllib.parse import urlparse
-from agentguard import Guard, CheckResult
+from agentguard import Guard, CheckResult, DEFAULT_BASE_URL
 
 
 class GuardedBrowser:
@@ -34,7 +34,7 @@ class GuardedBrowser:
     def __init__(
         self,
         guard: Optional[Guard] = None,
-        guard_url: str = "http://localhost:8080",
+        guard_url: str = DEFAULT_BASE_URL,
         agent_id: str = "",
         browser: Any = None,
     ):

{agentguardproxy-0.2.0 → agentguardproxy-0.2.2}/agentguard/adapters/crewai.py

@@ -18,7 +18,7 @@ Usage:
 """
 
 from typing import Any, List, Optional
-from agentguard import Guard
+from agentguard import Guard, DEFAULT_BASE_URL
 
 
 class GuardedCrewTool:
@@ -32,7 +32,7 @@ class GuardedCrewTool:
         self,
         tool: Any,
         guard: Optional[Guard] = None,
-        guard_url: str = "http://localhost:8080",
+        guard_url: str = DEFAULT_BASE_URL,
         agent_id: str = "",
         scope: str = "shell",
     ):

{agentguardproxy-0.2.0 → agentguardproxy-0.2.2}/agentguard/adapters/langchain.py

@@ -16,7 +16,7 @@ Usage:
 """
 
 from typing import Any, List, Optional
-from agentguard import Guard, CheckResult
+from agentguard import Guard, CheckResult, DEFAULT_BASE_URL
 
 
 class GuardedTool:
@@ -133,7 +133,7 @@ class GuardedToolkit:
     def __init__(
         self,
         tools: List[Any],
-        guard_url: str = "http://localhost:8080",
+        guard_url: str = DEFAULT_BASE_URL,
         agent_id: str = "",
         default_scope: str = "shell",
     ):

{agentguardproxy-0.2.0 → agentguardproxy-0.2.2}/agentguard/adapters/mcp.py

@@ -35,7 +35,11 @@ MCP config (claude_desktop_config.json / .cursor/mcp.json):
 import json
 import sys
 from typing import Any, Callable, Dict, List, Optional
-from agentguard import Guard, CheckResult
+from agentguard import Guard, CheckResult, DEFAULT_BASE_URL
+
+# MCP protocol constants
+MCP_PROTOCOL_VERSION = "2024-11-05"
+SDK_VERSION = "0.2.2"
 
 
 class ToolDefinition:
@@ -64,10 +68,10 @@ class GuardedMCPServer:
     def __init__(
         self,
         guard: Optional[Guard] = None,
-        guard_url: str = "http://localhost:8080",
+        guard_url: str = DEFAULT_BASE_URL,
         agent_id: str = "mcp-agent",
         server_name: str = "agentguard",
-        server_version: str = "0.2.0",
+        server_version: str = SDK_VERSION,
     ):
         self._guard = guard or Guard(guard_url, agent_id=agent_id)
         self._tools: Dict[str, ToolDefinition] = {}
@@ -141,7 +145,7 @@ class GuardedMCPServer:
                 "jsonrpc": "2.0",
                 "id": req_id,
                 "result": {
-                    "protocolVersion": "2024-11-05",
+                    "protocolVersion": MCP_PROTOCOL_VERSION,
                     "serverInfo": {
                         "name": self._server_name,
                         "version": self._server_version,