:AgentBay: Browser Use

Principais recursos

• Compatibilidade com frameworks de automação: Alta compatibilidade com Playwright e Puppeteer por meio do Chrome DevTools Protocol (CDP).

• Infraestrutura segura e escalável: Sessões gerenciadas, ambientes isolados e alocação elástica de recursos.

• Observabilidade: Reprodução de sessões, inspetor de sessões e modo em tempo real para depuração ao vivo.

• Capacidades avançadas: Gerenciamento de contexto, proxy de IP e opções de stealth/fingerprint.

• PageUseAgent orientado por IA: Executa tarefas complexas de fluxo web usando linguagem natural.

• Operações ricas de API: Fornece interfaces simples para gerenciamento de sessões, controle do ciclo de vida do navegador e operações de proxy.

Pré-requisitos

Antes de começar, certifique-se de ter concluído as etapas a seguir:

• Defina sua chave de API: export AGENTBAY_API_KEY=your_api_key

• Instale as dependências: pip install wuying-agentbay-sdk playwright

• Instale o navegador do Playwright: python -m playwright install chromium

Visão geral

Este exemplo mínimo e executável demonstra como inicializar um navegador com o SDK do AgentBay para Python e controlá-lo com o Playwright via CDP. O código de exemplo executa as seguintes etapas:

1. Crie um cliente AgentBay com sua chave de API para autenticação.

2. Crie uma sessão com CreateSessionParams(image_id="browser_latest") para provisionar um ambiente de execução habilitado para navegador.

3. Inicializa o navegador da sessão usando BrowserOption() para iniciar uma instância remota do navegador.

4. Obtém a URL do endpoint WebSocket CDP com get_endpoint_url() e conecta o Playwright usando connect_over_cdp.

5. Abre uma nova página, acesse um site e interage com o DOM.

6. Exclua a sessão para liberar os recursos alocados.

Código de exemplo

import os
import asyncio
from agentbay import AgentBay
from agentbay.session_params import CreateSessionParams
from agentbay.browser.browser import BrowserOption
from playwright.async_api import async_playwright

async def main():
    api_key = os.getenv("AGENTBAY_API_KEY")
    if not api_key:
        raise RuntimeError("AGENTBAY_API_KEY environment variable not set")

    agent_bay = AgentBay(api_key=api_key)

    # Create a session. Use an image with a browser preinstalled.
    params = CreateSessionParams(image_id="browser_latest")
    session_result = agent_bay.create(params)
    if not session_result.success:
        raise RuntimeError(f"Failed to create session: {session_result.error_message}")

    session = session_result.session

    # Initialize the browser. BrowserOption supports stealth, proxy, fingerprint, and more.
    ok = await session.browser.initialize_async(BrowserOption())
    if not ok:
        raise RuntimeError("Browser initialization failed")

    endpoint_url = session.browser.get_endpoint_url()

    # Connect Playwright over CDP and automate.
    async with async_playwright() as p:
        browser = await p.chromium.connect_over_cdp(endpoint_url)
        page = await browser.new_page()
        await page.goto("https://www.aliyun.com")
        print("Title:", await page.title())
        await browser.close()

    session.delete()

if __name__ == "__main__":
    asyncio.run(main())

Principais APIs do navegador

import os
import asyncio
from agentbay import AgentBay
from agentbay.session_params import CreateSessionParams
from agentbay.browser.browser import BrowserOption, BrowserViewport
from playwright.async_api import async_playwright

CUSTOM_UA = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.0.0 Safari/537.36"

async def main():
    agent_bay = AgentBay(api_key=os.environ["AGENTBAY_API_KEY"])  # Authenticate.

    params = CreateSessionParams(image_id="browser_latest")       # Provision a browser-ready session.
    result = agent_bay.create(params)
    if not result.success:
        raise RuntimeError(result.error_message)

    session = result.session

    # Define the browser's appearance and behavior.
    option = BrowserOption(
        user_agent=CUSTOM_UA,                    # Set a custom identity.
        viewport=BrowserViewport(width=1366, height=768),  # Set a viewport size for a common laptop.
    )

    ok = await session.browser.initialize_async(option)
    if not ok:
        raise RuntimeError("Browser initialization failed")

    endpoint_url = session.browser.get_endpoint_url()      # Get the CDP endpoint.

    async with async_playwright() as p:
        browser = await p.chromium.connect_over_cdp(endpoint_url)  # Connect and take control.
        page = await browser.new_page()

        await page.goto("https://www.whatismybrowser.com/detect/what-is-my-user-agent")
        # Verify the new user agent and viewport size.
        ua = await page.evaluate("navigator.userAgent")
        w = await page.evaluate("window.innerWidth")
        h = await page.evaluate("window.innerHeight")
        print("Effective UA:", ua)
        print("Viewport:", w, "x", h)

        await browser.close()

    session.delete()  # Delete the session to release resources.

if __name__ == "__main__":
    asyncio.run(main())

import os
import asyncio
from agentbay import AgentBay
from agentbay.session_params import CreateSessionParams
from agentbay.browser.browser import BrowserOption
from agentbay.browser.browser_agent import ActOptions
from playwright.async_api import async_playwright

BOOK_QUERY = "The Pragmatic Programmer"

async def main():
    agent_bay = AgentBay(api_key=os.environ["AGENTBAY_API_KEY"])  # Authenticate.

    params = CreateSessionParams(image_id="browser_latest")       # Provision a session with a browser image.
    result = agent_bay.create(params)
    if not result.success:
        raise RuntimeError(result.error_message)
    session = result.session

    # Initialize the remote browser.
    if not await session.browser.initialize_async(BrowserOption()):
        raise RuntimeError("Browser initialization failed")

    endpoint_url = session.browser.get_endpoint_url()

    async with async_playwright() as p:
        browser = await p.chromium.connect_over_cdp(endpoint_url)
        page = await browser.new_page()

        # Navigate to the page.
        await page.goto("https://www.google.com")

        # Ask the agent to type the book name into the search box and submit.
        act_result = await session.browser.agent.act_async(ActOptions(
            action=f"Type '{BOOK_QUERY}' into the search box and submit",
        ), page)
        print("act_result:", act_result.success, act_result.message)

        # Let the agent open the first search result.
        open_first = await session.browser.agent.act_async(ActOptions(
            action="Click the first result in the search results",
        ), page)
        print("open_first:", open_first.success, open_first.message)

        # Pause briefly to observe the result.
        await page.wait_for_timeout(5000)
        await browser.close()

    session.delete()

if __name__ == "__main__":
    asyncio.run(main())

Sobre PageUseAgent.act

• variables interpola valores dinâmicos para permitir prompts reutilizáveis.

• Opera em uma página ativa do Playwright recuperando seu context_id e page_id subjacentes.

• Retorna um ActResult estruturado contendo success e message para facilitar o registro de logs e fluxos de recuperação.

Limitações

O PageUseAgent não inclui um planejador de longo prazo e não orquestra planos de múltiplas etapas por conta própria. Ele depende do chamador ou de um agente de nível superior para dividir um projeto em etapas e chamar act ou outros métodos do PageUseAgent para cada etapa.

A principal vantagem do PageUseAgent reside na execução rápida e consistente de operações web atômicas e precisas, como cliques, preenchimentos e rolagens.

O PageUseAgent prioriza o throughput e a precisão de cada etapa. O planejamento complexo de tarefas e a lógica de ramificação ficam a cargo de um controlador externo.