Proteja o comércio de agentes com AP2 e UCP

1. Visão geral

Neste codelab, você vai executar um agente do ADK que reserva ingressos de cinema em vários comerciantes de teatro usando dois protocolos de comércio de código aberto:

  • UCP (Protocolo de Comércio Universal): um padrão para agentes descobrirem comerciantes, pesquisarem catálogos e gerenciarem fluxos de pagamento.
  • AP2 (Protocolo de Pagamentos com Agentes): um protocolo para autorização de pagamento segura e verificável usando mandatos assinados criptograficamente.

O app de demonstração, CineAgent, se conecta a duas lojas de teatro simuladas com diferentes recursos (seleção de assentos, formatos especializados e formas de pagamento) e organiza o fluxo completo de reservas, desde a pesquisa até o pagamento.

O que você vai aprender

  • Como a descoberta de comerciantes da UCP funciona com os perfis do /.well-known/ucp
  • Como um agente do ADK usa a UCP para pesquisar catálogos e criar finalizações de compra
  • Como os mandatos do AP2 (CheckoutMandate, PaymentMandate) protegem as transações
  • Como os protocolos UCP e AP2 de ponta a ponta funcionam para proteger o e-commerce inteligente

O que é necessário

  • Tenha um projeto do Google Cloud com o faturamento ativado.
  • Um navegador da web, como o Chrome
  • Python 3.11+ e uv, se você executar o código na sua própria máquina em vez do Cloud Shell

Este codelab é destinado a desenvolvedores intermediários que têm alguma familiaridade com Python e o Google Cloud. Este codelab leva aproximadamente 30 minutos para ser concluído.

Os recursos criados neste codelab custam menos de US $5.

2. Noções básicas sobre os protocolos UCP e AP2

Antes de criar o agente, vamos entender os dois protocolos que tornam possível esse comércio agêntico seguro.

Este codelab usa a versão 2026-08-25 do UCP com o SDK do UCP para Python e a AP2 v0.2 com o SDK da AP2 para Python.

Protocolo de Comércio Universal (UCP)

O UCP padroniza a forma como os agentes de IA interagem com os comerciantes. Ele resolve o problema de os agentes precisarem aprender APIs personalizadas para cada loja ao introduzir um modelo de recurso padronizado.

Como funciona:

  1. Descoberta: todo comerciante em conformidade com a UCP expõe um perfil em um local padrão: /.well-known/ucp. Exemplo: endpoint UCP da Everlane.Quando um agente lê esse perfil, ele procura:
    • Recursos: os recursos principais independentes que uma empresa oferece, como pesquisa de catálogo ou finalização da compra.
    • Serviços: as camadas de comunicação de nível mais baixo usadas para trocar dados. Exemplos: API REST, MCP (Protocolo de Contexto de Modelo), A2A (Protocolo Agent2Agent).
    • Extensões: se um comerciante precisar de um comportamento especializado, ele poderá definir Extensões personalizadas neste perfil.
    • Chaves: as chaves públicas de assinatura do comerciante, que os agentes usam para verificar as assinaturas dele.
  2. Operações: depois de descoberto, o agente usa o endpoint de serviço fornecido para realizar operações. Neste codelab, usamos o Protocolo de Contexto de Modelo (MCP) como o transporte de serviço. O agente faz chamadas JSON-RPC 2.0 para esse endpoint e invoca os recursos descobertos: pesquisa de produtos, criação de finalizações de compra e conclusão de compras.

Fluxo de trabalho da UCP

Protocolo de Pagamentos com Agentes (AP2)

O AP2 padroniza a forma como os pagamentos são autorizados pelos agentes em nome dos usuários. Ele resolve o problema de segurança dos agentes que lidam com credenciais de pagamento sensíveis.

Como funciona:

  1. Assinatura do comerciante: quando um agente cria uma finalização de compra usando o protocolo UCP, o comerciante assina a finalização de compra (itens de linha e totais) e retorna a assinatura em ap2.merchant_authorization. Ela funciona como uma garantia de bloqueio de preço. Se o comerciante mudar o preço depois de assinar, a assinatura não vai mais corresponder.
  2. Mandato de finalização da compra e mandato de pagamento: depois de verificar o conteúdo da finalização da compra, o usuário (ou o agente em nome dele) assina dois mandatos. O CheckoutMandate contém a finalização de compra assinada pelo comerciante e informa que o usuário aprovou. O PaymentMandate autoriza o valor do pagamento para essa finalização de compra. Ambos referenciam um hash do pagamento assinado e carregam a assinatura criptográfica do usuário.
  3. Verificação de assinatura: o comerciante recebe os dois mandatos. Ele verifica a assinatura do usuário no CheckoutMandate e se o pagamento dentro dele tem a assinatura do comerciante. O PaymentMandate vai para o lado do pagamento (um provedor de credenciais ou um processador de pagamentos), que o verifica antes de movimentar qualquer dinheiro. Se tudo for válido, a transação vai continuar.

Esse sistema de "bloqueio duplo" garante que os comerciantes não possam cobrar demais e que os agentes não possam gastar sem autorização. Os mandatos são credenciais SD-JWT (Selective Disclosure JWT), que protegem a privacidade do usuário revelando apenas os campos de que cada parte precisa. Na AP2 v0.2, o CheckoutMandate substitui o CartMandate da AP2 v0.1.

Fluxo de trabalho do AP2

3. Configurar o ambiente

Configuração do projeto do Google Cloud

Criar um projeto do Google Cloud

  1. No console do Google Cloud, na página do seletor de projetos, selecione ou crie um projeto na nuvem do Google Cloud.
  2. Verifique se o faturamento está ativado para seu projeto do Cloud. Saiba como verificar se o faturamento está ativado em um projeto.

Iniciar o Cloud Shell

O Cloud Shell é um ambiente de linha de comando executado no Google Cloud que vem pré-carregado com as ferramentas necessárias.

  1. Clique em Ativar o Cloud Shell na parte de cima do console do Google Cloud.
  2. Depois de se conectar ao Cloud Shell, verifique sua autenticação:
    gcloud auth list
    
  3. Confirme se o projeto está configurado:
    gcloud config get project
    
  4. Se o projeto não estiver definido como esperado, faça a configuração:
    export PROJECT_ID=<YOUR_PROJECT_ID>
    gcloud config set project $PROJECT_ID
    

Ativar APIs

Execute o comando a seguir para ativar as APIs necessárias:

gcloud services enable aiplatform.googleapis.com

Configurar a estrutura de diretórios

Copie e cole os comandos a seguir para criar uma pasta para este codelab, com uma pasta agent_payments dentro dela para o código do agente:

mkdir -p ~/adk-agent-commerce/agent_payments
cd ~/adk-agent-commerce

Acessar modelos do Gemini

Copie e cole o comando a seguir para criar agent_payments/.env com seu projeto na nuvem e local e para que o ADK chame o Gemini pelo seu projeto do Google Cloud. O agente de cinema usa o Gemini para decidir quais ferramentas chamar. O ADK carrega esse arquivo automaticamente, então as configurações também funcionam em novos terminais.

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

Instalar dependências

O Google Cloud Shell vem pré-instalado com o uv para gerenciar o ambiente e as dependências.

  1. Crie um arquivo pyproject.toml na raiz da pasta adk-agent-commerce e adicione o seguinte conteúdo a ele. Esse arquivo define os metadados e as dependências do projeto.
[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",
]

O SDK do AP2 é instalado do repositório do GitHub porque ainda não foi publicado no PyPI. O pacote ap2 no PyPI é um projeto não relacionado.

  1. Execute o comando a seguir para criar o ambiente virtual e instalar todas as dependências:
uv sync

O uv cria um ambiente Python isolado para este codelab, então você não precisa ativar nada. Adicione o prefixo uv run aos comandos do Python.

4. Definir o agente

Antes de escrever qualquer lógica de ferramenta, vamos definir o próprio agente em um arquivo chamado agent.py. Esse agente vai atuar como o orquestrador do fluxo de reserva de filmes.

Crie 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),
    ],
)

Explicação de código

Vamos entender o que está acontecendo nessa definição de agente:

  • model=Gemini(...): estamos usando o Gemini 3.8 Flash para raciocínio e uso de ferramentas.
  • instruction: é o comando que orienta o comportamento do agente. Ele informa explicitamente ao agente para usar UCP e AP2, lista as ferramentas disponíveis e define regras importantes, como "Nunca invente dados" e "Os preços estão em centavos".
  • tools: é uma lista de funções Python (que vamos criar em seguida) que o agente pode chamar com base nas solicitações do usuário.
  • require_confirmation: é possível encapsular qualquer ferramenta com FunctionTool(my_function,require_confirmation=True). Quando acionado, o agente faz uma pausa e aguarda uma aprovação simples com "sim" ou "não" antes de executar a ferramenta. Aqui, antes de executar a ferramenta complete_purchase, o agente pausa para uma confirmação humana.

A lista de ferramentas

A definição do agente declara o que precisamos criar. Cada ferramenta é mapeada para uma operação específica no protocolo UCP ou AP2:

Ferramenta

O que faz?

Ação de protocolo

discover_theaters

Encontrar comerciantes e recursos

Consultas /.well-known/ucp

search_movies

Pesquisar catálogos em várias lojas

Endpoint JSON-RPC para MCP

get_movie_detail

Receber horários de exibição em uma loja específica

Endpoint JSON-RPC para MCP

create_checkout

Iniciar uma sessão de pagamento

Endpoint JSON-RPC para MCP

complete_purchase

Autorizar o pagamento e concluir o pedido

Assina os mandatos da AP2 e envia para o MCP

O modelo do Gemini vai decidir quando chamar cada ferramenta com base na conversa. Em seguida, vamos implementar o que cada ferramenta faz em tools.py.

5. Criar as ferramentas do agente: descoberta e navegação

Agora vamos implementar as ferramentas que o agente vai usar para navegar e descobrir filmes. Cada ferramenta encapsula uma operação da UCP.

Crie um arquivo chamado agent_payments/tools.py e copie e cole o seguinte código:

"""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])

Entenda a configuração

Para manter o foco deste codelab na criação do agente, estamos usando duas classes auxiliares, UCPClient e AP2Handler, que vamos analisar em uma etapa posterior.

  • O que são?: São pequenas classes auxiliares que escrevemos para este codelab e que se comunicam com os comerciantes simulados. Os SDKs oficiais fornecem as partes do protocolo: o SDK da UCP tem modelos de dados para todos os esquemas da UCP, e o SDK da AP2 cria e verifica mandatos assinados. Nenhum dos SDKs inclui um cliente para chamar comerciantes, então esses helpers cuidam dessa parte.
  • Por enquanto, trate-os como objetos auxiliares:
    • _ucp.discover(url): busca e valida o perfil de um comerciante.
    • _ucp.mcp_call(url, method, params): envia uma solicitação JSON-RPC 2.0 ao endpoint do MCP do comerciante.

Descobrir teatros

Essa ferramenta é a primeira etapa do fluxo da UCP. Ele encontra os comerciantes que existem e o que eles oferecem.

Adicione a 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)

O que isso faz:

  1. Ele itera uma lista de URLs de comerciantes fornecidos pelo servidor. Neste codelab, vamos configurar duas lojas fictícias na seção posterior.
  2. Para cada URL, ele chama _ucp.discover(url), que acessa o endpoint /.well-known/ucp.
  3. Ele coleta o nome, os recursos e os manipuladores de pagamento em uma lista de resumo.
  4. Ela retorna a lista como uma string JSON para o agente ler.

Pesquisar filmes

Essa ferramenta pesquisa todos os comerciantes descobertos e mescla os resultados. Isso é crucial porque o mesmo filme pode estar sendo exibido em vários cinemas com formatos (IMAX, Dolby) e preços diferentes.

Adicione a 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)

O que isso faz:

  1. Ele faz um loop por todos os cinemas descobertos.
  2. Ele envia uma solicitação JSON-RPC de catálogo de pesquisa (_ucp.mcp_call(url, "search_catalog", {"catalog": {"query": query}})) para o endpoint do MCP do comerciante.
  3. Em seguida, ele faz uma limpeza para analisar os resultados e encontrar filmes e suas "variantes" (que representam horários e formatos específicos). Agrupa os filmes por ID para que o usuário não veja entradas duplicadas.

Receber detalhes do filme

Essa ferramenta recebe os detalhes completos do catálogo de um filme específico em um cinema específico.

Adicione a 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)

O que isso faz:

  • Ele chama o método lookup_catalog no endpoint do MCP do comerciante, transmitindo o movie_id específico em catalog.ids. Isso retorna informações detalhadas, como horários de exibição e disponibilidade de assentos para esse cinema específico.

6. Criar as ferramentas do agente: finalização da compra e pagamento

Essas ferramentas cuidam do fluxo de finalização da compra. É aqui que o protocolo AP2 entra em ação para garantir transações seguras.

Criar a finalização de compra

Essa ferramenta inicia uma sessão de finalização de compra em um cinema específico para um horário de exibição específico.

Adicione a 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)

O que isso faz:

  1. Ele chama o método create_checkout no endpoint do MCP do comerciante.
  2. Ele transmite o showtime_id e o quantity solicitados pelo usuário.
  3. O comerciante retorna um pagamento finalizado assinado com a chave dele.

Observação: se você analisar os dados de resposta, o campo ap2.merchant_authorization vai conter a assinatura criptográfica do comerciante na finalização da compra, bloqueando o preço cotado. Não é possível mudar depois.

Concluir a compra

Três coisas acontecem nessa ferramenta:

  1. Recebemos a finalização da compra e verificamos a assinatura do comerciante nela.
  2. Crie e assine o CheckoutMandate e o PaymentMandate com o SDK AP2.
  3. Envie os dois mandatos ao comerciante para concluir a compra.

Adicione a 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)

Por que dois mandatos? O mandato de finalização de compra prova ao comerciante que o usuário aprovou essa finalização de compra exata, pelo preço assinado pelo comerciante. O PaymentMandate prova ao lado do pagamento que o usuário autorizou essa cobrança. O fluxo é:

Merchant signs checkout -> User signs mandates -> Merchant and payment side verify -> Order completes.

Checkpoint: Full tools.py

Seu tools.py completo agora tem cinco funções de ferramenta e inicialização no nível do módulo para clientes UCP e AP2. Verifique se ele é parecido com isto:

"""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. Tornar executável

Com comerciantes reais da UCP, você apontaria o agente para os URLs deles e pronto. Para este codelab, precisamos de duas coisas para testar localmente:

  1. Comerciantes simulados: servidores locais que simulam endpoints da UCP para que você tenha algo para testar.
  2. Helpers de protocolo: wrappers leves que chamam as lojas por HTTP e usam os SDKs UCP e AP2 para dados e assinaturas de protocolo.

Observação: não é necessário ler esse código com atenção. Esses arquivos simulam comerciantes reais e a carteira de um usuário. Copie-os como estão.

Assistentes de protocolo

O SDK UCP fornece modelos de dados, e o SDK AP2 assina e verifica mandatos, mas nenhum deles inclui um cliente para conversar com comerciantes. Esses dois arquivos preenchem essa lacuna. Eles são chamados de ucp_client.py e ap2_handler.py para não ofuscarem o pacote ap2.

Crie 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()

Crie 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),
        )

Comerciantes simulados

Crie 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

Isso cria dois servidores FastAPI, cada um com dois endpoints:

  • GET /.well-known/ucp: descoberta do UCP. Retorna os recursos da loja, o URL do endpoint do MCP, as formas de pagamento aceitas e a chave de assinatura pública.
  • POST /mcp: operações do MCP (Protocolo de Contexto de Modelo). Processa chamadas JSON-RPC 2.0 para pesquisa no catálogo, finalização da compra e pagamento.

Cada comerciante assina os pagamentos com a própria chave, verifica os mandatos da AP2 antes de concluir um pedido e confere todas as respostas com os modelos do SDK da UCP.

Inicie as lojas em um novo terminal (elas precisam continuar em execução):

cd ~/adk-agent-commerce
uv run python agent_payments/merchants.py

Você verá:

Merchants running: Meridian (:8081), StarLight (:8082)

De volta ao primeiro terminal, verifique a descoberta da UCP:

curl -s http://localhost:8081/.well-known/ucp | uv run python -m json.tool

Você vai encontrar os recursos do comerciante, o URL do endpoint do MCP, os gerenciadores de pagamento e a chave pública.

8. Executar o agente com o ADK Web

Vamos usar a interface da Web integrada da CLI do ADK. Isso fornece uma interface de chat no navegador e processa automaticamente os comandos de confirmação de ferramentas.

Seu projeto vai ficar assim:

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

Testar

No primeiro terminal, acesse a pasta adk-agent-commerce (uma pasta acima de agent_payments) e inicie a interface da Web do ADK:

cd ~/adk-agent-commerce
uv run adk web --port 8080 --allow_origins '*'

Você vai ver uma saída indicando que o servidor está sendo executado em http://127.0.0.1:8080.

Fale com o agente

  1. Abra a interface da Web do ADK clicando em Ctrl ou Cmd no URL ou clicando no botão Visualização na Web e selecionando Visualizar na porta 8080.
  2. Selecione agent_payments no menu suspenso, caso ainda não esteja selecionado. Uma interface de chat vai aparecer.
  3. Tente perguntar: "Quais filmes estão em cartaz?"
  4. O agente vai descobrir cinemas e pesquisar catálogos nos bastidores, agregando resultados dos dois comerciantes pela UCP.
  5. Peça para reservar ingressos: "Reserve dois ingressos para Oppenheimer às 19h".
  6. Quando o agente tenta chamar complete_purchase, observe como a interface da Web do ADK mostra um card de confirmação com os detalhes da compra.
  7. Para autorizar a transação, marque a caixa de seleção Confirmado no cartão e clique em Enviar.
  8. O agente vai concluir a compra e enviar a confirmação do pedido com os códigos dos ingressos.

Veja o que aconteceu nos bastidores:

  1. create_checkout → o comerciante retornou um pagamento assinado com a chave dele (ap2.merchant_authorization, o bloqueio de preço).
  2. complete_purchase → verificou a assinatura do comerciante, criou um CheckoutMandate e um PaymentMandate, assinou os dois como SD-JWTs e os enviou ao comerciante
  3. O comerciante verificou os dois mandatos e conferiu se eles apontam para a finalização da compra que assinou → emitiu ingressos (no simulado)

9. Limpar

Para evitar deixar servidores locais em execução, limpe os recursos:

  1. No terminal que executa adk web, pressione Ctrl+C para interromper o servidor do agente.
  2. No terminal que executa merchants.py, pressione Ctrl+C para interromper os comerciantes simulados.
  3. (Opcional) Se você criou um projeto do Google Cloud para este codelab e quer excluí-lo, execute o comando a seguir, substituindo pelo ID do projeto:
gcloud projects delete <YOUR_PROJECT_ID>

10. Parabéns! 🎉

Você criou um agente do ADK que descobre comerciantes, navega em catálogos e conclui compras usando UCP e AP2.

O que você aprendeu

Neste codelab, você criou um agente do ADK que processa fluxos de comércio seguros. Confira um resumo do que você criou e dos principais conceitos aplicados:

O que você criou:

  • Cinco ferramentas de agente que envolvem operações de UCP e AP2: descoberta, pesquisa no catálogo, finalização da compra e pagamento.
  • Assinatura de mandato AP2: finalização de compra assinada pelo comerciante (bloqueio de preço) + CheckoutMandate e PaymentMandate (autorização do usuário).
  • Pesquisa em várias lojas: um agente consulta vários cinemas e mescla os resultados.

Principais conceitos:

Protocolo

O que faz?

Como funciona

Descoberta de UCP

O agente encontra comerciantes e os recursos deles

/.well-known/ucp → recursos, endpoint do MCP, formas de pagamento, chaves

UCP MCP

O agente navega pelos catálogos e cria finalizações de compra

Chamadas JSON-RPC 2.0 para o endpoint da MCP do comerciante

Autorização do comerciante

O comerciante bloqueia o preço cotado

Assinado pelo comerciante, cobre itens de linha e totais

AP2 CheckoutMandate

O usuário aprova o checkout exato

Assinado pelo usuário, contém o pagamento assinado pelo comerciante.

AP2 PaymentMandate

O usuário autoriza a cobrança

Assinado pelo usuário, faz referência ao hash de finalização da compra.

O que muda na produção?

Este codelab usa simulações. Em produção:

  • A descoberta do UCP é resolvida em um registro, não em URLs de localhost fixados no código.
  • Os endpoints do MCP são hospedados por comerciantes reais: mesmo protocolo JSON-RPC 2.0, inventário real
  • As determinações da AP2 são assinadas no dispositivo confiável do usuário ou por uma plataforma confiável, não com uma chave gerada pelo agente na inicialização.
  • As chaves de assinatura vêm do perfil da UCP de cada parte. Os comerciantes simulados recebem a chave pública do agente em cada solicitação.
  • A autorização de pagamento passa por um provedor de credenciais que verifica o PaymentMandate e pede o consentimento do usuário.
  • O front-end renderiza os resultados da ferramenta como uma interface avançada (grades de produtos, resumos de finalização de compra, cards de confirmação).

Próximas etapas

Documentos de referência