1. Przegląd
W tym ćwiczeniu uruchomisz agenta ADK, który rezerwuje bilety do kina u różnych sprzedawców, korzystając z 2 protokołów handlowych typu open source:
- UCP (Universal Commerce Protocol): standard umożliwiający agentom odkrywanie sprzedawców, przeszukiwanie katalogów i zarządzanie procesami płatności.
- AP2 (Agent Payments Protocol): protokół bezpiecznej, weryfikowalnej autoryzacji płatności za pomocą podpisanych kryptograficznie upoważnień.
Aplikacja w wersji demonstracyjnej CineAgent łączy się z 2 przykładowymi sprzedawcami biletów do kina o różnych możliwościach (wybór miejsc, specjalne formaty i formy płatności) i koordynuje cały proces rezerwacji od wyszukiwania po płatność.
Czego się nauczysz
- Jak działa odkrywanie sprzedawców w UCP za pomocą
/.well-known/ucpprofili - Jak agent ADK używa UCP do wyszukiwania katalogów i tworzenia płatności
- Jak mandaty AP2 (CheckoutMandate, PaymentMandate) zabezpieczają transakcje
- Jak protokoły UCP i AP2 działają w celu zabezpieczenia handlu elektronicznego opartego na agentach
Czego potrzebujesz
- Projekt Google Cloud z włączonymi płatnościami
- przeglądarka, np. Chrome;
- Python 3.11 lub nowszy i uv, jeśli kod jest uruchamiany na własnym komputerze zamiast w Cloud Shell
To ćwiczenie jest przeznaczone dla średnio zaawansowanych programistów, którzy znają już Pythona i Google Cloud. Wykonanie tego laboratorium zajmie około 30 minut.
Zasoby utworzone w tym module powinny kosztować mniej niż 5 USD.
2. Omówienie protokołów UCP i AP2
Zanim przejdziemy do tworzenia agenta, poznajmy 2 protokoły, które umożliwiają bezpieczny handel agentowy.
W tym ćwiczeniu używamy platformy UCP w wersji 2026-08-25 z pakietem UCP Python SDK oraz AP2 w wersji 0.2 z pakietem AP2 Python SDK.
Protokół Universal Commerce Protocol (UCP)
UCP ujednolica sposób, w jaki agenci AI wchodzą w interakcje ze sprzedawcami. Rozwiązuje problem związany z koniecznością uczenia się przez agentów niestandardowych interfejsów API dla każdego sklepu, wprowadzając standardowy model zasobów.
Jak to działa:
- Wykrywanie: każdy sprzedawca zgodny z protokołem UCP udostępnia profil w standardowej lokalizacji:
/.well-known/ucp. Przykład: punkt końcowy UCP firmy Everlane.Gdy agent odczytuje ten profil, szuka:- Funkcje: samodzielne funkcje podstawowe, które obsługuje firma, np. wyszukiwanie w katalogu lub płatność.
- Usługi: niższe warstwy komunikacji używane do wymiany danych. Przykłady: REST API, MCP (Model Context Protocol), A2A (Agent2Agent Protocol).
- Rozszerzenia: jeśli sprzedawca potrzebuje specjalistycznych funkcji, może zdefiniować w tym profilu niestandardowe rozszerzenia.
- Klucze: publiczne klucze podpisywania sprzedawcy, których agenci używają do sprawdzania podpisów sprzedawcy.
- Operacje: po wykryciu agent używa podanego punktu końcowego usługi do wykonywania operacji. W tym ćwiczeniu używamy protokołu Model Context Protocol (MCP) jako transportu usługi. Agent wykonuje wywołania JSON-RPC 2.0 do tego punktu końcowego, aby wywołać wykryte funkcje: wyszukiwanie produktów, tworzenie płatności i dokonywanie zakupów.

Agent Payments Protocol (AP2)
AP2 ujednolica sposób autoryzowania płatności przez agentów w imieniu użytkowników. Rozwiązuje problem z bezpieczeństwem związany z obsługą przez agentów poufnych danych logowania do płatności.
Jak to działa:
- Podpis sprzedawcy: gdy agent tworzy proces płatności za pomocą protokołu UCP, sprzedawca podpisuje proces płatności (elementy zamówienia i sumy) i zwraca podpis w
ap2.merchant_authorization. Działa to jako gwarancja ceny. Jeśli sprzedawca zmieni cenę po podpisaniu, podpis przestanie pasować. - Upoważnienie do zapłaty i upoważnienie do płatności: po sprawdzeniu zawartości koszyka użytkownik (lub agent w jego imieniu) podpisuje 2 upoważnienia.
CheckoutMandatezawiera podpisany przez sprzedawcę proces płatności i informuje sprzedawcę, że użytkownik go zatwierdził.PaymentMandateautoryzuje kwotę płatności za to zamówienie. Oba odwołują się do haszu podpisanego procesu płatności i zawierają podpis kryptograficzny użytkownika. - Weryfikacja podpisu: sprzedawca otrzymuje oba mandaty. Weryfikuje podpis użytkownika na
CheckoutMandatei sprawdza, czy płatność w nim zawiera podpis sprzedawcy.PaymentMandatejest przekazywany do strony płatności (dostawcy danych logowania lub firmy obsługującej płatności), która weryfikuje go przed przekazaniem środków. Jeśli wszystko jest prawidłowe, transakcja zostanie zrealizowana.
Ten system „podwójnej blokady” zapewnia, że sprzedawcy nie mogą pobierać zbyt wysokich opłat, a agenci nie mogą wydawać środków bez autoryzacji. Mandaty to SD-JWT (Selective Disclosure JWT), czyli poświadczenia, które chronią prywatność użytkowników, ujawniając tylko te pola, których potrzebuje każda ze stron. W AP2 w wersji 0.2 znak CheckoutMandate zastępuje znak CartMandate z AP2 w wersji 0.1.

3. Konfigurowanie środowiska
Konfigurowanie projektu Google Cloud
Tworzenie projektu Google Cloud
- W konsoli Google Cloud na stronie wyboru projektu wybierz lub utwórz projekt w chmurze Google Cloud.
- Sprawdź, czy w projekcie Cloud włączone są płatności. Dowiedz się, jak sprawdzić, czy w projekcie są włączone płatności.
Uruchamianie Cloud Shell
Cloud Shell to środowisko wiersza poleceń działające w Google Cloud, które zawiera niezbędne narzędzia.
- Kliknij Aktywuj Cloud Shell u góry konsoli Google Cloud.
- Po połączeniu z Cloud Shell sprawdź uwierzytelnianie:
gcloud auth list - Sprawdź, czy projekt jest skonfigurowany:
gcloud config get project - Jeśli projekt nie jest ustawiony zgodnie z oczekiwaniami, ustaw go:
export PROJECT_ID=<YOUR_PROJECT_ID> gcloud config set project $PROJECT_ID
Włącz interfejsy API
Aby włączyć wymagane interfejsy API, uruchom to polecenie:
gcloud services enable aiplatform.googleapis.com
Konfigurowanie struktury katalogu
Skopiuj i wklej te polecenia, aby utworzyć folder na potrzeby tego laboratorium, a w nim folder agent_payments na kod agenta:
mkdir -p ~/adk-agent-commerce/agent_payments
cd ~/adk-agent-commerce
Dostęp do modeli Gemini
Skopiuj i wklej to polecenie, aby utworzyć agent_payments/.env z Twoim projektem w chmurze i lokalizacją oraz aby pakiet ADK wywoływał Gemini za pomocą Twojego projektu Google Cloud. Agent filmowy używa Gemini do określania, których narzędzi użyć. ADK automatycznie wczytuje ten plik, więc ustawienia działają też na nowych terminalach.
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
Instalowanie zależności
Google Cloud Shell jest dostarczany z zainstalowanym narzędziem uv do zarządzania środowiskiem i zależnościami.
- Utwórz plik
pyproject.tomlw katalogu głównym folderuadk-agent-commercei dodaj do niego tę treść. Ten plik określa metadane i zależności projektu.
[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",
]
Pakiet AP2 SDK jest instalowany z repozytorium GitHub, ponieważ nie został jeszcze opublikowany w PyPI. (Pakiet ap2 w PyPI to niepowiązany projekt).
- Aby utworzyć środowisko wirtualne i zainstalować wszystkie zależności, uruchom to polecenie:
uv sync
uv tworzy izolowane środowisko Pythona na potrzeby tego ćwiczenia, więc nie musisz niczego aktywować. Polecenia Pythona poprzedzaj znakiem uv run.
4. Zdefiniuj agenta
Zanim napiszesz logikę narzędzia, zdefiniujmy samego agenta w pliku o nazwie agent.py. Ten agent będzie koordynatorem procesu rezerwacji biletów do kina.
Utwórz 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),
],
)
Wyjaśnienie kodu
Przyjrzyjmy się, co się dzieje w tej definicji agenta:
model=Gemini(...): do wnioskowania i korzystania z narzędzi używamy Gemini 3.8 Flash.instruction: to prompt, który określa zachowanie agenta. Wyraźnie informuje agenta o konieczności używania UCP i AP2, zawiera listę dostępnych narzędzi i określa kluczowe reguły, takie jak „Nigdy nie wymyślaj danych” i „Ceny są podawane w centach”.tools: to lista funkcji Pythona (które utworzymy w następnym kroku), które agent może wywołać na podstawie żądań użytkownika.require_confirmation: możesz otoczyć dowolne narzędzie za pomocąFunctionTool(my_function,require_confirmation=True). Gdy agent zostanie aktywowany, wstrzymuje działanie i czeka na proste potwierdzenie „tak” lub „nie”, zanim wykona narzędzie. W tym przypadku przed wykonaniem narzędziacomplete_purchaseagent wstrzymuje działanie, aby uzyskać potwierdzenie od człowieka.
Lista narzędzi
Definicja agenta określa, co musimy utworzyć. Każde narzędzie jest powiązane z określoną operacją w protokole UCP lub AP2:
Narzędzie | Działanie | Działanie protokołu |
| Znajdowanie sprzedawców i ich rozwiązań | Zapytania |
| Przeszukiwanie katalogów różnych sprzedawców | Punkt końcowy JSON-RPC do MCP |
| Sprawdzanie godzin seansów u konkretnego sprzedawcy | Punkt końcowy JSON-RPC do MCP |
| Rozpoczęcie sesji płatności | Punkt końcowy JSON-RPC do MCP |
| Autoryzowanie płatności i realizacja zamówienia | Podpisuje zlecenia AP2 i wysyła je do MCP |
Model Gemini zdecyduje, kiedy wywołać poszczególne narzędzia na podstawie rozmowy. Następnie musimy zaimplementować w tools.py działanie każdego narzędzia.
5. Tworzenie narzędzi agenta: odkrywanie i przeglądanie
Teraz wdróżmy narzędzia, których agent będzie używać do przeglądania i odkrywania filmów. Każde narzędzie obejmuje operację UCP.
Utwórz nowy plik o nazwie agent_payments/tools.py i wklej do niego ten kod:
"""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])
Konfiguracja
Aby skupić się w tym ćwiczeniu na tworzeniu agenta, używamy 2 klas pomocniczych: UCPClient i AP2Handler, które omówimy w dalszej części.
- Co to jest? Są to małe klasy pomocnicze, które napisaliśmy na potrzeby tego laboratorium, aby komunikować się z przykładowymi sprzedawcami. Oficjalne pakiety SDK udostępniają elementy protokołu: pakiet SDK UCP zawiera modele danych dla każdego schematu UCP, a pakiet SDK AP2 tworzy i weryfikuje podpisane mandaty. Żaden z tych pakietów SDK nie zawiera klienta do dzwonienia do sprzedawców, więc te funkcje pomocnicze obsługują tę część.
- Na razie traktuj je jako obiekty pomocnicze:
_ucp.discover(url): pobiera i weryfikuje profil sprzedawcy._ucp.mcp_call(url, method, params): wysyła żądanie JSON-RPC 2.0 do punktu końcowego MCP sprzedawcy.
Odkrywanie kin
To narzędzie jest pierwszym krokiem w procesie UCP. Wyszukuje sprzedawców i sprawdza, co obsługują.
Dodaj do 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)
Działanie:
- Iteruje po liście adresów URL sprzedawców podanych przez serwer. W dalszej części tego laboratorium utworzymy 2 przykładowych sprzedawców.
- W przypadku każdego adresu URL wywołuje funkcję
_ucp.discover(url), która wysyła żądanie do punktu końcowego/.well-known/ucp. - Zbiera nazwy, możliwości i programy obsługi płatności na liście podsumowującej.
- Zwraca listę w formie ciągu JSON, który może odczytać agent.
Szukaj filmów
To narzędzie przeszukuje wszystkich wykrytych sprzedawców i łączy wyniki. Jest to kluczowe, ponieważ ten sam film może być wyświetlany w wielu kinach w różnych formatach (IMAX, Dolby) i w różnych cenach.
Dodaj do 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)
Działanie:
- Przechodzi przez wszystkie wykryte kina.
- Wysyła żądanie JSON-RPC wyszukiwania katalogu (
_ucp.mcp_call(url, "search_catalog", {"catalog": {"query": query}})) do punktu końcowego MCP sprzedawcy. - Następnie przeprowadza niewielkie czyszczenie, aby przeanalizować wyniki i znaleźć filmy oraz ich „wersje” (które reprezentują konkretne godziny seansów i formaty). Grupuje filmy według identyfikatora, aby użytkownik nie widział zduplikowanych wpisów.
Pobieranie szczegółów filmu
To narzędzie pobiera pełne szczegóły katalogu dotyczące konkretnego filmu w konkretnym kinie.
Dodaj do 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)
Działanie:
- Wywołuje metodę
lookup_catalogw punkcie końcowym MCP sprzedawcy, przekazując konkretny parametrmovie_idw parametrzecatalog.ids. Wyświetlą się szczegółowe informacje, takie jak godziny seansów i dostępność miejsc w danym kinie.
6. Tworzenie narzędzi agenta: płatność
Te narzędzia obsługują proces realizacji zakupu. W tym momencie protokół AP2 zapewnia bezpieczeństwo transakcji.
Tworzenie procesu płatności
To narzędzie rozpoczyna sesję płatności w konkretnym kinie dla konkretnego seansu.
Dodaj do 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)
Działanie:
- Wywołuje metodę
create_checkoutw punkcie końcowym MCP sprzedawcy. - Przekazuje
showtime_idiquantity, o które prosi użytkownik. - Sprzedawca zwraca stronę płatności podpisaną kluczem sprzedawcy.
Uwaga: jeśli sprawdzisz dane odpowiedzi, pole ap2.merchant_authorization zawiera podpis kryptograficzny sprzedawcy dotyczący płatności, który blokuje podaną cenę. Nie mogą go później zmienić.
Dokończ zakup
W tym narzędziu dzieją się 3 rzeczy:
- Otrzymujemy płatność i weryfikujemy podpis sprzedawcy.
- Utwórz i podpisz dokumenty CheckoutMandate i PaymentMandate za pomocą pakietu AP2 SDK.
- Wyślij oba mandaty do sprzedawcy, aby dokończyć zakup.
Dodaj do 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)
Dlaczego potrzebne są 2 mandaty? Dokument CheckoutMandate potwierdza sprzedawcy, że użytkownik zaakceptował konkretną płatność w cenie, którą sprzedawca podpisał. Dokument PaymentMandate potwierdza po stronie płatności, że użytkownik autoryzował tę opłatę. Proces wygląda tak:
Merchant signs checkout -> User signs mandates -> Merchant and payment side verify -> Order completes.
Punkt kontrolny: pełny tools.py
Kompletny plik tools.py powinien teraz zawierać 5 funkcji narzędziowych i inicjowanie na poziomie modułu dla klientów UCP i AP2. Sprawdź, czy wygląda tak:
"""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. Uruchamianie
W przypadku prawdziwych sprzedawców korzystających z UCP wystarczy wskazać pracownikowi obsługi klienta ich adresy URL. Aby przetestować lokalnie to ćwiczenie, potrzebujemy 2 rzeczy:
- Sprzedawcy testowi: lokalne serwery, które symulują punkty końcowe UCP, dzięki czemu możesz przeprowadzać testy.
- Pomocnicy protokołu: proste otoczki, które wywołują sprzedawców za pomocą protokołu HTTP i używają pakietów SDK UCP i AP2 do obsługi danych protokołu i podpisów.
Uwaga: nie musisz uważnie czytać tego kodu. Te pliki symulują prawdziwych sprzedawców i portfel użytkownika. Skopiuj je w niezmienionej formie.
Pomoc dotycząca protokołów
Pakiet SDK UCP udostępnia modele danych, a pakiet SDK AP2 podpisuje i weryfikuje upoważnienia, ale żaden z nich nie zawiera klienta do komunikacji ze sprzedawcami. Te 2 pliki wypełniają tę lukę. Mają nazwy ucp_client.py i ap2_handler.py, aby nie zasłaniać pakietu ap2.
Utwórz 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()
Utwórz 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),
)
Sprzedawcy testowi
Utwórz 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
Spowoduje to utworzenie 2 serwerów FastAPI, z których każdy będzie miał 2 punkty końcowe:
GET /.well-known/ucp: odkrywanie UCP. Zwraca możliwości sprzedawcy, adres URL punktu końcowego MCP, akceptowane formy płatności i publiczny klucz podpisu.POST /mcp: operacje MCP (Model Context Protocol). Obsługuje wywołania JSON-RPC 2.0 dotyczące wyszukiwania w katalogu, płatności i realizacji zamówienia.
Każdy sprzedawca podpisuje swoje strony płatności własnym kluczem, weryfikuje wymagania AP2 przed sfinalizowaniem zamówienia i sprawdza każdą odpowiedź w odniesieniu do modeli pakietu UCP SDK.
Uruchom sprzedawców w nowym terminalu (muszą pozostać uruchomieni):
cd ~/adk-agent-commerce
uv run python agent_payments/merchants.py
Zobaczysz, że:
Merchants running: Meridian (:8081), StarLight (:8082)
Wróć do pierwszego terminala i sprawdź wykrywanie UCP:
curl -s http://localhost:8081/.well-known/ucp | uv run python -m json.tool
Powinny być widoczne możliwości sprzedawcy, URL punktu końcowego MCP, moduły obsługi płatności i klucz publiczny.
8. Uruchamianie agenta za pomocą ADK Web
Użyjmy wbudowanego interfejsu internetowego interfejsu wiersza poleceń ADK. Zapewnia to interfejs czatu w przeglądarce i automatycznie obsługuje prośby o potwierdzenie narzędzia.
Projekt powinien teraz wyglądać tak:
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
Wypróbuj
W pierwszym terminalu przejdź do folderu adk-agent-commerce (jeden folder powyżej agent_payments) i uruchom interfejs ADK Web UI:
cd ~/adk-agent-commerce
uv run adk web --port 8080 --allow_origins '*'
Powinny się wyświetlić dane wyjściowe wskazujące, że serwer działa pod adresem http://127.0.0.1:8080.
Rozmowa z pracownikiem obsługi klienta
- Otwórz interfejs ADK, klikając adres URL z przytrzymanym klawiszem Ctrl lub Cmd albo klikając przycisk Podgląd w przeglądarce i wybierając Podejrzyj na porcie 8080.
- W menu kliknij
agent_payments, jeśli nie jest jeszcze zaznaczona. Zobaczysz interfejs czatu. - Spróbuj zapytać: „Jakie filmy są wyświetlane?”
- Agent odkrywa kina i wyszukuje katalogi za kulisami, agregując wyniki od obu sprzedawców za pomocą UCP.
- Poproś o zarezerwowanie biletów: „Zarezerwuj 2 bilety na film Oppenheimer na godzinę 19:00”.
- Gdy agent spróbuje zadzwonić pod numer
complete_purchase, zwróć uwagę, jak interfejs internetowy ADK wyświetla kartę potwierdzenia ze szczegółami zakupu. - Aby autoryzować transakcję, zaznacz pole wyboru Potwierdzono na karcie i kliknij Prześlij.
- Przedstawiciel sfinalizuje zakup i prześle Ci potwierdzenie zamówienia z kodami biletów.
Co działo się za kulisami:
create_checkout→ sprzedawca zwrócił stronę płatności podpisaną swoim kluczem (ap2.merchant_authorization, blokada ceny)complete_purchase→ zweryfikował podpis sprzedawcy, utworzył CheckoutMandate i PaymentMandate, podpisał oba dokumenty jako SD-JWT i wysłał je do sprzedawcy.- Sprzedawca zweryfikował oba mandaty i sprawdził, czy wskazują one na koszyk, w którym dokonano płatności → wydał bilety (w wersji demonstracyjnej).
9. Czyszczenie danych
Aby uniknąć pozostawienia uruchomionych serwerów lokalnych, zwolnij miejsce na zasoby:
- W terminalu, w którym działa
adk web, naciśnij Ctrl+C, aby zatrzymać serwer agenta. - W terminalu, w którym działa
merchants.py, naciśnij Ctrl+C, aby zatrzymać fikcyjnych sprzedawców. - (Opcjonalnie) Jeśli na potrzeby tego ćwiczenia w Codelabs został przez Ciebie utworzony nowy projekt w chmurze Google Cloud i chcesz go usunąć, uruchom to polecenie, zastępując
identyfikatorem projektu:
gcloud projects delete <YOUR_PROJECT_ID>
10. Gratulacje! 🎉
Utworzono agenta ADK, który wykrywa sprzedawców, przegląda katalogi i dokonuje zakupów za pomocą UCP i AP2.
Czego się dowiedzieliśmy
W tym ćwiczeniu utworzyliśmy agenta ADK, który obsługuje bezpieczne przepływy handlowe. Oto podsumowanie tego, co udało Ci się stworzyć, i najważniejszych zastosowanych pojęć:
Co zostało utworzone:
- 5 narzędzi agenta obejmujących operacje UCP i AP2: odkrywanie, wyszukiwanie w katalogu, płatność.
- Podpisanie mandatu AP2: proces płatności podpisany przez sprzedawcę (blokada ceny) + CheckoutMandate i PaymentMandate (autoryzacja użytkownika).
- Wyszukiwanie u wielu sprzedawców: jeden agent wysyła zapytania do wielu kin i łączy wyniki.
Najważniejsze pojęcia:
Protokół | Działanie | Jak to działa |
UCP Discovery | Agent znajduje sprzedawców i ich możliwości |
|
UCP MCP | Agent przegląda katalogi, tworzy płatności | Wywołania JSON-RPC 2.0 do punktu końcowego MCP sprzedawcy |
Autoryzacja sprzedawcy | Sprzedawca blokuje podaną cenę | Podpisany przez sprzedawcę, obejmuje elementy zamówienia i sumy |
AP2 CheckoutMandate | Użytkownik zatwierdza dokładną płatność | Podpisany przez użytkownika, zawiera podpisane przez sprzedawcę informacje o płatności |
AP2 PaymentMandate | Użytkownik autoryzuje obciążenie | Podpisany przez użytkownika, odwołuje się do haszu płatności |
Co się zmieniło w produkcji?
W tym ćwiczeniu używamy atrap. W wersji produkcyjnej:
- Wykrywanie UCP odbywa się na podstawie rejestru, a nie adresów URL localhost zakodowanych na stałe.
- Punkty końcowe MCP są hostowane przez prawdziwych sprzedawców: ten sam protokół JSON-RPC 2.0, prawdziwy asortyment.
- Wymagania AP2 są podpisywane na zaufanym urządzeniu użytkownika lub przez zaufaną platformę, a nie za pomocą klucza generowanego przez agenta podczas uruchamiania.
- Klucze podpisywania pochodzą z profilu UCP każdej ze stron (w przypadku sprzedawców testowych w każdej prośbie otrzymywany jest klucz publiczny agenta).
- Autoryzacja płatności przechodzi przez dostawcę danych logowania, który weryfikuje PaymentMandate i prosi użytkownika o zgodę.
- Frontend renderuje wyniki narzędzia jako rozbudowany interfejs użytkownika (siatki produktów, podsumowania płatności, karty potwierdzenia).
Dalsze kroki
- Zapoznaj się ze specyfikacją protokołu AP2 i utwórz własnego agenta obsługującego płatności.
- Wdróż UCP dla sprzedawcy, aby włączyć handel agentowy
- Połącz AP2 z A2A, aby korzystać z wieloagentowych przepływów pracy w zakresie handlu
- Dowiedz się więcej o rozszerzeniu AP2 x402 w przypadku płatności kryptowalutami