codesec-agentguard 1.0.0__py3-none-any.whl

agentguard/__init__.py

@@ -0,0 +1,31 @@
+"""AgentGuard Python SDK."""
+
+from .client import AgentGuard
+from .exceptions import (
+    AgentGuardAuthenticationError,
+    AgentGuardError,
+    AgentGuardForbiddenError,
+    AgentGuardGatewayError,
+    AgentGuardNotFoundError,
+    AgentGuardRateLimitError,
+    AgentGuardTimeoutError,
+    AgentGuardValidationError,
+)
+from .models import ApprovalRecord, EvaluationResult, PromptScanResult
+
+__all__ = [
+    "AgentGuard",
+    "AgentGuardError",
+    "AgentGuardAuthenticationError",
+    "AgentGuardForbiddenError",
+    "AgentGuardValidationError",
+    "AgentGuardNotFoundError",
+    "AgentGuardRateLimitError",
+    "AgentGuardTimeoutError",
+    "AgentGuardGatewayError",
+    "EvaluationResult",
+    "ApprovalRecord",
+    "PromptScanResult",
+]
+
+__version__ = "1.0.0"

agentguard/client.py

@@ -0,0 +1,278 @@
+"""AgentGuard Official Python Client."""
+
+import json
+import socket
+import time
+import urllib.error
+import urllib.parse
+import urllib.request
+from typing import Any, Dict, Optional, Union
+
+from .exceptions import (
+    AgentGuardAuthenticationError,
+    AgentGuardError,
+    AgentGuardForbiddenError,
+    AgentGuardGatewayError,
+    AgentGuardNotFoundError,
+    AgentGuardRateLimitError,
+    AgentGuardTimeoutError,
+    AgentGuardValidationError,
+)
+from .models import ApprovalRecord, EvaluationResult, PromptScanResult
+
+
+class AgentGuard:
+    """Official Python Client for the AgentGuard AI Agent Security Gateway.
+
+    Intercepts and authorizes agent tool calls, financial actions, and prompt inputs
+    using deterministic policy enforcement and adversarial heuristic scanning.
+    """
+
+    def __init__(
+        self,
+        base_url: str,
+        api_key: str,
+        timeout: float = 5.0,
+        max_retries: int = 2,
+        headers: Optional[Dict[str, str]] = None,
+        workspace_id: Optional[str] = None,
+    ):
+        if not base_url or not isinstance(base_url, str):
+            raise AgentGuardError("AgentGuard base_url is required and must be a non-empty string.")
+        if not api_key or not isinstance(api_key, str):
+            raise AgentGuardError("AgentGuard api_key is required and must be a non-empty string.")
+
+        self.base_url = base_url.rstrip("/")
+        self.api_key = api_key.strip()
+        self.timeout = float(timeout)
+        self.max_retries = int(max_retries)
+        self.workspace_id = workspace_id
+
+        self.default_headers = {
+            "Content-Type": "application/json",
+            "Accept": "application/json",
+            "Authorization": f"Bearer {self.api_key}",
+            "X-API-Key": self.api_key,
+            "User-Agent": "agentguard-sdk-python/1.0.0",
+        }
+        if headers:
+            self.default_headers.update(headers)
+        if self.workspace_id:
+            self.default_headers["X-Workspace-Id"] = self.workspace_id
+
+    def __enter__(self) -> "AgentGuard":
+        return self
+
+    def __exit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
+        self.close()
+
+    def close(self) -> None:
+        """Explicit resource cleanup if required."""
+        pass
+
+    def evaluate(
+        self,
+        action: Optional[Union[str, Dict[str, Any]]] = None,
+        amount: Optional[Union[float, int, str]] = None,
+        currency: str = "USD",
+        recipient: Optional[Union[str, Dict[str, Any]]] = None,
+        description: Optional[str] = None,
+        agent_id: Optional[str] = None,
+        tool: Optional[str] = None,
+        operation: Optional[str] = None,
+        prompt_context: Optional[str] = None,
+        human_approval_token: Optional[str] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+        idempotency_key: Optional[str] = None,
+        **extra_kwargs: Any,
+    ) -> EvaluationResult:
+        """Pre-flight policy evaluation for autonomous AI agents and backend actions.
+
+        Supports both dictionary style (evaluate({"action": "payment.create", ...}))
+        and keyword-argument style (evaluate(action="payment.create", amount=1500)).
+        """
+        payload: Dict[str, Any] = {}
+
+        if isinstance(action, dict):
+            payload = dict(action)
+        elif isinstance(action, str):
+            payload["action"] = action
+            if amount is not None:
+                payload["amount"] = amount
+            if currency:
+                payload["currency"] = currency
+            if recipient is not None:
+                payload["recipient"] = recipient
+            if description is not None:
+                payload["description"] = description
+            if agent_id is not None:
+                payload["agentId"] = agent_id
+            if tool is not None:
+                payload["tool"] = tool
+            if operation is not None:
+                payload["operation"] = operation
+            if prompt_context is not None:
+                payload["promptContext"] = prompt_context
+            if human_approval_token is not None:
+                payload["humanApprovalToken"] = human_approval_token
+            if metadata is not None:
+                payload["metadata"] = metadata
+            if idempotency_key is not None:
+                payload["idempotencyKey"] = idempotency_key
+            if extra_kwargs:
+                payload.update(extra_kwargs)
+        else:
+            raise AgentGuardValidationError("First argument must be either an action string or a payload dictionary.")
+
+        if not payload.get("action"):
+            raise AgentGuardValidationError("Evaluation request must specify an 'action'.")
+
+        request_id = payload.get("idempotencyKey") or f"py_sdk_{int(time.time() * 1000)}"
+        headers = {"X-Request-Id": request_id}
+
+        status_code, body = self._request("POST", "/api/v1/evaluate", payload=payload, extra_headers=headers)
+
+        # Policy decision returns structured evaluation even on HTTP 202 (HOLD) or 403 (BLOCK)
+        if isinstance(body, dict) and body.get("status") in ("ALLOW", "HOLD", "BLOCK"):
+            return EvaluationResult.from_dict(body)
+
+        if status_code in (200, 201, 202):
+            return EvaluationResult.from_dict(body)
+
+        raise self._parse_error(status_code, body, request_id)
+
+    def evaluate_safely(
+        self,
+        action: Optional[Union[str, Dict[str, Any]]] = None,
+        **kwargs: Any,
+    ) -> EvaluationResult:
+        """Safe evaluation wrapper with strict fail-closed guarantee.
+
+        Never raises exceptions for network failures or gateway outages;
+        strictly returns an authoritative BLOCK decision.
+        """
+        try:
+            return self.evaluate(action, **kwargs)
+        except Exception as exc:  # pylint: disable=broad-except
+            reason = str(exc)
+            return EvaluationResult(
+                status="BLOCK",
+                decision="BLOCK",
+                is_allowed=False,
+                is_held=False,
+                is_blocked=True,
+                reason=f"FAIL_CLOSED: {reason}",
+                violations=[f"Gateway communication error: {reason}"],
+                request_id=f"fail_closed_{int(time.time() * 1000)}",
+                timestamp=time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
+            )
+
+    def get_approval(self, approval_id: str) -> ApprovalRecord:
+        """Fetch human review approval record by ID."""
+        if not approval_id or not isinstance(approval_id, str):
+            raise AgentGuardError("approval_id is required.")
+
+        encoded_id = urllib.parse.quote(approval_id)
+        status_code, body = self._request("GET", f"/api/v1/approvals/{encoded_id}")
+
+        if status_code == 200 and isinstance(body, dict):
+            return ApprovalRecord.from_dict(body)
+
+        raise self._parse_error(status_code, body)
+
+    def wait_for_approval(
+        self,
+        approval_id: str,
+        poll_interval: float = 1.0,
+        timeout: float = 30.0,
+    ) -> ApprovalRecord:
+        """Poll a held transaction until approved, rejected, or timed out."""
+        start_time = time.time()
+        while time.time() - start_time < timeout:
+            record = self.get_approval(approval_id)
+            if record.status != "PENDING":
+                return record
+            time.sleep(poll_interval)
+
+        raise AgentGuardTimeoutError(
+            f"Timed out waiting for approval on '{approval_id}' after {timeout} seconds."
+        )
+
+    def scan_prompt(self, input_text: str) -> PromptScanResult:
+        """Scan prompt context for adversarial prompt injection heuristics."""
+        status_code, body = self._request("POST", "/api/v1/scan", payload={"input": input_text})
+        if status_code == 200 and isinstance(body, dict):
+            return PromptScanResult.from_dict(body)
+        raise self._parse_error(status_code, body)
+
+    def _request(
+        self,
+        method: str,
+        path: str,
+        payload: Optional[Dict[str, Any]] = None,
+        extra_headers: Optional[Dict[str, str]] = None,
+    ) -> tuple[int, Any]:
+        url = f"{self.base_url}{path}"
+        headers = dict(self.default_headers)
+        if extra_headers:
+            headers.update(extra_headers)
+
+        data = json.dumps(payload).encode("utf-8") if payload is not None else None
+        req = urllib.request.Request(url, data=data, headers=headers, method=method)
+
+        try:
+            with urllib.request.urlopen(req, timeout=self.timeout) as response:
+                status_code = response.status
+                response_text = response.read().decode("utf-8")
+                try:
+                    return status_code, json.loads(response_text)
+                except Exception:
+                    return status_code, {"raw": response_text}
+        except urllib.error.HTTPError as exc:
+            status_code = exc.code
+            try:
+                error_body = json.loads(exc.read().decode("utf-8"))
+            except Exception:
+                error_body = {"error": exc.reason}
+            return status_code, error_body
+        except urllib.error.URLError as exc:
+            reason = str(exc.reason)
+            if "timed out" in reason.lower() or isinstance(getattr(exc, "reason", None), (socket.timeout, TimeoutError)):
+                raise AgentGuardTimeoutError(
+                    f"AgentGuard request timed out after {self.timeout}s: {reason}"
+                ) from exc
+            raise AgentGuardGatewayError(
+                f"Failed to connect to AgentGuard gateway at {self.base_url}: {reason}",
+                status_code=503,
+            ) from exc
+        except (socket.timeout, TimeoutError) as exc:
+            raise AgentGuardTimeoutError(
+                f"AgentGuard request timed out after {self.timeout}s: {exc}"
+            ) from exc
+        except Exception as exc:
+            raise AgentGuardGatewayError(f"Unexpected error communicating with AgentGuard: {exc}") from exc
+
+    def _parse_error(self, status_code: int, body: Any, request_id: Optional[str] = None) -> AgentGuardError:
+        message = (
+            body.get("message")
+            or body.get("error")
+            or f"AgentGuard request failed with HTTP {status_code}"
+            if isinstance(body, dict)
+            else f"AgentGuard request failed with HTTP {status_code}"
+        )
+        details = body.get("details") if isinstance(body, dict) else None
+
+        if status_code == 401:
+            return AgentGuardAuthenticationError(message, request_id=request_id, details=details)
+        if status_code == 403:
+            return AgentGuardForbiddenError(message, request_id=request_id, details=details)
+        if status_code == 400:
+            return AgentGuardValidationError(message, request_id=request_id, details=details)
+        if status_code == 404:
+            return AgentGuardNotFoundError(message, request_id=request_id, details=details)
+        if status_code == 429:
+            return AgentGuardRateLimitError(message, request_id=request_id, details=details)
+        if status_code >= 500:
+            return AgentGuardGatewayError(message, status_code=status_code, request_id=request_id, details=details)
+
+        return AgentGuardError(message, status_code=status_code, request_id=request_id, details=details)

agentguard/exceptions.py

@@ -0,0 +1,120 @@
+"""AgentGuard Python SDK Exception Hierarchy."""
+
+from typing import Any, Optional
+
+
+class AgentGuardError(Exception):
+    """Base exception for all AgentGuard errors."""
+
+    def __init__(
+        self,
+        message: str,
+        status_code: Optional[int] = None,
+        error_code: Optional[str] = None,
+        request_id: Optional[str] = None,
+        details: Optional[Any] = None,
+    ):
+        super().__init__(message)
+        self.message = message
+        self.status_code = status_code
+        self.error_code = error_code
+        self.request_id = request_id
+        self.details = details
+
+    @property
+    def status(self) -> Optional[int]:
+        """HTTP status code alias."""
+        return self.status_code
+
+    @property
+    def code(self) -> Optional[str]:
+        """Error code alias."""
+        return self.error_code
+
+    def __str__(self) -> str:
+        req_suffix = f" [Request ID: {self.request_id}]" if self.request_id else ""
+        return f"{self.message}{req_suffix}"
+
+
+class AgentGuardAuthenticationError(AgentGuardError):
+    """Raised when authentication fails (HTTP 401: missing, expired, or revoked API key)."""
+
+    def __init__(
+        self,
+        message: str = "Authentication failed. Please verify your AgentGuard API key.",
+        request_id: Optional[str] = None,
+        details: Optional[Any] = None,
+    ):
+        super().__init__(message, status_code=401, error_code="AUTHENTICATION_FAILED", request_id=request_id, details=details)
+
+
+class AgentGuardForbiddenError(AgentGuardError):
+    """Raised when permissions are insufficient (HTTP 403: API key lacks required scope)."""
+
+    def __init__(
+        self,
+        message: str = "Permission denied. The API key lacks the necessary permissions.",
+        request_id: Optional[str] = None,
+        details: Optional[Any] = None,
+    ):
+        super().__init__(message, status_code=403, error_code="FORBIDDEN", request_id=request_id, details=details)
+
+
+class AgentGuardValidationError(AgentGuardError):
+    """Raised when request parameters fail schema validation (HTTP 400)."""
+
+    def __init__(
+        self,
+        message: str = "Invalid request parameters.",
+        request_id: Optional[str] = None,
+        details: Optional[Any] = None,
+    ):
+        super().__init__(message, status_code=400, error_code="VALIDATION_ERROR", request_id=request_id, details=details)
+
+
+class AgentGuardNotFoundError(AgentGuardError):
+    """Raised when a requested resource (e.g., approval ID) is not found (HTTP 404)."""
+
+    def __init__(
+        self,
+        message: str = "Requested resource not found.",
+        request_id: Optional[str] = None,
+        details: Optional[Any] = None,
+    ):
+        super().__init__(message, status_code=404, error_code="NOT_FOUND", request_id=request_id, details=details)
+
+
+class AgentGuardRateLimitError(AgentGuardError):
+    """Raised when the gateway rate limit is exceeded (HTTP 429)."""
+
+    def __init__(
+        self,
+        message: str = "Rate limit exceeded. Please back off before retrying.",
+        request_id: Optional[str] = None,
+        details: Optional[Any] = None,
+    ):
+        super().__init__(message, status_code=429, error_code="RATE_LIMIT_EXCEEDED", request_id=request_id, details=details)
+
+
+class AgentGuardTimeoutError(AgentGuardError):
+    """Raised when an HTTP request or approval wait times out."""
+
+    def __init__(
+        self,
+        message: str = "AgentGuard evaluation request timed out.",
+        request_id: Optional[str] = None,
+    ):
+        super().__init__(message, status_code=408, error_code="TIMEOUT", request_id=request_id)
+
+
+class AgentGuardGatewayError(AgentGuardError):
+    """Raised when the AgentGuard gateway is unreachable or returns HTTP 5xx."""
+
+    def __init__(
+        self,
+        message: str = "AgentGuard gateway error or service unavailable.",
+        status_code: int = 500,
+        request_id: Optional[str] = None,
+        details: Optional[Any] = None,
+    ):
+        super().__init__(message, status_code=status_code, error_code="GATEWAY_ERROR", request_id=request_id, details=details)

agentguard/models.py

@@ -0,0 +1,122 @@
+"""AgentGuard Python SDK Data Models."""
+
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional
+
+
+@dataclass
+class EvaluationResult:
+    """Authoritative decision returned by the AgentGuard security gateway."""
+
+    status: str
+    decision: str
+    is_allowed: bool
+    is_held: bool
+    is_blocked: bool
+    reason: str
+    violations: List[str] = field(default_factory=list)
+    request_id: str = ""
+    policy_id: Optional[str] = None
+    policy_version: Optional[int] = None
+    pending_approval_id: Optional[str] = None
+    authorization_token: Optional[str] = None
+    amount_formatted: Optional[str] = None
+    amount_cents: Optional[str] = None
+    currency: Optional[str] = None
+    timestamp: str = ""
+    metadata: Optional[Dict[str, Any]] = None
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "EvaluationResult":
+        status = data.get("status") or data.get("decision", "BLOCK")
+        return cls(
+            status=status,
+            decision=status,
+            is_allowed=(status == "ALLOW"),
+            is_held=(status == "HOLD"),
+            is_blocked=(status == "BLOCK"),
+            reason=data.get("reason", "No reason provided by gateway"),
+            violations=data.get("violations", []),
+            request_id=data.get("requestId", ""),
+            policy_id=data.get("policyId"),
+            policy_version=data.get("policyVersion"),
+            pending_approval_id=data.get("pendingApprovalId"),
+            authorization_token=data.get("authorizationToken"),
+            amount_formatted=data.get("amountFormatted"),
+            amount_cents=data.get("amountCents"),
+            currency=data.get("currency"),
+            timestamp=data.get("timestamp", ""),
+            metadata=data.get("metadata"),
+        )
+
+
+@dataclass
+class ApprovalRecord:
+    """Human-in-the-Loop approval record for held transactions."""
+
+    id: str
+    request_id: str
+    agent_id: str
+    policy_id: str
+    policy_version: int
+    tool: str
+    operation: str
+    amount_formatted: str
+    amount_cents: str
+    currency: str
+    merchant: str
+    description: str
+    status: str
+    risk_reasons: List[str] = field(default_factory=list)
+    server_authorization_token: Optional[str] = None
+    token_expires_at: Optional[str] = None
+    reviewed_by: Optional[str] = None
+    reviewed_at: Optional[str] = None
+    rejection_reason: Optional[str] = None
+    created_at: str = ""
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "ApprovalRecord":
+        return cls(
+            id=data.get("id", ""),
+            request_id=data.get("requestId", ""),
+            agent_id=data.get("agentId", ""),
+            policy_id=data.get("policyId", ""),
+            policy_version=data.get("policyVersion", 1),
+            tool=data.get("tool", ""),
+            operation=data.get("operation", ""),
+            amount_formatted=data.get("amountFormatted", ""),
+            amount_cents=data.get("amountCents", "0"),
+            currency=data.get("currency", "USD"),
+            merchant=str(data.get("merchant", "")),
+            description=data.get("description", ""),
+            status=data.get("status", "PENDING"),
+            risk_reasons=data.get("riskReasons", []),
+            server_authorization_token=data.get("serverAuthorizationToken"),
+            token_expires_at=data.get("tokenExpiresAt"),
+            reviewed_by=data.get("reviewedBy"),
+            reviewed_at=data.get("reviewedAt"),
+            rejection_reason=data.get("rejectionReason"),
+            created_at=data.get("createdAt", ""),
+        )
+
+
+@dataclass
+class PromptScanResult:
+    """Result of prompt injection heuristic scanning."""
+
+    is_threat_detected: bool
+    risk_score: float
+    threat_level: str
+    findings: List[Dict[str, Any]] = field(default_factory=list)
+    sanitized_input: str = ""
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "PromptScanResult":
+        return cls(
+            is_threat_detected=bool(data.get("isThreatDetected", False)),
+            risk_score=float(data.get("riskScore", 0.0)),
+            threat_level=data.get("threatLevel", "NONE"),
+            findings=data.get("findings", []),
+            sanitized_input=data.get("sanitizedInput", ""),
+        )

agentguard/py.typed

@@ -0,0 +1 @@
+# Marker file for PEP 561. The agentguard package uses inline type annotations.

codesec_agentguard-1.0.0.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 CodeSec AI / AgentGuard Authors
+
+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.

codesec_agentguard-1.0.0.dist-info/METADATA

@@ -0,0 +1,96 @@
+Metadata-Version: 2.1
+Name: codesec-agentguard
+Version: 1.0.0
+Summary: Official Python SDK for the AgentGuard AI Agent Security Gateway
+Home-page: https://github.com/altafpasha/agentguard
+Author: CodeSec AI / AgentGuard Security Team
+Author-email: security@agentguard.dev
+License: MIT
+Platform: UNKNOWN
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# codesec-agentguard (Python SDK)
+
+Official Python SDK for the **AgentGuard** AI Agent Security Gateway.
+
+AgentGuard intercepts, evaluates, and verifies autonomous AI agent actions against deterministic spending limits, currency controls, capability whitelists, and adversarial prompt injection heuristic scans before downstream payment APIs (such as Razorpay or PayPal) are executed.
+
+---
+
+## Installation
+
+```bash
+pip install codesec-agentguard
+```
+
+Or install locally in editable mode:
+
+```bash
+pip install -e packages/python-sdk
+```
+
+---
+
+## Quickstart
+
+```python
+import os
+from agentguard import AgentGuard
+
+# Initialize client
+guard = AgentGuard(
+    base_url=os.environ.get("AGENTGUARD_URL", "http://localhost:3001"),
+    api_key=os.environ["AGENTGUARD_API_KEY"],
+    timeout=5.0,
+)
+
+# Pre-flight evaluation
+decision = guard.evaluate({
+    "action": "payment.create",
+    "amount": 1200.0,
+    "currency": "INR",
+    "recipient": "merchant@store.com",
+    "description": "Autonomous grocery restocking order",
+    "prompt_context": "User prompt: Restock organic coffee beans.",
+})
+
+if decision.status == "ALLOW":
+    print(f"Action permitted! Policy version: {decision.policy_version}")
+    # Safe to initiate Razorpay order
+elif decision.status == "HOLD":
+    print(f"Action held for human review: {decision.pending_approval_id}")
+    # Wait for operator in AgentGuard dashboard
+else:
+    print(f"Blocked by AgentGuard: {decision.reason}")
+    for violation in decision.violations:
+        print(f" - {violation}")
+```
+
+### Context Manager Usage
+
+```python
+with AgentGuard(base_url="http://localhost:3001", api_key="ag_live_...") as guard:
+    decision = guard.evaluate(action="payment.create", amount=25.0)
+    if decision.is_allowed:
+        pass
+```
+
+### Strict Fail-Closed Guarantee
+
+```python
+# evaluate_safely catches all timeouts, DNS failures, and gateway crashes,
+# strictly returning an authoritative BLOCK decision so your code never fails open.
+decision = guard.evaluate_safely(action="payment.create", amount=50.0)
+if not decision.is_allowed:
+    print(f"Transaction denied: {decision.reason}")
+```
+
+---
+
+## License
+
+MIT © AgentGuard Security Team
+
+

codesec_agentguard-1.0.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+agentguard/__init__.py,sha256=vp0-ZYB4knyzevaZOYP5IJB65ivk5KXI58qwGvH7GVc,766
+agentguard/client.py,sha256=wmBVsmqtZ6kwE-JsYAHLHzgkOtJao4gzNVmmyA2UsRI,11338
+agentguard/exceptions.py,sha256=yWHSVNmWXa95x2ZLEiCb03G4UYs4IxRko4aNJjYpzPg,4108
+agentguard/models.py,sha256=6F9iFPIpOgGvFH97GNej98uVKvOAqXQjMR4wSj74qC8,4277
+agentguard/py.typed,sha256=jKVcLoqUzJAhSwO-U3ztJHFft9oHMcj4681w24jTnac,80
+codesec_agentguard-1.0.0.dist-info/LICENSE,sha256=wrpoyW6mMh07hQj-FUo87mBKRJMC-ekqVTR5t7NmMEc,1088
+codesec_agentguard-1.0.0.dist-info/METADATA,sha256=yoFYTbByf70_Jw_EGO5TN9lv8lEQBSxgDyXf4_cIsK4,2561
+codesec_agentguard-1.0.0.dist-info/WHEEL,sha256=ewwEueio1C2XeHTvT17n8dZUJgOvyCWCt0WVNLClP9o,92
+codesec_agentguard-1.0.0.dist-info/top_level.txt,sha256=rEW5sAnjxXRs63ja2psmsMRMJJfi_3EAxf7crl1nHyw,11
+codesec_agentguard-1.0.0.dist-info/RECORD,,

codesec_agentguard-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.37.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

codesec_agentguard-1.0.0.dist-info/top_level.txt

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