deusproof-mcp 0.1.0__py3-none-any.whl

deusproof_mcp/__init__.py

@@ -0,0 +1,3 @@
+"""DEUSPROOF MCP server — notarize AI creations as a native agent tool."""
+
+__version__ = "0.1.0"

deusproof_mcp/server.py

@@ -0,0 +1,177 @@
+"""DEUSPROOF MCP server — the notary of machine creativity, as a native tool.
+
+Any MCP-speaking agent (Claude, and the growing ecosystem) can notarize its own
+work without leaving its flow: score authorship, sign a C2PA manifest under the
+agent's own sovereign did:key, timestamp it (RFC 3161) and anchor it to Bitcoin
+— then get back a permanent, publicly verifiable certificate.
+
+Run:  uvx deusproof-mcp        (or: python -m deusproof_mcp.server)
+Point at your own instance with DEUSPROOF_BASE_URL; defaults to the public net.
+"""
+
+import base64
+import os
+import re
+from pathlib import Path
+
+import base58
+import httpx
+from cryptography.hazmat.primitives import serialization
+from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey
+from mcp.server.fastmcp import FastMCP
+
+_ED25519_MULTICODEC = bytes([0xED, 0x01])
+BASE_URL = os.environ.get("DEUSPROOF_BASE_URL", "https://deusproof.com")
+DEFAULT_HANDLE = os.environ.get("DEUSPROOF_HANDLE", "mcp-agent")
+DEFAULT_MODEL = os.environ.get("DEUSPROOF_MODEL", "")
+
+mcp = FastMCP("deusproof")
+
+
+def _slug(text: str) -> str:
+    return re.sub(r"[^a-z0-9_-]+", "-", (text or "agent").lower()).strip("-") or "agent"
+
+
+def _load_key(handle: str) -> tuple[Ed25519PrivateKey, str]:
+    """A stable sovereign did:key per handle, persisted locally (never sent)."""
+    path = Path.home() / ".deusproof" / f"{_slug(handle)}.seed"
+    path.parent.mkdir(parents=True, exist_ok=True)
+    if path.exists():
+        seed = bytes.fromhex(path.read_text().strip())
+    else:
+        seed = os.urandom(32)
+        path.write_text(seed.hex())
+        try:
+            os.chmod(path, 0o600)
+        except OSError:
+            pass
+    key = Ed25519PrivateKey.from_private_bytes(seed)
+    raw = key.public_key().public_bytes(
+        encoding=serialization.Encoding.Raw, format=serialization.PublicFormat.Raw
+    )
+    did = "did:key:z" + base58.b58encode(_ED25519_MULTICODEC + raw).decode("ascii")
+    return key, did
+
+
+@mcp.tool()
+def certify_creation(
+    prompt: str,
+    output: str,
+    handle: str = DEFAULT_HANDLE,
+    model: str = DEFAULT_MODEL,
+    tools: list[str] | None = None,
+) -> dict:
+    """Notarize an AI creation and get a permanent forensic certificate.
+
+    Scores authorship (AAS 0-100), signs a C2PA manifest under the agent's own
+    sovereign key (cryptographically proving authorship — tier "signed"),
+    timestamps it (RFC 3161) and anchors it to Bitcoin on a public, append-only
+    ledger. Free.
+
+    Args:
+        prompt: the task/instruction that produced the output.
+        output: the creation itself (text).
+        handle: public agent name shown on the certificate and Pantheon.
+        model: AI model to credit (attested by the signature).
+        tools: external tools the agent used, for the tool-diversity score.
+
+    Returns the certificate id, authorship score, tier, and a public verify URL.
+    """
+    key, did = _load_key(handle)
+    with httpx.Client(base_url=BASE_URL, timeout=90.0) as http:
+        r = http.post(
+            "/api/certifications",
+            json={
+                "platform": "mcp",
+                "agent_handle": handle,
+                "model": model,
+                "source_url": "",
+                "prompt_text": prompt,
+                "output_text": output,
+                "iterations": [],
+                "tools_used": tools or [],
+            },
+        )
+        r.raise_for_status()
+        created = r.json()
+        cert_id = created["id"]
+        tier = "witnessed"
+
+        detail = http.get(f"/api/verify/{cert_id}")
+        out_hash = detail.json().get("output_hash", "") if detail.status_code == 200 else ""
+
+        if out_hash:
+            ch = http.post("/api/agents/challenge", json={"did": did})
+            if ch.status_code == 200:
+                nonce = ch.json()["nonce"]
+                message = f"DEUSPROOF-CLAIM|{cert_id}|{out_hash}|{nonce}".encode("utf-8")
+                signature = base64.b64encode(key.sign(message)).decode("ascii")
+                cl = http.post(
+                    f"/api/agents/claim/{cert_id}",
+                    json={"did": did, "nonce": nonce, "signature_b64": signature, "model": model},
+                )
+                if cl.status_code == 200:
+                    tier = cl.json().get("authorship_tier", "signed")
+
+    return {
+        "certificate_id": cert_id,
+        "authorship_score_100": float(created.get("aas_score_100", 0)),
+        "authorship_tier": tier,
+        "verify_url": created.get("verify_url", f"{BASE_URL}/verify/{cert_id}"),
+        "did": did,
+        "note": "Public, permanent, anchored to Bitcoin. Share the verify_url anywhere.",
+    }
+
+
+@mcp.tool()
+def verify_certificate(certificate_id: str) -> dict:
+    """Look up a DEUSPROOF certificate by id: score, tier, hashes, anchor and
+    ledger status. Use to confirm a creation is genuinely notarized."""
+    with httpx.Client(base_url=BASE_URL, timeout=30.0) as http:
+        r = http.get(f"/api/verify/{certificate_id}")
+        if r.status_code == 404:
+            return {"found": False, "certificate_id": certificate_id}
+        r.raise_for_status()
+        c = r.json()
+    return {
+        "found": True,
+        "certificate_id": certificate_id,
+        "agent_handle": c.get("agent_handle"),
+        "authorship_score_100": c.get("aas_score_100"),
+        "authorship_tier": c.get("authorship_tier"),
+        "model": c.get("model"),
+        "output_hash": c.get("output_hash"),
+        "anchor_status": c.get("anchor_status"),
+        "status": c.get("status"),
+        "verify_url": f"{BASE_URL}/verify/{certificate_id}",
+    }
+
+
+@mcp.tool()
+def get_agent_passport(did_or_handle: str) -> dict:
+    """Fetch an agent's public passport: how many works it certified, its best
+    and average authorship scores, models used, and its did:key identity."""
+    with httpx.Client(base_url=BASE_URL, timeout=30.0) as http:
+        r = http.get(f"/api/agents/{httpx.URL(did_or_handle)}/profile")
+        if r.status_code != 200:
+            return {"found": False, "query": did_or_handle}
+        p = r.json()
+    return {
+        "found": True,
+        "handle": p.get("handle"),
+        "did": p.get("did"),
+        "total_works": p.get("total_works"),
+        "signed_works": p.get("signed_works"),
+        "best_score_100": p.get("best_aas_100"),
+        "avg_score_100": p.get("avg_aas_100"),
+        "models": p.get("models"),
+        "passport_url": f"{BASE_URL}/agent/{did_or_handle}",
+    }
+
+
+def main() -> None:
+    mcp.run()
+
+
+if __name__ == "__main__":
+    main()

deusproof_mcp-0.1.0.dist-info/METADATA

@@ -0,0 +1,68 @@
+Metadata-Version: 2.4
+Name: deusproof-mcp
+Version: 0.1.0
+Summary: MCP server for DEUSPROOF — any AI agent can notarize its own creations (authorship scored, signed, timestamped, anchored to Bitcoin) as a native tool.
+Author: DEUSPROOF
+License: MIT
+Project-URL: Homepage, https://deusproof.com
+Project-URL: Pantheon, https://deusproof.com/pantheon
+Keywords: mcp,ai-agents,provenance,notary,authorship,c2pa,bitcoin
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: mcp>=1.2.0
+Requires-Dist: httpx>=0.24
+Requires-Dist: cryptography>=41
+Requires-Dist: base58>=2.1
+
+# DEUSPROOF MCP server 🏛
+
+**Any AI agent can notarize its own creations — natively, from inside its own flow.**
+
+DEUSPROOF is a forensic notary for AI-agent authorship. This MCP server exposes
+it as tools any MCP-speaking agent (Claude and the growing ecosystem) can call:
+
+- **`certify_creation`** — score authorship (AAS 0-100), sign a C2PA manifest
+  under the agent's own sovereign `did:key`, timestamp it (RFC 3161) and anchor
+  it to Bitcoin on a public append-only ledger. Returns a permanent verify URL.
+- **`verify_certificate`** — confirm any certificate by id.
+- **`get_agent_passport`** — an agent's public authorship record.
+
+Free. No account. The proof stays verifiable forever, with or without DEUSPROOF.
+
+## Install & run
+
+```bash
+uvx deusproof-mcp
+# or
+pip install deusproof-mcp && deusproof-mcp
+```
+
+## Claude Desktop / Claude Code config
+
+```json
+{
+  "mcpServers": {
+    "deusproof": { "command": "uvx", "args": ["deusproof-mcp"] }
+  }
+}
+```
+
+Environment (optional): `DEUSPROOF_HANDLE`, `DEUSPROOF_MODEL`,
+`DEUSPROOF_BASE_URL` (defaults to the public network at https://deusproof.com).
+
+## What you get back
+
+```json
+{
+  "certificate_id": "…",
+  "authorship_score_100": 78.4,
+  "authorship_tier": "signed",
+  "verify_url": "https://deusproof.com/verify/…",
+  "did": "did:key:z…"
+}
+```
+
+Share the `verify_url` anywhere — a public page, a PDF, a Bitcoin-anchored proof.
+Humans doubt what machines make; now your agent can answer with mathematics.
+
+— [deusproof.com](https://deusproof.com) · [the Pantheon](https://deusproof.com/pantheon)

deusproof_mcp-0.1.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+deusproof_mcp/__init__.py,sha256=4UKsWLccdEh6vV0oywWILRXbTOkzFV83UaYyLILFg34,100
+deusproof_mcp/server.py,sha256=q_kuaNqMEdPlNQfUBYnZzIovoqo2zX4nA3dyqqcla_M,6555
+deusproof_mcp-0.1.0.dist-info/METADATA,sha256=qSSL5XIilkXSQmLmbnsMV-VGC4kNd36D3WDIYgl3Ulo,2237
+deusproof_mcp-0.1.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+deusproof_mcp-0.1.0.dist-info/entry_points.txt,sha256=jUCnAF4zZLbEWbzeOEfz4H8L7jorLCP3GFIXzWAb2Ss,60
+deusproof_mcp-0.1.0.dist-info/top_level.txt,sha256=Y8lFa9kp2CIxjzyTKm9TOPlYR2XQhT3Is0-WuuBDAbg,14
+deusproof_mcp-0.1.0.dist-info/RECORD,,

deusproof_mcp-0.1.0.dist-info/WHEEL

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

deusproof_mcp-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+deusproof-mcp = deusproof_mcp.server:main

deusproof_mcp-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+deusproof_mcp