agentscore-gate 1.0.0__py3-none-any.whl

agentscore_gate/__init__.py

@@ -0,0 +1,22 @@
+"""Trust-gating middleware for Python web frameworks using AgentScore."""
+
+from agentscore_gate.client import GateClient
+from agentscore_gate.types import AssessResult, DenialReason, Grade
+
+# ASGI middleware is the default import.
+# Flask and Django adapters are imported from their submodules:
+#   from agentscore_gate.flask import agentscore_gate
+#   from agentscore_gate.django import AgentScoreMiddleware
+try:
+    from agentscore_gate.middleware import AgentScoreGate
+except ImportError:
+    # starlette not installed
+    AgentScoreGate = None  # type: ignore[assignment,misc]
+
+__all__ = [
+    "AgentScoreGate",
+    "AssessResult",
+    "DenialReason",
+    "GateClient",
+    "Grade",
+]

agentscore_gate/cache.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+import threading
+import time
+from typing import Generic, TypeVar
+
+T = TypeVar("T")
+
+
+class TTLCache(Generic[T]):
+    """Simple in-memory cache with per-entry TTL expiry."""
+
+    def __init__(self, default_ttl_seconds: float, max_size: int = 10000) -> None:
+        self._store: dict[str, tuple[T, float]] = {}
+        self._default_ttl = default_ttl_seconds
+        self._max_size = max_size
+        self._lock = threading.Lock()
+
+    def get(self, key: str) -> T | None:
+        """Return the cached value, or ``None`` if missing or expired."""
+        with self._lock:
+            entry = self._store.get(key)
+            if entry is None:
+                return None
+            value, expires_at = entry
+            if time.monotonic() > expires_at:
+                del self._store[key]
+                return None
+            return value
+
+    def set(self, key: str, value: T, ttl: float | None = None) -> None:
+        """Store *value* under *key* with an optional custom TTL (seconds)."""
+        with self._lock:
+            if len(self._store) >= self._max_size and key not in self._store:
+                self._sweep_expired()
+                if len(self._store) >= self._max_size:
+                    self._evict_oldest()
+            self._store[key] = (value, time.monotonic() + (ttl if ttl is not None else self._default_ttl))
+
+    def _sweep_expired(self) -> None:
+        """Remove all expired entries. Must be called with ``_lock`` held."""
+        now = time.monotonic()
+        expired = [k for k, (_, exp) in self._store.items() if now > exp]
+        for k in expired:
+            del self._store[k]
+
+    def _evict_oldest(self) -> None:
+        """Evict entries with the earliest expiry until under max_size. Must be called with ``_lock`` held."""
+        entries = sorted(self._store.items(), key=lambda item: item[1][1])
+        while len(self._store) >= self._max_size and entries:
+            del self._store[entries.pop(0)[0]]

agentscore_gate/client.py

@@ -0,0 +1,122 @@
+"""Shared AgentScore assess client with TTL caching."""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+import httpx
+
+from agentscore_gate.cache import TTLCache
+from agentscore_gate.types import AssessResult, Grade
+
+DEFAULT_BASE_URL = "https://api.agentscore.sh"
+DEFAULT_CACHE_SECONDS = 300
+
+
+class GateClient:
+    """Shared client for calling the AgentScore assess API.
+
+    Manages caching and policy construction. Used by all framework adapters.
+    """
+
+    def __init__(
+        self,
+        *,
+        api_key: str,
+        min_grade: Grade | None = None,
+        min_score: int | None = None,
+        require_verified_activity: bool | None = None,
+        fail_open: bool = False,
+        cache_seconds: int = DEFAULT_CACHE_SECONDS,
+        base_url: str = DEFAULT_BASE_URL,
+    ) -> None:
+        if not api_key:
+            msg = "AgentScore API key is required. Get one at https://agentscore.sh/sign-up"
+            raise ValueError(msg)
+
+        self.fail_open = fail_open
+        self._api_key = api_key
+        self._base_url = base_url
+        self._cache: TTLCache[AssessResult] = TTLCache(cache_seconds)
+
+        self._policy: dict[str, Any] = {}
+        if min_grade is not None:
+            self._policy["min_grade"] = min_grade
+        if min_score is not None:
+            self._policy["min_score"] = min_score
+        if require_verified_activity is not None:
+            self._policy["require_verified_payment_activity"] = require_verified_activity
+
+        self._async_client = httpx.AsyncClient(timeout=10.0)
+        self._sync_client = httpx.Client(timeout=10.0)
+
+    def _cache_key(self, address: str, chain: str) -> str:
+        return f"{chain}:{address.lower()}"
+
+    def _build_body(self, address: str, chain: str) -> dict[str, Any]:
+        body: dict[str, Any] = {"address": address, "chain": chain}
+        if self._policy:
+            body["policy"] = self._policy
+        return body
+
+    def _headers(self) -> dict[str, str]:
+        return {
+            "Authorization": f"Bearer {self._api_key}",
+            "Content-Type": "application/json",
+            "Accept": "application/json",
+            "User-Agent": "agentscore-gate/1.0.0",
+        }
+
+    def _parse_response(self, resp: httpx.Response) -> AssessResult:
+        if resp.status_code == 402:
+            raise PaymentRequiredError
+
+        if not resp.is_success:
+            msg = f"AgentScore API returned {resp.status_code}"
+            raise RuntimeError(msg)
+
+        data: dict[str, Any] = resp.json()
+        decision = data.get("decision")
+        reasons: list[str] = data.get("decision_reasons", [])
+        allow = decision == "allow" or decision is None
+
+        return AssessResult(allow=allow, decision=decision, reasons=reasons, raw=data)
+
+    def check(self, address: str, chain: str = "base") -> AssessResult:
+        """Synchronous assess call with caching."""
+        key = self._cache_key(address, chain)
+
+        cached = self._cache.get(key)
+        if cached is not None:
+            return cached
+
+        resp = self._sync_client.post(
+            f"{self._base_url}/v1/assess",
+            headers=self._headers(),
+            content=json.dumps(self._build_body(address, chain)),
+        )
+        result = self._parse_response(resp)
+        self._cache.set(key, result)
+        return result
+
+    async def acheck(self, address: str, chain: str = "base") -> AssessResult:
+        """Asynchronous assess call with caching."""
+        key = self._cache_key(address, chain)
+
+        cached = self._cache.get(key)
+        if cached is not None:
+            return cached
+
+        resp = await self._async_client.post(
+            f"{self._base_url}/v1/assess",
+            headers=self._headers(),
+            content=json.dumps(self._build_body(address, chain)),
+        )
+        result = self._parse_response(resp)
+        self._cache.set(key, result)
+        return result
+
+
+class PaymentRequiredError(Exception):
+    """Raised when the AgentScore API returns 402."""

agentscore_gate/django.py

@@ -0,0 +1,98 @@
+"""Django middleware for trust-gating requests using AgentScore."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from django.http import HttpRequest, JsonResponse
+
+from agentscore_gate.client import GateClient, PaymentRequiredError
+from agentscore_gate.types import DenialReason
+
+DEFAULT_ADDRESS_HEADER = "HTTP_X_WALLET_ADDRESS"
+
+
+class AgentScoreMiddleware:
+    """Django middleware that gates requests based on AgentScore wallet reputation.
+
+    Usage in settings.py::
+
+        MIDDLEWARE = [
+            ...
+            "agentscore_gate.django.AgentScoreMiddleware",
+            ...
+        ]
+
+        AGENTSCORE_GATE = {
+            "api_key": "ask_...",
+            "min_score": 50,
+        }
+    """
+
+    def __init__(self, get_response: Any) -> None:
+        from django.conf import settings
+
+        config: dict[str, Any] = getattr(settings, "AGENTSCORE_GATE", {})
+
+        self._client = GateClient(
+            api_key=config.get("api_key", ""),
+            min_grade=config.get("min_grade"),
+            min_score=config.get("min_score"),
+            require_verified_activity=config.get("require_verified_activity"),
+            fail_open=config.get("fail_open", False),
+            cache_seconds=config.get("cache_seconds", 300),
+            base_url=config.get("base_url", "https://api.agentscore.sh"),
+        )
+        self._extract_address = config.get("extract_address", self._default_extract_address)
+        self._extract_chain = config.get("extract_chain", self._default_extract_chain)
+        self._on_denied = config.get("on_denied", self._default_on_denied)
+        self.get_response = get_response
+
+    @staticmethod
+    def _default_extract_address(request: HttpRequest) -> str | None:
+        value = request.META.get(DEFAULT_ADDRESS_HEADER)
+        if value and len(value) > 0:
+            return value
+        return None
+
+    @staticmethod
+    def _default_extract_chain(_request: HttpRequest) -> str | None:
+        return None
+
+    @staticmethod
+    def _default_on_denied(_request: HttpRequest, reason: DenialReason) -> JsonResponse:
+        body: dict[str, Any] = {"error": reason.code}
+        if reason.decision is not None:
+            body["decision"] = reason.decision
+        if reason.reasons:
+            body["reasons"] = reason.reasons
+        return JsonResponse(body, status=403)
+
+    def __call__(self, request: HttpRequest) -> Any:
+        """Process the request."""
+        address = self._extract_address(request)
+
+        if not address:
+            if self._client.fail_open:
+                return self.get_response(request)
+            return self._on_denied(request, DenialReason(code="missing_wallet_address"))
+
+        chain = self._extract_chain(request) or "base"
+
+        try:
+            result = self._client.check(address, chain)
+
+            if result.allow:
+                request.agentscore = result.raw  # type: ignore[attr-defined]
+                return self.get_response(request)
+
+            reason = DenialReason(code="wallet_not_trusted", decision=result.decision, reasons=result.reasons)
+            return self._on_denied(request, reason)
+        except PaymentRequiredError:
+            if self._client.fail_open:
+                return self.get_response(request)
+            return self._on_denied(request, DenialReason(code="payment_required"))
+        except Exception:
+            if self._client.fail_open:
+                return self.get_response(request)
+            return self._on_denied(request, DenialReason(code="api_error"))

agentscore_gate/flask.py

@@ -0,0 +1,126 @@
+"""Flask integration for trust-gating requests using AgentScore."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from agentscore_gate.client import GateClient, PaymentRequiredError
+from agentscore_gate.types import DenialReason, Grade
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from flask import Flask, Request, Response
+
+DEFAULT_ADDRESS_HEADER = "x-wallet-address"
+
+
+def _default_extract_address(request: Request) -> str | None:
+    value = request.headers.get(DEFAULT_ADDRESS_HEADER)
+    if value and len(value) > 0:
+        return value
+    return None
+
+
+def _default_extract_chain(_request: Request) -> str | None:
+    return None
+
+
+def _default_on_denied(_request: Request, reason: DenialReason) -> tuple[dict[str, Any], int]:
+    body: dict[str, Any] = {"error": reason.code}
+    if reason.decision is not None:
+        body["decision"] = reason.decision
+    if reason.reasons:
+        body["reasons"] = reason.reasons
+    return body, 403
+
+
+def agentscore_gate(
+    app: Flask,
+    *,
+    api_key: str,
+    min_grade: Grade | None = None,
+    min_score: int | None = None,
+    require_verified_activity: bool | None = None,
+    fail_open: bool = False,
+    cache_seconds: int = 300,
+    base_url: str = "https://api.agentscore.sh",
+    extract_address: Callable[[Request], str | None] | None = None,
+    extract_chain: Callable[[Request], str | None] | None = None,
+    on_denied: Callable[[Request, DenialReason], tuple[dict[str, Any], int]] | None = None,
+) -> None:
+    """Register AgentScore gate as a Flask before_request handler.
+
+    Usage::
+
+        from flask import Flask
+        from agentscore_gate.flask import agentscore_gate
+
+        app = Flask(__name__)
+        agentscore_gate(app, api_key="ask_...", min_score=50)
+    """
+    from flask import g, jsonify
+    from flask import request as flask_request
+
+    client = GateClient(
+        api_key=api_key,
+        min_grade=min_grade,
+        min_score=min_score,
+        require_verified_activity=require_verified_activity,
+        fail_open=fail_open,
+        cache_seconds=cache_seconds,
+        base_url=base_url,
+    )
+    _extract_address = extract_address or _default_extract_address
+    _extract_chain = extract_chain or _default_extract_chain
+    _on_denied = on_denied or _default_on_denied
+
+    @app.before_request
+    def _agentscore_check() -> Response | None:
+        address = _extract_address(flask_request)
+        if not address:
+            if client.fail_open:
+                return None
+            try:
+                body, status = _on_denied(flask_request, DenialReason(code="missing_wallet_address"))
+            except (TypeError, ValueError) as exc:
+                msg = "on_denied must return a (dict, int) tuple, e.g. ({'error': 'denied'}, 403)"
+                raise TypeError(msg) from exc
+            return jsonify(body), status
+
+        chain = _extract_chain(flask_request) or "base"
+
+        try:
+            result = client.check(address, chain)
+
+            if result.allow:
+                g.agentscore = result.raw
+                return None
+
+            reason = DenialReason(code="wallet_not_trusted", decision=result.decision, reasons=result.reasons)
+            try:
+                body, status = _on_denied(flask_request, reason)
+            except (TypeError, ValueError) as exc:
+                msg = "on_denied must return a (dict, int) tuple, e.g. ({'error': 'denied'}, 403)"
+                raise TypeError(msg) from exc
+            return jsonify(body), status
+        except PaymentRequiredError:
+            if client.fail_open:
+                return None
+            try:
+                body, status = _on_denied(flask_request, DenialReason(code="payment_required"))
+            except (TypeError, ValueError) as exc:
+                msg = "on_denied must return a (dict, int) tuple, e.g. ({'error': 'denied'}, 403)"
+                raise TypeError(msg) from exc
+            return jsonify(body), status
+        except TypeError:
+            raise
+        except Exception:
+            if client.fail_open:
+                return None
+            try:
+                body, status = _on_denied(flask_request, DenialReason(code="api_error"))
+            except (TypeError, ValueError) as exc:
+                msg = "on_denied must return a (dict, int) tuple, e.g. ({'error': 'denied'}, 403)"
+                raise TypeError(msg) from exc
+            return jsonify(body), status

agentscore_gate/middleware.py

@@ -0,0 +1,126 @@
+"""ASGI middleware for trust-gating requests using AgentScore."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from starlette.requests import Request
+from starlette.responses import JSONResponse
+
+from agentscore_gate.client import GateClient, PaymentRequiredError
+from agentscore_gate.types import DenialReason, Grade
+
+if TYPE_CHECKING:
+    from collections.abc import Awaitable, Callable
+
+    from starlette.types import ASGIApp, Receive, Scope, Send
+
+DEFAULT_ADDRESS_HEADER = "x-wallet-address"
+
+
+def _default_extract_address(request: Request) -> str | None:
+    value = request.headers.get(DEFAULT_ADDRESS_HEADER)
+    if value and len(value) > 0:
+        return value
+    return None
+
+
+def _default_extract_chain(_request: Request) -> str | None:
+    return None
+
+
+async def _default_on_denied(_request: Request, reason: DenialReason) -> JSONResponse:
+    body: dict[str, Any] = {"error": reason.code}
+    if reason.decision is not None:
+        body["decision"] = reason.decision
+    if reason.reasons:
+        body["reasons"] = reason.reasons
+    return JSONResponse(body, status_code=403)
+
+
+class AgentScoreGate:
+    """ASGI middleware that gates requests based on AgentScore wallet reputation.
+
+    Usage with Starlette / FastAPI::
+
+        app.add_middleware(
+            AgentScoreGate,
+            api_key="ask_...",
+            min_score=50,
+        )
+    """
+
+    def __init__(
+        self,
+        app: ASGIApp,
+        *,
+        api_key: str,
+        min_grade: Grade | None = None,
+        min_score: int | None = None,
+        require_verified_activity: bool | None = None,
+        fail_open: bool = False,
+        cache_seconds: int = 300,
+        base_url: str = "https://api.agentscore.sh",
+        extract_address: Callable[[Request], str | None] | None = None,
+        extract_chain: Callable[[Request], str | None] | None = None,
+        on_denied: Callable[[Request, DenialReason], Awaitable[JSONResponse]] | None = None,
+    ) -> None:
+        self.app = app
+        self._client = GateClient(
+            api_key=api_key,
+            min_grade=min_grade,
+            min_score=min_score,
+            require_verified_activity=require_verified_activity,
+            fail_open=fail_open,
+            cache_seconds=cache_seconds,
+            base_url=base_url,
+        )
+        self._extract_address = extract_address or _default_extract_address
+        self._extract_chain = extract_chain or _default_extract_chain
+        self._on_denied = on_denied or _default_on_denied
+
+    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
+        """ASGI entry point."""
+        if scope["type"] != "http":
+            await self.app(scope, receive, send)
+            return
+
+        request = Request(scope, receive, send)
+
+        address = self._extract_address(request)
+        if not address:
+            if self._client.fail_open:
+                await self.app(scope, receive, send)
+                return
+            reason = DenialReason(code="missing_wallet_address")
+            response = await self._on_denied(request, reason)
+            await response(scope, receive, send)
+            return
+
+        chain = self._extract_chain(request) or "base"
+
+        try:
+            result = await self._client.acheck(address, chain)
+
+            if result.allow:
+                scope["state"] = {**scope.get("state", {}), "agentscore": result.raw}
+                await self.app(scope, receive, send)
+                return
+
+            reason = DenialReason(code="wallet_not_trusted", decision=result.decision, reasons=result.reasons)
+            response = await self._on_denied(request, reason)
+            await response(scope, receive, send)
+        except PaymentRequiredError:
+            if self._client.fail_open:
+                await self.app(scope, receive, send)
+                return
+            reason = DenialReason(code="payment_required")
+            response = await self._on_denied(request, reason)
+            await response(scope, receive, send)
+        except Exception:
+            if self._client.fail_open:
+                await self.app(scope, receive, send)
+                return
+            reason = DenialReason(code="api_error")
+            response = await self._on_denied(request, reason)
+            await response(scope, receive, send)

agentscore_gate/types.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Literal
+
+Grade = Literal["A", "B", "C", "D", "F"]
+
+DenialCode = Literal["wallet_not_trusted", "missing_wallet_address", "api_error", "payment_required"]
+
+
+@dataclass
+class DenialReason:
+    """Reason a request was denied by the gate middleware."""
+
+    code: DenialCode
+    decision: str | None = None
+    reasons: list[str] = field(default_factory=list)
+
+
+@dataclass
+class AssessResult:
+    """Internal result from the AgentScore assess API."""
+
+    allow: bool
+    decision: str | None = None
+    reasons: list[str] = field(default_factory=list)
+    raw: dict[str, Any] | None = None

agentscore_gate-1.0.0.dist-info/METADATA

@@ -0,0 +1,107 @@
+Metadata-Version: 2.4
+Name: agentscore-gate
+Version: 1.0.0
+Summary: Trust-gating middleware for Python web frameworks using AgentScore
+Project-URL: Homepage, https://agentscore.sh
+Project-URL: Repository, https://github.com/agentscore/python-gate
+Project-URL: Issues, https://github.com/agentscore/python-gate/issues
+License-Expression: MIT
+License-File: LICENSE
+Keywords: agent,agentic-payments,agentscore,ai-agent,blockchain,django,erc-8004,fastapi,flask,gate,middleware,reputation,starlette,trust,wallet,x402
+Classifier: Development Status :: 4 - Beta
+Classifier: Framework :: AsyncIO
+Classifier: Framework :: Django
+Classifier: Framework :: FastAPI
+Classifier: Framework :: Flask
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.10
+Requires-Dist: httpx<1.0.0,>=0.25.0
+Provides-Extra: django
+Requires-Dist: django>=4.0; extra == 'django'
+Provides-Extra: fastapi
+Requires-Dist: starlette>=0.27.0; extra == 'fastapi'
+Provides-Extra: flask
+Requires-Dist: flask>=2.0.0; extra == 'flask'
+Provides-Extra: starlette
+Requires-Dist: starlette>=0.27.0; extra == 'starlette'
+Description-Content-Type: text/markdown
+
+# agentscore-gate
+
+[![PyPI version](https://img.shields.io/pypi/v/agentscore-gate.svg)](https://pypi.org/project/agentscore-gate/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+
+ASGI middleware for trust-gating requests using [AgentScore](https://agentscore.sh). Verify AI agent wallet reputation before allowing requests through, built for the [x402](https://github.com/coinbase/x402) payment ecosystem and [ERC-8004](https://eips.ethereum.org/EIPS/eip-8004) agent registry. Works with FastAPI, Starlette, and any ASGI framework.
+
+## Install
+
+```bash
+pip install agentscore-gate
+```
+
+## Quick Start
+
+### FastAPI
+
+```python
+from fastapi import FastAPI
+from agentscore_gate import AgentScoreGate
+
+app = FastAPI()
+app.add_middleware(AgentScoreGate, api_key="ask_...", min_score=50)
+
+@app.get("/")
+async def root():
+    return {"message": "Hello, trusted agent!"}
+```
+
+### Starlette
+
+```python
+from starlette.applications import Starlette
+from starlette.responses import PlainTextResponse
+from starlette.routing import Route
+from agentscore_gate import AgentScoreGate
+
+async def homepage(request):
+    agentscore_data = request.state.agentscore
+    return PlainTextResponse("Hello, trusted agent!")
+
+app = Starlette(routes=[Route("/", homepage)])
+app.add_middleware(AgentScoreGate, api_key="ask_...", min_score=50)
+```
+
+## Options
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `api_key` | `str` | *required* | API key from [agentscore.sh](https://agentscore.sh) |
+| `min_score` | `int \| None` | `None` | Minimum score (0–100) |
+| `min_grade` | `str \| None` | `None` | Minimum grade (A–F) |
+| `require_verified_activity` | `bool \| None` | `None` | Require verified payment activity |
+| `fail_open` | `bool` | `False` | Allow requests when API is unreachable |
+| `cache_seconds` | `int` | `300` | Cache TTL for results |
+| `base_url` | `str` | `https://api.agentscore.sh` | API base URL |
+| `extract_address` | `callable` | Reads `x-wallet-address` header | Custom address extractor |
+| `on_denied` | `async callable` | Returns 403 JSON | Custom denial handler |
+
+## How It Works
+
+1. Extracts wallet address from request header (`x-wallet-address`)
+2. Checks in-memory cache for a previous result
+3. Calls AgentScore `/v1/assess` with your policy
+4. Allows or blocks based on the decision
+5. Attaches data to `request.state.agentscore` on allowed requests
+
+## Documentation
+
+- [API Reference](https://docs.agentscore.sh)
+- [ERC-8004 Standard](https://eips.ethereum.org/EIPS/eip-8004)
+- [x402 Protocol](https://github.com/coinbase/x402)
+
+## License
+
+[MIT](LICENSE)

agentscore_gate-1.0.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+agentscore_gate/__init__.py,sha256=juN16XA46sg7hhZE_yz8U82It49yIZhZTdB2XStpcDE,689
+agentscore_gate/cache.py,sha256=OE5Aqc-pNSU8I06ZB-oDI4uT_yPGI0pIoDFJfNiaT7I,1989
+agentscore_gate/client.py,sha256=P_QiDRq4hoWReOOQhod7-28PngZhQJwXqyzlKcgvbns,4022
+agentscore_gate/django.py,sha256=WMLKn2OBU9NwAT2f80qTm3vapHPRY7W4MDf5zanzFBw,3532
+agentscore_gate/flask.py,sha256=GFD5YwB5FRDAIPhkj91OtBb2p_Gr09QxrY_6mFaIwA4,4465
+agentscore_gate/middleware.py,sha256=Weyu9VkHo-INU7VtcBrjB-PJESSbva51268DI90nJnU,4356
+agentscore_gate/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+agentscore_gate/types.py,sha256=0aP7HuowGgEHtAeWkfZXW3IejA6-vAGecuUQCI9I-4Y,687
+agentscore_gate-1.0.0.dist-info/METADATA,sha256=PzlK2PzqM_Xurl22YfM-IFf7SMo35YGs_b_mwckuMNA,3923
+agentscore_gate-1.0.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+agentscore_gate-1.0.0.dist-info/licenses/LICENSE,sha256=bwu2k82ka0IA05vhtYU4O1oc4tdPEv1FYLdwyxhCAx8,1067
+agentscore_gate-1.0.0.dist-info/RECORD,,

agentscore_gate-1.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

agentscore_gate-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 AgentScore
+
+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.