Безопасная агентская коммерция с использованием AP2 и UCP

1. Обзор

В этом практическом занятии вы запустите агент ADK , который будет бронировать билеты в кино у нескольких кинотеатральных компаний, используя два протокола электронной коммерции с открытым исходным кодом:

  • UCP (Universal Commerce Protocol) : Стандарт, позволяющий агентам находить продавцов, искать товары в каталогах и управлять процессами оформления заказа.
  • AP2 (Agent Payments Protocol) : протокол для безопасной и проверяемой авторизации платежей с использованием криптографически подписанных мандатов.

Демонстрационное приложение CineAgent подключается к двум имитированным кинотеатрам с различными возможностями (выбор мест, специализированные форматы и способы оплаты) и управляет полным процессом бронирования от поиска до оплаты.

Что вы узнаете

  • Как работает поиск продавцов UCP через профили /.well-known/ucp
  • Как агент ADK использует UCP для поиска по каталогам и создания заказов.
  • Как требования AP2 (CheckoutMandate, PaymentMandate) обеспечивают безопасность транзакций
  • Как работают сквозные протоколы UCP и AP2 для обеспечения безопасности агентской электронной коммерции

Что вам понадобится

  • Проект Google Cloud с включенной функцией выставления счетов.
  • Веб-браузер, например Chrome.
  • Python 3.11+ и uv , если вы запускаете код на своем компьютере, а не в Cloud Shell.

Этот практический урок предназначен для разработчиков среднего уровня, знакомых с Python и Google Cloud. Выполнение урока занимает приблизительно 30 минут.

Стоимость ресурсов, созданных в рамках этого практического занятия, должна составлять менее 5 долларов.

2. Понимание протоколов UCP и AP2

Прежде чем приступить к созданию агента, давайте разберемся в двух протоколах, которые обеспечивают безопасную агентскую коммерцию.

В этом практическом занятии используется UCP версии 2026-08-25 с Python SDK UCP и AP2 версии 0.2 с Python SDK AP2 .

Универсальный протокол коммерции ( UCP )

UCP стандартизирует взаимодействие агентов ИИ с продавцами. Он решает проблему необходимости изучения агентами пользовательских API для каждого отдельного магазина, вводя стандартизированную модель ресурсов.

Как это работает:

  1. Обнаружение : Каждый продавец, соответствующий стандарту UCP, предоставляет свой профиль по стандартному адресу: /.well-known/ucp . Пример: конечная точка UCP компании Everlane . Когда агент считывает этот профиль, он ищет:
    • Возможности : Автономные основные функции, которые поддерживает компания, такие как поиск по каталогу или оформление заказа.
    • Сервисы : Нижние уровни связи, используемые для обмена данными. Примеры: REST API, MCP (Model Context Protocol), A2A (Agent2Agent Protocol).
    • Расширения : Если продавцу требуется специализированное поведение, он может определить пользовательские расширения в этом профиле.
    • Ключи : Открытые ключи для подписи продавца, которые агенты используют для проверки подписей продавца.
  2. Операции : После обнаружения агент использует предоставленную конечную точку сервиса для выполнения операций. В этом практическом занятии мы используем протокол контекста модели (MCP) в качестве транспортного протокола сервиса. Агент выполняет вызовы JSON-RPC 2.0 к этой конечной точке для активации обнаруженных возможностей: поиска товаров, создания заказов и завершения покупок.

Рабочий процесс UCP

Протокол агентских платежей ( AP2 )

AP2 стандартизирует порядок авторизации платежей агентами от имени пользователей. Он решает проблему безопасности, связанную с обработкой агентами конфиденциальных платежных данных.

Как это работает:

  1. Подпись продавца : Когда агент создает чек с использованием протокола UCP, продавец подписывает чек (позиции и итоговые суммы) и возвращает подпись в ap2.merchant_authorization . Это служит гарантией фиксации цены. Если продавец изменит цену после подписания, подпись перестанет соответствовать условиям.
  2. Мандат оформления заказа и мандат оплаты : После проверки содержимого формы оформления заказа пользователь (или его представитель) подписывает два мандата. CheckoutMandate содержит подписанную продавцом форму и сообщает продавцу, что пользователь одобрил её. Мандат PaymentMandate авторизует сумму платежа по данной форме оформления заказа. Оба документа содержат хеш подписанной формы оформления заказа и криптографическую подпись пользователя.
  3. Проверка подписи : Продавец получает оба мандата. Он проверяет подпись пользователя в CheckoutMandate и убеждается, что оформление заказа внутри него содержит подпись самого продавца. PaymentMandate отправляется на сторону платежа (поставщику учетных данных или платежному процессору), который проверяет его перед переводом каких-либо средств. Если все в порядке, транзакция продолжается.

Эта система «двойной блокировки» гарантирует, что продавцы не смогут завышать цены, а агенты не смогут тратить деньги без разрешения. Мандаты представляют собой учетные данные SD-JWT (Selective Disclosure JWT), которые защищают конфиденциальность пользователей, раскрывая только те поля, которые необходимы каждой стороне. В AP2 версии 0.2 CheckoutMandate заменяет CartMandate из AP2 версии 0.1.

Рабочий процесс AP2

3. Настройте свою среду.

Настройка проекта Google Cloud

Создайте проект в Google Cloud.

  1. В консоли Google Cloud на странице выбора проекта выберите или создайте проект Google Cloud .
  2. Убедитесь, что для вашего облачного проекта включена функция выставления счетов. Узнайте, как проверить, включена ли функция выставления счетов для проекта .

Запустить Cloud Shell

Cloud Shell — это среда командной строки, работающая в Google Cloud и поставляемая с предустановленными необходимыми инструментами.

  1. В верхней части консоли Google Cloud нажмите кнопку «Активировать Cloud Shell» .
  2. После подключения к Cloud Shell подтвердите свою аутентификацию:
    gcloud auth list
    
  3. Убедитесь, что ваш проект настроен:
    gcloud config get project
    
  4. Если параметры вашего проекта заданы не так, как ожидалось, настройте их следующим образом:
    export PROJECT_ID=<YOUR_PROJECT_ID>
    gcloud config set project $PROJECT_ID
    

Включить API

Выполните следующую команду, чтобы включить необходимые API:

gcloud services enable aiplatform.googleapis.com

Структура каталогов установки

Скопируйте и вставьте следующие команды, чтобы создать папку для этого практического задания, внутри которой будет папка agent_payments для кода агента:

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

Доступ к моделям Gemini

Скопируйте и вставьте следующую команду, чтобы создать файл agent_payments/.env с указанием вашего проекта и местоположения, а также чтобы ADK вызывал Gemini через ваш проект Google Cloud. Cine Agent использует Gemini для определения того, какие инструменты следует вызывать. ADK загружает этот файл автоматически, поэтому настройки будут работать и в новых терминалах.

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

Установите зависимости

В Google Cloud Shell предустановлен uv для управления средой и зависимостями.

  1. Создайте файл pyproject.toml в корневой папке вашего проекта adk-agent-commerce и добавьте в него следующее содержимое. Этот файл определяет метаданные проекта и зависимости.
[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",
]

SDK AP2 устанавливается из своего репозитория GitHub, поскольку он ещё не опубликован на PyPI. (Пакет ap2 на PyPI — это несвязанный проект.)

  1. Выполните следующую команду, чтобы создать виртуальное окружение и установить все зависимости:
uv sync

uv создает изолированную среду Python для этого практического занятия, поэтому вам не нужно ничего активировать. Добавляйте префикс uv run к командам Python.

4. Определите агента.

Прежде чем писать логику для работы инструмента, давайте определим самого агента в файле с именем agent.py . Этот агент будет выступать в роли координатора процесса бронирования билетов в кино.

Создайте файл 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),
    ],
)

Пояснение к коду

Давайте разберем, что происходит в этом определении агента:

  • model=Gemini(...) : Мы используем Gemini 3.8 Flash для логического вывода и работы с инструментами.
  • instruction : Это подсказка, которая направляет поведение агента. Она явно указывает агенту использовать UCP и AP2, перечисляет доступные инструменты и устанавливает важные правила, такие как «Никогда не выдумывайте данные» и «Цены указаны в центах».
  • tools : Это список функций Python (которые мы создадим позже), которые агент может вызывать по запросу пользователя.
  • require_confirmation : Вы можете обернуть любой инструмент функцией FunctionTool(my_function,require_confirmation=True) . При срабатывании агент приостанавливает работу и ожидает простого подтверждения «да» или «нет», прежде чем выполнить инструмент. В данном случае, перед выполнением инструмента complete_purchase , агент приостанавливает работу для подтверждения от человека.

Список инструментов

В определении агента указано, что нам нужно построить. Каждый инструмент соответствует определенной операции в протоколе UCP или AP2:

Инструмент

Что это делает

Действие протокола

discover_theaters

Найдите продавцов и узнайте об их возможностях.

Запросы /.well-known/ucp

search_movies

Поиск по каталогам различных продавцов.

JSON-RPC в конечную точку MCP

get_movie_detail

Узнайте расписание сеансов в конкретном заведении.

JSON-RPC в конечную точку MCP

create_checkout

Начать оформление заказа

JSON-RPC в конечную точку MCP

complete_purchase

Авторизуйте платеж и завершите оформление заказа.

Подписывает мандаты AP2 и направляет их в MCP.

Модель Gemini будет определять, когда вызывать каждый инструмент, исходя из диалога. Наша следующая задача — реализовать функции каждого инструмента в tools.py .

5. Создайте инструменты агента: обнаружение и просмотр.

Теперь давайте реализуем инструменты, которые агент будет использовать для просмотра и поиска фильмов. Каждый инструмент представляет собой обертку операции UCP.

Создайте новый файл с именем agent_payments/tools.py и скопируйте в него следующий код:

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

Понимание настройки

Чтобы в этом практическом занятии основное внимание уделялось созданию агента, мы используем два вспомогательных класса, UCPClient и AP2Handler , которые мы рассмотрим позже.

  • Что это такое? Это небольшие вспомогательные классы, которые мы написали для этой практической работы, чтобы взаимодействовать с условными торговыми точками. Официальные SDK предоставляют компоненты протокола: SDK UCP содержит модели данных для каждой схемы UCP, а SDK AP2 создает и проверяет подписанные мандаты. Ни один из SDK не включает клиент для связи с торговыми точками, поэтому эти вспомогательные классы берут на себя эту часть работы.
  • Пока что рассматривайте их как вспомогательные объекты :
    • _ucp.discover(url) : Получает и проверяет профиль продавца.
    • _ucp.mcp_call(url, method, params) : Отправляет JSON-RPC 2.0 запрос на конечную точку MCP продавца.

Откройте для себя театры

Этот инструмент — первый шаг в процессе UCP. Он определяет, какие продавцы существуют и что они поддерживают.

Добавить в 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)

Что это делает :

  1. Программа перебирает список URL-адресов продавцов, предоставленный сервером. В этом практическом занятии мы создадим двух фиктивных продавцов в последующем разделе.
  2. Для каждого URL-адреса вызывается функция _ucp.discover(url) , которая обращается к конечной точке /.well-known/ucp .
  3. Он собирает имя, возможности и обработчики платежей в сводный список.
  4. Функция возвращает список в виде строки JSON, которую затем может прочитать агент.

Поиск фильмов

Этот инструмент выполняет поиск по всем найденным продавцам и объединяет результаты. Это крайне важно, поскольку один и тот же фильм может демонстрироваться в нескольких кинотеатрах с разными форматами (IMAX, Dolby) и разными ценами.

Добавить в 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)

Что это делает :

  1. Он проходит через все обнаруженные театры военных действий.
  2. Он отправляет JSON-RPC-запрос к каталогу поиска ( _ucp.mcp_call(url, "search_catalog", {"catalog": {"query": query}}) ) на конечную точку MCP продавца.
  3. Затем выполняется небольшая обработка результатов для поиска фильмов и их «вариантов» (которые представляют собой конкретное время показа и форматы). Фильмы группируются по ID, чтобы пользователь не видел повторяющихся записей.

Получить подробную информацию о фильме

Этот инструмент позволяет получить полную информацию о конкретном фильме в конкретном кинотеатре.

Добавить в 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)

Что это делает :

  • Этот метод вызывает метод lookup_catalog в конечной точке MCP продавца, передавая конкретный movie_id из catalog.ids . Он возвращает подробную информацию, такую ​​как расписание сеансов и наличие мест в конкретном кинотеатре.

6. Создайте инструменты для агентов: оформление заказа и оплата.

Эти инструменты обрабатывают процесс оформления заказа и покупки. Именно здесь вступает в игру протокол AP2, обеспечивающий безопасность транзакций.

Создать оформление заказа

Этот инструмент запускает сеанс оформления заказа в конкретном кинотеатре на конкретное время сеанса.

Добавить в 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)

Что это делает :

  1. Он вызывает метод create_checkout на конечной точке MCP продавца.
  2. Он передает идентификатор showtime_id и quantity запрошенные пользователем.
  3. Продавец возвращает кассу, подписанную ключом продавца.

Примечание : Если вы изучите данные ответа, то увидите, что поле ap2.merchant_authorization содержит криптографическую подпись продавца над процессом оформления заказа, фиксирующую указанную цену. Изменить её позже будет невозможно!

Завершить покупку

В этом инструменте происходит три вещи:

  1. Мы получаем чек и проверяем подпись продавца на нем.
  2. Создайте и подпишите документы CheckoutMandate и PaymentMandate с помощью AP2 SDK.
  3. Отправьте оба подтверждения продавцу для завершения покупки.

Добавить в 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)

Почему два мандата? Мандат оформления заказа подтверждает продавцу, что пользователь одобрил именно этот способ оформления заказа по цене, указанной продавцом. Мандат платежа подтверждает платежной стороне, что пользователь авторизовал этот платеж. Процесс выглядит следующим образом:

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

Контрольная точка: Полный файл tools.py

Теперь ваш файл tools.py должен содержать 5 функций инструментов и инициализацию на уровне модуля для клиентов UCP и AP2. Убедитесь, что он выглядит следующим образом:

"""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. Сделайте его работоспособным.

При работе с реальными продавцами UCP вы просто указываете агенту их URL-адреса, и всё готово. Для этого практического занятия нам нужно протестировать локально две вещи:

  1. Имитаторы торговых точек : локальные серверы, которые моделируют конечные точки UCP, чтобы у вас была возможность проводить тестирование.
  2. Вспомогательные протоколы : тонкие обертки, которые обращаются к продавцам по HTTP и используют SDK UCP и AP2 для передачи данных и подписей протокола.

Примечание : Внимательно читать этот код не нужно. Эти файлы имитируют реальных продавцов и кошелек пользователя. Копируйте их как есть.

Вспомогательные протоколы

SDK UCP предоставляет модели данных, а SDK AP2 подписывает и проверяет мандаты, но ни один из них не включает клиент для взаимодействия с продавцами. Эти два файла заполняют этот пробел. Они называются ucp_client.py и ap2_handler.py , чтобы не дублировать пакет ap2 .

Создайте 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()

Создайте 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),
        )

Имитация торговцев

Создайте файл 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

Это создаст два сервера FastAPI, каждый с двумя конечными точками:

  • GET /.well-known/ucp : Обнаружение UCP. Возвращает возможности продавца, URL-адрес конечной точки MCP, принимаемые способы оплаты и открытый ключ подписи.
  • POST /mcp : Операции MCP (Model Context Protocol). Обрабатывает вызовы JSON-RPC 2.0 для поиска в каталоге, оформления заказа и оплаты.

Каждый продавец подписывает свои кассовые аппараты собственным ключом, проверяет соответствие требованиям AP2 перед завершением заказа и сверяет каждый ответ с моделями UCP SDK.

Запустите торговцев в новом терминале (они должны оставаться запущенными):

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

Вам следует увидеть:

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

Вернувшись в первый терминал , проверьте обнаружение UCP:

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

Вы должны увидеть возможности продавца, URL-адрес конечной точки MCP, обработчики платежей и открытый ключ.

8. Запустите агент через ADK Web.

Давайте воспользуемся встроенным веб-интерфейсом ADK CLI! Он предоставляет чат в браузере и автоматически обрабатывает запросы на подтверждение использования инструмента.

Теперь ваш проект должен выглядеть так:

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

Попробуйте!

В первом терминале перейдите в папку adk-agent-commerce (на одну папку выше agent_payments ) и запустите веб-интерфейс ADK:

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

Вы должны увидеть сообщение о том, что сервер запущен по адресу http://127.0.0.1:8080 .

Поговорите с агентом

  1. Откройте веб-интерфейс ADK, щелкнув по URL-адресу с помощью клавиши Ctrl или Cmd , или нажав кнопку « Предварительный просмотр веб-страницы» и выбрав «Предварительный просмотр на порту 8080» .
  2. Выберите agent_payments из выпадающего меню, если этот параметр еще не выбран. Вы увидите интерфейс чата.
  3. Попробуйте спросить: "Какие фильмы идут в кинотеатрах?"
  4. Агент будет находить кинотеатры и искать информацию в каталогах, объединяя результаты от обоих продавцов через UCP.
  5. Запрос на бронирование билетов: «Забронируйте 2 билета на концерт Оппенхаймера на 19:00» .
  6. Когда агент пытается позвонить по complete_purchase , обратите внимание, как веб-интерфейс ADK отображает карточку подтверждения с подробной информацией о покупке!
  7. Для авторизации транзакции установите флажок «Подтверждено» на карте и нажмите «Отправить» .
  8. Агент завершит покупку и вернет вам подтверждение заказа с кодами билетов!

Вот что происходило за кулисами:

  1. create_checkout → merchant вернул чек, подписанный своим ключом ( ap2.merchant_authorization , блокировка цены).
  2. complete_purchase → проверил подпись продавца, создал CheckoutMandate и PaymentMandate , подписал оба как SD-JWT и отправил их продавцу.
  3. Продавец проверил оба поручения и убедился, что они указывают на подписанный им документ, на выданные чеки (в имитационном сценарии).

9. Уборка

Чтобы избежать работы локальных серверов, очистите ресурсы:

  1. В терминале, где запущена adk web , нажмите Ctrl+C , чтобы остановить сервер-агент.
  2. В терминале, где запущен merchants.py , нажмите Ctrl+C, чтобы остановить работу фиктивных продавцов.
  3. (Необязательно) Если вы создали новый проект Google Cloud для этого практического занятия и хотите его удалить, выполните следующую команду, заменив с идентификатором проекта:
gcloud projects delete <YOUR_PROJECT_ID>

10. Поздравляем! 🎉

Вы создали агента ADK, который находит продавцов, просматривает каталоги и совершает покупки, используя UCP и AP2.

Что вы узнали

В этом практическом задании вы создали агент ADK, который обрабатывает безопасные коммерческие потоки. Вот краткое описание того, что вы создали, и ключевых концепций, которые вы применили:

Что вы построили:

  • 5 инструментов для агентов, объединяющих операции UCP и AP2: поиск, поиск по каталогу, оформление заказа, оплата.
  • Подписание мандата AP2 : подписанное продавцом оформление заказа (фиксация цены) + CheckoutMandate и PaymentMandate (авторизация пользователя).
  • Поиск по нескольким торговым точкам : один агент отправляет запросы в несколько кинотеатров и объединяет результаты.

Ключевые понятия:

Протокол

Что это делает

Как это работает

Открытие UCP

Агент находит продавцов и оценивает их возможности.

/.well-known/ucp → возможности, конечная точка MCP, способы оплаты, ключи

UCP MCP

Агент просматривает каталоги, оформляет заказы.

Вызовы JSON-RPC 2.0 к конечной точке MCP продавца

Авторизация продавца

Продавец фиксирует указанную цену.

Подписано продавцом, содержит перечень товаров и итоговые суммы.

AP2 CheckoutMandate

Пользователь подтверждает точную сумму при оформлении заказа.

Подписано пользователем, содержит подписанный продавцом документ оформления заказа.

AP2 PaymentMandate

Пользователь дает разрешение на списание средств.

Подписано пользователем, содержит ссылку на хэш страницы оформления заказа.

В чём заключаются отличия в производстве?

В этом практическом занятии используются моки. В производственной среде:

  • Обнаружение UCP осуществляется путем обращения к реестру, а не к жестко закодированным URL-адресам localhost.
  • Конечные точки MCP размещаются у реальных продавцов: тот же протокол JSON-RPC 2.0, реальный ассортимент товаров.
  • Подтверждение AP2 подписывается на доверенном устройстве пользователя или доверенной платформой, а не ключом, который агент генерирует при запуске.
  • Ключи подписи берутся из профиля UCP каждой стороны (фиктивные продавцы получают открытый ключ агента в каждом запросе).
  • Авторизация платежа осуществляется через поставщика учетных данных, который проверяет платежный мандат и запрашивает согласие пользователя.
  • Фронтенд отображает результаты работы инструмента в виде расширенного пользовательского интерфейса (сетки товаров, сводки оформления заказа, карточки подтверждения).

Следующие шаги

Справочная документация