ausca 0.0.2__py3-none-any.whl

ausca/__init__.py

@@ -0,0 +1,47 @@
+"""Ausca: metered agent infrastructure services, paid per call."""
+
+from ausca.artifacts import (
+    MAX_ARTIFACT_BYTES,
+    ArtifactCommitment,
+    ArtifactError,
+    ArtifactStore,
+    AuscaArtifactStore,
+)
+from ausca.client import (
+    CATALOG_URL,
+    ORIGIN,
+    SKILL_URL,
+    AuscaClient,
+    AuscaError,
+    InvocationResult,
+    Offer,
+    Price,
+    PriceOption,
+)
+from ausca.payment import (
+    InertAuthority,
+    LocalKeyAuthority,
+    PaymentAuthority,
+    PaymentReceipt,
+)
+
+__all__ = [
+    "ArtifactCommitment",
+    "ArtifactError",
+    "ArtifactStore",
+    "AuscaArtifactStore",
+    "AuscaClient",
+    "AuscaError",
+    "CATALOG_URL",
+    "InertAuthority",
+    "InvocationResult",
+    "LocalKeyAuthority",
+    "ORIGIN",
+    "Offer",
+    "PaymentAuthority",
+    "PaymentReceipt",
+    "Price",
+    "PriceOption",
+    "MAX_ARTIFACT_BYTES",
+    "SKILL_URL",
+]

ausca/artifacts.py

@@ -0,0 +1,97 @@
+"""Artifact commitments for document and media offers.
+
+Artifact-backed offers take an immutable input commitment instead of raw
+bytes. This port turns bytes into that commitment; Ausca's keyless ingress is
+the default implementation and custom stores remain an explicit seam.
+"""
+
+from __future__ import annotations
+
+import base64
+import hashlib
+from dataclasses import dataclass
+from typing import Protocol
+
+import httpx
+
+AUSCA_ORIGIN = "https://ausca.com"
+MAX_ARTIFACT_BYTES = 25 * 1024 * 1024
+
+
+class ArtifactError(Exception):
+    """A refused or failed artifact operation."""
+
+
+@dataclass(frozen=True)
+class ArtifactCommitment:
+    """The immutable input commitment an artifact-backed offer requires."""
+
+    artifact_ref: str
+    content_digest: str
+    media_type: str
+
+
+class ArtifactStore(Protocol):
+    """Stores bytes and returns the commitment the invocation input carries."""
+
+    def commit(self, data: bytes, media_type: str) -> ArtifactCommitment: ...
+
+
+class AuscaArtifactStore:
+    """Commits bytes through Ausca's keyless temporary artifact ingress."""
+
+    def __init__(
+        self,
+        *,
+        origin: str = AUSCA_ORIGIN,
+        http: httpx.Client | None = None,
+    ) -> None:
+        self._origin = origin.rstrip("/")
+        self._http = http or httpx.Client(timeout=120)
+
+    def commit(self, data: bytes, media_type: str) -> ArtifactCommitment:
+        if not data or len(data) > MAX_ARTIFACT_BYTES:
+            raise ArtifactError(f"artifact must contain 1 to {MAX_ARTIFACT_BYTES} bytes")
+        if not media_type or media_type.strip() != media_type or len(media_type) > 200:
+            raise ArtifactError("artifact media type is invalid")
+        digest_hex = hashlib.sha256(data).hexdigest()
+        content_digest = f"sha256:{digest_hex}"
+        request_hex = hashlib.sha256(
+            f"{content_digest}\n{media_type}".encode()
+        ).hexdigest()
+        response = self._http.post(
+            f"{self._origin}/v1/artifacts",
+            json={
+                "data_base64": base64.b64encode(data).decode(),
+                "content_digest": content_digest,
+                "media_type": media_type,
+                "idempotency_key": f"ausca-artifact-{request_hex[:32]}",
+            },
+        )
+        if response.status_code >= 400:
+            raise ArtifactError(
+                f"artifact ingress answered {response.status_code}: {response.text[:512]}"
+            )
+        try:
+            result = response.json()
+        except ValueError as error:
+            raise ArtifactError("artifact ingress answered non-JSON") from error
+        if set(result) != {"status", "artifact"} or result["status"] != "stored":
+            raise ArtifactError("artifact ingress returned malformed evidence")
+        evidence = result["artifact"]
+        if not isinstance(evidence, dict) or set(evidence) != {
+            "artifact_ref", "content_digest", "created_at", "media_type", "size_bytes"
+        }:
+            raise ArtifactError("artifact ingress returned malformed evidence")
+        artifact_ref = f"runx:artifact:{content_digest}"
+        if (
+            evidence["artifact_ref"] != artifact_ref
+            or evidence["content_digest"] != content_digest
+            or evidence["media_type"] != media_type
+            or evidence["size_bytes"] != len(data)
+            or not isinstance(evidence["created_at"], str)
+        ):
+            raise ArtifactError("artifact ingress returned mismatched evidence")
+        return ArtifactCommitment(
+            artifact_ref=artifact_ref, content_digest=content_digest, media_type=media_type
+        )

ausca/cli.py

@@ -0,0 +1,181 @@
+"""The front-door verbs, mirroring the npm ``ausca`` bin.
+
+Configuration is environment only: a signing key and a mandatory per-call
+USD cap for paying verbs, nothing else. Artifact commits are keyless. Output
+is JSON on stdout.
+"""
+
+from __future__ import annotations
+
+import dataclasses
+import json
+import os
+import sys
+from pathlib import Path
+from typing import Any, Mapping, TextIO
+
+from ausca.client import AuscaClient, ORIGIN
+
+USAGE = """ausca: metered agent infrastructure services, paid per call
+
+  ausca catalog                    active offers, prices, routes
+  ausca price <offer-id>           published price policy
+  ausca invoke <offer-id> [input] [--idempotency-key <key>]
+                                     paid invocation; input inline, @file, or stdin
+  ausca commit <file>              artifact commitment for document and media offers
+
+Environment: AUSCA_PRIVATE_KEY and AUSCA_MAX_PAYMENT_USD pay invocations;
+AUSCA_NETWORK overrides the payment network; AUSCA_ORIGIN overrides the service.
+The MCP server ships in the npm package: npx ausca mcp."""
+
+MEDIA_TYPES = {
+    "pdf": "application/pdf",
+    "png": "image/png",
+    "jpg": "image/jpeg",
+    "jpeg": "image/jpeg",
+    "gif": "image/gif",
+    "webp": "image/webp",
+    "tif": "image/tiff",
+    "tiff": "image/tiff",
+    "txt": "text/plain",
+    "md": "text/markdown",
+    "html": "text/html",
+    "csv": "text/csv",
+    "json": "application/json",
+    "mp3": "audio/mpeg",
+    "wav": "audio/wav",
+    "m4a": "audio/mp4",
+    "flac": "audio/flac",
+    "ogg": "audio/ogg",
+    "mp4": "video/mp4",
+    "mov": "video/quicktime",
+    "webm": "video/webm",
+    "mkv": "video/x-matroska",
+}
+
+
+def media_type_for(name: str) -> str:
+    return MEDIA_TYPES.get(name.lower().rsplit(".", 1)[-1], "application/octet-stream")
+
+
+def _client(env: Mapping[str, str], *, require_payment: bool = False) -> AuscaClient:
+    origin = env.get("AUSCA_ORIGIN", ORIGIN)
+    key = env.get("AUSCA_PRIVATE_KEY")
+    if not key:
+        if require_payment:
+            raise SystemExit(
+                "paid invocations need AUSCA_PRIVATE_KEY and AUSCA_MAX_PAYMENT_USD"
+                " in the environment"
+            )
+        return AuscaClient(origin=origin)
+    try:
+        cap = float(env.get("AUSCA_MAX_PAYMENT_USD", ""))
+    except ValueError:
+        cap = 0.0
+    if cap <= 0:
+        raise SystemExit(
+            "AUSCA_MAX_PAYMENT_USD must be a positive USD amount when"
+            " AUSCA_PRIVATE_KEY is set; refusing to guess a spend limit"
+        )
+    return AuscaClient.with_local_key(
+        private_key=key,
+        max_payment_usd=cap,
+        network=env.get("AUSCA_NETWORK", "eip155:8453"),
+        origin=origin,
+    )
+
+
+def _json(value: Any) -> str:
+    if dataclasses.is_dataclass(value) and not isinstance(value, type):
+        value = dataclasses.asdict(value)
+    return json.dumps(value, indent=2, default=lambda item: dataclasses.asdict(item))
+
+
+def _resolve_input(argument: str | None, stdin: TextIO) -> dict[str, Any]:
+    if argument is None or argument == "-":
+        text = stdin.read()
+    elif argument.startswith("@"):
+        text = Path(argument[1:]).read_text()
+    else:
+        text = argument
+    try:
+        return json.loads(text)
+    except ValueError as error:
+        raise SystemExit("invocation input must be valid JSON") from error
+
+
+def _invocation_args(argv: list[str]) -> tuple[str, str | None, str | None]:
+    if not argv:
+        raise SystemExit(
+            "usage: ausca invoke <offer-id> [input] [--idempotency-key <key>]"
+        )
+    offer_id = argv[0]
+    input_argument: str | None = None
+    idempotency_key: str | None = None
+    index = 1
+    while index < len(argv):
+        argument = argv[index]
+        if argument == "--idempotency-key":
+            if idempotency_key is not None or index + 1 >= len(argv):
+                raise SystemExit("--idempotency-key requires one value")
+            idempotency_key = argv[index + 1]
+            index += 2
+        elif input_argument is None:
+            input_argument = argument
+            index += 1
+        else:
+            raise SystemExit(f"unexpected invoke argument {argument}")
+    return offer_id, input_argument, idempotency_key
+
+
+def run(
+    argv: list[str],
+    env: Mapping[str, str],
+    stdout: TextIO,
+    stdin: TextIO,
+) -> int:
+    verb = argv[0] if argv else None
+    if verb in (None, "help", "--help"):
+        print(USAGE, file=stdout)
+        return 1 if verb is None else 0
+    if verb == "catalog":
+        offers = _client(env).catalog().get("offers", [])
+        listing = [
+            {key: offer.get(key) for key in ("offer_id", "title", "route", "price", "revision")}
+            for offer in offers
+        ]
+        print(_json(listing), file=stdout)
+        return 0
+    if verb == "price":
+        if len(argv) < 2:
+            raise SystemExit("usage: ausca price <offer-id>")
+        print(_json(_client(env).price(argv[1])), file=stdout)
+        return 0
+    if verb == "invoke":
+        offer_id, input_argument, idempotency_key = _invocation_args(argv[1:])
+        client = _client(env, require_payment=True)
+        outcome = client.invoke(
+            offer_id,
+            _resolve_input(input_argument, stdin),
+            idempotency_key=idempotency_key,
+        )
+        print(_json(outcome), file=stdout)
+        return 0
+    if verb == "commit":
+        if len(argv) < 2:
+            raise SystemExit("usage: ausca commit <file>")
+        path = Path(argv[1])
+        commitment = _client(env).commit(path.read_bytes(), media_type_for(path.name))
+        print(_json(commitment), file=stdout)
+        return 0
+    raise SystemExit(f"unknown verb {verb}; run ausca help")
+
+
+def main() -> None:
+    try:
+        sys.exit(run(sys.argv[1:], os.environ, sys.stdout, sys.stdin))
+    except SystemExit:
+        raise
+    except Exception as error:  # noqa: BLE001 - the CLI boundary reports and exits
+        print(str(error), file=sys.stderr)
+        sys.exit(1)

ausca/client.py

@@ -0,0 +1,244 @@
+"""The Ausca client: catalog-bound paid invocations.
+
+It resolves an offer's immutable binding from the live catalog, builds the
+exact envelope with a caller-stable idempotency key, and pays the offer's
+own payable resource through the configured payment authority. Rails are
+authority implementations, never client concerns.
+"""
+
+from __future__ import annotations
+
+import uuid
+from dataclasses import dataclass
+from typing import Any
+
+import httpx
+from eth_account.signers.local import LocalAccount
+
+from ausca.artifacts import ArtifactCommitment, ArtifactStore, AuscaArtifactStore
+from ausca.payment import (
+    InertAuthority,
+    LocalKeyAuthority,
+    PaymentAuthority,
+    PaymentReceipt,
+)
+
+ORIGIN = "https://ausca.com"
+CATALOG_URL = f"{ORIGIN}/catalog.json"
+SKILL_URL = f"{ORIGIN}/SKILL.md"
+
+
+class AuscaError(Exception):
+    """A refused, failed, or unpayable invocation."""
+
+
+@dataclass(frozen=True)
+class PriceOption:
+    """One price option of an input_choice offer."""
+
+    amount_minor: int
+    value: Any
+
+
+@dataclass(frozen=True)
+class Price:
+    """The published price policy of one active offer."""
+
+    currency: str
+    model: str
+    minimum_minor: int
+    maximum_minor: int
+    options: tuple[PriceOption, ...] | None
+    input_field: str | None
+
+
+@dataclass(frozen=True)
+class Offer:
+    """One active offer's immutable binding from the live catalog."""
+
+    offer_id: str
+    revision: str
+    revision_digest: str
+    input_schema_digest: str
+    input_schema_path: str
+    output_schema_digest: str
+    canonicalizer_version: str
+    route_method: str
+    route_path: str
+    title: str
+    description: str
+    price: Price
+    artifact_input_mode: str
+
+
+@dataclass(frozen=True)
+class InvocationResult:
+    """The invocation outcome with its settlement proof when the call paid."""
+
+    result: Any
+    payment: PaymentReceipt | None
+    status: int
+
+
+class AuscaClient:
+    """Discover offers and run paid invocations under an explicit policy.
+
+    Payment flows through a ``PaymentAuthority``; the default local-key
+    authority enforces a hard per-call USD cap before anything is signed
+    and keys never leave the process.
+    """
+
+    def __init__(
+        self,
+        *,
+        payment: PaymentAuthority | None = None,
+        artifacts: ArtifactStore | None = None,
+        origin: str = ORIGIN,
+        http: httpx.Client | None = None,
+    ) -> None:
+        self._origin = origin.rstrip("/")
+        self._http = http or httpx.Client(timeout=60)
+        self._payment: PaymentAuthority = payment or InertAuthority()
+        self._artifacts = artifacts or AuscaArtifactStore(origin=self._origin, http=self._http)
+        self._catalog: dict[str, Any] | None = None
+
+    @classmethod
+    def with_local_key(
+        cls,
+        *,
+        private_key: str | None = None,
+        account: LocalAccount | None = None,
+        max_payment_usd: float,
+        network: str = "eip155:8453",
+        origin: str = ORIGIN,
+        artifacts: ArtifactStore | None = None,
+        http: httpx.Client | None = None,
+    ) -> "AuscaClient":
+        """Sugar for the default rail: a local signing key under a hard USD cap."""
+        return cls(
+            payment=LocalKeyAuthority(
+                private_key=private_key,
+                account=account,
+                max_payment_usd=max_payment_usd,
+                network=network,
+            ),
+            artifacts=artifacts,
+            origin=origin,
+            http=http,
+        )
+
+    def catalog(self, *, refresh: bool = False) -> dict[str, Any]:
+        """The live immutable catalog, fetched once and cached."""
+        if self._catalog is None or refresh:
+            response = self._http.get(f"{self._origin}/catalog.json")
+            response.raise_for_status()
+            self._catalog = response.json()
+        return self._catalog
+
+    def offer(self, offer_id: str) -> Offer:
+        """Resolve one active offer's immutable binding."""
+        for entry in self.catalog().get("offers", []):
+            if entry["offer_id"] == offer_id:
+                price = entry.get("price", {})
+                options = price.get("options")
+                return Offer(
+                    offer_id=entry["offer_id"],
+                    revision=entry["revision"],
+                    revision_digest=entry["revision_digest"],
+                    input_schema_digest=entry["input_schema"]["digest"],
+                    input_schema_path=entry["input_schema"].get("public_path", ""),
+                    output_schema_digest=entry["output_schema"]["digest"],
+                    canonicalizer_version=entry["canonicalizer_version"],
+                    route_method=entry["route"]["method"],
+                    route_path=entry["route"]["path"],
+                    title=entry["title"],
+                    description=entry["description"],
+                    artifact_input_mode=entry.get("artifact", {}).get("input_mode", "none"),
+                    price=Price(
+                        currency=price.get("currency", "USD"),
+                        model=price.get("model", ""),
+                        minimum_minor=price.get("minimum_minor", 0),
+                        maximum_minor=price.get("maximum_minor", 0),
+                        input_field=price.get("input_field"),
+                        options=tuple(
+                            PriceOption(amount_minor=option["amount_minor"], value=option["value"])
+                            for option in options
+                        )
+                        if options
+                        else None,
+                    ),
+                )
+        raise AuscaError(f"offer {offer_id!r} is not active in the catalog")
+
+    def price(self, offer_id: str) -> Price:
+        """The published price policy of one offer. No wallet is needed."""
+        return self.offer(offer_id).price
+
+    def envelope(
+        self, offer: Offer, invocation_input: dict[str, Any], idempotency_key: str | None = None
+    ) -> dict[str, Any]:
+        """The exact invocation envelope for one offer.
+
+        A fresh default key starts one intentional purchase. Supply the same
+        explicit key to recover or retry that purchase without minting another.
+        """
+        if idempotency_key is None:
+            idempotency_key = f"ausca-{uuid.uuid4()}"
+        key_bytes = idempotency_key.encode("utf-8")
+        if (
+            not 16 <= len(key_bytes) <= 128
+            or idempotency_key.strip() != idempotency_key
+            or any(ord(character) < 0x20 or ord(character) == 0x7F for character in idempotency_key)
+        ):
+            raise AuscaError("idempotency_key must be 16 to 128 clean UTF-8 bytes")
+        return {
+            "offer_id": offer.offer_id,
+            "offer_revision": offer.revision,
+            "offer_revision_digest": offer.revision_digest,
+            "input_schema_digest": offer.input_schema_digest,
+            "output_schema_digest": offer.output_schema_digest,
+            "canonicalizer_version": offer.canonicalizer_version,
+            "input": invocation_input,
+            "idempotency_key": idempotency_key,
+        }
+
+    def invoke(
+        self,
+        offer_id: str,
+        invocation_input: dict[str, Any],
+        *,
+        idempotency_key: str | None = None,
+    ) -> InvocationResult:
+        """Run one paid invocation: probe, pay within policy, return proof."""
+        offer = self.offer(offer_id)
+        body = self.envelope(offer, invocation_input, idempotency_key)
+        return self.pay_request(
+            f"{self._origin}{offer.route_path}", method=offer.route_method, json_body=body
+        )
+
+    def pay_request(
+        self, url: str, *, method: str = "POST", json_body: dict[str, Any] | None = None
+    ) -> InvocationResult:
+        """One paid call against any resource the configured authority can pay."""
+        response = self._payment.request(self._http, method, url, json_body)
+        payment = self._payment.receipt(response)
+        try:
+            result: Any = response.json()
+        except ValueError:
+            result = response.text
+        if response.status_code >= 400:
+            raise AuscaError(
+                f"payable resource {url} answered {response.status_code}: {response.text[:512]}"
+            )
+        return InvocationResult(result=result, payment=payment, status=response.status_code)
+
+    def invocation(self, invocation_id: str) -> dict[str, Any]:
+        """Read authoritative durable invocation state without a new purchase."""
+        response = self._http.get(f"{self._origin}/v1/invocations/{invocation_id}")
+        if response.status_code >= 400:
+            raise AuscaError(f"invocation read answered {response.status_code}")
+        return response.json()
+
+    def commit(self, data: bytes, media_type: str) -> ArtifactCommitment:
+        """Commit input bytes through the configured artifact store."""
+        return self._artifacts.commit(data, media_type)

ausca/payment.py

@@ -0,0 +1,129 @@
+"""The payment boundary of the client.
+
+The core never sees a rail, a header name, a scheme, or a wallet: it hands
+the request to the configured authority and asks it to decode settlement
+evidence. Any rail that can answer an HTTP 402 challenge fits, including
+delegated executors that perform their own transport. Cap enforcement lives
+inside the authority, before anything is signed.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Protocol
+
+import httpx
+from eth_account import Account
+from eth_account.signers.local import LocalAccount
+from x402 import SchemeRegistration, SpendControls, x402ClientConfig, x402ClientSync
+from x402.http import x402HTTPClientSync
+from x402.mechanisms.evm.exact import ExactEvmClientScheme
+from x402.mechanisms.evm.signers import EthAccountSigner
+
+_PAYMENT_RESPONSE = "PAYMENT-RESPONSE"
+
+
+@dataclass(frozen=True)
+class PaymentReceipt:
+    """Settlement proof decoded from a paid response."""
+
+    success: bool
+    network: str | None
+    transaction: str | None
+    payer: str | None
+
+
+class PaymentAuthority(Protocol):
+    """A payment rail the client can pay HTTP 402 challenges with."""
+
+    rails: tuple[str, ...]
+
+    def request(
+        self,
+        http: httpx.Client,
+        method: str,
+        url: str,
+        json_body: dict[str, Any] | None,
+    ) -> httpx.Response:
+        """Perform the request, paying any challenge it understands within policy."""
+
+    def receipt(self, response: httpx.Response) -> PaymentReceipt | None:
+        """Decode settlement evidence from a completed response, if present."""
+
+
+class InertAuthority:
+    """An authority that pays nothing: reads, price discovery, tests."""
+
+    rails: tuple[str, ...] = ()
+
+    def request(
+        self,
+        http: httpx.Client,
+        method: str,
+        url: str,
+        json_body: dict[str, Any] | None,
+    ) -> httpx.Response:
+        return http.request(method=method, url=url, json=json_body)
+
+    def receipt(self, response: httpx.Response) -> PaymentReceipt | None:
+        return None
+
+
+class LocalKeyAuthority:
+    """The zero-friction default rail: x402 v2 with a local signing key.
+
+    Payment construction and signing stay entirely in the official ``x402``
+    library; the hard per-call USD cap is enforced by its spend controls
+    before anything is signed.
+    """
+
+    rails: tuple[str, ...] = ("x402-v2",)
+
+    def __init__(
+        self,
+        *,
+        private_key: str | None = None,
+        account: LocalAccount | None = None,
+        max_payment_usd: float,
+        network: str = "eip155:8453",
+    ) -> None:
+        if not max_payment_usd or max_payment_usd <= 0:
+            raise ValueError("max_payment_usd must be a positive number")
+        if (account is None) == (private_key is None):
+            raise ValueError("provide exactly one of account or private_key")
+        if account is None:
+            account = Account.from_key(private_key)
+        scheme = ExactEvmClientScheme(EthAccountSigner(account))
+        client = x402ClientSync.from_config(
+            x402ClientConfig(
+                schemes=[SchemeRegistration(network=network, client=scheme, x402_version=2)],
+                spend_controls=SpendControls(max_amount_per_payment=f"${max_payment_usd}"),
+            )
+        )
+        self._payments = x402HTTPClientSync(client)
+
+    def request(
+        self,
+        http: httpx.Client,
+        method: str,
+        url: str,
+        json_body: dict[str, Any] | None,
+    ) -> httpx.Response:
+        response = http.request(method=method, url=url, json=json_body)
+        if response.status_code != 402:
+            return response
+        extra_headers, _payload = self._payments.handle_402_response(
+            dict(response.headers), response.content, url
+        )
+        return http.request(method=method, url=url, json=json_body, headers=extra_headers)
+
+    def receipt(self, response: httpx.Response) -> PaymentReceipt | None:
+        if _PAYMENT_RESPONSE not in response.headers:
+            return None
+        settled = self._payments.get_payment_settle_response(response.headers.get)
+        return PaymentReceipt(
+            success=bool(getattr(settled, "success", False)),
+            network=getattr(settled, "network", None),
+            transaction=getattr(settled, "transaction", None),
+            payer=getattr(settled, "payer", None),
+        )

ausca-0.0.2.dist-info/METADATA

@@ -0,0 +1,96 @@
+Metadata-Version: 2.4
+Name: ausca
+Version: 0.0.2
+Summary: Client for Ausca metered agent infrastructure services: catalog-bound invocations paid per call under a hard USD cap, through pluggable payment authorities (x402 v2 today), with receipt-backed results.
+License-Expression: MIT
+Project-URL: Homepage, https://ausca.com
+Project-URL: Documentation, https://ausca.com/docs
+Project-URL: Repository, https://github.com/auscahq/ausca-integrations
+Project-URL: Issues, https://github.com/auscahq/ausca-integrations/issues
+Keywords: ausca,x402,agents,payments,mcp
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.28
+Requires-Dist: x402[evm]>=2.21.0
+Requires-Dist: eth-account>=0.13
+
+# ausca
+
+Client for [Ausca](https://ausca.com) metered agent infrastructure services:
+document OCR, document analysis, media transcription, browser sessions, and
+agent inboxes. Paid per call under a hard USD cap you set, with no account
+or provider API keys, and a settlement receipt on every completed
+invocation.
+
+## Install
+
+```bash
+pip install ausca
+```
+
+## Use
+
+```python
+import os
+from ausca import AuscaClient
+
+client = AuscaClient.with_local_key(
+    private_key=os.environ["AUSCA_PRIVATE_KEY"],  # pays USDC on Base
+    max_payment_usd=0.50,                         # hard per-call cap
+)
+
+outcome = client.invoke("browser.session", {"duration_seconds": 600})
+print(outcome.result)
+print(outcome.payment.transaction)  # settlement proof
+```
+
+`invoke` resolves the offer's immutable revision, schema digests, and
+payable route from the live catalog, reads the exact payment requirement,
+pays it if it fits the cap, and retries the same bytes with the same
+idempotency key. Each call starts with a fresh key. For recovery after an
+uncertain response, pass the same caller-owned `idempotency_key`; use a new
+key for another intentional purchase, even when its input is identical.
+
+A CLI ships with the package:
+
+```bash
+ausca catalog
+ausca price document.ocr
+AUSCA_PRIVATE_KEY=0x... AUSCA_MAX_PAYMENT_USD=0.50 \
+  ausca invoke browser.session '{"duration_seconds":600}'
+# Reuse this key only to recover that same intended purchase:
+ausca invoke browser.session '{"duration_seconds":600}' \
+  --idempotency-key browser-attempt-20260903-0001
+```
+
+## Payment rails
+
+Payment is a pluggable authority, never a client concern. The built-in
+`LocalKeyAuthority` pays x402 v2 with a local signing key through the
+official [`x402`](https://pypi.org/project/x402/) library, which enforces
+the cap through its spend controls before anything is signed; other rails
+implement the same small `PaymentAuthority` protocol.
+`client.pay_request(url, ...)` runs one paid call against any resource the
+configured authority can pay; nothing in it is vendor-specific.
+
+## Artifact-backed offers
+
+Document and media offers take an immutable artifact commitment instead of
+raw bytes. `ausca commit file.pdf` sends the bytes to Ausca's keyless
+temporary ingress and returns the commitment the offer input carries; the
+library equivalent is `client.commit(data, media_type)`. Repeating the same
+bytes is idempotent. The active offer catalog sets the usable input limit.
+
+Successful paid state includes `receipt_ref.public_url`, an immutable
+hash-only proof of the Ausca service, public price, completion time, and
+receipt digest. It contains no request or result bytes, content digests, or
+access capabilities. Anyone holding the unguessable URL can read it.
+
+The full agent contract lives at <https://ausca.com/SKILL.md>; discover the
+active offers at <https://ausca.com/catalog.json>. The npm equivalent is
+[`ausca`](https://www.npmjs.com/package/ausca), which adds a local MCP
+server (`npx ausca mcp`).
+
+## License
+
+MIT

ausca-0.0.2.dist-info/RECORD

@@ -0,0 +1,10 @@
+ausca/__init__.py,sha256=VS8YTHk31AS3BAJ_Rx3Slr4jLZD2a49yi7pQULdCUlE,876
+ausca/artifacts.py,sha256=2D2HEGdqq2RWvefiGcBttM_CuHMvrvhNyf0vg0ax1H8,3611
+ausca/cli.py,sha256=PRpxqd9qi_peHe7Ghx4JygpmhIOhmBahpjwAfquYTA4,5990
+ausca/client.py,sha256=pBwLkHpQrns8-l7CGq9lTWIWTlG6Mg8ahSOz1QLvR0I,8955
+ausca/payment.py,sha256=gaaG0RqD3sZYY5Lza8oFsASw2q0TakOgFS4D59iHPGU,4405
+ausca-0.0.2.dist-info/METADATA,sha256=h4nyVkjvKn0zDwFIkBQyPBnHwOwCmIVMp5pQcOvEboI,3721
+ausca-0.0.2.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+ausca-0.0.2.dist-info/entry_points.txt,sha256=7lJNSkura5Ay1388AcQkjBdTGXmxxhgmjN6qxGhD4ao,41
+ausca-0.0.2.dist-info/top_level.txt,sha256=ajbDxHMAhBPQ6tB-dYxIW6UPo5BMOkpLeKlSJSwWH_U,6
+ausca-0.0.2.dist-info/RECORD,,

ausca-0.0.2.dist-info/WHEEL

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

ausca-0.0.2.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+ausca = ausca.cli:main

ausca-0.0.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+ausca