aaa-server 0.1.0__py3-none-any.whl

aaa_server/__init__.py

@@ -0,0 +1,48 @@
+"""HTTP/SSE server for AAA agents: authentication, tenant isolation, rate limits, quotas and approvals."""
+
+from .a2a import A2AConfig
+from .admission import (
+    ConcurrencyLimiter,
+    Denied,
+    InMemoryRateLimiter,
+    Quota,
+    QuotaStore,
+    RateDecision,
+    RateLimiter,
+    RedisRateLimiter,
+)
+from .app import ServerConfig, clamp_budget, create_app, default_event_view
+from .auth import (
+    ApiKey,
+    ApiKeyAuthenticator,
+    Authenticator,
+    AuthError,
+    JWKSKeys,
+    JWTAuthenticator,
+    Principal,
+    hash_api_key,
+)
+
+__all__ = [
+    "A2AConfig",
+    "ApiKey",
+    "ApiKeyAuthenticator",
+    "AuthError",
+    "Authenticator",
+    "ConcurrencyLimiter",
+    "Denied",
+    "InMemoryRateLimiter",
+    "JWKSKeys",
+    "JWTAuthenticator",
+    "Principal",
+    "Quota",
+    "QuotaStore",
+    "RateDecision",
+    "RateLimiter",
+    "RedisRateLimiter",
+    "ServerConfig",
+    "clamp_budget",
+    "create_app",
+    "default_event_view",
+    "hash_api_key",
+]

aaa_server/a2a.py

@@ -0,0 +1,351 @@
+"""Agent2Agent (A2A) protocol, EXPERIMENTAL: serve one algorithm as an A2A agent.
+
+Targets **A2A 1.0**, the JSON-RPC binding (`SendMessage`, `SendStreamingMessage`, `GetTask`, `ListTasks`, `CancelTask`,
+`SubscribeToTask`) and an agent card at `/.well-known/agent-card.json`. The wire shapes were taken from the protocol's own
+generated types and checked against the official `a2a-sdk` client in the tests. Out of scope: push notifications, the extended
+card, multi-turn tasks (a message naming an existing task is refused), non-text parts, gRPC and REST bindings.
+
+A2A tasks ARE runs: they go through the same authentication, tenant scope, admission and budget as `POST /v1/runs`, and the
+tenant comes only from the credential. A task that parks on a human approval is reported as `TASK_STATE_INPUT_REQUIRED`; the
+approval itself is given through the REST API by a principal with the `approve` scope."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+from collections.abc import AsyncIterator, Callable
+from dataclasses import dataclass, field
+from datetime import UTC, datetime
+from typing import TYPE_CHECKING, Any
+
+from starlette.requests import Request
+from starlette.responses import JSONResponse, Response
+
+from aaa.core.ids import new_id
+from aaa.core.outcome import OutcomeKind
+from aaa.runtime.engine import RUN_COMPLETED, RUNMETA
+from aaa.tools.handler import (
+    APPROVAL_DENIED,
+    APPROVAL_GRANTED,
+    APPROVAL_REQUESTED,
+    COMPLETED,
+    FAILED,
+)
+
+from .auth import Principal
+
+if TYPE_CHECKING:
+    from .app import ServerApp
+
+VERSION = "1.0"
+TASK_NOT_FOUND, NOT_CANCELABLE, UNSUPPORTED_OP = -32001, -32002, -32004
+CONTENT_TYPE, VERSION_UNSUPPORTED = -32005, -32009
+INVALID_REQUEST, METHOD_NOT_FOUND, INVALID_PARAMS, INTERNAL, PARSE_ERROR = (
+    -32600,
+    -32601,
+    -32602,
+    -32603,
+    -32700,
+)
+MAX_TEXT = 100_000
+
+
+def _default_text(value: Any) -> str:
+    if isinstance(value, dict) and isinstance(value.get("text"), str):
+        return value["text"]
+    return value if isinstance(value, str) else json.dumps(value, default=str)
+
+
+@dataclass
+class A2AConfig:
+    """`url` is this server's public address (the card must carry an absolute URL)."""
+
+    algorithm: str  # a key of ServerConfig.algorithms
+    url: str
+    name: str = "AAA agent"
+    description: str = "An agent served by aaa-server."
+    version: str = "0.1"
+    skills: tuple[dict[str, Any], ...] = ()
+    to_input: Callable[[str], dict[str, Any]] = lambda text: {"task": text}
+    result_text: Callable[[Any], str] = _default_text
+    wait_s: float = (
+        300.0  # how long a blocking SendMessage waits before answering with the working task
+    )
+    extra: dict[str, Any] = field(default_factory=dict)
+
+    def card(self) -> dict[str, Any]:
+        skills = list(self.skills) or [
+            {"id": self.algorithm, "name": self.name, "description": self.description, "tags": []}
+        ]
+        return {
+            "name": self.name,
+            "description": self.description,
+            "version": self.version,
+            "supportedInterfaces": [
+                {
+                    "url": self.url.rstrip("/") + "/a2a",
+                    "protocolBinding": "JSONRPC",
+                    "protocolVersion": VERSION,
+                }
+            ],
+            "capabilities": {"streaming": True, "pushNotifications": False},
+            "securitySchemes": {"bearer": {"httpAuthSecurityScheme": {"scheme": "Bearer"}}},
+            "securityRequirements": [{"schemes": {"bearer": {}}}],
+            "defaultInputModes": ["text/plain"],
+            "defaultOutputModes": ["text/plain"],
+            "skills": skills,
+            **self.extra,
+        }
+
+
+class RpcError(Exception):
+    def __init__(self, code: int, message: str) -> None:
+        super().__init__(message)
+        self.code, self.message = code, message
+
+
+def _now() -> str:
+    return datetime.now(UTC).isoformat().replace("+00:00", "Z")
+
+
+def _agent_message(task_id: str, text: str) -> dict[str, Any]:
+    return {
+        "messageId": new_id(),
+        "taskId": task_id,
+        "contextId": task_id,
+        "role": "ROLE_AGENT",
+        "parts": [{"text": text}],
+    }
+
+
+class A2AEndpoint:
+    def __init__(self, app: ServerApp, cfg: A2AConfig) -> None:
+        self.app, self.cfg = app, cfg
+
+    @property
+    def algo(self) -> Any:
+        return self.app.cfg.algorithms[self.cfg.algorithm]
+
+    # -- task views -------------------------------------------------------------------------
+    async def _pending_approval(self, rid: str) -> bool:
+        asked, settled = set(), set()
+        for e in await self.app.engine.store.read(rid):
+            cid = e.data.get("call_id")
+            if e.type == APPROVAL_REQUESTED:
+                asked.add(cid)
+            elif e.type in (APPROVAL_GRANTED, APPROVAL_DENIED, COMPLETED, FAILED):
+                settled.add(cid)
+        return bool(asked - settled)
+
+    async def task(self, p: Principal, rid: str, *, artifacts: bool = True) -> dict[str, Any]:
+        tid = self.app._public(p, rid)
+        meta = await self.app.engine.project(RUNMETA, rid)
+        done, message = meta.completed, None
+        if done is None:
+            if await self._pending_approval(rid):
+                state, message = "TASK_STATE_INPUT_REQUIRED", "waiting for a human approval"
+            else:
+                state = "TASK_STATE_WORKING"
+        else:
+            kind = str(done.get("kind"))
+            state = {
+                OutcomeKind.SUCCESS.value: "TASK_STATE_COMPLETED",
+                OutcomeKind.CANCELLED.value: "TASK_STATE_CANCELED",
+                OutcomeKind.BLOCKED.value: "TASK_STATE_REJECTED",
+            }.get(kind, "TASK_STATE_FAILED")
+            if state != "TASK_STATE_COMPLETED":
+                message = done.get("reason") or str(kind)
+        out: dict[str, Any] = {
+            "id": tid,
+            "contextId": tid,
+            "status": {
+                "state": state,
+                "timestamp": _now(),
+                **({"message": _agent_message(tid, message)} if message else {}),
+            },
+        }
+        if artifacts and state == "TASK_STATE_COMPLETED":
+            out["artifacts"] = [
+                {
+                    "artifactId": "result",
+                    "name": "result",
+                    "parts": [{"text": self.cfg.result_text(done.get("value") if done else None)}],
+                }
+            ]
+        return out
+
+    async def _owned(self, p: Principal, params: dict[str, Any]) -> Any:
+        tid = params.get("id")
+        if not isinstance(tid, str) or not tid:
+            raise RpcError(INVALID_PARAMS, "id is required")
+        try:
+            h = await self.app.engine.tenant(p.tenant).handle(tid)
+            started = await self.app.engine._started_of(h.run_id)
+        except KeyError:
+            raise RpcError(TASK_NOT_FOUND, "task not found") from None
+        if started.data.get("algo") != self.algo.name:
+            raise RpcError(TASK_NOT_FOUND, "task not found")
+        return h
+
+    # -- methods ----------------------------------------------------------------------------
+    def _text_of(self, params: dict[str, Any]) -> str:
+        msg = params.get("message")
+        if not isinstance(msg, dict) or msg.get("role") not in (None, "ROLE_USER"):
+            raise RpcError(INVALID_PARAMS, "message with role ROLE_USER is required")
+        if msg.get("taskId"):
+            raise RpcError(UNSUPPORTED_OP, "continuing an existing task is not supported")
+        parts = msg.get("parts")
+        if not isinstance(parts, list) or not parts:
+            raise RpcError(INVALID_PARAMS, "message.parts is required")
+        texts = []
+        for part in parts:
+            if not isinstance(part, dict) or not isinstance(part.get("text"), str):
+                raise RpcError(CONTENT_TYPE, "only text parts are supported")
+            texts.append(part["text"])
+        text = "\n".join(texts)
+        if len(text) > MAX_TEXT:
+            raise RpcError(INVALID_PARAMS, "message is too long")
+        return text
+
+    async def send(self, p: Principal, params: dict[str, Any]) -> dict[str, Any]:
+        text = self._text_of(params)
+        rid, _ = await self.app.launch(p, self.algo, self.cfg.to_input(text))
+        cfgd = params.get("configuration") or {}
+        if not (isinstance(cfgd, dict) and cfgd.get("returnImmediately")):
+            try:
+                await asyncio.wait_for(self.app.engine.handle(rid).result(), self.cfg.wait_s)
+            except TimeoutError:
+                pass
+        return {"task": await self.task(p, rid)}
+
+    async def get(self, p: Principal, params: dict[str, Any]) -> dict[str, Any]:
+        h = await self._owned(p, params)
+        return await self.task(p, h.run_id)
+
+    async def cancel(self, p: Principal, params: dict[str, Any]) -> dict[str, Any]:
+        h = await self._owned(p, params)
+        if (await self.app.engine.project(RUNMETA, h.run_id)).completed is not None:
+            raise RpcError(NOT_CANCELABLE, "task is already finished")
+        await h.cancel(f"cancelled by {p.subject}")
+        try:
+            await asyncio.wait_for(h.result(), 5)
+        except TimeoutError:
+            pass
+        return await self.task(p, h.run_id)
+
+    async def list(self, p: Principal, params: dict[str, Any]) -> dict[str, Any]:
+        infos = [
+            r
+            for r in await self.app.engine.tenant(p.tenant).runs()
+            if r.started.data.get("algo") == self.algo.name
+        ][-50:]
+        tasks = [await self.task(p, r.stream, artifacts=False) for r in infos]
+        return {
+            "tasks": tasks,
+            "nextPageToken": "",
+            "pageSize": len(tasks),
+            "totalSize": len(tasks),
+        }
+
+    async def frames(
+        self, p: Principal, rid: str, *, snapshot: dict[str, Any]
+    ) -> AsyncIterator[dict[str, Any]]:
+        """StreamResponse objects: the task, then text as it is written, then the terminal status."""
+        tid = snapshot["id"]
+        yield {"task": snapshot}
+        streamed = False
+        start = (
+            (await self.app.engine.store.last_seq(rid)) + 1
+            if snapshot["status"]["state"] != "TASK_STATE_WORKING"
+            else 0
+        )
+        async for e in self.app.engine.store.subscribe(rid, start):
+            if e.type == "aaa.llm.delta" and e.data.get("tag") in (None, "main"):
+                yield {
+                    "artifactUpdate": {
+                        "taskId": tid,
+                        "contextId": tid,
+                        "artifact": {
+                            "artifactId": "stream",
+                            "parts": [{"text": e.data.get("text", "")}],
+                        },
+                        "append": streamed,
+                    }
+                }
+                streamed = True
+            elif e.type == RUN_COMPLETED:
+                final = await self.task(p, rid)
+                if final.get("artifacts"):
+                    yield {
+                        "artifactUpdate": {
+                            "taskId": tid,
+                            "contextId": tid,
+                            "artifact": final["artifacts"][0],
+                            "lastChunk": True,
+                        }
+                    }
+                yield {"statusUpdate": {"taskId": tid, "contextId": tid, "status": final["status"]}}
+                return
+
+    # -- HTTP entry --------------------------------------------------------------------------
+    async def rpc(self, request: Request, p: Principal) -> Response:
+        ver = request.headers.get("a2a-version")
+        raw = await self.app._raw(request)
+        try:
+            msg = json.loads(raw)
+        except ValueError:
+            return JSONResponse(self._err(None, PARSE_ERROR, "parse error"), 400)
+        if (
+            not isinstance(msg, dict)
+            or msg.get("jsonrpc") != "2.0"
+            or not isinstance(msg.get("method"), str)
+        ):
+            return JSONResponse(self._err(None, INVALID_REQUEST, "invalid JSON-RPC request"), 400)
+        id_, method, params = msg.get("id"), msg["method"], msg.get("params") or {}
+        if ver and ver.split(".")[0] != "1":
+            return JSONResponse(self._err(id_, VERSION_UNSUPPORTED, "only A2A 1.x is supported"))
+        if not isinstance(params, dict):
+            return JSONResponse(self._err(id_, INVALID_PARAMS, "params must be an object"))
+        try:
+            if method in ("SendStreamingMessage", "SubscribeToTask"):
+                return await self._stream(p, id_, method, params)
+            fn = {
+                "SendMessage": self.send,
+                "GetTask": self.get,
+                "CancelTask": self.cancel,
+                "ListTasks": self.list,
+            }.get(method)
+            if fn is None:
+                return JSONResponse(
+                    self._err(id_, METHOD_NOT_FOUND, f"method {method!r} is not supported")
+                )
+            return JSONResponse({"jsonrpc": "2.0", "id": id_, "result": await fn(p, params)})
+        except RpcError as e:
+            return JSONResponse(self._err(id_, e.code, e.message))
+
+    async def _stream(
+        self, p: Principal, id_: Any, method: str, params: dict[str, Any]
+    ) -> Response:
+        from contextlib import AsyncExitStack
+
+        if method == "SendStreamingMessage":
+            text = self._text_of(params)
+            rid, _ = await self.app.launch(p, self.algo, self.cfg.to_input(text))
+        else:
+            h = await self._owned(p, params)
+            rid = h.run_id
+            if (await self.app.engine.project(RUNMETA, rid)).completed is not None:
+                raise RpcError(UNSUPPORTED_OP, "task is already finished")
+        snapshot = await self.task(p, rid)
+        stack = AsyncExitStack()
+        await stack.enter_async_context(self.app.streams.hold(p.tenant))
+
+        async def body() -> AsyncIterator[bytes]:
+            async for frame in self.frames(p, rid, snapshot=snapshot):
+                yield f"data: {json.dumps({'jsonrpc': '2.0', 'id': id_, 'result': frame})}\n\n".encode()
+
+        return self.app._stream_response(p, body, stack, trailer=False)
+
+    @staticmethod
+    def _err(id_: Any, code: int, message: str) -> dict[str, Any]:
+        return {"jsonrpc": "2.0", "id": id_, "error": {"code": code, "message": message}}

aaa_server/admission.py

@@ -0,0 +1,247 @@
+"""Admission control: rate limits, concurrency caps and event-sourced usage quotas, all keyed by tenant.
+
+Decisions are made BEFORE any work is started. Quota is a projection over usage events in the same event store
+that holds the runs, so it survives restarts and is the same on every server process; the check-and-reserve is an
+optimistic-concurrency append, so two requests racing for the last unit of quota cannot both win."""
+
+from __future__ import annotations
+
+import time
+from collections import defaultdict
+from collections.abc import Callable
+from contextlib import asynccontextmanager
+from dataclasses import dataclass
+from datetime import UTC, datetime
+from typing import TYPE_CHECKING, Any, Protocol, runtime_checkable
+
+from pydantic import BaseModel
+
+from aaa.core.errors import ConcurrencyError
+from aaa.events import Event, Projection
+
+if TYPE_CHECKING:
+    from collections.abc import AsyncIterator
+
+    from aaa.events import EventStore
+
+
+class Denied(Exception):
+    """A request was refused before any work started. `status` is the HTTP status to answer with."""
+
+    def __init__(self, status: int, code: str, message: str, retry_after: float | None = None):
+        super().__init__(message)
+        self.status, self.code, self.message, self.retry_after = status, code, message, retry_after
+
+
+# -- rate limiting -------------------------------------------------------------------------------
+@dataclass(frozen=True)
+class RateDecision:
+    allowed: bool
+    retry_after: float = 0.0  # seconds until `cost` tokens will be available
+
+
+@runtime_checkable
+class RateLimiter(Protocol):
+    async def take(self, key: str, cost: float = 1.0) -> RateDecision: ...
+
+
+class InMemoryRateLimiter:
+    """Token bucket per key: `burst` tokens, refilled at `per_second`. One process only; use the Redis limiter to
+    share a limit between server processes."""
+
+    def __init__(
+        self, per_second: float, burst: float, *, clock: Callable[[], float] | None = None
+    ) -> None:
+        if per_second <= 0 or burst < 1:
+            raise ValueError("per_second must be > 0 and burst >= 1")
+        self.rate, self.burst = per_second, burst
+        self._clock = clock or time.monotonic
+        self._state: dict[str, tuple[float, float]] = {}  # key -> (tokens, last)
+
+    async def take(self, key: str, cost: float = 1.0) -> RateDecision:
+        now = self._clock()
+        tokens, last = self._state.get(key, (self.burst, now))
+        tokens = min(self.burst, tokens + (now - last) * self.rate)
+        if tokens >= cost:
+            self._state[key] = (tokens - cost, now)
+            return RateDecision(True)
+        self._state[key] = (tokens, now)
+        return RateDecision(False, (cost - tokens) / self.rate)
+
+
+_LUA_BUCKET = """
+local t = redis.call('TIME')
+local now = tonumber(t[1]) + tonumber(t[2]) / 1000000
+local rate, burst, cost = tonumber(ARGV[1]), tonumber(ARGV[2]), tonumber(ARGV[3])
+local s = redis.call('HMGET', KEYS[1], 'tokens', 'ts')
+local tokens, ts = tonumber(s[1]), tonumber(s[2])
+if tokens == nil then tokens, ts = burst, now end
+tokens = math.min(burst, tokens + math.max(0, now - ts) * rate)
+local ok, wait = 0, 0
+if tokens >= cost then tokens = tokens - cost; ok = 1 else wait = (cost - tokens) / rate end
+redis.call('HSET', KEYS[1], 'tokens', tostring(tokens), 'ts', tostring(now))
+redis.call('PEXPIRE', KEYS[1], math.ceil(burst / rate * 1000) + 1000)
+return {ok, tostring(wait)}
+"""
+
+
+class RedisRateLimiter:
+    """The same token bucket in Redis, evaluated atomically by a Lua script, so every server process shares one
+    limit. Time comes from the Redis server (`TIME`), not from the callers' clocks."""
+
+    def __init__(self, redis: Any, per_second: float, burst: float, *, prefix: str = "aaa:rl:"):
+        if per_second <= 0 or burst < 1:
+            raise ValueError("per_second must be > 0 and burst >= 1")
+        self.redis, self.rate, self.burst, self.prefix = redis, per_second, burst, prefix
+
+    async def take(self, key: str, cost: float = 1.0) -> RateDecision:
+        ok, wait = await self.redis.eval(
+            _LUA_BUCKET, 1, self.prefix + key, self.rate, self.burst, cost
+        )
+        return RateDecision(bool(int(ok)), float(wait))
+
+
+# -- concurrency ---------------------------------------------------------------------------------
+class ConcurrencyLimiter:
+    """At most `limit` things in flight per key in THIS process (used for open SSE streams)."""
+
+    def __init__(self, limit: int) -> None:
+        self.limit = limit
+        self._n: dict[str, int] = defaultdict(int)
+
+    @asynccontextmanager
+    async def hold(self, key: str) -> AsyncIterator[None]:
+        if self._n[key] >= self.limit:
+            raise Denied(429, "too_many_streams", "too many concurrent streams", retry_after=1.0)
+        self._n[key] += 1
+        try:
+            yield
+        finally:
+            self._n[key] -= 1
+            if self._n[key] <= 0:
+                self._n.pop(key, None)
+
+    def active(self, key: str) -> int:
+        return self._n.get(key, 0)
+
+
+# -- quota ---------------------------------------------------------------------------------------
+ADMITTED = "aaa_server.usage.admitted"
+SETTLED = "aaa_server.usage.settled"
+
+
+class Usage(BaseModel):
+    admitted: int = 0
+    settled: int = 0
+    tokens: int = 0
+    cost: float = 0.0
+
+
+def _fold(u: Usage, e: Event) -> Usage:
+    if e.type == ADMITTED:
+        u.admitted += 1
+    elif e.type == SETTLED:
+        u.settled += 1
+        u.tokens += int(e.data.get("tokens", 0))
+        u.cost += float(e.data.get("cost", 0.0))
+    return u
+
+
+USAGE = Projection(Usage, _fold, name="aaa_server.usage", version=1, state_type=Usage, every=256)
+
+
+class Quota(BaseModel):
+    """Per-tenant limits per UTC day. `None` = unlimited. `max_cost` is checked against spend SETTLED so far
+    (a run's cost is recorded when it finishes), so concurrent runs can overshoot it by what they are still
+    spending; pair it with per-run budgets."""
+
+    max_runs: int | None = None
+    max_tokens: int | None = None
+    max_cost: float | None = None
+
+
+class QuotaStore:
+    def __init__(
+        self,
+        store: EventStore,
+        default: Quota,
+        *,
+        overrides: dict[str, Quota] | None = None,
+        clock: Callable[[], datetime] | None = None,
+    ) -> None:
+        self.store, self.default, self.overrides = store, default, overrides or {}
+        self._clock = clock or (lambda: datetime.now(UTC))
+
+    def limits(self, tenant: str) -> Quota:
+        return self.overrides.get(tenant, self.default)
+
+    def stream(self, tenant: str) -> str:
+        return f"aaa_server.quota/{tenant}/{self._clock():%Y-%m-%d}"
+
+    async def usage(self, tenant: str) -> Usage:
+        return (await USAGE.load(self.store, self.stream(tenant))).state
+
+    async def admit(self, tenant: str, unit_id: str) -> None:
+        """Reserve one run/turn against today's quota or raise `Denied(429)`. Idempotent per `unit_id`."""
+        lim = self.limits(tenant)
+        stream = self.stream(tenant)
+        for _ in range(8):
+            events = await self.store.read(stream)
+            u = USAGE.replay(events)
+            if any(e.id == f"{unit_id}:admit" for e in events):
+                return
+            for cap, used, what in (
+                (lim.max_runs, u.admitted, "runs"),
+                (lim.max_tokens, u.tokens, "tokens"),
+                (lim.max_cost, u.cost, "cost"),
+            ):
+                if cap is not None and used >= cap:
+                    raise Denied(429, "quota_exceeded", f"daily {what} quota exhausted")
+            try:
+                await self.store.append(
+                    stream,
+                    [
+                        Event(
+                            id=f"{unit_id}:admit",
+                            type=ADMITTED,
+                            stream=stream,
+                            tenant=tenant,
+                            source="aaa-server",
+                        )
+                    ],
+                    expected_seq=events[-1].seq if events else -1,
+                )
+                return
+            except ConcurrencyError:
+                continue  # someone else took a unit: re-check against the new total
+        raise Denied(503, "busy", "could not reserve quota, retry", retry_after=1.0)
+
+    async def settle(self, tenant: str, unit_id: str, *, tokens: int, cost: float) -> None:
+        """Record what a finished run actually used (idempotent per `unit_id`)."""
+        stream = self.stream(tenant)
+        await self.store.append(
+            stream,
+            [
+                Event(
+                    id=f"{unit_id}:settle",
+                    type=SETTLED,
+                    stream=stream,
+                    tenant=tenant,
+                    source="aaa-server",
+                    data={"tokens": tokens, "cost": cost},
+                )
+            ],
+        )
+
+
+__all__ = [
+    "ConcurrencyLimiter",
+    "Denied",
+    "InMemoryRateLimiter",
+    "Quota",
+    "QuotaStore",
+    "RateDecision",
+    "RateLimiter",
+    "RedisRateLimiter",
+    "Usage",
+]