mint-attest 0.1.0__tar.gz

mint_attest-0.1.0/LICENSE

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

mint_attest-0.1.0/PKG-INFO

@@ -0,0 +1,160 @@
+Metadata-Version: 2.4
+Name: mint-attest
+Version: 0.1.0
+Summary: Universal work attestation for AI agents. Prove your agent did the work.
+Author: FoundryNet
+License: MIT
+Project-URL: Homepage, https://github.com/FoundryNet/mint-attest
+Project-URL: Documentation, https://mint.foundrynet.io
+Project-URL: Source, https://github.com/FoundryNet/mint-attest
+Keywords: ai,agents,attestation,trust,solana,verification,mint,langchain,crewai,autogen
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: httpx>=0.24
+Provides-Extra: langchain
+Requires-Dist: langchain>=0.1; extra == "langchain"
+Provides-Extra: crewai
+Requires-Dist: crewai>=0.1; extra == "crewai"
+Provides-Extra: autogen
+Requires-Dist: pyautogen>=0.2; extra == "autogen"
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21; extra == "dev"
+Dynamic: license-file
+
+# mint-attest
+
+**Universal work attestation for AI agents.** Prove your agent did the work. Build verifiable trust. Settled on Solana.
+
+```bash
+pip install mint-attest
+```
+
+## Quick start (3 lines)
+
+```python
+from mint_attest import attest
+
+@attest(work_type="code_review")
+def review(files):
+    return do_review(files)
+```
+
+Every call to `review()` is now attested on Solana mainnet with a tamper-evident work record — input/output hashed, duration recorded, trust score updated, Solscan verify URL minted. Your function's return value is unchanged.
+
+Set your key once (mirrors `OPENAI_API_KEY` / `ANTHROPIC_API_KEY`):
+
+```bash
+export MINT_API_KEY=fnet_…        # free key at foundrynet.io
+```
+
+## Why?
+
+1.3 billion AI agents by 2028. No way to verify which ones actually do good work.
+
+mint-attest gives your agent a verifiable track record. Register once. Attest every task. Build trust that any other agent or human can verify on-chain — no wallet, no keys, no blockchain code on your side. It's just an API call.
+
+## Two ways to use it
+
+### 1 — Decorator (zero friction)
+
+```python
+from mint_attest import attest
+
+@attest(work_type="code_review")
+def review_code(files):
+    return do_the_review(files)
+# auto-registers the agent once, hashes input/output, records duration,
+# attests on MINT, and returns results unchanged.
+```
+
+Attestation never breaks your function: if the network hiccups or no key is set, it logs and returns your result anyway. Pass `@attest(..., strict=True)` to opt into raising.
+
+### 2 — Explicit client (more control)
+
+```python
+from mint_attest import MintClient
+
+mint = MintClient(api_key="fnet_…")          # or MINT_API_KEY env
+
+actor = mint.register(
+    name="CodeReviewBot",
+    actor_type="ai_agent",
+    capabilities=["code_review", "security_audit"],
+)
+
+receipt = mint.attest(
+    work_type="code_review",
+    input_data=files,            # hashed for you (SHA-256)
+    output_data=results,
+    duration_seconds=elapsed,
+)
+print(receipt.verify_url)        # https://solscan.io/tx/…
+
+trust = mint.verify(actor.mint_id)
+print(trust.score, trust.total_attestations)
+```
+
+## Works with your framework
+
+```python
+# LangChain — every chain.run() attests
+from mint_attest.langchain import MintAttestCallback
+chain = LLMChain(llm=llm, prompt=prompt, callbacks=[MintAttestCallback(api_key="fnet_…")])
+
+# CrewAI — give the crew an attest tool (or use mint_attest_step_callback)
+from mint_attest.crewai import MintAttestTool
+crew = Crew(agents=[researcher], tools=[MintAttestTool(api_key="fnet_…")])
+
+# AutoGen — attest every reply
+from mint_attest.autogen import MintAttestHook
+MintAttestHook(api_key="fnet_…").attach(agent)
+```
+
+Install the extra you need: `pip install mint-attest[langchain]` · `[crewai]` · `[autogen]`.
+
+## What happens on each attestation
+
+1. Input/output hashed (SHA-256) — your data never leaves; only the hash does
+2. Duration recorded
+3. Work record settled on Solana mainnet
+4. Trust score updated
+5. Verify URL returned (Solscan)
+
+Your agent's work history is permanent, tamper-evident, and publicly verifiable.
+
+## Pricing
+
+| Action | Price |
+|--------|-------|
+| Register | **FREE** |
+| Verify | **FREE** |
+| Attest | **$0.02** per attestation |
+
+## Configuration
+
+| Env var | Purpose |
+|---------|---------|
+| `MINT_API_KEY` | your `fnet_` key (required for register/attest) |
+| `MINT_AGENT_NAME` | default agent name (optional) |
+| `MINT_ENDPOINT` | override the MINT server (default `https://mint-mcp-production.up.railway.app`) |
+
+No Solana dependency. No wallet. No transaction signing. The SDK calls the MINT server's HTTPS API; the server handles all on-chain interaction.
+
+## Links
+
+- Explorer: https://mint.foundrynet.io
+- MCP server: https://github.com/FoundryNet/mint-mcp
+- Protocol: https://foundrynet.io
+
+MIT licensed.

mint_attest-0.1.0/README.md

@@ -0,0 +1,126 @@
+# mint-attest
+
+**Universal work attestation for AI agents.** Prove your agent did the work. Build verifiable trust. Settled on Solana.
+
+```bash
+pip install mint-attest
+```
+
+## Quick start (3 lines)
+
+```python
+from mint_attest import attest
+
+@attest(work_type="code_review")
+def review(files):
+    return do_review(files)
+```
+
+Every call to `review()` is now attested on Solana mainnet with a tamper-evident work record — input/output hashed, duration recorded, trust score updated, Solscan verify URL minted. Your function's return value is unchanged.
+
+Set your key once (mirrors `OPENAI_API_KEY` / `ANTHROPIC_API_KEY`):
+
+```bash
+export MINT_API_KEY=fnet_…        # free key at foundrynet.io
+```
+
+## Why?
+
+1.3 billion AI agents by 2028. No way to verify which ones actually do good work.
+
+mint-attest gives your agent a verifiable track record. Register once. Attest every task. Build trust that any other agent or human can verify on-chain — no wallet, no keys, no blockchain code on your side. It's just an API call.
+
+## Two ways to use it
+
+### 1 — Decorator (zero friction)
+
+```python
+from mint_attest import attest
+
+@attest(work_type="code_review")
+def review_code(files):
+    return do_the_review(files)
+# auto-registers the agent once, hashes input/output, records duration,
+# attests on MINT, and returns results unchanged.
+```
+
+Attestation never breaks your function: if the network hiccups or no key is set, it logs and returns your result anyway. Pass `@attest(..., strict=True)` to opt into raising.
+
+### 2 — Explicit client (more control)
+
+```python
+from mint_attest import MintClient
+
+mint = MintClient(api_key="fnet_…")          # or MINT_API_KEY env
+
+actor = mint.register(
+    name="CodeReviewBot",
+    actor_type="ai_agent",
+    capabilities=["code_review", "security_audit"],
+)
+
+receipt = mint.attest(
+    work_type="code_review",
+    input_data=files,            # hashed for you (SHA-256)
+    output_data=results,
+    duration_seconds=elapsed,
+)
+print(receipt.verify_url)        # https://solscan.io/tx/…
+
+trust = mint.verify(actor.mint_id)
+print(trust.score, trust.total_attestations)
+```
+
+## Works with your framework
+
+```python
+# LangChain — every chain.run() attests
+from mint_attest.langchain import MintAttestCallback
+chain = LLMChain(llm=llm, prompt=prompt, callbacks=[MintAttestCallback(api_key="fnet_…")])
+
+# CrewAI — give the crew an attest tool (or use mint_attest_step_callback)
+from mint_attest.crewai import MintAttestTool
+crew = Crew(agents=[researcher], tools=[MintAttestTool(api_key="fnet_…")])
+
+# AutoGen — attest every reply
+from mint_attest.autogen import MintAttestHook
+MintAttestHook(api_key="fnet_…").attach(agent)
+```
+
+Install the extra you need: `pip install mint-attest[langchain]` · `[crewai]` · `[autogen]`.
+
+## What happens on each attestation
+
+1. Input/output hashed (SHA-256) — your data never leaves; only the hash does
+2. Duration recorded
+3. Work record settled on Solana mainnet
+4. Trust score updated
+5. Verify URL returned (Solscan)
+
+Your agent's work history is permanent, tamper-evident, and publicly verifiable.
+
+## Pricing
+
+| Action | Price |
+|--------|-------|
+| Register | **FREE** |
+| Verify | **FREE** |
+| Attest | **$0.02** per attestation |
+
+## Configuration
+
+| Env var | Purpose |
+|---------|---------|
+| `MINT_API_KEY` | your `fnet_` key (required for register/attest) |
+| `MINT_AGENT_NAME` | default agent name (optional) |
+| `MINT_ENDPOINT` | override the MINT server (default `https://mint-mcp-production.up.railway.app`) |
+
+No Solana dependency. No wallet. No transaction signing. The SDK calls the MINT server's HTTPS API; the server handles all on-chain interaction.
+
+## Links
+
+- Explorer: https://mint.foundrynet.io
+- MCP server: https://github.com/FoundryNet/mint-mcp
+- Protocol: https://foundrynet.io
+
+MIT licensed.

mint_attest-0.1.0/mint_attest/__init__.py

@@ -0,0 +1,29 @@
+"""mint-attest — universal work attestation for AI agents.
+
+    from mint_attest import attest
+
+    @attest(work_type="code_review")
+    def review(files):
+        return do_review(files)
+
+Register once, attest every task, build a verifiable on-chain track record. The
+SDK is a thin HTTPS client to the MINT server; all Solana interaction happens
+server-side. Framework integrations live in mint_attest.langchain / .crewai /
+.autogen (imported only when you use them).
+"""
+from __future__ import annotations
+
+__version__ = "0.1.0"
+
+from .client import MintClient, hash_data
+from .decorator import attest, configure, get_default_client, set_default_client
+from .exceptions import MintAPIError, MintAuthError, MintConfigError, MintError
+from .models import Actor, Receipt, TrustScore
+
+__all__ = [
+    "__version__",
+    "attest", "configure", "MintClient",
+    "get_default_client", "set_default_client", "hash_data",
+    "Actor", "Receipt", "TrustScore",
+    "MintError", "MintAuthError", "MintAPIError", "MintConfigError",
+]

mint_attest-0.1.0/mint_attest/autogen.py

@@ -0,0 +1,5 @@
+"""Convenience shim so `from mint_attest.autogen import MintAttestHook` works
+(the implementation lives in mint_attest.integrations.autogen)."""
+from .integrations.autogen import MintAttestHook
+
+__all__ = ["MintAttestHook"]

mint_attest-0.1.0/mint_attest/client.py

@@ -0,0 +1,176 @@
+"""MintClient — the core: register, attest, verify against the MINT REST surface.
+
+Talks plain HTTPS to the MINT server (default mint-mcp); the server handles all
+Solana interaction. The developer never touches a wallet, signs a transaction, or
+imports a blockchain library — it's just an API call. The developer's fnet_ key
+(arg or MINT_API_KEY env) authenticates every request, so the agent and its
+attestations belong to their account.
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+import math
+import os
+import time
+from typing import Any, Optional
+
+import httpx
+
+from . import __version__
+from .exceptions import MintAPIError, MintAuthError, MintConfigError
+from .models import Actor, Receipt, TrustScore
+
+DEFAULT_ENDPOINT = "https://mint-mcp-production.up.railway.app"
+
+
+def hash_data(obj: Any) -> str:
+    """Deterministic SHA-256 of any value. bytes as-is, str as utf-8, everything
+    else as canonical (sorted-key) JSON so the same input always hashes the same."""
+    if isinstance(obj, (bytes, bytearray)):
+        b = bytes(obj)
+    elif isinstance(obj, str):
+        b = obj.encode("utf-8")
+    else:
+        b = json.dumps(obj, sort_keys=True, default=str).encode("utf-8")
+    return hashlib.sha256(b).hexdigest()
+
+
+def _strip_none(d: dict) -> dict:
+    return {k: v for k, v in d.items() if v is not None}
+
+
+class MintClient:
+    """One client per agent process. Register once (or let attest auto-register),
+    then attest each unit of work."""
+
+    def __init__(self, api_key: Optional[str] = None, endpoint: Optional[str] = None,
+                 *, name: Optional[str] = None, actor_type: str = "ai_agent",
+                 capabilities: Optional[list] = None, operator: Optional[str] = None,
+                 timeout: float = 30.0, transport: Optional[httpx.BaseTransport] = None):
+        self.api_key = api_key or os.environ.get("MINT_API_KEY")
+        self.endpoint = (endpoint or os.environ.get("MINT_ENDPOINT") or DEFAULT_ENDPOINT).rstrip("/")
+        self.timeout = timeout
+        # defaults used by auto-register; name also fills from MINT_AGENT_NAME
+        self._name = name or os.environ.get("MINT_AGENT_NAME")
+        self._actor_type = actor_type
+        self._capabilities = capabilities
+        self._operator = operator or os.environ.get("MINT_OPERATOR")
+        self._actor: Optional[Actor] = None
+        self._http = httpx.Client(timeout=timeout, transport=transport)
+
+    # ── identity helpers ──────────────────────────────────────────────────────
+    @property
+    def mint_id(self) -> Optional[str]:
+        return self._actor.mint_id if self._actor else None
+
+    @property
+    def actor(self) -> Optional[Actor]:
+        return self._actor
+
+    def _headers(self) -> dict:
+        if not self.api_key:
+            raise MintAuthError(
+                "No API key. Pass MintClient(api_key='fnet_…') or set MINT_API_KEY.")
+        return {"Authorization": f"Bearer {self.api_key}",
+                "Content-Type": "application/json",
+                "User-Agent": f"mint-attest/{__version__}"}
+
+    def _post(self, path: str, body: dict) -> dict:
+        try:
+            r = self._http.post(self.endpoint + path, json=body, headers=self._headers())
+        except httpx.HTTPError as e:
+            raise MintAPIError(f"network error calling {path}: {e}") from e
+        try:
+            data = r.json()
+        except Exception:
+            raise MintAPIError(f"non-JSON response from {path} (HTTP {r.status_code})",
+                               status=r.status_code, detail=r.text[:300])
+        if r.status_code >= 400 or (isinstance(data, dict) and data.get("error")):
+            detail = data.get("detail") if isinstance(data, dict) else data
+            code = data.get("error") if isinstance(data, dict) else f"http_{r.status_code}"
+            if r.status_code in (401, 403):
+                raise MintAuthError(f"{code}: {detail}")
+            raise MintAPIError(f"{code}: {detail}", status=r.status_code, detail=detail)
+        return data
+
+    # ── register ──────────────────────────────────────────────────────────────
+    def register(self, name: Optional[str] = None, actor_type: Optional[str] = None,
+                 capabilities: Optional[list] = None, operator: Optional[str] = None,
+                 metadata: Optional[dict] = None) -> Actor:
+        """Provision (or look up — idempotent) this agent's MINT identity. Caches
+        the mint_id so later attest() calls reuse it. FREE."""
+        resolved_name = name or self._name
+        if not resolved_name:
+            raise MintConfigError(
+                "An agent name is required to register. Pass name=… (or set "
+                "MINT_AGENT_NAME / use @attest, which names the agent after the function).")
+        body = _strip_none({
+            "name": resolved_name,
+            "actor_type": actor_type or self._actor_type,
+            "capabilities": capabilities if capabilities is not None else self._capabilities,
+            "operator": operator or self._operator,
+            "metadata": metadata,
+        })
+        actor = Actor.from_dict(self._post("/v1/register", body))
+        self._actor = actor
+        # remember resolved defaults for any future auto-register
+        self._name = self._name or resolved_name
+        return actor
+
+    def _ensure_actor(self) -> Actor:
+        if self._actor is None:
+            self.register()
+        return self._actor  # type: ignore[return-value]
+
+    # ── attest ─────────────────────────────────────────────────────────────────
+    def attest(self, work_type: str, input_data: Any = None, output_data: Any = None,
+               duration_seconds: Optional[float] = None, summary: Optional[str] = None,
+               metadata: Optional[dict] = None, *, mint_id: Optional[str] = None,
+               input_hash: Optional[str] = None, output_hash: Optional[str] = None) -> Receipt:
+        """Attest a completed unit of work — anchors a tamper-evident record on
+        Solana mainnet and returns a Receipt (with verify_url). 2¢ per attestation.
+
+        Pass input_data/output_data (any value — hashed for you) OR precomputed
+        input_hash/output_hash. Auto-registers the agent on the first call if it
+        hasn't been registered yet.
+        """
+        mid = mint_id or self.mint_id or self._ensure_actor().mint_id
+        if input_hash is None and input_data is not None:
+            input_hash = hash_data(input_data)
+        if output_hash is None and output_data is not None:
+            output_hash = hash_data(output_data)
+        # Forge requires duration_seconds > 0; round sub-second work up to 1.
+        dur = max(1, int(math.ceil(duration_seconds))) if duration_seconds else 1
+        body = _strip_none({
+            "mint_id": mid, "work_type": work_type, "duration_seconds": dur,
+            "summary": summary or f"{work_type} completed",
+            "input_hash": input_hash, "output_hash": output_hash, "metadata": metadata,
+        })
+        return Receipt.from_dict(self._post("/v1/attest", body))
+
+    # ── verify ──────────────────────────────────────────────────────────────────
+    def verify(self, mint_id: Optional[str] = None, actor_name: Optional[str] = None,
+               actor_type: Optional[str] = None) -> TrustScore:
+        """Look up any actor's trust profile. FREE. Defaults to this client's own
+        agent when no identifier is given."""
+        body = _strip_none({
+            "mint_id": mint_id or (None if actor_name else self.mint_id),
+            "actor_name": actor_name, "actor_type": actor_type,
+        })
+        if not body:
+            raise MintConfigError("Provide mint_id or actor_name (or register first).")
+        return TrustScore.from_dict(self._post("/v1/verify", body))
+
+    # ── lifecycle ────────────────────────────────────────────────────────────────
+    def close(self) -> None:
+        try:
+            self._http.close()
+        except Exception:
+            pass
+
+    def __enter__(self) -> "MintClient":
+        return self
+
+    def __exit__(self, *exc) -> None:
+        self.close()

mint_attest-0.1.0/mint_attest/crewai.py

@@ -0,0 +1,5 @@
+"""Convenience shim so `from mint_attest.crewai import MintAttestTool` works
+(the implementation lives in mint_attest.integrations.crewai)."""
+from .integrations.crewai import MintAttestTool, mint_attest_step_callback
+
+__all__ = ["MintAttestTool", "mint_attest_step_callback"]

mint_attest-0.1.0/mint_attest/decorator.py

@@ -0,0 +1,97 @@
+"""@attest — zero-friction attestation for any Python function, plus the
+process-wide default client.
+
+    from mint_attest import attest
+
+    @attest(work_type="code_review")
+    def review_code(files):
+        return do_the_review(files)
+
+Every call hashes the inputs/output, times the call, attests on MINT, and returns
+the function's result UNCHANGED. Attestation failures (no key, network blip) are
+logged and swallowed by default — instrumentation must never break the agent.
+Set strict=True to raise instead.
+"""
+from __future__ import annotations
+
+import logging
+import math
+import time
+from functools import wraps
+from typing import Callable, Optional
+
+from .client import MintClient, hash_data
+from .exceptions import MintError
+
+log = logging.getLogger("mint_attest")
+
+_default_client: Optional[MintClient] = None
+
+
+def get_default_client() -> MintClient:
+    """The lazily-created process-wide client (uses MINT_API_KEY / env defaults)."""
+    global _default_client
+    if _default_client is None:
+        _default_client = MintClient()
+    return _default_client
+
+
+def set_default_client(client: MintClient) -> None:
+    """Override the process-wide client (e.g. with a custom endpoint or key)."""
+    global _default_client
+    _default_client = client
+
+
+def configure(api_key: Optional[str] = None, endpoint: Optional[str] = None,
+              name: Optional[str] = None, actor_type: str = "ai_agent",
+              capabilities: Optional[list] = None, operator: Optional[str] = None) -> MintClient:
+    """Set up the default client in one call. Optional — env vars work too."""
+    client = MintClient(api_key=api_key, endpoint=endpoint, name=name,
+                        actor_type=actor_type, capabilities=capabilities, operator=operator)
+    set_default_client(client)
+    return client
+
+
+def attest(work_type: str, name: Optional[str] = None,
+           capabilities: Optional[list] = None, client: Optional[MintClient] = None,
+           strict: bool = False) -> Callable:
+    """Decorator: attest every call of the wrapped function on MINT.
+
+    Args:
+        work_type: code_review|research|generation|analysis|delivery|
+            normalization|manufacturing|custom.
+        name: agent name to register under (defaults to the function's name; set
+            once for the process).
+        capabilities: capability tags recorded at registration.
+        client: a specific MintClient (defaults to the process-wide one).
+        strict: if True, re-raise attestation errors instead of swallowing them.
+    """
+    def wrapper(func: Callable) -> Callable:
+        @wraps(func)
+        def inner(*args, **kwargs):
+            c = client or get_default_client()
+            # name the agent once: explicit name > whatever's already set > func name
+            if not c._name:
+                c._name = name or func.__name__
+            if capabilities and c._capabilities is None:
+                c._capabilities = capabilities
+
+            start = time.time()
+            result = func(*args, **kwargs)          # run the real work first
+            duration = max(1, int(math.ceil(time.time() - start)))
+
+            try:
+                c.attest(
+                    work_type=work_type,
+                    input_hash=hash_data({"args": args, "kwargs": kwargs}),
+                    output_hash=hash_data(result),
+                    duration_seconds=duration,
+                    summary=f"{func.__name__} completed",
+                )
+            except MintError as e:
+                if strict:
+                    raise
+                log.warning("mint-attest: attestation skipped (%s) — returning result anyway", e)
+            return result
+        return inner
+    return wrapper

mint_attest-0.1.0/mint_attest/exceptions.py

@@ -0,0 +1,31 @@
+"""Exceptions for the mint-attest SDK.
+
+All inherit from MintError so callers can `except MintError` to catch everything.
+The @attest decorator swallows MintError by default (attestation must never break
+the wrapped function); the explicit MintClient methods raise so callers can handle.
+"""
+from __future__ import annotations
+
+from typing import Any, Optional
+
+
+class MintError(Exception):
+    """Base class for all mint-attest errors."""
+
+
+class MintAuthError(MintError):
+    """No API key configured, or the server rejected it."""
+
+
+class MintConfigError(MintError):
+    """The client is missing required configuration (e.g. an agent name)."""
+
+
+class MintAPIError(MintError):
+    """The MINT API returned an error or was unreachable."""
+
+    def __init__(self, message: str, *, status: Optional[int] = None,
+                 detail: Any = None):
+        super().__init__(message)
+        self.status = status
+        self.detail = detail

mint_attest-0.1.0/mint_attest/integrations/__init__.py

@@ -0,0 +1,8 @@
+"""Framework integrations for mint-attest.
+
+Each module wraps a MintClient in a framework's native hook/callback/tool pattern
+so a developer adds ONE line to their existing agent and every task attests. The
+frameworks are optional dependencies — these modules import them lazily and raise
+a clear, install-hint error if the framework isn't present. Importing
+`mint_attest` itself never imports any framework.
+"""