1. Ringkasan
Dalam codelab ini, Anda akan menjalankan agen ADK yang memesan tiket bioskop di beberapa penjual tiket bioskop menggunakan dua protokol e-commerce open source:
- UCP (Universal Commerce Protocol): Standar bagi agen untuk menemukan penjual, menelusuri katalog, dan mengelola alur checkout.
- AP2 (Agent Payments Protocol): Protokol untuk otorisasi pembayaran yang aman dan dapat diverifikasi menggunakan perintah yang ditandatangani secara kriptografis.
Aplikasi demo, CineAgent, terhubung ke dua penjual tiket bioskop tiruan dengan kemampuan yang berbeda (pemilihan tempat duduk, format khusus, dan metode pembayaran) serta mengatur alur pemesanan lengkap dari penelusuran hingga pembayaran.
Yang akan Anda pelajari
- Cara kerja penemuan penjual UCP melalui profil
/.well-known/ucp - Cara agen ADK menggunakan UCP untuk menelusuri katalog dan membuat checkout
- Cara mandat AP2 (CheckoutMandate, PaymentMandate) mengamankan transaksi
- Cara kerja protokol UCP dan AP2 end-to-end untuk mengamankan e-commerce agentic
Yang Anda butuhkan
- Project Google Cloud yang mengaktifkan penagihan
- Browser web seperti Chrome
- Python 3.11+ dan uv, jika Anda menjalankan kode di komputer Anda sendiri, bukan di Cloud Shell
Codelab ini ditujukan bagi developer tingkat menengah yang sudah memahami Python dan Google Cloud. Codelab ini membutuhkan waktu sekitar 30 menit untuk diselesaikan.
Resource yang dibuat dalam codelab ini seharusnya berbiaya kurang dari $5.
2. Memahami Protokol UCP dan AP2
Sebelum kita mulai membangun agen, mari kita pahami dua protokol yang memungkinkan agentic commerce yang aman ini.
Codelab ini menggunakan UCP versi 2026-08-25 dengan UCP Python SDK, dan AP2 v0.2 dengan AP2 Python SDK.
Universal Commerce Protocol (UCP)
UCP menstandardisasi cara agen AI berinteraksi dengan penjual. API ini memecahkan masalah agen yang harus mempelajari API kustom untuk setiap toko dengan memperkenalkan model resource standar.
Cara kerjanya:
- Penemuan: Setiap penjual yang mematuhi UCP menampilkan profil di lokasi standar:
/.well-known/ucp. Contoh: Endpoint UCP Everlane.Saat agen membaca profil ini, agen akan mencari:- Kemampuan: Fitur inti mandiri yang didukung bisnis, seperti penelusuran katalog atau checkout.
- Layanan: Lapisan komunikasi tingkat bawah yang digunakan untuk bertukar data. Contoh: REST API, MCP (Model Context Protocol), A2A (Agent2Agent Protocol).
- Ekstensi: Jika penjual memerlukan perilaku khusus, mereka dapat menentukan Ekstensi kustom di profil ini.
- Kunci: Kunci penandatanganan publik penjual, yang digunakan agen untuk memeriksa tanda tangan penjual.
- Operasi: Setelah ditemukan, agen menggunakan endpoint layanan yang disediakan untuk melakukan operasi. Dalam codelab ini, kita menggunakan Model Context Protocol (MCP) sebagai transpor layanan. Agen melakukan panggilan JSON-RPC 2.0 ke endpoint ini untuk memanggil kemampuan yang ditemukan: menelusuri produk, membuat checkout, dan menyelesaikan pembelian.

Agent Payments Protocol (AP2)
AP2 menstandardisasi cara pembayaran diotorisasi oleh agen atas nama pengguna. Hal ini memecahkan masalah keamanan agen yang menangani kredensial pembayaran sensitif.
Cara kerjanya:
- Tanda Tangan Penjual: Saat agen membuat checkout menggunakan Protokol UCP, penjual menandatangani checkout (item baris dan total) dan menampilkan tanda tangan di
ap2.merchant_authorization. Fitur ini berfungsi sebagai jaminan penguncian harga. Jika penjual mengubah harga setelah menandatangani, tanda tangan tidak lagi cocok. - Surat Perintah Checkout dan Surat Perintah Pembayaran: Setelah memverifikasi konten checkout, pengguna (atau agen atas nama pengguna) menandatangani dua surat perintah.
CheckoutMandateberisi checkout yang ditandatangani penjual dan memberi tahu penjual bahwa pengguna menyetujuinya.PaymentMandatemengizinkan jumlah pembayaran untuk checkout tersebut. Keduanya merujuk ke hash checkout yang ditandatangani dan membawa tanda tangan kriptografi pengguna. - Verifikasi Tanda Tangan: Penjual menerima kedua surat perintah. Hal ini memverifikasi tanda tangan pengguna pada
CheckoutMandatedan memeriksa apakah checkout di dalamnya memiliki tanda tangan penjual.PaymentMandateakan diteruskan ke sisi pembayaran (penyedia kredensial atau pemroses pembayaran), yang akan memverifikasinya sebelum memindahkan uang. Jika semuanya valid, transaksi akan dilanjutkan.
Sistem "kunci ganda" ini memastikan bahwa penjual tidak dapat mengenakan biaya berlebih dan agen tidak dapat membelanjakan uang tanpa otorisasi. Mandat adalah kredensial SD-JWT (Selective Disclosure JWT), yang melindungi privasi pengguna dengan hanya mengungkapkan kolom yang dibutuhkan setiap pihak. Di AP2 v0.2, CheckoutMandate menggantikan CartMandate dari AP2 v0.1.

3. Menyiapkan lingkungan Anda
Penyiapan Project Google Cloud
Buat Project Google Cloud
- Di Konsol Google Cloud, di halaman pemilih project, pilih atau buat project Google Cloud.
- Pastikan penagihan diaktifkan untuk project Cloud Anda. Pelajari cara memeriksa apakah penagihan telah diaktifkan pada suatu project.
Mulai Cloud Shell
Cloud Shell adalah lingkungan command line yang berjalan di Google Cloud yang telah dilengkapi dengan alat yang diperlukan.
- Klik Activate Cloud Shell di bagian atas Konsol Google Cloud.
- Setelah terhubung ke Cloud Shell, verifikasi autentikasi Anda:
gcloud auth list - Pastikan project Anda dikonfigurasi:
gcloud config get project - Jika project Anda tidak ditetapkan seperti yang diharapkan, tetapkan project:
export PROJECT_ID=<YOUR_PROJECT_ID> gcloud config set project $PROJECT_ID
Mengaktifkan API
Jalankan perintah berikut untuk mengaktifkan API yang diperlukan:
gcloud services enable aiplatform.googleapis.com
Menyiapkan Struktur Direktori
Salin dan tempel perintah berikut untuk membuat folder bagi codelab ini, dengan folder agent_payments di dalamnya untuk kode agen:
mkdir -p ~/adk-agent-commerce/agent_payments
cd ~/adk-agent-commerce
Mengakses model Gemini
Salin dan tempel perintah berikut untuk membuat agent_payments/.env dengan project dan lokasi Anda, serta agar ADK memanggil Gemini melalui project Google Cloud Anda. Cine Agent menggunakan Gemini untuk memutuskan alat yang akan dipanggil. ADK memuat file ini secara otomatis, sehingga setelan juga berfungsi di terminal baru.
cat > ~/adk-agent-commerce/agent_payments/.env <<EOF
GOOGLE_CLOUD_PROJECT=$(gcloud config get project)
GOOGLE_CLOUD_LOCATION=global
GOOGLE_GENAI_USE_ENTERPRISE=True
EOF
Menginstal Dependensi
Google Cloud Shell telah diinstal sebelumnya dengan uv untuk mengelola lingkungan dan dependensi.
- Buat file
pyproject.tomldi root folderadk-agent-commerceAnda dan tambahkan konten berikut ke dalamnya. File ini menentukan metadata dan dependensi project.
[project]
name = "agent-payments-demo"
version = "0.1.0"
description = "CineAgent booking agent using UCP and AP2"
requires-python = ">=3.11"
dependencies = [
"google-adk",
"fastapi",
"uvicorn",
"httpx",
"ucp-sdk",
"ap2 @ git+https://github.com/google-agentic-commerce/AP2.git@main",
]
AP2 SDK diinstal dari repositori GitHub-nya karena belum dipublikasikan di PyPI. (Paket ap2 di PyPI adalah project yang tidak terkait.)
- Jalankan perintah berikut untuk membuat lingkungan virtual dan menginstal semua dependensi:
uv sync
uv membuat lingkungan Python yang terisolasi untuk codelab ini, jadi Anda tidak perlu mengaktifkan apa pun. Awali perintah Python dengan uv run.
4. Menentukan agen
Sebelum menulis logika alat apa pun, mari kita tentukan agen itu sendiri dalam file bernama agent.py. Agen ini akan bertindak sebagai pengelola alur pemesanan tiket bioskop.
Buat agent_payments/agent.py:
"""CineAgent — movie ticket booking agent using UCP and AP2."""
from google.adk.agents import Agent
from google.adk.models import Gemini
from google.genai import types
from google.adk.tools import FunctionTool
from agent_payments.tools import (
discover_theaters,
search_movies,
get_movie_detail,
create_checkout,
complete_purchase,
)
root_agent = Agent(
model=Gemini(
model="gemini-3.8-flash",
retry_options=types.HttpRetryOptions(attempts=5),
),
name="cineagent",
description="Movie ticket booking agent using UCP and AP2.",
instruction="""You are CineAgent, a movie ticket booking assistant.
You help users find and book movie tickets across multiple theaters
using UCP (Universal Commerce Protocol) and AP2 (Agent Payments).
**Your tools:**
- discover_theaters: Find theaters and what they support
- search_movies: Search movies across all theaters
- get_movie_detail: Get showtimes at a specific theater
- create_checkout: Start a checkout session
- complete_purchase: Finalize with AP2 mandate signing
**Rules:**
- Always call discover_theaters first if you haven't yet
- Keep responses concise — summarize and suggest next steps
- Prices from tools are in cents (1500 = $15.00)
- Never invent data — only state what tools return
""",
tools=[
discover_theaters,
search_movies,
get_movie_detail,
create_checkout,
FunctionTool(complete_purchase, require_confirmation=True),
],
)
Penjelasan Kode
Mari kita uraikan apa yang terjadi dalam definisi agen ini:
model=Gemini(...): Kami menggunakan Gemini 3.8 Flash untuk penalaran dan penggunaan alat.instruction: Ini adalah perintah yang memandu perilaku agen. Agen secara eksplisit diperintahkan untuk menggunakan UCP dan AP2, mencantumkan alat yang tersedia, dan menetapkan aturan penting seperti "Jangan mengarang data" dan "Harga dalam sen".tools: Ini adalah daftar fungsi Python (yang akan kita buat berikutnya) yang dapat dipilih agen untuk dipanggil berdasarkan permintaan pengguna.require_confirmation: Anda dapat membungkus alat apa pun denganFunctionTool(my_function,require_confirmation=True). Saat dipicu, agen akan berhenti dan menunggu persetujuan "ya" atau "tidak" sederhana sebelum menjalankan alat. Di sini, sebelum menjalankan alatcomplete_purchase, agen akan berhenti sejenak untuk menunggu konfirmasi dari manusia.
Daftar Alat
Definisi agen menyatakan apa yang perlu kita bangun. Setiap alat dipetakan ke operasi tertentu dalam protokol UCP atau AP2:
Alat | Fungsinya | Tindakan Protokol |
| Menemukan penjual dan kemampuannya | Kueri |
| Menelusuri katalog di seluruh penjual | Endpoint JSON-RPC ke MCP |
| Mendapatkan jadwal tayang di penjual tertentu | Endpoint JSON-RPC ke MCP |
| Mulai sesi checkout | Endpoint JSON-RPC ke MCP |
| Otorisasi pembayaran dan selesaikan pesanan | Menandatangani Mandat AP2 & mengirimkannya ke MCP |
Model Gemini akan memutuskan kapan harus memanggil setiap alat berdasarkan percakapan. Tugas kita selanjutnya adalah menerapkan fungsi setiap alat di tools.py.
5. Membangun alat agen: Penemuan & Penjelajahan
Sekarang, mari kita terapkan alat yang akan digunakan agen untuk menjelajahi dan menemukan film. Setiap alat membungkus operasi UCP.
Buat file baru bernama agent_payments/tools.py dan salin-tempel kode berikut:
"""Agent tools — each one wraps a UCP or AP2 operation."""
import json
from .ucp_client import UCPClient
from .ap2_handler import AP2Handler
# Initialize clients directly
_merchant_urls = ["http://localhost:8081", "http://localhost:8082"]
_ap2 = AP2Handler()
_ucp = UCPClient(platform_keys=[_ap2.public_key])
Memahami Penyiapan
Agar codelab ini tetap berfokus pada pembuatan agen, kita menggunakan dua class helper, UCPClient dan AP2Handler, yang akan kita lihat di langkah selanjutnya.
- Apa itu?: Ini adalah class helper kecil yang kami tulis untuk codelab ini guna berkomunikasi dengan penjual tiruan. SDK resmi menyediakan bagian protokol: UCP SDK memiliki model data untuk setiap skema UCP, dan AP2 SDK membuat serta memverifikasi surat perintah yang ditandatangani. Tidak ada SDK yang menyertakan klien untuk memanggil penjual, jadi helper ini menangani bagian tersebut.
- Untuk saat ini, perlakukan sebagai objek pembantu:
_ucp.discover(url): Mengambil dan memvalidasi profil penjual._ucp.mcp_call(url, method, params): Mengirim permintaan JSON-RPC 2.0 ke endpoint MCP penjual.
Menemukan Bioskop
Alat ini adalah langkah pertama dalam alur UCP. API ini menemukan penjual yang ada dan apa yang mereka dukung.
Tambahkan ke tools.py:
async def discover_theaters() -> str:
"""Discover available theater merchants and their capabilities via UCP."""
theaters = []
for url in _merchant_urls:
info = await _ucp.discover(url)
theaters.append(
{
"url": url,
"name": info["name"],
"capabilities": info["capabilities"],
"payment_handlers": info["payment_handlers"],
}
)
return json.dumps(theaters, indent=2)
Fungsi langkah ini:
- Fungsi ini melakukan iterasi pada daftar URL penjual yang disediakan oleh server. Dalam codelab ini, kita akan menyiapkan dua penjual tiruan di bagian selanjutnya.
- Untuk setiap URL,
_ucp.discover(url)dipanggil, yang akan mengakses endpoint/.well-known/ucp. - Bagian ini mengumpulkan nama, kemampuan, dan pengendali pembayaran ke dalam daftar ringkasan.
- API ini menampilkan daftar sebagai string JSON agar dapat dibaca oleh agen.
Telusuri Film
Alat ini menelusuri semua penjual yang ditemukan dan menggabungkan hasilnya. Hal ini sangat penting karena film yang sama dapat diputar di beberapa bioskop dengan format yang berbeda (IMAX, Dolby) dan harga yang berbeda.
Tambahkan ke tools.py:
async def search_movies(query: str = "") -> str:
"""Search for movies across all theaters. Use '' to browse all."""
all_movies = {}
for url, merchant in _ucp.merchants.items():
result = await _ucp.mcp_call(
url, "search_catalog", {"catalog": {"query": query}}
)
for product in result.get("products", []):
mid = product["id"]
if mid not in all_movies:
all_movies[mid] = {
"id": mid,
"title": product["title"],
"categories": [
c["value"] for c in product.get("categories", [])
],
"theaters": {},
}
showtimes = []
for v in product.get("variants", []):
opts = {o["name"]: o["label"] for o in v.get("options", [])}
showtimes.append(
{
"id": v["id"],
"format": opts.get("format", "Standard"),
"time": opts.get("time", ""),
"price": v.get("price", {}),
"seats": v.get("metadata", {}).get(
"seats_available", 0
),
}
)
all_movies[mid]["theaters"][url] = {
"name": merchant["name"],
"showtimes": showtimes,
}
return json.dumps(list(all_movies.values()), indent=2)
Fungsi langkah ini:
- Fungsi ini melakukan loop melalui semua bioskop yang ditemukan.
- Layanan ini mengirimkan permintaan JSON-RPC katalog penelusuran (
_ucp.mcp_call(url, "search_catalog", {"catalog": {"query": query}})) ke endpoint MCP penjual. - Kemudian, kode tersebut melakukan sedikit pembersihan untuk mengurai hasil guna menemukan film dan "varian"nya (yang merepresentasikan waktu tayang dan format tertentu). Mengelompokkan film menurut ID sehingga pengguna tidak melihat entri film duplikat.
Mendapatkan Detail Film
Alat ini mendapatkan detail katalog lengkap untuk film tertentu di bioskop tertentu.
Tambahkan ke tools.py:
async def get_movie_detail(movie_id: str, merchant_url: str) -> str:
"""Get detailed showtimes for a movie at a specific theater."""
result = await _ucp.mcp_call(
merchant_url, "lookup_catalog", {"catalog": {"ids": [movie_id]}}
)
return json.dumps(result, indent=2)
Fungsi langkah ini:
- Klien ini memanggil metode
lookup_catalogdi endpoint MCP penjual, dengan meneruskanmovie_idtertentu dicatalog.ids. Tindakan ini akan menampilkan informasi mendetail seperti jadwal pertunjukan dan ketersediaan tempat duduk untuk bioskop tertentu tersebut.
6. Membangun alat agen: Checkout & Pembayaran
Alat ini menangani alur checkout dan pembelian. Di sinilah protokol AP2 berperan untuk memastikan transaksi yang aman.
Buat Checkout
Alat ini memulai sesi checkout di bioskop tertentu untuk waktu pertunjukan tertentu.
Tambahkan ke tools.py:
async def create_checkout(
merchant_url: str, showtime_id: str, quantity: int = 1
) -> str:
"""Create a checkout session for tickets at a theater."""
result = await _ucp.mcp_call(merchant_url, "create_checkout", {
"checkout": {
"line_items": [
{"item": {"id": showtime_id}, "quantity": quantity}
],
"context": {"address_country": "US", "currency": "USD"},
}
})
return json.dumps(result, indent=2)
Fungsi langkah ini:
- Metode ini memanggil metode
create_checkoutdi endpoint MCP penjual. - API ini meneruskan
showtime_iddanquantityyang diminta oleh pengguna. - Penjual menampilkan checkout yang ditandatangani dengan kunci penjual.
Catatan: Jika Anda memeriksa data respons, kolom ap2.merchant_authorization berisi tanda tangan kriptografi penjual atas checkout, yang mengunci harga yang dikutip. Mereka tidak dapat mengubahnya nanti.
Selesaikan Pembelian
Tiga hal yang terjadi di alat ini:
- Kami mendapatkan checkout dan memverifikasi tanda tangan penjual di dalamnya.
- Buat dan tandatangani CheckoutMandate dan PaymentMandate dengan AP2 SDK.
- Kirim kedua surat kuasa kepada penjual untuk menyelesaikan pembelian.
Tambahkan ke tools.py:
async def complete_purchase(checkout_id: str, merchant_url: str) -> str:
"""Complete purchase with AP2 payment authorization."""
merchant = _ucp.merchants[merchant_url]
# 1. Get the checkout and verify the merchant's signature on it
checkout = await _ucp.mcp_call(
merchant_url, "get_checkout", {"id": checkout_id}
)
checkout_jwt = _ap2.verify_merchant_authorization(checkout, merchant["keys"])
if not checkout_jwt:
return json.dumps({"error": "Merchant signature is missing or invalid"})
# 2. Create and sign the CheckoutMandate and PaymentMandate
# In production, this step asks the user to approve on a trusted device
# (biometric or device auth). In this demo, the agent signs with a local key.
checkout_mandate, payment_mandate = _ap2.create_mandates(
checkout, checkout_jwt, merchant["name"]
)
# 3. Send both mandates to the merchant to complete the purchase
result = await _ucp.mcp_call(merchant_url, "complete_checkout", {
"id": checkout_id,
"checkout": {
"payment": {
"instruments": [{
"id": "instr_1",
"handler_id": merchant["payment_handlers"][0],
"type": "card",
"selected": True,
"credential": {
"type": "ap2_payment_mandate",
"token": payment_mandate,
},
}],
},
"ap2": {"checkout_mandate": checkout_mandate},
},
})
return json.dumps(result, indent=2)
Mengapa ada dua mandat? CheckoutMandate membuktikan kepada penjual bahwa pengguna menyetujui checkout ini persis seperti yang ditandatangani penjual, dengan harga yang ditandatangani penjual. PaymentMandate membuktikan kepada pihak pembayaran bahwa pengguna mengizinkan penagihan ini. Alurnya adalah:
Merchant signs checkout -> User signs mandates -> Merchant and payment side verify -> Order completes.
Checkpoint: Penuh tools.py
tools.py lengkap Anda sekarang akan memiliki 5 fungsi alat dan inisialisasi tingkat modul untuk klien UCP dan AP2. Pastikan tampilannya seperti ini:
"""Agent tools — each one wraps a UCP or AP2 operation."""
import json
from .ucp_client import UCPClient
from .ap2_handler import AP2Handler
# Initialize clients directly
_merchant_urls = ["http://localhost:8081", "http://localhost:8082"]
_ap2 = AP2Handler()
_ucp = UCPClient(platform_keys=[_ap2.public_key])
async def discover_theaters() -> str:
"""Discover available theater merchants and their capabilities via UCP."""
theaters = []
for url in _merchant_urls:
info = await _ucp.discover(url)
theaters.append(
{
"url": url,
"name": info["name"],
"capabilities": info["capabilities"],
"payment_handlers": info["payment_handlers"],
}
)
return json.dumps(theaters, indent=2)
async def search_movies(query: str = "") -> str:
"""Search for movies across all theaters. Use '' to browse all."""
all_movies = {}
for url, merchant in _ucp.merchants.items():
result = await _ucp.mcp_call(
url, "search_catalog", {"catalog": {"query": query}}
)
for product in result.get("products", []):
mid = product["id"]
if mid not in all_movies:
all_movies[mid] = {
"id": mid,
"title": product["title"],
"categories": [
c["value"] for c in product.get("categories", [])
],
"theaters": {},
}
showtimes = []
for v in product.get("variants", []):
opts = {o["name"]: o["label"] for o in v.get("options", [])}
showtimes.append(
{
"id": v["id"],
"format": opts.get("format", "Standard"),
"time": opts.get("time", ""),
"price": v.get("price", {}),
"seats": v.get("metadata", {}).get(
"seats_available", 0
),
}
)
all_movies[mid]["theaters"][url] = {
"name": merchant["name"],
"showtimes": showtimes,
}
return json.dumps(list(all_movies.values()), indent=2)
async def get_movie_detail(movie_id: str, merchant_url: str) -> str:
"""Get detailed showtimes for a movie at a specific theater."""
result = await _ucp.mcp_call(
merchant_url, "lookup_catalog", {"catalog": {"ids": [movie_id]}}
)
return json.dumps(result, indent=2)
async def create_checkout(
merchant_url: str, showtime_id: str, quantity: int = 1
) -> str:
"""Create a checkout session for tickets at a theater."""
result = await _ucp.mcp_call(merchant_url, "create_checkout", {
"checkout": {
"line_items": [
{"item": {"id": showtime_id}, "quantity": quantity}
],
"context": {"address_country": "US", "currency": "USD"},
}
})
return json.dumps(result, indent=2)
async def complete_purchase(checkout_id: str, merchant_url: str) -> str:
"""Complete purchase with AP2 payment authorization."""
merchant = _ucp.merchants[merchant_url]
# 1. Get the checkout and verify the merchant's signature on it
checkout = await _ucp.mcp_call(
merchant_url, "get_checkout", {"id": checkout_id}
)
checkout_jwt = _ap2.verify_merchant_authorization(checkout, merchant["keys"])
if not checkout_jwt:
return json.dumps({"error": "Merchant signature is missing or invalid"})
# 2. Create and sign the CheckoutMandate and PaymentMandate
# In production, this step asks the user to approve on a trusted device
# (biometric or device auth). In this demo, the agent signs with a local key.
checkout_mandate, payment_mandate = _ap2.create_mandates(
checkout, checkout_jwt, merchant["name"]
)
# 3. Send both mandates to the merchant to complete the purchase
result = await _ucp.mcp_call(merchant_url, "complete_checkout", {
"id": checkout_id,
"checkout": {
"payment": {
"instruments": [{
"id": "instr_1",
"handler_id": merchant["payment_handlers"][0],
"type": "card",
"selected": True,
"credential": {
"type": "ap2_payment_mandate",
"token": payment_mandate,
},
}],
},
"ap2": {"checkout_mandate": checkout_mandate},
},
})
return json.dumps(result, indent=2)
7. Buat agar dapat dijalankan
Dengan penjual UCP sungguhan, Anda akan mengarahkan agen ke URL mereka dan selesai. Untuk codelab ini, kita memerlukan dua hal untuk menguji secara lokal:
- Penjual tiruan: server lokal yang menyimulasikan endpoint UCP sehingga Anda memiliki sesuatu untuk diuji
- Helper protokol: wrapper tipis yang memanggil penjual melalui HTTP dan menggunakan SDK UCP dan AP2 untuk data dan tanda tangan protokol
Catatan: Anda tidak perlu membaca kode ini dengan cermat. File ini menyimulasikan penjual sungguhan dan dompet pengguna. Salin apa adanya.
Helper protokol
UCP SDK menyediakan model data, dan AP2 SDK menandatangani serta memverifikasi perintah, tetapi keduanya tidak menyertakan klien untuk berkomunikasi dengan penjual. Kedua file ini mengisi kesenjangan tersebut. Nama keduanya adalah ucp_client.py dan ap2_handler.py agar tidak menutupi paket ap2.
Buat agent_payments/ucp_client.py:
"""UCP client: discovers merchants and calls their MCP tools."""
import uuid
import httpx
from ucp_sdk.models.schemas.profile import BusinessSchema
# The platform (this agent) identifies itself with a UCP profile URL
PLATFORM_PROFILE = "https://cineagent.example/.well-known/ucp"
class UCPClient:
def __init__(self, platform_keys: list[dict]):
self.client = httpx.AsyncClient(timeout=30)
self.platform_keys = platform_keys
self.merchants = {} # url -> merchant info dict
async def discover(self, merchant_url: str) -> dict:
"""Fetch and validate a merchant's UCP profile from /.well-known/ucp."""
resp = await self.client.get(f"{merchant_url}/.well-known/ucp")
resp.raise_for_status()
profile = BusinessSchema.model_validate(resp.json())
ucp = profile.ucp
info = {
"name": merchant_url.split("//")[-1],
"mcp_endpoint": str(ucp.services["dev.ucp.shopping"][0].endpoint),
"capabilities": list(ucp.capabilities or {}),
"payment_handlers": [
h.id for handlers in ucp.payment_handlers.values() for h in handlers
],
"keys": [k.model_dump(exclude_none=True) for k in profile.keys or []],
}
self.merchants[merchant_url] = info
return info
async def mcp_call(
self, merchant_url: str, tool_name: str, arguments: dict
) -> dict:
"""Call a merchant's MCP tool via JSON-RPC 2.0."""
merchant = self.merchants[merchant_url]
meta = {
"ucp-agent": {
"profile": PLATFORM_PROFILE,
# Mock shortcut: a real merchant reads the platform's public
# keys from the profile URL above instead
"keys": self.platform_keys,
},
"idempotency-key": str(uuid.uuid4()),
}
resp = await self.client.post(
merchant["mcp_endpoint"],
json={
"jsonrpc": "2.0",
"id": uuid.uuid4().hex,
"method": "tools/call",
"params": {
"name": tool_name,
"arguments": {"meta": meta, **arguments},
},
},
)
resp.raise_for_status()
data = resp.json()
if "error" in data:
raise Exception(f"MCP error: {data['error']}")
return data["result"]["structuredContent"]
async def close(self):
await self.client.aclose()
Buat agent_payments/ap2_handler.py:
"""AP2 mandate handler: verifies the merchant's signature and signs mandates."""
import json
import time
from jwcrypto.jwk import JWK
from jwcrypto.jws import JWS
from ap2.sdk.mandate import MandateClient
from ap2.sdk.utils import b64url_decode, b64url_encode, compute_sha256_b64url
from ap2.sdk.generated.checkout_mandate import CheckoutMandate
from ap2.sdk.generated.payment_mandate import PaymentMandate
from ap2.sdk.generated.types.amount import Amount
from ap2.sdk.generated.types.merchant import Merchant
from ap2.sdk.generated.types.payment_instrument import PaymentInstrument
class AP2Handler:
def __init__(self):
# The user's signing key. In production, this key stays in a wallet or
# on a trusted device, and the user approves each signature.
self.key = JWK.generate(kty="EC", crv="P-256", kid="cineagent-user-key")
self.public_key = json.loads(self.key.export_public())
self.mandates = MandateClient()
def verify_merchant_authorization(
self, checkout: dict, merchant_keys: list[dict]
) -> str | None:
"""Check the merchant's signature on a checkout.
The signature is the merchant's price guarantee: if anything in the
checkout changes, the signature no longer matches. Returns the signed
checkout as a JWT, or None if the signature is missing or invalid.
"""
signature = checkout.get("ap2", {}).get("merchant_authorization")
if not signature:
return None
header, _, sig = signature.split(".") # detached JWS: header..signature
payload = {k: v for k, v in checkout.items() if k != "ap2"}
canonical = json.dumps(
payload, sort_keys=True, separators=(",", ":"), ensure_ascii=False
)
checkout_jwt = f"{header}.{b64url_encode(canonical.encode())}.{sig}"
kid = json.loads(b64url_decode(header))["kid"]
key = next((k for k in merchant_keys if k["kid"] == kid), None)
if not key:
return None
try:
jws = JWS()
jws.deserialize(checkout_jwt)
jws.verify(JWK(**key))
except Exception:
return None
return checkout_jwt
def create_mandates(
self, checkout: dict, checkout_jwt: str, merchant_name: str
) -> tuple[str, str]:
"""Create and sign a CheckoutMandate and a PaymentMandate.
Both mandates reference the hash of the merchant-signed checkout, so
the user's approval is bound to exactly this cart and price.
"""
checkout_hash = compute_sha256_b64url(checkout_jwt)
total = next(t["amount"] for t in checkout["totals"] if t["type"] == "total")
now = int(time.time())
checkout_mandate = CheckoutMandate(
checkout_jwt=checkout_jwt,
checkout_hash=checkout_hash,
iat=now,
exp=now + 600,
)
payment_mandate = PaymentMandate(
transaction_id=checkout_hash,
payee=Merchant(id=merchant_name, name=merchant_name),
payment_amount=Amount(amount=total, currency=checkout["currency"]),
payment_instrument=PaymentInstrument(
id="instr_1", type="card", description="Demo card"
),
iat=now,
exp=now + 600,
)
# Sign each mandate as an SD-JWT with the user's key
return (
self.mandates.create(payloads=[checkout_mandate], issuer_key=self.key),
self.mandates.create(payloads=[payment_mandate], issuer_key=self.key),
)
Penjual tiruan
Buat agent_payments/merchants.py:
"""Mock UCP merchant servers: two theaters with different capabilities."""
import json
import time
import uuid
import multiprocessing
from datetime import datetime, timezone, timedelta
import uvicorn
from fastapi import FastAPI
from jwcrypto.jwk import JWK
from jwcrypto.jws import JWS
from ap2.sdk.mandate import MandateClient
from ap2.sdk.utils import compute_sha256_b64url
from ap2.sdk.generated.checkout_mandate import CheckoutMandate
from ap2.sdk.generated.payment_mandate import PaymentMandate
from ucp_sdk.models.schemas.common.payment_ap2_mandate import Checkout
from ucp_sdk.models.schemas.profile import BusinessSchema
from ucp_sdk.models.schemas.shopping.catalog_lookup import LookupResponse
from ucp_sdk.models.schemas.shopping.catalog_search import SearchResponse
UCP_VERSION = "2026-08-25"
UCP_SPEC = f"https://ucp.dev/{UCP_VERSION}"
# ── Theater data ────────────────────────────────────────────
THEATERS = {
8081: {
"name": "Meridian Cinemas",
"movies": [
{
"id": "opp",
"title": "Oppenheimer",
"categories": ["Drama", "History"],
"showtimes": [
{"id": "st_opp_7pm_imax", "format": "IMAX", "time": "7:00 PM", "price": 2200, "seats": 45},
{"id": "st_opp_930pm", "format": "Standard", "time": "9:30 PM", "price": 1500, "seats": 80},
],
},
{
"id": "dune3",
"title": "Dune: Part Three",
"categories": ["Sci-Fi", "Action"],
"showtimes": [
{"id": "st_dune_8pm_imax", "format": "IMAX", "time": "8:00 PM", "price": 2200, "seats": 30},
],
},
],
},
8082: {
"name": "StarLight Theaters",
"movies": [
{
"id": "opp",
"title": "Oppenheimer",
"categories": ["Drama", "History"],
"showtimes": [
{"id": "st_opp_6pm_atmos", "format": "Dolby Atmos", "time": "6:00 PM", "price": 1800, "seats": 60},
],
},
{
"id": "spider",
"title": "Spider-Verse",
"categories": ["Animation", "Action"],
"showtimes": [
{"id": "st_spider_4pm", "format": "Standard", "time": "4:00 PM", "price": 1200, "seats": 100},
],
},
],
},
}
def create_app(port):
theater = THEATERS[port]
app = FastAPI()
sessions = {}
checkout_jwts = {} # checkout id -> merchant-signed checkout JWT
# The merchant's signing key. Its public half is published in the profile.
key = JWK.generate(kty="EC", crv="P-256", kid=f"merchant-{port}")
def _capability(name, path, schema, **extra):
return {name: [{
"version": UCP_VERSION,
"spec": f"{UCP_SPEC}/specification/{path}",
"schema": f"{UCP_SPEC}/schemas/{schema}",
**extra,
}]}
payment_handlers = {
"com.example.card": [
{"id": f"card_{port}", "version": UCP_VERSION,
"available_instruments": [{"type": "card"}], "config": {}}
]
}
# ── UCP Discovery endpoint ──────────────────────────────
@app.get("/.well-known/ucp")
def discovery():
profile = {
"ucp": {
"version": UCP_VERSION,
"services": {
"dev.ucp.shopping": [
{"version": UCP_VERSION,
"spec": f"{UCP_SPEC}/specification/overview",
"transport": "mcp",
"schema": f"{UCP_SPEC}/services/shopping/mcp.openrpc.json",
"endpoint": f"http://localhost:{port}/mcp"}
]
},
"capabilities": {
**_capability("dev.ucp.shopping.catalog.search",
"shopping/catalog/search", "shopping/catalog_search.json"),
**_capability("dev.ucp.shopping.catalog.lookup",
"shopping/catalog/lookup", "shopping/catalog_lookup.json"),
**_capability("dev.ucp.shopping.checkout",
"shopping/checkout", "shopping/checkout.json"),
**_capability("dev.ucp.common.payment.ap2_mandate",
"payment/extensions/ap2-mandates",
"common/payment_ap2_mandate.json",
extends="dev.ucp.shopping.checkout",
config={"vp_formats_supported": {"dc+sd-jwt": {}}}),
},
"payment_handlers": payment_handlers,
},
"keys": [json.loads(key.export_public())],
}
# Check the profile against the UCP SDK models before returning it
BusinessSchema.model_validate(profile)
return profile
# ── MCP JSON-RPC endpoint ───────────────────────────────
@app.post("/mcp")
def mcp(body: dict):
tool = body["params"]["name"]
args = body["params"].get("arguments", {})
rid = body.get("id", "1")
if tool == "search_catalog":
q = args.get("catalog", {}).get("query", "").lower()
hits = [m for m in theater["movies"]
if not q or q in m["title"].lower()
or any(q in c.lower() for c in m["categories"])]
result = {"ucp": _ucp_meta("dev.ucp.shopping.catalog.search"),
"products": [_product(m) for m in hits]}
return _ok(rid, SearchResponse, result)
if tool == "lookup_catalog":
ids = args.get("catalog", {}).get("ids", [])
movies = [m for m in theater["movies"] if m["id"] in ids]
if not movies:
return _err(rid, "Not found")
result = {"ucp": _ucp_meta("dev.ucp.shopping.catalog.lookup"),
"products": [_product(m, lookup=True) for m in movies]}
return _ok(rid, LookupResponse, result)
if tool == "create_checkout":
co = args.get("checkout", {})
sid = f"chk_{uuid.uuid4().hex[:12]}"
items, subtotal = [], 0
for li in co.get("line_items", []):
st = _find_showtime(li["item"]["id"])
if not st:
continue
mv = _find_movie(li["item"]["id"])
qty = li.get("quantity", 1)
amt = st["price"] * qty
subtotal += amt
items.append({
"id": f"li_{uuid.uuid4().hex[:8]}",
"item": {
"id": st["id"],
"title": f"{mv['title']} ({st['format']}, {st['time']})",
"price": st["price"],
},
"quantity": qty,
"totals": [{"type": "subtotal", "amount": amt},
{"type": "total", "amount": amt}],
})
if not items:
return _err(rid, "No valid showtimes in checkout")
tax = int(subtotal * 0.08)
total = subtotal + tax
session = {
"ucp": {
**_ucp_meta("dev.ucp.shopping.checkout",
"dev.ucp.common.payment.ap2_mandate"),
"payment_handlers": payment_handlers,
},
"id": sid,
"status": "ready_for_complete",
"currency": "USD",
"line_items": items,
"totals": [
{"type": "subtotal", "display_text": "Subtotal", "amount": subtotal},
{"type": "tax", "display_text": "Tax", "amount": tax},
{"type": "total", "display_text": "Total", "amount": total},
],
"links": [{"type": "terms_of_service",
"url": f"http://localhost:{port}/terms"}],
"expires_at": (
datetime.now(timezone.utc) + timedelta(minutes=10)
).isoformat(),
}
_sign(session)
sessions[sid] = session
return _ok(rid, Checkout, session)
if tool == "get_checkout":
session = sessions.get(args.get("id"))
if not session:
return _err(rid, "Not found")
return _ok(rid, Checkout, session)
if tool == "complete_checkout":
sid = args.get("id")
session = sessions.get(sid)
if not session:
return _err(rid, "Not found")
co = args.get("checkout", {})
checkout_mandate = co.get("ap2", {}).get("checkout_mandate")
instruments = co.get("payment", {}).get("instruments", [])
if not checkout_mandate or not instruments:
return _err(rid, "mandate_required")
payment_mandate = instruments[0]["credential"]["token"]
# Mock shortcut: a real merchant fetches the platform's keys
# from its profile URL (meta["ucp-agent"]["profile"])
platform_key = JWK(**args["meta"]["ucp-agent"]["keys"][0])
try:
cm = MandateClient().verify(
checkout_mandate, platform_key, payload_type=CheckoutMandate
).mandate_payload
pm = MandateClient().verify(
payment_mandate, platform_key, payload_type=PaymentMandate
).mandate_payload
except Exception as e:
return _err(rid, f"mandate_invalid_signature: {e}")
# The mandates must point at the exact checkout this merchant signed
expected_hash = compute_sha256_b64url(checkout_jwts[sid])
total = next(t["amount"] for t in session["totals"] if t["type"] == "total")
if (cm.checkout_jwt != checkout_jwts[sid]
or cm.checkout_hash != expected_hash
or pm.transaction_id != expected_hash
or pm.payment_amount.amount != total):
return _err(rid, "mandate_scope_mismatch")
order_id = f"ord_{uuid.uuid4().hex[:8]}"
session["status"] = "completed"
session["order"] = {
"id": order_id,
"label": theater["name"],
"permalink_url": f"http://localhost:{port}/orders/{order_id}",
"tickets": [
{
"movie": li["item"]["title"],
"quantity": li["quantity"],
"ticket_code": uuid.uuid4().hex[:8].upper(),
}
for li in session["line_items"]
],
}
_sign(session)
return _ok(rid, Checkout, session)
return _err(rid, f"Unknown tool: {tool}")
def _sign(session):
"""Add the merchant's signature (a detached JWS) to the checkout."""
payload = {k: v for k, v in session.items() if k != "ap2"}
canonical = json.dumps(
payload, sort_keys=True, separators=(",", ":"), ensure_ascii=False
)
jws = JWS(canonical.encode())
jws.add_signature(key, alg="ES256",
protected=json.dumps({"alg": "ES256", "kid": key.kid}))
checkout_jwt = jws.serialize(compact=True)
header, _, sig = checkout_jwt.split(".")
session["ap2"] = {"merchant_authorization": f"{header}..{sig}"}
checkout_jwts[session["id"]] = checkout_jwt
def _ucp_meta(*capabilities):
return {"version": UCP_VERSION,
"capabilities": {c: [{"version": UCP_VERSION}] for c in capabilities}}
def _ok(rid, model, result):
# Check the response against the UCP SDK models before returning it
model.model_validate(result)
return {"jsonrpc": "2.0", "id": rid, "result": {
"structuredContent": result,
"content": [{"type": "text", "text": json.dumps(result)}],
}}
def _err(rid, msg):
return {"jsonrpc": "2.0", "id": rid, "error": {"code": -32000, "message": msg}}
def _product(movie, lookup=False):
prices = [st["price"] for st in movie["showtimes"]]
return {
"id": movie["id"],
"title": movie["title"],
"description": {"plain": f"{movie['title']} at {theater['name']}"},
"categories": [{"value": c, "taxonomy": "merchant"} for c in movie["categories"]],
"price_range": {
"min": {"amount": min(prices), "currency": "USD"},
"max": {"amount": max(prices), "currency": "USD"},
},
"variants": [
{
"id": st["id"],
"title": f"{st['format']} {st['time']}",
"description": {"plain": f"{st['format']} showing at {st['time']}"},
"options": [
{"name": "format", "label": st["format"]},
{"name": "time", "label": st["time"]},
],
"price": {"amount": st["price"], "currency": "USD"},
"availability": {"available": st["seats"] > 0},
"metadata": {"seats_available": st["seats"]},
**({"inputs": [{"id": movie["id"], "match": "featured"}]} if lookup else {}),
}
for st in movie["showtimes"]
],
}
def _find_showtime(sid):
return next(
(st for m in theater["movies"] for st in m["showtimes"] if st["id"] == sid),
None,
)
def _find_movie(sid):
return next(
(m for m in theater["movies"] for st in m["showtimes"] if st["id"] == sid),
None,
)
return app
def _run(port):
uvicorn.run(create_app(port), host="0.0.0.0", port=port, log_level="warning")
if __name__ == "__main__":
for port in THEATERS:
multiprocessing.Process(target=_run, args=(port,), daemon=True).start()
print("Merchants running: Meridian (:8081), StarLight (:8082)")
print("Press Ctrl+C to stop")
try:
while True:
time.sleep(1)
except KeyboardInterrupt:
pass
Tindakan ini akan membuat dua server FastAPI, masing-masing dengan dua endpoint:
GET /.well-known/ucp: Penemuan UCP. Menampilkan kemampuan penjual, URL endpoint MCP, metode pembayaran yang diterima, dan kunci penandatanganan publik.POST /mcp: Operasi MCP (Model Context Protocol). Menangani panggilan JSON-RPC 2.0 untuk penelusuran katalog, checkout, dan pembayaran.
Setiap penjual menandatangani checkout-nya dengan kuncinya sendiri, memverifikasi mandat AP2 sebelum menyelesaikan pesanan, dan memeriksa setiap respons terhadap model SDK UCP.
Mulai penjual di terminal baru (penjual harus tetap berjalan):
cd ~/adk-agent-commerce
uv run python agent_payments/merchants.py
Anda akan melihat:
Merchants running: Meridian (:8081), StarLight (:8082)
Kembali di terminal pertama, verifikasi penemuan UCP:
curl -s http://localhost:8081/.well-known/ucp | uv run python -m json.tool
Anda akan melihat kemampuan penjual, URL endpoint MCP, handler pembayaran, dan kunci publik.
8. Menjalankan Agen dengan Web ADK
Mari kita gunakan UI Web bawaan ADK CLI. Hal ini menyediakan antarmuka chat di browser dan secara otomatis menangani perintah konfirmasi alat.
Project Anda sekarang akan terlihat seperti ini:
adk-agent-commerce/
├── pyproject.toml
└── agent_payments/
├── .env # Project settings
├── merchants.py # Mock UCP merchants
├── ucp_client.py # UCP client helper
├── ap2_handler.py # AP2 mandate handler
├── tools.py # Agent tools
└── agent.py # Agent definition
Coba
Di terminal pertama, buka folder adk-agent-commerce (satu folder di atas agent_payments) dan mulai UI Web ADK:
cd ~/adk-agent-commerce
uv run adk web --port 8080 --allow_origins '*'
Anda akan melihat output yang menunjukkan bahwa server berjalan di http://127.0.0.1:8080.
Berbicara dengan agen
- Buka UI Web ADK dengan mengklik URL sambil menekan Ctrl atau Cmd, atau dengan mengklik tombol Web Preview dan memilih Preview on port 8080.
- Pilih
agent_paymentsdari menu drop-down jika belum dipilih. Anda akan melihat antarmuka chat. - Coba tanyakan: "Film apa yang sedang diputar?"
- Agen akan menemukan bioskop dan menelusuri katalog di balik layar, menggabungkan hasil dari kedua penjual melalui UCP.
- Minta untuk memesan tiket: "Pesan 2 tiket untuk Oppenheimer pukul 19.00".
- Saat agen mencoba memanggil
complete_purchase, perhatikan bagaimana UI Web ADK menampilkan kartu konfirmasi dengan detail pembelian. - Untuk mengizinkan transaksi, pilih kotak centang Dikonfirmasi di kartu, lalu klik Kirim.
- Agen akan menyelesaikan pembelian dan mengembalikan konfirmasi pesanan Anda dengan kode tiket.
Berikut yang terjadi di balik layar:
create_checkout→ penjual menampilkan checkout yang ditandatangani dengan kuncinya (ap2.merchant_authorization, penguncian harga)complete_purchase→ memverifikasi tanda tangan penjual, membuat CheckoutMandate dan PaymentMandate, menandatangani keduanya sebagai SD-JWT, dan mengirimkannya kepada penjual- Penjual memverifikasi kedua mandat dan memeriksa apakah mandat tersebut mengarah ke checkout yang ditandatanganinya → mengeluarkan tiket (dalam tiruan)
9. Pembersihan
Untuk menghindari server lokal tetap berjalan, bersihkan resource:
- Di terminal yang menjalankan
adk web, tekan Ctrl+C untuk menghentikan server agen. - Di terminal yang menjalankan
merchants.py, tekan Ctrl+C untuk menghentikan penjual tiruan. - (Opsional) Jika Anda membuat project Google Cloud baru untuk codelab ini dan ingin menghapusnya, jalankan perintah berikut, dengan mengganti
dengan project ID-nya:
gcloud projects delete <YOUR_PROJECT_ID>
10. Selamat! 🎉
Anda telah membuat agen ADK yang menemukan penjual, menjelajahi katalog, dan menyelesaikan pembelian menggunakan UCP dan AP2.
Yang telah Anda pelajari
Dalam codelab ini, Anda telah membuat agen ADK yang menangani alur perdagangan yang aman. Berikut ringkasan tentang apa yang Anda bangun dan konsep utama yang Anda terapkan:
Yang Anda bangun:
- 5 alat agen yang membungkus operasi UCP dan AP2: penemuan, penelusuran katalog, checkout, pembayaran.
- Penandatanganan mandat AP2: checkout yang ditandatangani penjual (penguncian harga) + CheckoutMandate dan PaymentMandate (otorisasi pengguna).
- Penelusuran multi-penjual: satu agen membuat kueri beberapa bioskop, menggabungkan hasil.
Konsep Utama:
Protokol | Fungsinya | Cara kerjanya |
Penemuan UCP | Agen menemukan penjual dan kemampuannya |
|
UCP MCP | Agen menjelajahi katalog, membuat checkout | Panggilan JSON-RPC 2.0 ke endpoint MCP penjual |
Otorisasi penjual | Penjual mengunci harga yang dikutip | Ditandatangani oleh penjual, mencakup item baris + total |
AP2 CheckoutMandate | Pengguna menyetujui checkout persis | Ditandatangani oleh pengguna, berisi checkout yang ditandatangani penjual |
AP2 PaymentMandate | Pengguna mengizinkan penagihan | Ditandatangani oleh pengguna, merujuk ke hash checkout |
Apa yang berbeda dalam produksi?
Codelab ini menggunakan tiruan. Dalam produksi:
- Penemuan UCP diselesaikan terhadap registry, bukan URL localhost yang di-hardcode
- Endpoint MCP dihosting oleh penjual sungguhan: protokol JSON-RPC 2.0 yang sama, inventaris sungguhan
- Mandat AP2 ditandatangani di perangkat tepercaya pengguna atau oleh platform tepercaya, bukan dengan kunci yang dibuat agen saat startup
- Kunci penandatanganan berasal dari profil UCP setiap pihak (penjual tiruan menerima kunci publik agen di setiap permintaan)
- Otorisasi pembayaran dilakukan melalui penyedia kredensial yang memverifikasi PaymentMandate dan meminta izin pengguna
- Frontend merender hasil alat sebagai UI yang kaya (petak produk, ringkasan checkout, kartu konfirmasi)
Langkah berikutnya
- Pelajari spesifikasi protokol AP2 dan buat agen yang mendukung pembayaran Anda sendiri
- Terapkan UCP untuk penjual Anda guna mengaktifkan agentic commerce
- Menghubungkan AP2 dengan A2A untuk alur kerja perdagangan multi-agen
- Pelajari ekstensi AP2 x402 untuk pembayaran mata uang kripto