sweetai-agent-firewall 0.1.0__tar.gz

sweetai_agent_firewall-0.1.0/LICENSE

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

sweetai_agent_firewall-0.1.0/PKG-INFO

@@ -0,0 +1,69 @@
+Metadata-Version: 2.4
+Name: sweetai-agent-firewall
+Version: 0.1.0
+Summary: Pre-transaction trust firewall for AI agents: should-i-pay decisions, sybil forensics, liveness SLA (SweetAI x402 / ERC-8004)
+Author-email: SweetAI <tiamatboss@gmail.com>
+License: MIT
+Project-URL: Homepage, https://sweetai.tiamatcrypto.com
+Project-URL: Documentation, https://sweetai.tiamatcrypto.com/llms.txt
+Project-URL: MCP, https://sweetai.tiamatcrypto.com/mcp
+Project-URL: Source, https://sweetai.tiamatcrypto.com/agent.json
+Keywords: x402,erc-8004,ai-agents,agent-payments,sybil,trust,mcp,crypto,usdc,base,solana,a2a
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Security
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: httpx>=0.24
+Dynamic: license-file
+
+# sweetai-agent-firewall
+
+**Pre-transaction trust firewall for AI agents.** Ask *"should I pay agent X $N?"* before any agent-to-agent payment — one call, $0.02, no API key, no subscription (x402 / USDC).
+
+```python
+from sweetai_firewall import SweetAIFirewall
+
+fw = SweetAIFirewall()
+result = fw.should_i_pay(agent_id=55985, amount_usd=25)
+print(result.verdict)
+# pay 0.02 USDC on eip155:8453, ... to 0x... to unlock the 25.0 USD decision
+```
+
+After your agent settles the 0.02 USDC payment (x402 `X-PAYMENT` header), the
+same call returns the full decision:
+
+```python
+result.action          # "PAY" / "CAUTION" / "SKIP"
+result.confidence      # 0.0 - 1.0
+result.expected_loss_usd  # expected loss sized to YOUR amount
+```
+
+## What's under the hood
+
+- **ERC-8004 / Solana-8004 on-chain feedback** analytics (Base, Ethereum, X Layer, Solana, Bittensor)
+- **Sybil forensics**: reviewer concentration (Herfindahl), ghost-reviewer ratio, burst detection
+- **Liveness SLA**: p50/p95 latency + flap counts, probed every 15 min
+- **x402 pay-per-call**: 0.02 USDC per decision on Base/Polygon/Arbitrum/Avalanche/Sei/X Layer/Solana
+
+## Free surfaces (no payment needed)
+
+```python
+fw.status()               # live index stats
+fw.network_sybil_overview()  # risk tiers across all indexed agents
+fw.pricing()              # current prices
+```
+
+## MCP alternative
+
+All tools are also available as an MCP server for Claude Desktop / Cursor / any MCP agent:
+
+```json
+{"mcpServers": {"sweetai-agent-intel": {"url": "https://sweetai.tiamatcrypto.com/mcp", "transport": "http"}}}
+```
+
+Docs: <https://sweetai.tiamatcrypto.com/llms.txt> · Manifest: `/.well-known/x402` · agent.json: `/agent.json`

sweetai_agent_firewall-0.1.0/README.md

@@ -0,0 +1,46 @@
+# sweetai-agent-firewall
+
+**Pre-transaction trust firewall for AI agents.** Ask *"should I pay agent X $N?"* before any agent-to-agent payment — one call, $0.02, no API key, no subscription (x402 / USDC).
+
+```python
+from sweetai_firewall import SweetAIFirewall
+
+fw = SweetAIFirewall()
+result = fw.should_i_pay(agent_id=55985, amount_usd=25)
+print(result.verdict)
+# pay 0.02 USDC on eip155:8453, ... to 0x... to unlock the 25.0 USD decision
+```
+
+After your agent settles the 0.02 USDC payment (x402 `X-PAYMENT` header), the
+same call returns the full decision:
+
+```python
+result.action          # "PAY" / "CAUTION" / "SKIP"
+result.confidence      # 0.0 - 1.0
+result.expected_loss_usd  # expected loss sized to YOUR amount
+```
+
+## What's under the hood
+
+- **ERC-8004 / Solana-8004 on-chain feedback** analytics (Base, Ethereum, X Layer, Solana, Bittensor)
+- **Sybil forensics**: reviewer concentration (Herfindahl), ghost-reviewer ratio, burst detection
+- **Liveness SLA**: p50/p95 latency + flap counts, probed every 15 min
+- **x402 pay-per-call**: 0.02 USDC per decision on Base/Polygon/Arbitrum/Avalanche/Sei/X Layer/Solana
+
+## Free surfaces (no payment needed)
+
+```python
+fw.status()               # live index stats
+fw.network_sybil_overview()  # risk tiers across all indexed agents
+fw.pricing()              # current prices
+```
+
+## MCP alternative
+
+All tools are also available as an MCP server for Claude Desktop / Cursor / any MCP agent:
+
+```json
+{"mcpServers": {"sweetai-agent-intel": {"url": "https://sweetai.tiamatcrypto.com/mcp", "transport": "http"}}}
+```
+
+Docs: <https://sweetai.tiamatcrypto.com/llms.txt> · Manifest: `/.well-known/x402` · agent.json: `/agent.json`

sweetai_agent_firewall-0.1.0/pyproject.toml

@@ -0,0 +1,35 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "sweetai-agent-firewall"
+version = "0.1.0"
+description = "Pre-transaction trust firewall for AI agents: should-i-pay decisions, sybil forensics, liveness SLA (SweetAI x402 / ERC-8004)"
+readme = "README.md"
+requires-python = ">=3.9"
+license = {text = "MIT"}
+authors = [{name = "SweetAI", email = "tiamatboss@gmail.com"}]
+keywords = [
+  "x402", "erc-8004", "ai-agents", "agent-payments", "sybil",
+  "trust", "mcp", "crypto", "usdc", "base", "solana", "a2a",
+]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Intended Audience :: Developers",
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3",
+  "Topic :: Software Development :: Libraries :: Python Modules",
+  "Topic :: Security",
+]
+dependencies = ["httpx>=0.24"]
+
+[project.urls]
+Homepage = "https://sweetai.tiamatcrypto.com"
+Documentation = "https://sweetai.tiamatcrypto.com/llms.txt"
+MCP = "https://sweetai.tiamatcrypto.com/mcp"
+Source = "https://sweetai.tiamatcrypto.com/agent.json"
+
+[tool.setuptools]
+packages = ["sweetai_firewall"]
+package-dir = {"" = "src"}

sweetai_agent_firewall-0.1.0/setup.cfg

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

sweetai_agent_firewall-0.1.0/src/sweetai_agent_firewall.egg-info/PKG-INFO

@@ -0,0 +1,69 @@
+Metadata-Version: 2.4
+Name: sweetai-agent-firewall
+Version: 0.1.0
+Summary: Pre-transaction trust firewall for AI agents: should-i-pay decisions, sybil forensics, liveness SLA (SweetAI x402 / ERC-8004)
+Author-email: SweetAI <tiamatboss@gmail.com>
+License: MIT
+Project-URL: Homepage, https://sweetai.tiamatcrypto.com
+Project-URL: Documentation, https://sweetai.tiamatcrypto.com/llms.txt
+Project-URL: MCP, https://sweetai.tiamatcrypto.com/mcp
+Project-URL: Source, https://sweetai.tiamatcrypto.com/agent.json
+Keywords: x402,erc-8004,ai-agents,agent-payments,sybil,trust,mcp,crypto,usdc,base,solana,a2a
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Security
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: httpx>=0.24
+Dynamic: license-file
+
+# sweetai-agent-firewall
+
+**Pre-transaction trust firewall for AI agents.** Ask *"should I pay agent X $N?"* before any agent-to-agent payment — one call, $0.02, no API key, no subscription (x402 / USDC).
+
+```python
+from sweetai_firewall import SweetAIFirewall
+
+fw = SweetAIFirewall()
+result = fw.should_i_pay(agent_id=55985, amount_usd=25)
+print(result.verdict)
+# pay 0.02 USDC on eip155:8453, ... to 0x... to unlock the 25.0 USD decision
+```
+
+After your agent settles the 0.02 USDC payment (x402 `X-PAYMENT` header), the
+same call returns the full decision:
+
+```python
+result.action          # "PAY" / "CAUTION" / "SKIP"
+result.confidence      # 0.0 - 1.0
+result.expected_loss_usd  # expected loss sized to YOUR amount
+```
+
+## What's under the hood
+
+- **ERC-8004 / Solana-8004 on-chain feedback** analytics (Base, Ethereum, X Layer, Solana, Bittensor)
+- **Sybil forensics**: reviewer concentration (Herfindahl), ghost-reviewer ratio, burst detection
+- **Liveness SLA**: p50/p95 latency + flap counts, probed every 15 min
+- **x402 pay-per-call**: 0.02 USDC per decision on Base/Polygon/Arbitrum/Avalanche/Sei/X Layer/Solana
+
+## Free surfaces (no payment needed)
+
+```python
+fw.status()               # live index stats
+fw.network_sybil_overview()  # risk tiers across all indexed agents
+fw.pricing()              # current prices
+```
+
+## MCP alternative
+
+All tools are also available as an MCP server for Claude Desktop / Cursor / any MCP agent:
+
+```json
+{"mcpServers": {"sweetai-agent-intel": {"url": "https://sweetai.tiamatcrypto.com/mcp", "transport": "http"}}}
+```
+
+Docs: <https://sweetai.tiamatcrypto.com/llms.txt> · Manifest: `/.well-known/x402` · agent.json: `/agent.json`

sweetai_agent_firewall-0.1.0/src/sweetai_agent_firewall.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+LICENSE
+README.md
+pyproject.toml
+src/sweetai_agent_firewall.egg-info/PKG-INFO
+src/sweetai_agent_firewall.egg-info/SOURCES.txt
+src/sweetai_agent_firewall.egg-info/dependency_links.txt
+src/sweetai_agent_firewall.egg-info/requires.txt
+src/sweetai_agent_firewall.egg-info/top_level.txt
+src/sweetai_firewall/__init__.py
+src/sweetai_firewall/client.py

sweetai_agent_firewall-0.1.0/src/sweetai_agent_firewall.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

sweetai_agent_firewall-0.1.0/src/sweetai_agent_firewall.egg-info/requires.txt

@@ -0,0 +1 @@
+httpx>=0.24

sweetai_agent_firewall-0.1.0/src/sweetai_agent_firewall.egg-info/top_level.txt

@@ -0,0 +1 @@
+sweetai_firewall

sweetai_agent_firewall-0.1.0/src/sweetai_firewall/__init__.py

@@ -0,0 +1,16 @@
+"""SweetAI pre-transaction trust firewall for AI agents.
+
+One call before any agent-to-agent payment:
+
+    from sweetai_firewall import SweetAIFirewall
+    fw = SweetAIFirewall()
+    fw.should_i_pay(agent_id=55985, amount_usd=25)
+    # -> {"action": "SKIP", "confidence": 0.9, "expected_loss_usd": 22.5, ...}
+
+Pay $0.02 per call via x402 (USDC, Base/Polygon/Arbitrum/Avalanche/Sei/X Layer/Solana).
+No API key, no subscription.
+"""
+from .client import SweetAIFirewall, ShouldIPayResult
+
+__all__ = ["SweetAIFirewall", "ShouldIPayResult"]
+__version__ = "0.1.0"

sweetai_agent_firewall-0.1.0/src/sweetai_firewall/client.py

@@ -0,0 +1,164 @@
+"""HTTP client for the SweetAI x402 trust API.
+
+The firewall endpoints are pay-per-call via the x402 protocol: the first
+request returns HTTP 402 with a PAYMENT-REQUIRED header describing exactly
+what to pay, to whom, on which chain. This client does three things:
+
+1. Free endpoints (/status, teaser aggregates) are plain GETs.
+2. ``should_i_pay`` / ``trust_forensics`` surface the 402 payment
+   requirements in a structured, agent-readable form (the caller — an AI
+   agent with a wallet — completes the x402 payment itself).
+3. Nothing is ever cached longer than the answer's own TTL.
+"""
+from __future__ import annotations
+
+import base64
+from dataclasses import dataclass, field
+from typing import Any, Dict, Optional
+
+import httpx
+
+DEFAULT_BASE_URL = "https://sweetai.tiamatcrypto.com"
+SHOULD_I_PAY_PRICE_USD = 0.02
+
+
+@dataclass
+class ShouldIPayResult:
+    """Structured result of a pre-payment decision."""
+
+    agent_id: Optional[int]
+    solana_asset: Optional[str]
+    amount_usd: float
+    payment_required: bool
+    price_usd: float
+    pay_to: Optional[str]
+    networks: list = field(default_factory=list)
+    action: Optional[str] = None          # PAY / CAUTION / SKIP (after paying)
+    confidence: Optional[float] = None
+    expected_loss_usd: Optional[float] = None
+    raw: Dict[str, Any] = field(default_factory=dict)
+
+    @property
+    def verdict(self) -> str:
+        """Human/agent-readable one-liner for logs."""
+        if self.payment_required:
+            nets = ", ".join(self.networks) or "x402 network"
+            return (
+                f"pay {self.price_usd} USDC on {nets} to {self.pay_to} "
+                f"to unlock the {self.amount_usd} USD decision"
+            )
+        return f"{self.action} (confidence {self.confidence}, expected loss {self.expected_loss_usd} USD)"
+
+
+class SweetAIFirewall:
+    """Pre-transaction risk firewall powered by SweetAI.
+
+    Checks the target agent's on-chain reputation (ERC-8004 feedback,
+    sybil forensics, liveness SLA) before your agent wires funds.
+
+    Usage — decision-first:
+        fw = SweetAIFirewall()
+        result = fw.should_i_pay(agent_id=55985, amount_usd=25)
+        print(result.verdict)
+
+    The x402 payment itself (0.02 USDC per should-i-pay call) is done by
+    your agent's wallet using the structured ``accepts`` list returned in
+    ``result.raw`` — see https://sweetai.tiamatcrypto.com/llms.txt.
+    """
+
+    def __init__(self, base_url: str = DEFAULT_BASE_URL, timeout: float = 15.0):
+        self.base_url = base_url.rstrip("/")
+        self._client = httpx.Client(timeout=timeout)
+
+    # ------------------------------------------------------------------
+    # Free surfaces
+    # ------------------------------------------------------------------
+    def status(self) -> Dict[str, Any]:
+        """Live index stats (agents, feedbacks, chains) — free."""
+        return self._client.get(f"{self.base_url}/api/v1/status").json()
+
+    def network_sybil_overview(self) -> Dict[str, Any]:
+        """Free teaser from the global trust-forensics gate: risk tiers
+        across all indexed agents without paying."""
+        res = self._client.get(f"{self.base_url}/api/v1/trust-forensics", params={"limit": 1})
+        if res.status_code == 402:
+            return res.json().get("teaser", {})
+        return res.json()
+
+    def pricing(self) -> Dict[str, Any]:
+        """Current per-endpoint prices."""
+        return self._client.get(f"{self.base_url}/api/v1/pricing").json()
+
+    # ------------------------------------------------------------------
+    # Paid: the flagship pre-payment decision
+    # ------------------------------------------------------------------
+    def should_i_pay(
+        self,
+        agent_id: Optional[int] = None,
+        solana_asset: Optional[str] = None,
+        amount_usd: float = 0.05,
+    ) -> ShouldIPayResult:
+        """"Should I pay agent X $N?" — the decision BEFORE the payment.
+
+        Returns a :class:`ShouldIPayResult`. On first contact the endpoint
+        answers HTTP 402 (x402 protocol); the result then carries the
+        exact price (0.02 USDC), the payTo address and every accepted
+        network so a wallet-holding agent can settle and re-call with the
+        X-PAYMENT header.
+        """
+        params: Dict[str, Any] = {"amount_usd": amount_usd}
+        if agent_id is not None:
+            params["agent_id"] = agent_id
+        elif solana_asset:
+            params["solana_asset"] = solana_asset
+        else:
+            raise ValueError("pass agent_id (ERC-8004) or solana_asset (Solana pubkey)")
+
+        res = self._client.get(f"{self.base_url}/api/v1/should-i-pay", params=params)
+        out = ShouldIPayResult(
+            agent_id=agent_id,
+            solana_asset=solana_asset,
+            amount_usd=amount_usd,
+            payment_required=(res.status_code == 402),
+            price_usd=SHOULD_I_PAY_PRICE_USD,
+            pay_to=None,
+        )
+        if res.status_code == 402:
+            header = res.headers.get("payment-required") or ""
+            try:
+                req = json_loads_b64(header)
+                accepts = req.get("accepts", [])
+                out.pay_to = next((a.get("payTo") for a in accepts if a.get("payTo")), None)
+                out.networks = [a.get("network") for a in accepts if a.get("network")]
+                out.raw = req
+            except Exception:  # header missing/malformed — keep 402 info minimal
+                out.raw = {"status_code": 402}
+            out.raw["teaser"] = _safe_json(res)
+            return out
+
+        body = res.json()
+        out.action = body.get("action")
+        out.confidence = body.get("confidence")
+        out.expected_loss_usd = body.get("expected_loss_usd")
+        out.raw = body
+        return out
+
+    def close(self) -> None:
+        self._client.close()
+
+    def __enter__(self) -> "SweetAIFirewall":
+        return self
+
+    def __exit__(self, *exc) -> None:
+        self.close()
+
+
+def json_loads_b64(value: str) -> Dict[str, Any]:
+    return dict(__import__("json").loads(base64.b64decode(value)))
+
+
+def _safe_json(res: httpx.Response) -> Any:
+    try:
+        return res.json()
+    except Exception:
+        return {"body": res.text[:500]}