Ir para o conteúdo principal
Português— Escolher um idioma
Menu

Arquitetura: Capturas de ecrã, ações e o ciclo de interação

Aula 2 de 14 Atualizada a 3 de novembro de 2026 Programador
Nesta página
  1. O ciclo perceção-ação
  2. O ponto de partida: a captura de ecrã
  3. Análise e decisão
  4. O repertório de ações
  5. O fluxo completo
  6. O custo de um turno do ciclo
  7. Pontos-chave

Lição reescrita a 3 de novembro de 2026 com base no guia Computer use da OpenAI e nas receitas de integração do Computer use: Este curso baseava-se anteriormente na API da Anthropic (import anthropic, ferramenta computer_20241022). Utiliza agora a ferramenta computer da API Responses da OpenAI, com ações agrupadas num computer_call e capturas de ecrã devolvidas via computer_call_output. Removemos as contagens de tokens e estimativas de duração sem fontes da versão anterior. Fontes: Computer use · Receitas de integração.

O ciclo perceção-ação

Toda a arquitetura do Computer Use resume-se a um único ciclo: observar → decidir → agir → observar. Enquanto este ciclo não estiver claro na sua mente, as suas automações permanecerão erráticas; assim que o compreender, o resto será apenas infraestrutura.

A diferença face a um script Selenium reside no local onde reside o conhecimento. O Selenium executa cegamente uma sequência pré-determinada: clique aqui, depois ali, depois escreva isto. O Computer Use escolhe o próximo passo apenas depois de ver o resultado do anterior. Aparece um pop-up, uma página demora mais a carregar ou o rótulo de um botão muda da noite para o dia: em todos os três casos, o modelo vê a situação real e ajusta-se, enquanto o script continua a recitar no vazio.

Com a ferramenta computer da OpenAI, a troca ocorre em três passos: envia a tarefa, executa as ações que o modelo devolve e, em seguida, reenvia uma captura de ecrã. A sua aplicação controla o rato e o teclado; o modelo apenas toma as decisões.

O ponto de partida: a captura de ecrã

Cada turno baseia-se numa imagem do estado atual do ecrã. Esta captura de ecrã provém de um navegador controlado pelo Playwright — o caso mais comum para automação web —, de um ambiente de trabalho virtual ao automatizar uma aplicação de desktop ou de um contentor Docker que isola o agente. A OpenAI recomenda a utilização de um navegador isolado ou de uma máquina virtual em todos os casos.

import base64

def capture_screen(page) -> str:
    """Capture the screen with Playwright and return the PNG image as base64."""
    return base64.b64encode(page.screenshot()).decode("utf-8")

A captura de ecrã é devolvida ao modelo como um URL de dados PNG. Conta como uma entrada de imagem, pelo que afeta o custo de cada turno: o tamanho da janela que captura é um parâmetro de design real.

Análise e decisão

O modelo recebe a tarefa, o histórico da conversa e a captura de ecrã mais recente. A sua resposta não é uma frase, mas um item computer_call, que transporta uma lista ordenada de ações a executar. Eis um exemplo da documentação da OpenAI que seleciona um campo de pesquisa e depois escreve uma palavra:

{
  "type": "computer_call",
  "call_id": "call_002",
  "actions": [
    { "type": "click", "button": "left", "x": 405, "y": 157 },
    { "type": "type", "text": "penguin" }
  ],
  "status": "completed"
}

Dois detalhes são importantes. A primeira chamada pode conter apenas uma ação screenshot: o modelo está a pedir para ver o ecrã antes de agir, e deve devolver uma captura de ecrã sem alterar nada. Além disso, status: "completed" significa que o modelo terminou de gerar a chamada, não que as ações foram executadas: cabe-lhe a si executá-las.

O repertório de ações

O vocabulário disponível para o modelo é intencionalmente limitado; combinados, estes primitivos cobrem a maior parte do que um humano faz com um rato e um teclado.

AçãoDescriçãoCampos
clickClicar numa posiçãox, y, button (left, right, wheel, back, forward)
double_clickDuplo cliquex, y
dragArrastar ao longo de um caminhopath (lista de pontos)
moveMover o ponteirox, y
scrollDeslocar a vistax, y, scroll_x, scroll_y
keypressTecla ou combinaçãokeys (ex.: ["CTRL", "A"])
typeEscrever textotext
waitAguardar o carregamento da página—
screenshotSolicitar uma nova captura de ecrã—

O fluxo completo

Reunidos, estes elementos criam o seguinte ciclo, modelado na documentação da OpenAI. Enquanto a resposta contiver um computer_call, executa as suas ações, captura o ecrã e devolve a captura de ecrã num computer_call_output que reutiliza o mesmo call_id; o previous_response_id liga cada turno ao anterior.

from openai import OpenAI

client = OpenAI()

def computer_use_loop(page, task: str):
    """Computer Use loop with the computer tool from the Responses API."""
    response = client.responses.create(
        model="gpt-6.1-sol",
        tools=[{"type": "computer"}],
        input=task,
    )

    while True:
        call = next(
            (item for item in response.output if item.type == "computer_call"),
            None,
        )
        if call is None:
            return response.output_text  # no more actions requested: task is done

        execute_actions(page, call.actions)  # your action handler (Lesson 4)
        screenshot = capture_screen(page)

        response = client.responses.create(
            model="gpt-6.1-sol",
            tools=[{"type": "computer"}],
            previous_response_id=response.id,
            input=[{
                "type": "computer_call_output",
                "call_id": call.call_id,
                "output": {
                    "type": "computer_screenshot",
                    "image_url": f"data:image/png;base64,{screenshot}",
                    "detail": "original",
                },
            }],
        )

Este ciclo ainda não tem salvaguardas: em produção, limite o número de turnos, a duração e o custo; pare se uma chamada incluir verificações de segurança pendentes (pending_safety_checks); e verifique o resultado real em vez de confiar apenas na mensagem final do modelo. Estas são as diretrizes de segurança da OpenAI, abordadas na Lição 12.

O custo de um turno do ciclo

Cada pedido à API Responses cobra tokens de entrada e de saída, e cada captura de ecrã conta como uma entrada de imagem; um ambiente alojado pode ser faturado separadamente. O custo de uma tarefa depende, portanto, do número de turnos, do tamanho da captura de ecrã e do modelo — e cresce mais rapidamente do que o número de turnos, porque mesmo com previous_response_id, todos os tokens de entrada das respostas anteriores na cadeia são novamente cobrados como entrada em cada pedido. A OpenAI disponibiliza uma calculadora de custos de imagem e expõe a utilização de cada pedido: meça nos seus próprios fluxos de trabalho antes de definir um orçamento. Um script Selenium fará sempre a mesma coisa de forma mais rápida e barata — mas terá de o reescrever da próxima vez que o formulário mudar, o que o agente não exige.

Pontos-chave

  • O ciclo tarefa → ações → captura de ecrã é o coração do Computer Use; a sua aplicação executa as ações
  • Com a OpenAI, declare a ferramenta com tools=[{"type": "computer"}] na API Responses
  • Um computer_call transporta uma lista ordenada de ações (click, type, scroll, keypress, etc.) a executar em sequência
  • A captura de ecrã é devolvida ao modelo num computer_call_output com o mesmo call_id, encadeado por previous_response_id
  • Cada turno custa tokens e uma imagem: limite os turnos e meça antes de definir um orçamento