Comercio seguro con agentes a través de AP2 y UCP

1. Descripción general

En este codelab, ejecutarás un agente del ADK que reserva entradas de cine en varios comercios de cines con dos protocolos de comercio de código abierto:

  • UCP (Universal Commerce Protocol): Es un estándar para que los agentes descubran comercios, busquen catálogos y administren flujos de confirmación de compra.
  • AP2 (protocolo de pagos con agentes): Es un protocolo para la autorización de pagos seguros y verificables con mandatos firmados de forma criptográfica.

La app de demostración, CineAgent, se conecta a dos comercios de cine simulados con diferentes capacidades (selección de asientos, formatos especializados y formas de pago) y coordina el flujo de reserva completo, desde la búsqueda hasta el pago.

Qué aprenderás

  • Cómo funciona el descubrimiento de comercios del UCP a través de los perfiles de /.well-known/ucp
  • Cómo un agente del ADK usa la UCP para buscar catálogos y crear pagos
  • Cómo los mandatos de AP2 (CheckoutMandate y PaymentMandate) protegen las transacciones
  • Cómo funcionan los protocolos UCP y AP2 de extremo a extremo para proteger el comercio electrónico basado en agentes

Requisitos

  • Un proyecto de Google Cloud con la facturación habilitada.
  • Un navegador web, como Chrome
  • Python 3.11 y uv, si ejecutas el código en tu propia máquina en lugar de Cloud Shell

Este codelab está dirigido a desarrolladores intermedios que tienen cierta familiaridad con Python y Google Cloud. Este codelab toma aproximadamente 30 minutos en completarse.

Los recursos creados en este codelab deberían costar menos de USD 5.

2. Información sobre los protocolos UCP y AP2

Antes de comenzar a crear el agente, comprendamos los dos protocolos que hacen posible este comercio con agentes seguro.

En este codelab, se usa la versión 2026-08-25 de UCP con el SDK de Python de UCP y la versión 0.2 de AP2 con el SDK de Python de AP2.

Universal Commerce Protocol (UCP)

El UCP estandariza la forma en que los agentes de IA interactúan con los comercios. Introduce un modelo de recursos estandarizado para resolver el problema de que los agentes tengan que aprender APIs personalizadas para cada tienda.

Cómo funciona:

  1. Descubrimiento: Todos los comercios que cumplen con el UCP exponen un perfil en una ubicación estándar: /.well-known/ucp. Ejemplo: Extremo de UCP de Everlane.Cuando un agente lee este perfil, busca lo siguiente:
    • Capacidades: Son las funciones principales independientes que admite una empresa, como la búsqueda en el catálogo o la confirmación de compra.
    • Servicios: Son las capas de comunicación de nivel inferior que se usan para intercambiar datos. Ejemplos: API de REST, MCP (Protocolo de contexto del modelo), A2A (Protocolo de Agent2Agent).
    • Extensiones: Si un comercio necesita un comportamiento especializado, puede definir Extensiones personalizadas en este perfil.
    • Claves: Son las claves de firma públicas del comercio, que los agentes usan para verificar las firmas del comercio.
  2. Operaciones: Una vez que se descubre, el agente usa el extremo de servicio proporcionado para realizar operaciones. En este codelab, usamos el Protocolo de contexto del modelo (MCP) como transporte de servicio. El agente realiza llamadas JSON-RPC 2.0 a este extremo para invocar las capacidades descubiertas: buscar productos, crear pagos y completar compras.

Flujo de trabajo del UCP

Protocolo de pagos con agentes (AP2)

La AP2 estandariza la forma en que los agentes autorizan los pagos en nombre de los usuarios. Resuelve el problema de seguridad de los agentes que manejan credenciales de pago sensibles.

Cómo funciona:

  1. Firma del comercio: Cuando un agente crea una confirmación de compra con el protocolo de UCP, el comercio firma la confirmación de compra (conceptos y totales) y devuelve la firma en ap2.merchant_authorization. Actúa como una garantía de bloqueo de precios. Si el comercio cambia el precio después de firmar, la firma ya no coincidirá.
  2. Mandato de confirmación de compra y mandato de pago: Después de verificar el contenido de la confirmación de compra, el usuario (o el agente en nombre del usuario) firma dos mandatos. El CheckoutMandate contiene la confirmación de compra firmada por el comercio y le indica a este que el usuario la aprobó. PaymentMandate autoriza el importe del pago para esa confirmación de compra. Ambos hacen referencia a un hash de la confirmación de compra firmada y contienen la firma criptográfica del usuario.
  3. Verificación de la firma: El comercio recibe ambos mandatos. Verifica la firma del usuario en el CheckoutMandate y comprueba que la confirmación de compra que contiene lleve la firma propia del comercio. El PaymentMandate se envía al lado del pago (un proveedor de credenciales o un procesador de pagos), que lo verifica antes de transferir dinero. Si todo es válido, la transacción continúa.

Este sistema de "doble bloqueo" garantiza que los comercios no puedan cobrar de más y que los agentes no puedan gastar sin autorización. Los mandatos son credenciales de SD-JWT (JWT de divulgación selectiva) que protegen la privacidad del usuario, ya que solo revelan los campos que necesita cada parte. En la versión 0.2 de la AP2, CheckoutMandate reemplaza a CartMandate de la versión 0.1 de la AP2.

Flujo de trabajo de AP2

3. Configura tu entorno

Configuración del proyecto de Google Cloud

Crea un proyecto de Google Cloud

  1. En la página del selector de proyectos de la consola de Google Cloud, selecciona o crea un proyecto de Google Cloud.
  2. Asegúrate de que la facturación esté habilitada para tu proyecto de Cloud. Obtén información para verificar si la facturación está habilitada en un proyecto.

Inicie Cloud Shell

Cloud Shell es un entorno de línea de comandos que se ejecuta en Google Cloud y que viene precargado con las herramientas necesarias.

  1. Haz clic en Activar Cloud Shell en la parte superior de la consola de Google Cloud.
  2. Una vez que te conectes a Cloud Shell, verifica tu autenticación:
    gcloud auth list
    
  3. Confirma que tu proyecto esté configurado:
    gcloud config get project
    
  4. Si tu proyecto no está configurado como se espera, configúralo:
    export PROJECT_ID=<YOUR_PROJECT_ID>
    gcloud config set project $PROJECT_ID
    

Habilita las APIs

Ejecuta el siguiente comando para habilitar las APIs requeridas:

gcloud services enable aiplatform.googleapis.com

Configura la estructura de directorios

Copia y pega los siguientes comandos para crear una carpeta para este codelab, con una carpeta agent_payments dentro para el código del agente:

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

Accede a los modelos de Gemini

Copia y pega el siguiente comando para crear agent_payments/.env con tu proyecto y ubicación, y para que el ADK llame a Gemini a través de tu proyecto de Google Cloud. El agente de Cine usa Gemini para decidir qué herramientas llamar. El ADK carga este archivo automáticamente, por lo que la configuración también funciona en terminales nuevos.

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

Instala las dependencias

Google Cloud Shell ya viene instalado con uv para administrar el entorno y las dependencias.

  1. Crea un archivo pyproject.toml en la raíz de tu carpeta adk-agent-commerce y agrégale el siguiente contenido. Este archivo define los metadatos y las dependencias del proyecto.
[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",
]

El SDK de AP2 se instala desde su repositorio de GitHub porque aún no se publicó en PyPI. (El paquete ap2 en PyPI es un proyecto no relacionado).

  1. Ejecuta el siguiente comando para crear el entorno virtual y, luego, instalar todas las dependencias:
uv sync

uv crea un entorno aislado de Python para este codelab, por lo que no necesitas activar nada. Agrega el prefijo uv run a los comandos de Python.

4. Define el agente

Antes de escribir cualquier lógica de herramientas, definamos el agente en un archivo llamado agent.py. Este agente actuará como el organizador del flujo de reserva de películas.

Crea un 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),
    ],
)

Explicación del código

Analicemos qué sucede en esta definición del agente:

  • model=Gemini(...): Usamos Gemini 3.8 Flash para el razonamiento y el uso de herramientas.
  • instruction: Es la instrucción que guía el comportamiento del agente. Le indica explícitamente al agente que use UCP y AP2, enumera las herramientas disponibles y establece reglas críticas, como "Nunca inventes datos" y "Los precios están en centavos".
  • tools: Es una lista de funciones de Python (que compilaremos a continuación) que el agente puede elegir llamar en función de las solicitudes del usuario.
  • require_confirmation: Puedes unir cualquier herramienta con FunctionTool(my_function,require_confirmation=True). Cuando se activa, el agente se pausa y espera una aprobación simple con un "sí" o un "no" antes de ejecutar la herramienta. Aquí, antes de ejecutar la herramienta complete_purchase, el agente hace una pausa para solicitar la confirmación de un humano.

La lista de herramientas

La definición del agente declara lo que necesitamos compilar. Cada herramienta se asigna a una operación específica en el protocolo de UCP o AP2:

Herramienta

Qué hace

Acción del protocolo

discover_theaters

Encuentra comercios y sus capacidades

Consultas /.well-known/ucp

search_movies

Busca catálogos en todos los comercios

Extremo de JSON-RPC a MCP

get_movie_detail

Obtener horarios de funciones en un comercio específico

Extremo de JSON-RPC a MCP

create_checkout

Inicia una sesión de confirmación de compra

Extremo de JSON-RPC a MCP

complete_purchase

Autoriza el pago y completa el pedido

Firma los mandatos de AP2 y los envía al MCP

El modelo de Gemini decidirá cuándo llamar a cada herramienta según la conversación. A continuación, nuestro trabajo es implementar lo que hace cada herramienta en tools.py.

5. Crea las herramientas del agente: Descubrimiento y navegación

Ahora implementemos las herramientas que usará el agente para explorar y descubrir películas. Cada herramienta encapsula una operación de UCP.

Crea un archivo nuevo llamado agent_payments/tools.py y copia y pega el siguiente 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])

Información sobre la configuración

Para que este codelab se centre en la creación del agente, usamos dos clases de ayuda, UCPClient y AP2Handler, que veremos en un paso posterior.

  • ¿Qué son?: Son pequeñas clases auxiliares que escribimos para este codelab para comunicarnos con los comercios simulados. Los SDKs oficiales proporcionan las partes del protocolo: el SDK de UCP tiene modelos de datos para cada esquema de UCP, y el SDK de AP2 crea y verifica los mandatos firmados. Ninguno de los SDKs incluye un cliente para llamar a los comercios, por lo que estos asistentes se encargan de esa parte.
  • Por el momento, trátalos como objetos auxiliares:
    • _ucp.discover(url): Recupera y valida el perfil de un comercio.
    • _ucp.mcp_call(url, method, params): Envía una solicitud JSON-RPC 2.0 al extremo del MCP del comercio.

Descubre teatros

Esta herramienta es el primer paso en el flujo del UCP. Encuentra los comercios existentes y los que admiten la opción.

Agrega lo siguiente 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)

Qué hace:

  1. Itera en una lista de URLs de comercios proporcionadas por el servidor. En este codelab, configuraremos dos comercios simulados en la sección posterior.
  2. Para cada URL, llama a _ucp.discover(url), que alcanza el endpoint /.well-known/ucp.
  3. Recopila el nombre, las capacidades y los controladores de pagos en una lista de resumen.
  4. Devuelve la lista como una cadena JSON para que el agente la lea.

Buscar películas

Esta herramienta busca en todos los comercios descubiertos y combina los resultados. Esto es fundamental porque la misma película puede proyectarse en varios cines con diferentes formatos (IMAX, Dolby) y precios.

Agrega lo siguiente 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)

Qué hace:

  1. Itera por todos los cines que se descubrieron.
  2. Envía una solicitud JSON-RPC del catálogo de búsqueda (_ucp.mcp_call(url, "search_catalog", {"catalog": {"query": query}})) al extremo del MCP del comercio.
  3. Luego, realiza una pequeña limpieza para analizar los resultados y encontrar películas y sus "variantes" (que representan horarios y formatos específicos). Agrupa las películas por ID para que el usuario no vea entradas duplicadas.

Obtener detalles de la película

Esta herramienta obtiene los detalles completos del catálogo de una película específica en un cine específico.

Agrega lo siguiente 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)

Qué hace:

  • Llama al método lookup_catalog en el extremo del MCP del comercio y pasa el movie_id específico en catalog.ids. Esto devuelve información detallada, como los horarios de las funciones y la disponibilidad de asientos para ese cine específico.

6. Crea las herramientas del agente: Checkout y pago

Estas herramientas controlan el flujo de compra y confirmación de compra. Aquí es donde entra en juego el protocolo AP2 para garantizar transacciones seguras.

Crea la confirmación de compra

Esta herramienta inicia una sesión de confirmación de compra en un cine específico para una hora de función específica.

Agrega lo siguiente 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)

Qué hace:

  1. Llama al método create_checkout en el extremo del MCP del comercio.
  2. Pasa los parámetros showtime_id y quantity solicitados por el usuario.
  3. El comercio devuelve una confirmación de compra firmada con su clave.

Nota: Si examinas los datos de la respuesta, el campo ap2.merchant_authorization contiene la firma criptográfica del comercio sobre la confirmación de compra, lo que bloquea el precio cotizado. No podrán cambiarlo más adelante.

Completa la compra

En esta herramienta, suceden tres cosas:

  1. Obtenemos la confirmación de compra y verificamos la firma del comercio en ella.
  2. Crea y firma los objetos CheckoutMandate y PaymentMandate con el SDK de la AP2.
  3. Envía ambos mandatos al comercio para completar la compra.

Agrega lo siguiente 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 qué dos mandatos? El CheckoutMandate le demuestra al comercio que el usuario aprobó esta confirmación de compra exacta al precio que firmó el comercio. El PaymentMandate demuestra al lado del pago que el usuario autorizó este cargo. El flujo es así:

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

Punto de control: Completo tools.py

Tu tools.py completo ahora debería tener 5 funciones de herramientas y la inicialización a nivel del módulo para los clientes de UCP y AP2. Verifica que se vea de la siguiente manera:

"""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. Haz que se pueda ejecutar

Con comercios reales de UCP, dirigirías al agente a sus URLs y listo. Para este codelab, necesitamos dos elementos para realizar pruebas de forma local:

  1. Comercios simulados: Son servidores locales que simulan extremos de UCP para que tengas algo con lo que realizar pruebas.
  2. Auxiliares de protocolo: Wrappers delgados que llaman a los comercios a través de HTTP y usan los SDKs de UCP y AP2 para los datos y las firmas del protocolo

Nota: No es necesario que leas este código con atención. Estos archivos simulan comercios reales y la billetera de un usuario. Cópialos tal cual.

Ayudantes de protocolos

El SDK del UCP proporciona modelos de datos, y el SDK de la AP2 firma y verifica los mandatos, pero ninguno incluye un cliente para comunicarse con los comercios. Estos dos archivos cubren esa brecha. Se llaman ucp_client.py y ap2_handler.py para que no oculten el paquete ap2.

Crea un 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()

Crea un 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),
        )

Comercios simulados

Crea un 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

Esto crea dos servidores de FastAPI, cada uno con dos extremos:

  • GET /.well-known/ucp: Descubrimiento de UCP. Devuelve las capacidades del comercio, la URL del extremo de MCP, las formas de pago aceptadas y la clave de firma pública.
  • POST /mcp: Operaciones del MCP (Protocolo de contexto del modelo). Controla las llamadas JSON-RPC 2.0 para la búsqueda en el catálogo, la confirmación de compra y el pago.

Cada comercio firma sus confirmaciones de compra con su propia clave, verifica los mandatos de la AP2 antes de completar un pedido y comprueba cada respuesta con los modelos del SDK de UCP.

Inicia los comercios en una terminal nueva (deben seguir ejecutándose):

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

Deberías ver lo siguiente:

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

De vuelta en tu primera terminal, verifica el descubrimiento de UCP:

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

Deberías ver las capacidades del comercio, la URL del extremo del MCP, los controladores de pago y la clave pública.

8. Ejecuta el agente con la Web del ADK

Usemos la IU web integrada en la CLI del ADK. Esto proporciona una interfaz de chat en el navegador y controla automáticamente las indicaciones para confirmar herramientas.

Ahora, tu proyecto debería verse de la siguiente manera:

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

Probar

En tu primera terminal, ve a la carpeta adk-agent-commerce (una carpeta sobre agent_payments) y, luego, inicia la IU web del ADK:

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

Deberías ver un resultado que indica que el servidor se está ejecutando en http://127.0.0.1:8080.

Hablar con el agente

  1. Para abrir la IU web del ADK, haz clic en la URL con Ctrl o Cmd, o bien haz clic en el botón Vista previa en la Web y selecciona Vista previa en el puerto 8080.
  2. Selecciona agent_payments en el menú desplegable si aún no está seleccionado. Verás una interfaz de chat.
  3. Intenta preguntar: "¿Qué películas se están proyectando?"
  4. El agente descubrirá cines y buscará catálogos tras bambalinas, y agregará los resultados de ambos comercios a través de la UCP.
  5. Pídele que reserve entradas: "Reserva 2 entradas para Oppenheimer a las 7 p.m.".
  6. Cuando el agente intenta llamar a complete_purchase, observa cómo la IU web del ADK muestra una tarjeta de confirmación con los detalles de la compra.
  7. Para autorizar la transacción, selecciona la casilla de verificación Confirmado en la tarjeta y haz clic en Enviar.
  8. El agente completará la compra y te devolverá la confirmación del pedido con los códigos de las entradas.

Esto es lo que sucedió tras bambalinas:

  1. create_checkout → El comercio devolvió una confirmación de compra firmada con su clave (ap2.merchant_authorization, el bloqueo de precios)
  2. complete_purchase → Verificó la firma del comercio, creó un CheckoutMandate y un PaymentMandate, firmó ambos como SD-JWT y los envió al comercio.
  3. El comercio verificó ambos mandatos y comprobó que apuntan a la confirmación de compra que firmó → se emitieron tickets (en la simulación)

9. Limpia

Para evitar que los servidores locales sigan en ejecución, limpia los recursos:

  1. En la terminal que ejecuta adk web, presiona Ctrl + C para detener el servidor del agente.
  2. En la terminal que ejecuta merchants.py, presiona Ctrl + C para detener los comercios simulados.
  3. (Opcional) Si creaste un proyecto de Google Cloud nuevo para este codelab y deseas borrarlo, ejecuta el siguiente comando y reemplaza por su ID del proyecto:
gcloud projects delete <YOUR_PROJECT_ID>

10. ¡Felicitaciones! 🎉

Creaste un agente de ADK que descubre comercios, explora catálogos y completa compras con UCP y AP2.

Qué aprendiste

En este codelab, creaste un agente del ADK que controla flujos de comercio seguros. Este es un resumen de lo que creaste y los conceptos clave que aplicaste:

Qué creaste:

  • 5 herramientas de agentes que encapsulan las operaciones de UCP y AP2: descubrimiento, búsqueda en el catálogo, confirmación de compra y pago.
  • Firma de mandato de AP2: Confirmación de compra firmada por el comercio (bloqueo de precios) + CheckoutMandate y PaymentMandate (autorización del usuario).
  • Búsqueda en múltiples comercios: Un agente consulta varios cines y combina los resultados.

Conceptos clave:

Protocolo

Qué hace

Cómo funciona

Descubrimiento de UCP

El agente encuentra comercios y sus capacidades

/.well-known/ucp → capacidades, extremo de MCP, formas de pago, claves

UCP MCP

El agente explora catálogos y crea pagos

Llamadas a JSON-RPC 2.0 al extremo del MCP del comercio

Autorización del comercio

El comercio bloquea el precio cotizado

Firmada por el comercio, incluye los totales y las líneas de pedido

AP2 CheckoutMandate

El usuario aprueba la compra exacta

Firmado por el usuario, contiene la confirmación de compra firmada por el comercio

AP2 PaymentMandate

El usuario autoriza el cargo

Firmado por el usuario y hace referencia al hash de la confirmación de compra

¿Qué cambia en la producción?

En este codelab, se usan simulaciones. En producción:

  • La detección de UCP se resuelve en un registro, no en URLs de localhost codificadas.
  • Los extremos de MCP están alojados por comercios reales: mismo protocolo JSON-RPC 2.0, inventario real
  • Las autorizaciones de la AP2 se firman en el dispositivo de confianza del usuario o en una plataforma de confianza, no con una clave que el agente genera al inicio.
  • Las claves de firma provienen del perfil de UCP de cada parte (en cada solicitud, los comercios simulados reciben la clave pública del agente).
  • La autorización de pago pasa por un proveedor de credenciales que verifica el PaymentMandate y solicita el consentimiento del usuario.
  • El frontend renderiza los resultados de la herramienta como una IU enriquecida (cuadrículas de productos, resúmenes de confirmación de compra, tarjetas de confirmación).

Próximos pasos

Documentos de referencia