phion-client 1.52.9__tar.gz

phion_client-1.52.9/PKG-INFO

@@ -0,0 +1,49 @@
+Metadata-Version: 2.4
+Name: phion-client
+Version: 1.52.9
+Summary: Budget-safe x402 client for PHION agent services
+Author: PHION Systems
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://phion.systems
+Project-URL: Documentation, https://phion.systems/docs
+Project-URL: Source, https://github.com/NeoNine0/phion-agent-connector
+Project-URL: Issues, https://github.com/NeoNine0/phion-agent-connector/issues
+Keywords: agents,mcp,x402,usdc,phion
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: x402<3,>=2.22
+Requires-Dist: eth-account<1,>=0.13
+Requires-Dist: requests<3,>=2.32
+Provides-Extra: test
+Requires-Dist: pytest<9,>=8; extra == "test"
+
+# PHION Python client
+
+Budget-safe synchronous x402 v2 client. It gets a non-paying quote, validates the
+origin, Base network, official USDC contract, PHION recipient and maximum amount,
+then delegates local signing and retry to the official `x402` SDK.
+
+Installing this package never authorizes a payment. A paid call requires an
+explicit `PhionBuyer.call(...)`, a locally supplied wallet key and a
+`SpendingPolicy`. Use a dedicated low-balance wallet and set cumulative, call,
+expiry and service-path limits through `SpendingMandate`.
+
+```bash
+python -m venv .venv
+. .venv/bin/activate
+pip install -e .
+export EVM_PRIVATE_KEY=0x... # dedicated agent wallet; never commit this value
+python example.py
+```
+
+The example has a hard limit of `0.001 USDC` and verifies the signed result.
+
+The public MCP decision surface remains available without this package at
+`https://phion.systems/mcp/decision`; start with `phion_resolve` in `PREFLIGHT`
+mode when payment is not yet authorized.

phion_client-1.52.9/README.md

@@ -0,0 +1,24 @@
+# PHION Python client
+
+Budget-safe synchronous x402 v2 client. It gets a non-paying quote, validates the
+origin, Base network, official USDC contract, PHION recipient and maximum amount,
+then delegates local signing and retry to the official `x402` SDK.
+
+Installing this package never authorizes a payment. A paid call requires an
+explicit `PhionBuyer.call(...)`, a locally supplied wallet key and a
+`SpendingPolicy`. Use a dedicated low-balance wallet and set cumulative, call,
+expiry and service-path limits through `SpendingMandate`.
+
+```bash
+python -m venv .venv
+. .venv/bin/activate
+pip install -e .
+export EVM_PRIVATE_KEY=0x... # dedicated agent wallet; never commit this value
+python example.py
+```
+
+The example has a hard limit of `0.001 USDC` and verifies the signed result.
+
+The public MCP decision surface remains available without this package at
+`https://phion.systems/mcp/decision`; start with `phion_resolve` in `PREFLIGHT`
+mode when payment is not yet authorized.

phion_client-1.52.9/phion_client/__init__.py

@@ -0,0 +1,26 @@
+from .client import (
+    BASE_MAINNET,
+    BASE_USDC,
+    PHION_ORIGIN,
+    PHION_RECEIVER,
+    PhionBuyer,
+    SpendingPolicy,
+    SpendingMandate,
+    authorize_requirement,
+    decode_base64_json,
+)
+
+__version__ = "1.52.9"
+
+__all__ = [
+    "BASE_MAINNET",
+    "BASE_USDC",
+    "PHION_ORIGIN",
+    "PHION_RECEIVER",
+    "PhionBuyer",
+    "SpendingPolicy",
+    "SpendingMandate",
+    "authorize_requirement",
+    "decode_base64_json",
+    "__version__",
+]

phion_client-1.52.9/phion_client/client.py

@@ -0,0 +1,178 @@
+from __future__ import annotations
+
+import base64
+import json
+import threading
+import time
+from dataclasses import dataclass, field
+from typing import Any
+from urllib.parse import urljoin, urlparse
+
+import requests
+
+PHION_ORIGIN = "https://phion.systems"
+BASE_MAINNET = "eip155:8453"
+BASE_USDC = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"
+PHION_RECEIVER = "0x7BEcA68DD9aC733D4de6b16d16B85Dc391c071e2"
+
+
+@dataclass(frozen=True)
+class SpendingPolicy:
+    """All amounts use atomic USDC units: 1,000 = 0.001 USDC."""
+
+    max_atomic: int
+    allowed_origins: tuple[str, ...] = (PHION_ORIGIN,)
+    allowed_networks: tuple[str, ...] = (BASE_MAINNET,)
+    allowed_assets: tuple[str, ...] = (BASE_USDC,)
+    allowed_recipients: tuple[str, ...] = (PHION_RECEIVER,)
+    allowed_paths: tuple[str, ...] | None = None
+    max_total_atomic: int | None = None
+    max_calls: int | None = None
+    expires_at: int | None = None
+
+
+class SpendingMandate:
+    """Thread-safe, conservative in-process authorization budget."""
+
+    def __init__(
+        self,
+        policy: SpendingPolicy,
+        *,
+        authorized_atomic: int = 0,
+        calls: int = 0,
+    ):
+        if authorized_atomic < 0 or calls < 0:
+            raise ValueError("Invalid mandate snapshot")
+        if policy.max_total_atomic is not None and authorized_atomic > policy.max_total_atomic:
+            raise ValueError("Mandate snapshot exceeds cumulative limit")
+        self.policy = policy
+        self._authorized_atomic = authorized_atomic
+        self._calls = calls
+        self._lock = threading.Lock()
+
+    def authorize(self, requirement: dict[str, Any], url: str) -> None:
+        path = urlparse(url).path
+        with self._lock:
+            if self.policy.allowed_paths is not None and path not in self.policy.allowed_paths:
+                raise ValueError(f"Service path is not allowed: {path}")
+            if self.policy.expires_at is not None and int(time.time()) >= self.policy.expires_at:
+                raise ValueError("Spending mandate has expired")
+            if self.policy.max_calls is not None and self._calls >= self.policy.max_calls:
+                raise ValueError("Spending mandate call limit reached")
+            amount = int(requirement["amount"])
+            if (
+                self.policy.max_total_atomic is not None
+                and self._authorized_atomic + amount > self.policy.max_total_atomic
+            ):
+                raise ValueError("Spending mandate cumulative limit exceeded")
+            # Reserve before signing. Unknown settlements remain counted to avoid overspend.
+            self._authorized_atomic += amount
+            self._calls += 1
+
+    def snapshot(self) -> dict[str, int | None]:
+        with self._lock:
+            total = self.policy.max_total_atomic
+            return {
+                "authorized_atomic": self._authorized_atomic,
+                "calls": self._calls,
+                "remaining_atomic": None if total is None else total - self._authorized_atomic,
+            }
+
+
+def decode_base64_json(value: str) -> dict[str, Any]:
+    padding = "=" * (-len(value) % 4)
+    return json.loads(base64.urlsafe_b64decode(value + padding))
+
+
+def _contains(values: tuple[str, ...], candidate: str) -> bool:
+    return candidate.casefold() in {value.casefold() for value in values}
+
+
+def authorize_requirement(
+    challenge: dict[str, Any], url: str, policy: SpendingPolicy
+) -> dict[str, Any]:
+    if challenge.get("x402Version") != 2:
+        raise ValueError("PHION returned an invalid x402 v2 challenge")
+    requirement = next(
+        (item for item in challenge.get("accepts", []) if item.get("scheme") == "exact"),
+        None,
+    )
+    if requirement is None:
+        raise ValueError("No supported exact payment requirement")
+
+    parsed = urlparse(url)
+    origin = f"{parsed.scheme}://{parsed.netloc}"
+    checks = (
+        (_contains(policy.allowed_origins, origin), f"Origin is not allowed: {origin}"),
+        (_contains(policy.allowed_networks, requirement.get("network", "")), "Network is not allowed"),
+        (_contains(policy.allowed_assets, requirement.get("asset", "")), "Asset is not allowed"),
+        (_contains(policy.allowed_recipients, requirement.get("payTo", "")), "Recipient is not allowed"),
+    )
+    for accepted, message in checks:
+        if not accepted:
+            raise ValueError(message)
+    amount_text = requirement.get("amount", "")
+    if not isinstance(amount_text, str) or not amount_text.isdigit():
+        raise ValueError("Payment amount must be an atomic-unit integer")
+    if int(amount_text) > policy.max_atomic:
+        raise ValueError(f"Price {amount_text} exceeds limit {policy.max_atomic}")
+    return requirement
+
+
+class PhionBuyer:
+    def __init__(self, private_key: str):
+        # Imports stay here so policy validation can be tested without wallet packages.
+        from eth_account import Account
+        from x402 import x402ClientSync
+        from x402.mechanisms.evm import EthAccountSigner
+        from x402.mechanisms.evm.exact.register import register_exact_evm_client
+
+        self._client = x402ClientSync()
+        register_exact_evm_client(
+            self._client, EthAccountSigner(Account.from_key(private_key))
+        )
+
+    def call(
+        self, path: str, body: dict[str, Any], policy: SpendingPolicy | SpendingMandate
+    ) -> dict[str, Any]:
+        from x402.http.clients import x402_requests
+
+        url = urljoin(f"{PHION_ORIGIN}/", path.lstrip("/"))
+        # Quote first without a signer. This request cannot charge.
+        quote = requests.post(url, json=body, timeout=30)
+        if quote.status_code != 402:
+            raise RuntimeError(f"Expected an x402 quote, received HTTP {quote.status_code}")
+        encoded = quote.headers.get("PAYMENT-REQUIRED")
+        if not encoded:
+            raise RuntimeError("Missing PAYMENT-REQUIRED header")
+        effective_policy = policy.policy if isinstance(policy, SpendingMandate) else policy
+        requirement = authorize_requirement(decode_base64_json(encoded), url, effective_policy)
+        if isinstance(policy, SpendingMandate):
+            policy.authorize(requirement, url)
+
+        with x402_requests(self._client) as session:
+            response = session.post(url, json=body, timeout=60)
+        if not response.ok:
+            raise RuntimeError(
+                f"Paid PHION call failed with HTTP {response.status_code}: {response.text}"
+            )
+        settlement_header = response.headers.get("PAYMENT-RESPONSE")
+        return {
+            "data": response.json(),
+            "requirement": requirement,
+            "settlement": decode_base64_json(settlement_header)
+            if settlement_header
+            else None,
+        }
+
+    @staticmethod
+    def verify_receipt(
+        receipt: dict[str, Any], content: Any, sources: list[dict[str, Any]] | None = None
+    ) -> bool:
+        response = requests.post(
+            f"{PHION_ORIGIN}/v1/verify",
+            json={"receipt": receipt, "content": content, "sources": sources or []},
+            timeout=30,
+        )
+        response.raise_for_status()
+        return response.json().get("valid") is True

phion_client-1.52.9/phion_client.egg-info/PKG-INFO

@@ -0,0 +1,49 @@
+Metadata-Version: 2.4
+Name: phion-client
+Version: 1.52.9
+Summary: Budget-safe x402 client for PHION agent services
+Author: PHION Systems
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://phion.systems
+Project-URL: Documentation, https://phion.systems/docs
+Project-URL: Source, https://github.com/NeoNine0/phion-agent-connector
+Project-URL: Issues, https://github.com/NeoNine0/phion-agent-connector/issues
+Keywords: agents,mcp,x402,usdc,phion
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: x402<3,>=2.22
+Requires-Dist: eth-account<1,>=0.13
+Requires-Dist: requests<3,>=2.32
+Provides-Extra: test
+Requires-Dist: pytest<9,>=8; extra == "test"
+
+# PHION Python client
+
+Budget-safe synchronous x402 v2 client. It gets a non-paying quote, validates the
+origin, Base network, official USDC contract, PHION recipient and maximum amount,
+then delegates local signing and retry to the official `x402` SDK.
+
+Installing this package never authorizes a payment. A paid call requires an
+explicit `PhionBuyer.call(...)`, a locally supplied wallet key and a
+`SpendingPolicy`. Use a dedicated low-balance wallet and set cumulative, call,
+expiry and service-path limits through `SpendingMandate`.
+
+```bash
+python -m venv .venv
+. .venv/bin/activate
+pip install -e .
+export EVM_PRIVATE_KEY=0x... # dedicated agent wallet; never commit this value
+python example.py
+```
+
+The example has a hard limit of `0.001 USDC` and verifies the signed result.
+
+The public MCP decision surface remains available without this package at
+`https://phion.systems/mcp/decision`; start with `phion_resolve` in `PREFLIGHT`
+mode when payment is not yet authorized.

phion_client-1.52.9/phion_client.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+README.md
+pyproject.toml
+phion_client/__init__.py
+phion_client/client.py
+phion_client.egg-info/PKG-INFO
+phion_client.egg-info/SOURCES.txt
+phion_client.egg-info/dependency_links.txt
+phion_client.egg-info/requires.txt
+phion_client.egg-info/top_level.txt
+tests/test_policy.py

phion_client-1.52.9/phion_client.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

phion_client-1.52.9/phion_client.egg-info/requires.txt

@@ -0,0 +1,6 @@
+x402<3,>=2.22
+eth-account<1,>=0.13
+requests<3,>=2.32
+
+[test]
+pytest<9,>=8

phion_client-1.52.9/phion_client.egg-info/top_level.txt

@@ -0,0 +1 @@
+phion_client

phion_client-1.52.9/pyproject.toml

@@ -0,0 +1,39 @@
+[build-system]
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "phion-client"
+version = "1.52.9"
+description = "Budget-safe x402 client for PHION agent services"
+readme = "README.md"
+license = "Apache-2.0"
+authors = [{ name = "PHION Systems" }]
+requires-python = ">=3.11"
+dependencies = [
+  "x402>=2.22,<3",
+  "eth-account>=0.13,<1",
+  "requests>=2.32,<3"
+]
+
+keywords = ["agents", "mcp", "x402", "usdc", "phion"]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Intended Audience :: Developers",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Topic :: Software Development :: Libraries :: Python Modules",
+]
+
+[project.urls]
+Homepage = "https://phion.systems"
+Documentation = "https://phion.systems/docs"
+Source = "https://github.com/NeoNine0/phion-agent-connector"
+Issues = "https://github.com/NeoNine0/phion-agent-connector/issues"
+
+[project.optional-dependencies]
+test = ["pytest>=8,<9"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

phion_client-1.52.9/setup.cfg

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

phion_client-1.52.9/tests/test_policy.py

@@ -0,0 +1,79 @@
+import pytest
+
+from phion_client import (
+    BASE_MAINNET,
+    BASE_USDC,
+    PHION_RECEIVER,
+    SpendingPolicy,
+    SpendingMandate,
+    authorize_requirement,
+    __version__,
+)
+
+
+def test_package_version_matches_phion_release():
+    assert __version__ == "1.52.9"
+
+
+def challenge():
+    return {
+        "x402Version": 2,
+        "accepts": [{
+            "scheme": "exact",
+            "network": BASE_MAINNET,
+            "asset": BASE_USDC,
+            "amount": "1000",
+            "payTo": PHION_RECEIVER,
+        }],
+    }
+
+
+def test_accepts_quote_within_budget():
+    result = authorize_requirement(
+        challenge(), "https://phion.systems/v1/paid/attest", SpendingPolicy(1000)
+    )
+    assert result["amount"] == "1000"
+
+
+def test_rejects_quote_above_budget():
+    with pytest.raises(ValueError, match="exceeds limit"):
+        authorize_requirement(
+            challenge(), "https://phion.systems/v1/paid/attest", SpendingPolicy(999)
+        )
+
+
+def test_rejects_recipient_substitution():
+    value = challenge()
+    value["accepts"][0]["payTo"] = "0x0000000000000000000000000000000000000001"
+    with pytest.raises(ValueError, match="Recipient"):
+        authorize_requirement(
+            value, "https://phion.systems/v1/paid/attest", SpendingPolicy(1000)
+        )
+
+
+def test_rejects_untrusted_origin():
+    with pytest.raises(ValueError, match="Origin"):
+        authorize_requirement(challenge(), "https://evil.example/attest", SpendingPolicy(1000))
+
+
+def test_mandate_enforces_cumulative_and_service_limits():
+    mandate = SpendingMandate(
+        SpendingPolicy(
+            max_atomic=1_000,
+            max_total_atomic=2_000,
+            max_calls=2,
+            allowed_paths=("/v1/paid/attest",),
+        )
+    )
+    requirement = authorize_requirement(
+        challenge(), "https://phion.systems/v1/paid/attest", mandate.policy
+    )
+    mandate.authorize(requirement, "https://phion.systems/v1/paid/attest")
+    mandate.authorize(requirement, "https://phion.systems/v1/paid/attest")
+    assert mandate.snapshot() == {
+        "authorized_atomic": 2_000,
+        "calls": 2,
+        "remaining_atomic": 0,
+    }
+    with pytest.raises(ValueError, match="call limit"):
+        mandate.authorize(requirement, "https://phion.systems/v1/paid/attest")