dokimo-mcp 0.1.0__tar.gz

dokimo_mcp-0.1.0/LICENSE

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

dokimo_mcp-0.1.0/PKG-INFO

@@ -0,0 +1,133 @@
+Metadata-Version: 2.4
+Name: dokimo-mcp
+Version: 0.1.0
+Summary: MCP server to verify AI-agent revenue claims: recompute a Merkle proof and check it against an on-chain anchor.
+Author: Augaster Technologies
+License-Expression: MIT
+Project-URL: Homepage, https://dokimo.augaster.com
+Project-URL: Demo, https://dokimo.augaster.com/agent-audits-agents.html
+Project-URL: Repository, https://github.com/ypratap11/dokimo-mcp
+Project-URL: Issues, https://github.com/ypratap11/dokimo-mcp/issues
+Keywords: mcp,model-context-protocol,x402,agentic-payments,merkle,verification,agents
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Security
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: mcp<2,>=1.2
+Requires-Dist: uvicorn>=0.30
+Dynamic: license-file
+
+# dokimo-mcp
+
+<!-- mcp-name: io.github.ypratap11/dokimo-mcp -->
+
+**Give an AI agent the ability to verify another agent's revenue claims.**
+
+An [MCP](https://modelcontextprotocol.io) server exposing [Dokimo's](https://dokimo.augaster.com)
+trustless evidence verification as tools any MCP client (Claude Desktop, IDE
+agents, custom agents) can call. It's the "agent that audits agents" — as tools.
+
+Live, clickable version of what these tools do:
+**https://dokimo.augaster.com/agent-audits-agents.html**
+
+> This is a thin, self-contained **client**: it calls Dokimo's public endpoints and
+> implements the public `dokimo-merkle-v1` hashing scheme. It contains no proprietary
+> code. MIT-licensed.
+
+## Tools
+
+| Tool | What it does | Network? |
+|---|---|---|
+| `recompute_merkle_root(leaf, proof_path)` | **Trustless local recompute** — hash a leaf under `dokimo-merkle-v1` and replay the proof path to a root, with **no network and no trust in anyone**. Compare it to a package's claimed `root` yourself. | none |
+| `verify_evidence_package(package)` | **Full verification** via Dokimo's public A2A endpoint: recompute **and** check the compound commitment (root + rule version) against the **on-chain anchor on Base**. Returns `verified: true` only if both hold. | Dokimo A2A |
+| `dokimo_agent_card()` | Fetch Dokimo's public A2A agent card — what it can verify. | Dokimo |
+
+**Verification model:** there is no path to `verified: true` without (1) the
+caller's `(leaf, proof_path)` recomputing to the claimed `root`, **and** (2) the
+compound commitment of `(root, rule_version_commitment)` being anchored on-chain.
+Tamper one byte → recompute fails. Swap the rule version → the commitment changes
+→ not anchored.
+
+**Honest scope:** attests that a *reported* figure is reproducible and
+tamper-evident against an on-chain anchor — not that any underlying business
+number is "good." Non-custodial; reads public on-chain state only.
+
+## Install & run
+
+```bash
+pip install dokimo-mcp
+dokimo-mcp                 # runs over stdio
+# or, from a clone:
+pip install .
+python -m dokimo_mcp
+```
+
+## Add to an MCP client
+
+**Claude Desktop** — add to `claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "dokimo": {
+      "command": "dokimo-mcp"
+    }
+  }
+}
+```
+
+If `dokimo-mcp` isn't on `PATH`, use the module form:
+
+```json
+{
+  "mcpServers": {
+    "dokimo": {
+      "command": "python",
+      "args": ["-m", "dokimo_mcp"]
+    }
+  }
+}
+```
+
+Then ask the agent: *"Use Dokimo to verify this evidence package"* (paste one), or
+*"recompute this Merkle root and tell me if it matches."*
+
+## Try it
+
+The live demo page embeds a real, anchored evidence package. Fetch it and verify:
+
+```python
+import re, json, urllib.request
+import dokimo_mcp as d
+html = urllib.request.urlopen(urllib.request.Request(
+    "https://dokimo.augaster.com/agent-audits-agents.html",
+    headers={"User-Agent": d._UA})).read().decode()
+pkg = json.loads(re.search(r"const PKG\s*=\s*(\{.*?\})\s*;", html, re.S).group(1))
+print(d.verify_evidence_package(pkg)["verified"])   # True
+# tamper one unit -> False
+pkg["leaf"] = pkg["leaf"].replace("1001190933933115", "1001190933933116")
+print(d.verify_evidence_package(pkg)["verified"])   # False
+```
+
+## Hosted / HTTP mode
+
+The default transport is **stdio** (local use). Set `MCP_TRANSPORT=http` to serve
+**MCP Streamable HTTP at `/mcp`** on `$PORT` (default 8081) with CORS — the shape
+hosted platforms like [Smithery](https://smithery.ai) require. The included
+`Dockerfile` + `smithery.yaml` (`runtime: container`) are set up for exactly this,
+so Smithery can build and host it from this repo.
+
+```bash
+MCP_TRANSPORT=http PORT=8081 dokimo-mcp     # or: docker run -p 8081:8081 <image>
+```
+
+## What is Dokimo?
+
+Verifiable revenue infrastructure for autonomous commerce — audit-ready, independently
+reproducible books for AI-agent machine payments (x402 / AP2 / Stripe), with each figure
+tamper-evidently committed and anchored on-chain. https://dokimo.augaster.com
+
+## License
+
+MIT — see [LICENSE](LICENSE).

dokimo_mcp-0.1.0/README.md

@@ -0,0 +1,113 @@
+# dokimo-mcp
+
+<!-- mcp-name: io.github.ypratap11/dokimo-mcp -->
+
+**Give an AI agent the ability to verify another agent's revenue claims.**
+
+An [MCP](https://modelcontextprotocol.io) server exposing [Dokimo's](https://dokimo.augaster.com)
+trustless evidence verification as tools any MCP client (Claude Desktop, IDE
+agents, custom agents) can call. It's the "agent that audits agents" — as tools.
+
+Live, clickable version of what these tools do:
+**https://dokimo.augaster.com/agent-audits-agents.html**
+
+> This is a thin, self-contained **client**: it calls Dokimo's public endpoints and
+> implements the public `dokimo-merkle-v1` hashing scheme. It contains no proprietary
+> code. MIT-licensed.
+
+## Tools
+
+| Tool | What it does | Network? |
+|---|---|---|
+| `recompute_merkle_root(leaf, proof_path)` | **Trustless local recompute** — hash a leaf under `dokimo-merkle-v1` and replay the proof path to a root, with **no network and no trust in anyone**. Compare it to a package's claimed `root` yourself. | none |
+| `verify_evidence_package(package)` | **Full verification** via Dokimo's public A2A endpoint: recompute **and** check the compound commitment (root + rule version) against the **on-chain anchor on Base**. Returns `verified: true` only if both hold. | Dokimo A2A |
+| `dokimo_agent_card()` | Fetch Dokimo's public A2A agent card — what it can verify. | Dokimo |
+
+**Verification model:** there is no path to `verified: true` without (1) the
+caller's `(leaf, proof_path)` recomputing to the claimed `root`, **and** (2) the
+compound commitment of `(root, rule_version_commitment)` being anchored on-chain.
+Tamper one byte → recompute fails. Swap the rule version → the commitment changes
+→ not anchored.
+
+**Honest scope:** attests that a *reported* figure is reproducible and
+tamper-evident against an on-chain anchor — not that any underlying business
+number is "good." Non-custodial; reads public on-chain state only.
+
+## Install & run
+
+```bash
+pip install dokimo-mcp
+dokimo-mcp                 # runs over stdio
+# or, from a clone:
+pip install .
+python -m dokimo_mcp
+```
+
+## Add to an MCP client
+
+**Claude Desktop** — add to `claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "dokimo": {
+      "command": "dokimo-mcp"
+    }
+  }
+}
+```
+
+If `dokimo-mcp` isn't on `PATH`, use the module form:
+
+```json
+{
+  "mcpServers": {
+    "dokimo": {
+      "command": "python",
+      "args": ["-m", "dokimo_mcp"]
+    }
+  }
+}
+```
+
+Then ask the agent: *"Use Dokimo to verify this evidence package"* (paste one), or
+*"recompute this Merkle root and tell me if it matches."*
+
+## Try it
+
+The live demo page embeds a real, anchored evidence package. Fetch it and verify:
+
+```python
+import re, json, urllib.request
+import dokimo_mcp as d
+html = urllib.request.urlopen(urllib.request.Request(
+    "https://dokimo.augaster.com/agent-audits-agents.html",
+    headers={"User-Agent": d._UA})).read().decode()
+pkg = json.loads(re.search(r"const PKG\s*=\s*(\{.*?\})\s*;", html, re.S).group(1))
+print(d.verify_evidence_package(pkg)["verified"])   # True
+# tamper one unit -> False
+pkg["leaf"] = pkg["leaf"].replace("1001190933933115", "1001190933933116")
+print(d.verify_evidence_package(pkg)["verified"])   # False
+```
+
+## Hosted / HTTP mode
+
+The default transport is **stdio** (local use). Set `MCP_TRANSPORT=http` to serve
+**MCP Streamable HTTP at `/mcp`** on `$PORT` (default 8081) with CORS — the shape
+hosted platforms like [Smithery](https://smithery.ai) require. The included
+`Dockerfile` + `smithery.yaml` (`runtime: container`) are set up for exactly this,
+so Smithery can build and host it from this repo.
+
+```bash
+MCP_TRANSPORT=http PORT=8081 dokimo-mcp     # or: docker run -p 8081:8081 <image>
+```
+
+## What is Dokimo?
+
+Verifiable revenue infrastructure for autonomous commerce — audit-ready, independently
+reproducible books for AI-agent machine payments (x402 / AP2 / Stripe), with each figure
+tamper-evidently committed and anchored on-chain. https://dokimo.augaster.com
+
+## License
+
+MIT — see [LICENSE](LICENSE).

dokimo_mcp-0.1.0/dokimo_mcp.egg-info/PKG-INFO

@@ -0,0 +1,133 @@
+Metadata-Version: 2.4
+Name: dokimo-mcp
+Version: 0.1.0
+Summary: MCP server to verify AI-agent revenue claims: recompute a Merkle proof and check it against an on-chain anchor.
+Author: Augaster Technologies
+License-Expression: MIT
+Project-URL: Homepage, https://dokimo.augaster.com
+Project-URL: Demo, https://dokimo.augaster.com/agent-audits-agents.html
+Project-URL: Repository, https://github.com/ypratap11/dokimo-mcp
+Project-URL: Issues, https://github.com/ypratap11/dokimo-mcp/issues
+Keywords: mcp,model-context-protocol,x402,agentic-payments,merkle,verification,agents
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Security
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: mcp<2,>=1.2
+Requires-Dist: uvicorn>=0.30
+Dynamic: license-file
+
+# dokimo-mcp
+
+<!-- mcp-name: io.github.ypratap11/dokimo-mcp -->
+
+**Give an AI agent the ability to verify another agent's revenue claims.**
+
+An [MCP](https://modelcontextprotocol.io) server exposing [Dokimo's](https://dokimo.augaster.com)
+trustless evidence verification as tools any MCP client (Claude Desktop, IDE
+agents, custom agents) can call. It's the "agent that audits agents" — as tools.
+
+Live, clickable version of what these tools do:
+**https://dokimo.augaster.com/agent-audits-agents.html**
+
+> This is a thin, self-contained **client**: it calls Dokimo's public endpoints and
+> implements the public `dokimo-merkle-v1` hashing scheme. It contains no proprietary
+> code. MIT-licensed.
+
+## Tools
+
+| Tool | What it does | Network? |
+|---|---|---|
+| `recompute_merkle_root(leaf, proof_path)` | **Trustless local recompute** — hash a leaf under `dokimo-merkle-v1` and replay the proof path to a root, with **no network and no trust in anyone**. Compare it to a package's claimed `root` yourself. | none |
+| `verify_evidence_package(package)` | **Full verification** via Dokimo's public A2A endpoint: recompute **and** check the compound commitment (root + rule version) against the **on-chain anchor on Base**. Returns `verified: true` only if both hold. | Dokimo A2A |
+| `dokimo_agent_card()` | Fetch Dokimo's public A2A agent card — what it can verify. | Dokimo |
+
+**Verification model:** there is no path to `verified: true` without (1) the
+caller's `(leaf, proof_path)` recomputing to the claimed `root`, **and** (2) the
+compound commitment of `(root, rule_version_commitment)` being anchored on-chain.
+Tamper one byte → recompute fails. Swap the rule version → the commitment changes
+→ not anchored.
+
+**Honest scope:** attests that a *reported* figure is reproducible and
+tamper-evident against an on-chain anchor — not that any underlying business
+number is "good." Non-custodial; reads public on-chain state only.
+
+## Install & run
+
+```bash
+pip install dokimo-mcp
+dokimo-mcp                 # runs over stdio
+# or, from a clone:
+pip install .
+python -m dokimo_mcp
+```
+
+## Add to an MCP client
+
+**Claude Desktop** — add to `claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "dokimo": {
+      "command": "dokimo-mcp"
+    }
+  }
+}
+```
+
+If `dokimo-mcp` isn't on `PATH`, use the module form:
+
+```json
+{
+  "mcpServers": {
+    "dokimo": {
+      "command": "python",
+      "args": ["-m", "dokimo_mcp"]
+    }
+  }
+}
+```
+
+Then ask the agent: *"Use Dokimo to verify this evidence package"* (paste one), or
+*"recompute this Merkle root and tell me if it matches."*
+
+## Try it
+
+The live demo page embeds a real, anchored evidence package. Fetch it and verify:
+
+```python
+import re, json, urllib.request
+import dokimo_mcp as d
+html = urllib.request.urlopen(urllib.request.Request(
+    "https://dokimo.augaster.com/agent-audits-agents.html",
+    headers={"User-Agent": d._UA})).read().decode()
+pkg = json.loads(re.search(r"const PKG\s*=\s*(\{.*?\})\s*;", html, re.S).group(1))
+print(d.verify_evidence_package(pkg)["verified"])   # True
+# tamper one unit -> False
+pkg["leaf"] = pkg["leaf"].replace("1001190933933115", "1001190933933116")
+print(d.verify_evidence_package(pkg)["verified"])   # False
+```
+
+## Hosted / HTTP mode
+
+The default transport is **stdio** (local use). Set `MCP_TRANSPORT=http` to serve
+**MCP Streamable HTTP at `/mcp`** on `$PORT` (default 8081) with CORS — the shape
+hosted platforms like [Smithery](https://smithery.ai) require. The included
+`Dockerfile` + `smithery.yaml` (`runtime: container`) are set up for exactly this,
+so Smithery can build and host it from this repo.
+
+```bash
+MCP_TRANSPORT=http PORT=8081 dokimo-mcp     # or: docker run -p 8081:8081 <image>
+```
+
+## What is Dokimo?
+
+Verifiable revenue infrastructure for autonomous commerce — audit-ready, independently
+reproducible books for AI-agent machine payments (x402 / AP2 / Stripe), with each figure
+tamper-evidently committed and anchored on-chain. https://dokimo.augaster.com
+
+## License
+
+MIT — see [LICENSE](LICENSE).

dokimo_mcp-0.1.0/dokimo_mcp.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+LICENSE
+README.md
+dokimo_mcp.py
+pyproject.toml
+dokimo_mcp.egg-info/PKG-INFO
+dokimo_mcp.egg-info/SOURCES.txt
+dokimo_mcp.egg-info/dependency_links.txt
+dokimo_mcp.egg-info/entry_points.txt
+dokimo_mcp.egg-info/requires.txt
+dokimo_mcp.egg-info/top_level.txt

dokimo_mcp-0.1.0/dokimo_mcp.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

dokimo_mcp-0.1.0/dokimo_mcp.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+dokimo-mcp = dokimo_mcp:main

dokimo_mcp-0.1.0/dokimo_mcp.egg-info/requires.txt

@@ -0,0 +1,2 @@
+mcp<2,>=1.2
+uvicorn>=0.30

dokimo_mcp-0.1.0/dokimo_mcp.egg-info/top_level.txt

@@ -0,0 +1 @@
+dokimo_mcp

dokimo_mcp-0.1.0/dokimo_mcp.py

@@ -0,0 +1,198 @@
+"""Dokimo MCP server — give an AI agent the ability to verify another agent's
+revenue claims.
+
+A self-contained Model Context Protocol server exposing three tools:
+
+  - ``recompute_merkle_root``  — PURE, LOCAL, trustless: recompute a
+    ``dokimo-merkle-v1`` root from a leaf + proof path, with no network and no
+    trust in anyone. The "check the math yourself" primitive.
+  - ``verify_evidence_package`` — full verification via Dokimo's public A2A
+    endpoint: recompute + on-chain anchor check, returning a signed-off verdict.
+  - ``dokimo_agent_card``       — fetch Dokimo's public A2A agent card.
+
+This is a thin CLIENT: it talks to Dokimo's public endpoints and implements the
+public ``dokimo-merkle-v1`` hashing scheme (RFC-6962-style, domain-separated).
+It contains no proprietary code.
+
+Verification model: there is NO path to ``verified: true`` without BOTH
+(1) the caller's ``(leaf, proof_path)`` recomputing to the claimed root, AND
+(2) the compound commitment of ``(root, rule_version_commitment)`` being anchored
+on-chain. Tamper one byte → recompute fails. Swap the rule version → the compound
+commitment changes → not anchored.
+
+Honest scope: attests that a *reported* figure is reproducible and tamper-evident
+against an on-chain anchor — not that any underlying business number is "good."
+
+Run:  ``dokimo-mcp``  (after ``pip install dokimo-mcp``), or ``python -m dokimo_mcp``.
+Live demo the tools mirror: https://dokimo.augaster.com/agent-audits-agents.html
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import urllib.request
+from typing import Annotated, Any
+
+from mcp.server.fastmcp import FastMCP
+from mcp.types import ToolAnnotations
+from pydantic import Field
+
+# Public Dokimo endpoints by default. Override (e.g. a self-hosted deploy pointing
+# at an internal address to avoid a hairpin) via DOKIMO_A2A_URL / DOKIMO_AGENT_CARD_URL.
+DOKIMO_A2A = os.environ.get("DOKIMO_A2A_URL", "https://dokimo.augaster.com/a2a")
+DOKIMO_AGENT_CARD = os.environ.get(
+    "DOKIMO_AGENT_CARD_URL", "https://dokimo.augaster.com/.well-known/agent-card.json")
+
+# A real User-Agent — the default Python-urllib UA is 403'd by the CDN's bot filter.
+_UA = "dokimo-mcp/0.1 (+https://dokimo.augaster.com)"
+
+# --- the public dokimo-merkle-v1 scheme (documented on the public site/demo) ----
+# Domain separation: leaves H(0x00 ‖ leaf), internal nodes H(0x01 ‖ left ‖ right),
+# over the hex-string representations. No proprietary logic — the published scheme.
+MERKLE_SCHEME = "dokimo-merkle-v1"
+_LEAF_PREFIX = b"\x00"
+_NODE_PREFIX = b"\x01"
+
+
+def _hash_leaf(leaf: str) -> str:
+    return hashlib.sha256(_LEAF_PREFIX + leaf.encode()).hexdigest()
+
+
+def _hash_node(a: str, b: str) -> str:
+    return hashlib.sha256(_NODE_PREFIX + a.encode() + b.encode()).hexdigest()
+
+
+mcp = FastMCP("dokimo")
+
+
+def _post_json(url: str, payload: dict, timeout: float = 25.0) -> Any:
+    data = json.dumps(payload).encode()
+    req = urllib.request.Request(
+        url, data=data,
+        headers={"Content-Type": "application/json", "User-Agent": _UA})
+    with urllib.request.urlopen(req, timeout=timeout) as resp:
+        return json.loads(resp.read())
+
+
+def _get_json(url: str, timeout: float = 25.0) -> Any:
+    req = urllib.request.Request(url, headers={"User-Agent": _UA})
+    with urllib.request.urlopen(req, timeout=timeout) as resp:
+        return json.loads(resp.read())
+
+
+@mcp.tool(annotations=ToolAnnotations(
+    title="Recompute Merkle root (local)",
+    readOnlyHint=True, idempotentHint=True, openWorldHint=False))
+def recompute_merkle_root(
+    leaf: Annotated[str, Field(description=(
+        "The raw leaf value (e.g. a JSON string like '{\"k\":\"total_assets\",\"v\":\"...\"}'). "
+        "Hashed in the leaf domain as H(0x00 ‖ leaf)."))],
+    proof_path: Annotated[list, Field(description=(
+        "Ordered Merkle proof path: a list of [sibling_hash_hex, side] pairs, where side is "
+        "\"L\" if the sibling is on the left or \"R\" if on the right. Empty list for a single-leaf tree."))],
+) -> dict:
+    """Trustlessly recompute a dokimo-merkle-v1 root — LOCAL, no network, no trust.
+
+    Hash ``leaf`` in the leaf domain (H(0x00 ‖ leaf)) and replay ``proof_path`` —
+    a list of ``[sibling_hash, side]`` where side is "L" or "R" — hashing internal
+    nodes as H(0x01 ‖ left ‖ right). Compare the returned root to the ``root`` in an
+    evidence package yourself; if it differs, the package was tampered with.
+
+    Returns ``{recomputed_root, merkle_scheme, steps}``.
+    """
+    path = [(str(h), str(s)) for h, s in proof_path]
+    for _, side in path:
+        if side not in ("L", "R"):
+            raise ValueError("each proof_path side must be 'L' or 'R'")
+    acc = _hash_leaf(leaf)
+    for sibling, side in path:
+        acc = _hash_node(sibling, acc) if side == "L" else _hash_node(acc, sibling)
+    return {"recomputed_root": acc, "merkle_scheme": MERKLE_SCHEME, "steps": len(path)}
+
+
+@mcp.tool(annotations=ToolAnnotations(
+    title="Verify evidence package (on-chain)",
+    readOnlyHint=True, idempotentHint=True, openWorldHint=True))
+def verify_evidence_package(
+    package: Annotated[dict, Field(description=(
+        "The Dokimo evidence package to verify. Required keys: 'leaf' (str), 'root' (str), "
+        "'proof_path' (list of [sibling_hash, \"L\"|\"R\"]), and 'rule_version_commitment' (str). "
+        "'close_id' (str) is optional and echoed back."))],
+) -> dict:
+    """Fully verify a Dokimo evidence package against the LIVE on-chain anchor.
+
+    Sends the package to Dokimo's public A2A endpoint, which recomputes the Merkle
+    proof AND checks the compound commitment (root + rule version) against the
+    anchor on Base. ``package`` must contain: ``leaf`` (str), ``root`` (str),
+    ``proof_path`` (list of [sibling_hash, "L"|"R"]), and
+    ``rule_version_commitment`` (str); ``close_id`` is optional/echoed.
+
+    Returns the verdict: ``{verified, checks:{recompute, onchain_anchor,
+    rule_version_bound}, ...}``. ``verified`` is true only if the proof recomputes
+    AND the commitment is anchored on-chain.
+    """
+    payload = {
+        "jsonrpc": "2.0", "id": "dokimo-mcp", "method": "SendMessage",
+        "params": {"message": {"role": "user", "parts": [{"data": package}]}},
+    }
+    resp = _post_json(DOKIMO_A2A, payload)
+    if isinstance(resp, dict) and resp.get("error"):
+        return {"verified": False, "error": resp["error"]}
+    result = resp.get("result", {}) if isinstance(resp, dict) else {}
+    task = result.get("task", result)          # v1.0.1 wraps in {task:...}; legacy is bare
+    for artifact in (task.get("artifacts") or []):
+        for part in (artifact.get("parts") or []):
+            if isinstance(part.get("data"), dict):
+                return part["data"]
+    return {"verified": False, "error": "no verdict artifact in A2A response", "raw": resp}
+
+
+@mcp.tool(annotations=ToolAnnotations(
+    title="Fetch Dokimo agent card",
+    readOnlyHint=True, idempotentHint=True, openWorldHint=True))
+def dokimo_agent_card() -> dict:
+    """Fetch Dokimo's public A2A agent card — the discovery document describing what
+    it can verify (skills, endpoints, supported A2A versions)."""
+    return _get_json(DOKIMO_AGENT_CARD)
+
+
+def main() -> None:
+    """Console-script entry point (``dokimo-mcp``).
+
+    Default transport is **stdio** (local use — Claude Desktop, IDE agents).
+    Set ``MCP_TRANSPORT=http`` (as the container image does) to serve **Streamable
+    HTTP at /mcp** on ``$PORT`` (default 8081) with CORS — the shape Smithery's
+    hosted deployments require.
+    """
+    transport = os.environ.get("MCP_TRANSPORT", "stdio").lower()
+    if transport in ("http", "streamable-http", "shttp"):
+        import uvicorn
+        from starlette.middleware.cors import CORSMiddleware
+        from mcp.server.transport_security import TransportSecuritySettings
+
+        port = int(os.environ.get("PORT", "8081"))
+        mcp.settings.host = "0.0.0.0"
+        mcp.settings.port = port
+        # DNS-rebinding protection defaults to localhost-only hosts/origins; that
+        # protects *local* servers from malicious sites. This is a public, hosted,
+        # read-only verifier (calls only public endpoints), and it sits behind a
+        # host (Smithery) that sets its own Host/Origin — so allow any.
+        mcp.settings.transport_security = TransportSecuritySettings(
+            enable_dns_rebinding_protection=False,
+        )
+        app = mcp.streamable_http_app()          # serves MCP at /mcp
+        app.add_middleware(
+            CORSMiddleware,
+            allow_origins=["*"],
+            allow_methods=["*"],
+            allow_headers=["*"],
+            expose_headers=["mcp-session-id"],   # Smithery/browser clients need this
+        )
+        uvicorn.run(app, host="0.0.0.0", port=port)
+    else:
+        mcp.run()   # stdio
+
+
+if __name__ == "__main__":
+    main()

dokimo_mcp-0.1.0/pyproject.toml

@@ -0,0 +1,37 @@
+[build-system]
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "dokimo-mcp"
+version = "0.1.0"
+description = "MCP server to verify AI-agent revenue claims: recompute a Merkle proof and check it against an on-chain anchor."
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "Augaster Technologies" }]
+keywords = ["mcp", "model-context-protocol", "x402", "agentic-payments", "merkle", "verification", "agents"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Topic :: Security",
+]
+dependencies = [
+    # Pinned to the 1.x line: this server uses the FastMCP API, which mcp 2.x
+    # renamed to MCPServer. Keeps a fresh container install (Smithery) on the API
+    # this code targets.
+    "mcp>=1.2,<2",
+    "uvicorn>=0.30",   # serving Streamable HTTP at /mcp for hosted (Smithery) deploys
+]
+
+[project.scripts]
+dokimo-mcp = "dokimo_mcp:main"
+
+[project.urls]
+Homepage = "https://dokimo.augaster.com"
+Demo = "https://dokimo.augaster.com/agent-audits-agents.html"
+Repository = "https://github.com/ypratap11/dokimo-mcp"
+Issues = "https://github.com/ypratap11/dokimo-mcp/issues"
+
+[tool.setuptools]
+py-modules = ["dokimo_mcp"]

dokimo_mcp-0.1.0/setup.cfg

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