View a markdown version of this page

Integrazione dei AgentCore pagamenti con Browser Tool - Fondamento Amazon AgentCore
Integrazione con Browser Tool (Playwright)Non-browser Integrazione HTTP

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Integrazione dei AgentCore pagamenti con Browser Tool

L'agente può accedere ai contenuti a pagamento x402 in due modi: tramite il Browser Tool o tramite chiamate HTTP standard.

Integrazione con Browser Tool (Playwright)

Il AgentCore Browser Tool offre all'agente una sessione del browser Chromium headless gestita all'interno del Runtime. AgentCore Il tuo agente si connette WebSocket utilizzando il DevTools protocollo Chrome (CDP), consentendogli di navigare tra le pagine JavaScript, eseguire e intercettare le risposte HTTP a livello di rete. Per iniziare, consulta la guida all'onboarding del browser.

Questa opzione utilizza Strands SDK insieme allo strumento browser e allo strumento di pagamento per navigare nei siti Web ed elaborare i pagamenti. Quando un agente utilizza lo strumento browser per navigare nei siti Web, utilizza le funzionalità di intercettazione delle risposte di Playwright per rilevare automaticamente i siti a pagamento:

  1. Navigazione nel browser: l'agente utilizza browse_with_payment uno strumento fornito da Playwright.

  2. Rilevamento 402 automatico: Playwright intercetta tutte le risposte HTTP e attiva il gestore delle risposte dell'agente per rilevare i codici di stato 402.

  3. Estrazione x402: gli strumenti di pagamento analizzano automaticamente i dettagli di pagamento x402 a partire dalla risposta. headers/body Questo può essere fatto anche dalla logica aziendale degli agenti.

  4. Elaborazione dei AgentCore pagamenti: il processore di pagamento crea firme crittografiche utilizzando portafogli CDP configurati.

  5. Riprova: gli strumenti di pagamento inseriscono le intestazioni di autorizzazione e ritentano la richiesta nella stessa sessione del browser.

from agentcore.payments import PaymentClient
from agentcore.browser import browser_tool

@tool
async def browse_with_payment(url: str, auto_pay: bool = True) -> dict:
    payment_requirements = None

    async def handle_response(response):
        nonlocal payment_requirements
        if response.status == 402:
            payment_requirements = await extract_x402_requirements(response)

    async def add_payment_header(route, request):
        headers = {**request.headers, **payment_result["authorization"]}
        await route.continue_(headers=headers)

    async with async_playwright() as p:
        # 1. Browser setup
        browser = await p.chromium.connect_over_cdp(AGENTCORE_BROWSER_WS_URL)
        page = await browser.contexts[0].new_page()

        # 2. Register response interceptor
        page.on("response", handle_response)

        # 3. Initial navigation (handle_response runs automatically here)
        response = await page.goto(url)

        # 4. Payment processing logic (runs AFTER navigation completes)
        if response.status == 402 and payment_requirements and auto_pay:
            payment_result = payment_client.process_payment(
                payment_session,
                payment_instrument,
                payment_requirements=payment_requirements
            )

            if payment_result["success"]:
                await page.route("**/*", add_payment_header)
                response = await page.goto(url)  # Retry with payment
            else:
                raise PaymentError(f"Payment failed: {payment_result['error_message']}")

        # 5. Capture content, cleanup, and return
        content = await page.content()
        await browser.close()
        return {"content": content, "status": response.status}

Non-browser Integrazione HTTP

Per le chiamate API dirette e gli scenari headless, gli sviluppatori possono scrivere una logica personalizzata degli strumenti utilizzando Strands SDK insieme a una libreria di richieste HTTP standard per elaborare i pagamenti con rilevamento x402:

  1. L'agente utilizza uno strumento personalizzato per effettuare chiamate HTTP dirette.

  2. Lo strumento monitora i codici di stato delle risposte HTTP per rilevare 402.

  3. Lo strumento estrae i requisiti x402 ed elabora i pagamenti.

  4. Lo strumento riprova la richiesta HTTP con le intestazioni di autorizzazione al pagamento.

@tool
async def make_payment(method, url, headers, body) -> dict:
    # Make initial HTTP request
    response = requests.request(method, url, headers=headers, data=body)

    # Check for 402 Payment Required
    if response.status_code == 402:
        payment_requirements = extract_x402_requirements(response)
        payment_result = payment_client.process_payment(
            payment_session,
            payment_instrument,
            payment_requirements=payment_requirements
        )

        if payment_result["success"]:
            # Retry request with payment authorization
            headers.update(payment_result["authorization"])
            response = requests.request(method, url, headers=headers, data=body)
        else:
            raise PaymentError(f"Payment failed: {payment_result['error_message']}")