AIMarket MCP Packager

Draw unbiasable, Ed25519-signed verifiable randomness (Platon). Use this when you need randomness an autonomous agent cannot bias or predict and that a third party can verify — fair selection, sampling, raffles, commit-reveal, anti-MEV ordering. The oracle signs the value, so you (or anyone) can verify it offline against the published signer key. Returns: The standard envelope (see server instructions). `result` contains: - `random_hex`: the random bytes, hex-encoded (`num_bytes` long). - `proof`: `{state_hash, tick, timestamp, entropy_commitment}` binding the value to the oracle's chaotic state at draw time. - `signature`: Ed25519 signature over the value+proof (verify with `verify_random`/the signer key in the Hub manifest). `verifiable.signed` will be true. Cost ~$0.004 USDC, charged per call. Example: get_random(num_bytes=32, client_seed="0xdeadbeef")

Fetch the round's public randomness beacon (Platon) — one shared value all callers in the round observe, useful as a common coin / shared seed. Returns: The standard envelope; `result` has the same `{random_hex, proof, signature}` shape as `get_random`, but the value is the round-wide beacon (not caller-specific). Cost ~$0.004 USDC. Example: get_randomness_beacon()

Ask the Platon oracle for a grounded, entropy-derived read-only answer. Use for lightweight oracle-mediated decisions (e.g. an unbiased pick among options). Read-only — no side effects, no state change. Returns: The standard envelope; `result` carries the oracle's answer payload. Cost ~$0.003 USDC. Example: ask_oracle(question="Pick one at random: red, green, or blue?")

Verify a Platon randomness draw without re-running it (Platon verify). Pass `random_hex`, `proof`, and `signature` exactly as returned by `get_random` / `get_randomness_beacon`. Confirms the Ed25519 signature over the canonical (random_hex, proof) against the signer's published public key — so you trust the math, not the service. Returns: The standard envelope; `result` is `{valid: <bool>}` (plus `error` if the input was malformed). Cost ~$0.001 USDC. Example: verify_random(random_hex="0x9f2c…", proof={"scheme": "platon-chaos-vrf/v1", …}, signature={"algorithm": "ed25519", "public_key": "<b64>", "value": "<b64>"})

Evaluate a Verifiable Delay Function (Chronos) — proof that real sequential work elapsed. Use when you need provable, unforgeable elapsed time / sequential work: timed reveals, fair ordering, proof-of-elapsed-time, randomness that cannot be precomputed. Producing the output requires `T` sequential squarings over an RSA-2048 modulus (no shortcut), so a valid proof attests the delay actually happened. Verify cheaply with `verify_vdf`. Returns: The standard envelope; `result` contains: - `scheme`, `g`, `y` (= g^(2^T) mod N), `proof` (`{pi, l}`, Wesolowski), `modulus`. `verifiable.has_proof` will be true. Cost ~$0.01 USDC. Example: compute_vdf(seed="0x1234abcd", difficulty=100000)

Verify a Chronos VDF proof in a single exponentiation. Pass the `g`, `y`, `T`, and `proof` returned by `compute_vdf` (or by any party claiming a VDF result). Confirms `y = g^(2^T) mod N` without redoing the T squarings. Returns: The standard envelope; `result` is `{valid: <bool>}`. Cost ~$0.001 USDC. Example: verify_vdf(g="0x03", y="0x9f2a…", T=100000, proof={"pi": "0x1a2b…", "l": "0x65"})

Compute PageRank/EigenTrust trust scores over a directed trust graph you supply (LUMEN). Use to rank agents/entities by trust when you have who-trusts-whom edges: counterparty selection, sybil-dampened weighting, prioritization. You provide the graph; the oracle returns a normalized score per node plus convergence info. Returns: The standard envelope; `result` contains: - `scores`: array of `nodes` floats that sum to 1 (±1e-6) — node i's trust share. - `iterations`, `converged`: power-iteration convergence info. Cost ~$0.005 USDC (scales with graph size). Example: get_reputation_scores(nodes=3, edges=[[0,1,1.0],[1,2,0.5],[2,0,0.5]], damping=0.85)

Blue-noise point set via Mitchell best-candidate (Turing). Evenly spaced points with large minimum distance — spawn placement, dithering, sensor layout. Omit seed for os.urandom (reported back). Cost ~$0.002 USDC per call.

Trust score, rank, and percentile of ONE node in a trust graph you supply (LUMEN). A single-agent reputation lookup over the same PageRank as `get_reputation_scores` — use when you only care about one counterparty's standing. Returns: The standard envelope; `result` is `{target_node, score, rank (1=highest), of, percentile, graph_commitment}`. Cost ~$0.003 USDC. Example: get_agent_trust(nodes=3, edges=[[0,1,1.0],[1,2,0.5],[2,0,0.5]], target_node=1)

Verify LUMEN reputation scores by re-deriving PageRank over the supplied graph (LUMEN verify). Pass the graph and the `scores` (and optionally the `graph_commitment`) from a `get_reputation_scores` result; confirms they are the correct PageRank of exactly that graph. Returns: The standard envelope; `result` is `{valid: <bool>, max_abs_diff, [commitment_match]}`. Cost ~$0.002 USDC. Example: verify_reputation(nodes=3, edges=[[0,1,1.0],[1,2,0.5],[2,0,0.5]], scores=[0.33,0.33,0.34])

List every oracle tool with capabilityId, price, category, and optional subscription tiers. Call this first to discover what's available and what each call costs before invoking. Returns: JSON with `tools` (flat catalog) and `categories` (group labels). Example: list_oracle_capabilities()

Robust consensus aggregation of multi-agent estimates (Murmuration). Combines median, trimmed mean, Tukey biweight, and DeGroot consensus — resistant to outliers and a few Byzantine agents. Use for multi-agent debate resolution, ensemble aggregation, DAO voting, and distributed anomaly consensus. Cost ~$0.002 USDC per call.

Thermodynamic compute-cost audit via Landauer's principle (Landauer). Counts irreversible bit erasures in an operation DAG, derives the energy floor (erasures · k_B·T·ln2), efficiency, and hot gates. Use for LLM cost optimization, carbon reporting, ESG compliance, and EU AI Act energy disclosure. Cost ~$0.01 USDC per call.

Trustless replay of a Landauer thermodynamic audit (Landauer verify). Recomputes erasures and energy floor from the ops DAG and checks claims. Cost ~$0.001 USDC.

Least-time routing with eikonal potentials + dual certificate (Fermat). Finds the minimum-time path on a weighted graph and returns potentials T(v) as an optimality certificate. Use for multi-agent task routing, supply chain, logistics, and data-pipeline optimization. Cost ~$0.01 USDC per call.

Trustless certificate check for a Fermat least-time route (Fermat verify). Confirms feasibility on every edge and tightness on the path in O(E) time. Cost ~$0.001 USDC.

Systemic cascade-risk analysis via abelian sandpile / SOC (Ablation). Returns avalanche-size distribution, power-law exponent tau, VaR/CVaR tail risk, and trigger nodes. Use for financial contagion, supply-chain resilience, and microservices failure analysis. Cost ~$0.01 USDC per call.

Trustless replay of an Ablation cascade analysis (Ablation verify). Re-runs the sandpile and checks tau / topple_total claims. Cost ~$0.001 USDC.

Halton low-discrepancy quasi-random sequence (Lattice). Fills [0,1)^dim more evenly than RNG — faster QMC convergence for integration, pricing, and space-filling search. Deterministic from (count, dim, skip). Cost ~$0.002 USDC per call.

Euclidean TSP tour with optimality gap certificate (Colony). Returns tour, length, admissible lower bound, and gap = how far from optimal. Use for routing, scheduling, and logistics with a quality proof. Cost ~$0.005 USDC per call.

Percolation threshold and network resilience analysis (Percola). Returns critical attack fraction f_c, collapse curves P_inf(f), robustness scalar, and keystone nodes. Use before joining exposure graphs or multi-hop agent routes. Cost ~$0.01 USDC per call.

Trustless replay of a Percola percolation threshold (Percola verify). Recomputes the attack sweep and checks the claimed f_c. Cost ~$0.001 USDC.

Build a complete self-hosted MCP server package for an AIMarket capability. Use this first. It assembles everything needed to ship the capability as a standalone MCP server: the Docker image name, the MCP manifest (server + tool definition), subscription/pricing tiers, and a connection string. Returns: A JSON object (string) with keys: - `docker_image`: the image name to build/run. - `mcp_manifest`: the full MCP manifest (server metadata + tools). - `subscription_tiers`: pricing tiers derived for the capability. - `connection_string`: how a client connects to the running server. Example: package_capability( capability_id="translate.multi@v2", product_id="prod-translate", name="Lyra Translator", description="Translate text into multiple languages.", input_schema={"type": "object", "properties": {"text": {"type": "string"}}, "required": ["text"]}, )

Generate a ready-to-build Dockerfile for the packaged MCP server. Takes the same capability inputs as `package_capability` and returns the Dockerfile text that builds the self-hosted MCP server image for it. Returns: The Dockerfile contents as plain text — write it to `Dockerfile` and run `docker build` to produce the image named in `package_capability`'s `docker_image` field. Example: generate_dockerfile( capability_id="translate.multi@v2", product_id="prod-translate", name="Lyra Translator", )

Generate a claude_desktop_config.json snippet for the packaged MCP server. Takes the same capability inputs as `package_capability` and returns the `mcpServers` entry that registers the docker-run MCP server with Claude Desktop (or any MCP host that reads this config format). Returns: A JSON object (string) containing an `mcpServers` block — merge it into the user's existing `claude_desktop_config.json` and restart the host. Example: generate_claude_desktop_config( capability_id="translate.multi@v2", product_id="prod-translate", name="Lyra Translator", )