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

Automatizar fluxos de trabalho em várias etapas

Aula 9 de 14 Atualizada a 3 de novembro de 2026 Programador
Nesta página
  1. Orquestração de tarefas complexas
  2. Arquitetura baseada em etapas
  3. O orquestrador
  4. Transferência de dados entre etapas
  5. Fluxos de trabalho condicionais
  6. Paralelização
  7. Pontos-chave

Lição atualizada em 3 de novembro de 2026 de acordo com as diretrizes de integração do Computer Use da OpenAI: o agente já não gere o início de sessão; a validação de comandos e os ramos que comprometem o utilizador (avaliações, novas encomendas) exigem confirmação humana; o orquestrador verifica agora o critério success_text_contains, que anteriormente ignorava, sinaliza as etapas falhadas em vez de as ignorar e nunca repete uma etapa que crie dados. Fonte: Confirmação e consentimento.

Orquestração de tarefas complexas

Os fluxos de trabalho reais raramente consistem numa única ação. Preencher um CRM envolve navegar entre páginas, localizar um contacto, atualizar as suas informações e, em seguida, criar uma oportunidade — quatro operações encadeadas, cada uma das quais pode falhar por razões próprias. Entregar todo este bloco a um agente num único prompt funciona por vezes, mas nunca saberá onde é que falhou. Esta lição ensina-o a estruturar estas automações em várias etapas para que cada elo seja observável e repetível.

Arquitetura baseada em etapas

Comece por dividir o fluxo de trabalho em etapas atómicas, cada uma com um objetivo claro e um critério de sucesso. Este critério é o que distingue uma lista de tarefas de um verdadeiro fluxo de trabalho: sem ele, o seu orquestrador não consegue distinguir se o agente teve sucesso ou se parou numa página de erro. No exemplo abaixo, a abertura do módulo é verificada pelo URL e a pesquisa pela presença do nome do contacto no ecrã. O início de sessão não está incluído aqui: o seu código tratou disso previamente, sem expor a palavra-passe ao modelo (Lição 8). A etapa final tem "retry": False porque cria dados: repeti-la após uma falha parcial poderia criar um duplicado.

workflow = [
    {
        "name": "open_contacts",
        "task": "Open the Contacts module in the CRM.",
        "success_url_contains": "/contacts",
    },
    {
        "name": "search_contact",
        "task": "Search for contact 'Jean Dupont' in the search bar.",
        "success_text_contains": "Jean Dupont",
    },
    {
        "name": "update_record",
        "task": "Open Jean Dupont's profile and update their phone number: 06 98 76 54 32.",
    },
    {
        "name": "create_opportunity",
        "task": "Create an opportunity: 'Cloud Migration Q2 2026', amount 50000 EUR, probability 60%.",
        "retry": False,  # non-replayable step: creates data
    },
]

O orquestrador

Agora precisa de executar esta lista. O orquestrador percorre as etapas sequencialmente, envolvendo cada uma num ciclo de nova tentativa: uma etapa que levante uma exceção ou falhe o seu critério de sucesso é repetida até max_retries vezes, a menos que esteja marcada como não repetível. Este detalhe é crucial em produção, pois muitas falhas de agentes visuais são transitórias — uma página lenta, uma renderização incompleta no momento da captura de ecrã. Uma etapa que falhe definitivamente interrompe o fluxo de trabalho, uma vez que as etapas subsequentes dependem dela. Por fim, o orquestrador devolve um registo estruturado indicando, para cada etapa, o seu estado e o número de tentativas consumidas: a sua primeira ferramenta de diagnóstico.

def run_workflow(workflow: list, page, max_retries: int = 2):
    """Executes a multi-step workflow with retries."""
    results = []

    for step in workflow:
        step_name = step["name"]
        print(f"\n--- Step: {step_name} ---")
        attempts = max_retries + 1 if step.get("retry", True) else 1
        error = "success criterion not met"

        for attempt in range(attempts):
            try:
                run_agent(step["task"], page=page)

                # Optional checks: URL, then visible text
                url_check = step.get("success_url_contains")
                if url_check and url_check not in page.url:
                    print("  Expected URL not found")
                    continue
                text_check = step.get("success_text_contains")
                if text_check and text_check not in page.locator("body").inner_text():
                    print("  Expected text not found")
                    continue

                print(f"  Success (attempt {attempt + 1})")
                results.append({"step": step_name, "status": "success", "attempts": attempt + 1})
                break

            except Exception as e:
                print(f"  Error: {e}")
                error = str(e)
        else:
            # No attempt succeeded: subsequent steps depend on this one
            results.append({"step": step_name, "status": "failed", "error": error})
            break

    return results

Transferência de dados entre etapas

Muitas vezes, uma etapa produz dados necessários para a seguinte: o preço lido numa página do carrinho deve ser verificado na etapa de pagamento; o número do processo criado na etapa 2 serve de referência na etapa 5. Um contexto partilhado resolve esta necessidade sem transformar o seu código numa emaranhado de variáveis globais. O exemplo abaixo para intencionalmente antes do pagamento: a OpenAI classifica a confirmação de uma transação financeira como uma ação que requer validação do utilizador no momento da execução. A classe abaixo armazena pares chave-valor e expõe um método inject que substitui marcadores {key} num modelo de prompt, permitindo-lhe escrever as suas tarefas como modelos parametrizados.

class WorkflowContext:
    """Stores data shared between steps."""

    def __init__(self):
        self.data = {}

    def set(self, key: str, value):
        self.data[key] = value

    def get(self, key: str, default=None):
        return self.data.get(key, default)

    def inject(self, template: str) -> str:
        """Replaces {key} variables in the template."""
        task = template
        for key, value in self.data.items():
            task = task.replace("{" + key + "}", str(value))
        return task


# Usage example
ctx = WorkflowContext()

# Step 1: agent reads a price
extracted_price = run_agent(
    "Read the total price displayed and return only the number.",
    page=page
)
ctx.set("price", extracted_price.strip())

# Step 2: agent verifies, without validating anything
verdict = run_agent(ctx.inject(
    "The expected amount is {price} EUR. Compare it to the total on the payment page "
    "and answer only OK or MISMATCH. Do not validate anything."
), page=page)

# Step 3: a transaction is confirmed at the moment of action, by a human
if verdict.strip() == "OK":
    if input(f"Confirm order for {ctx.get('price')} EUR? [y/N] ").strip().lower() == "y":
        run_agent("Click the order confirmation button.", page=page)

Fluxos de trabalho condicionais

As sequências lineares rapidamente atingem os seus limites, pois a etapa seguinte pode depender do resultado anterior. O padrão a reter é este: peça primeiro ao agente que leia um estado, restringindo-o a responder com um valor de um conjunto fechado, e depois faça a ramificação em Python. Para o acompanhamento de encomendas, um estado «em processamento» leva ao rastreio da encomenda, «entregue» à obtenção da data de entrega e «cancelado» à obtenção do motivo. As restrições de formato no prompt são essenciais: sem elas, o agente devolve uma frase que as suas comparações irão regularmente falhar. Todos os três ramos permanecem apenas de leitura: publicar uma avaliação ou fazer uma nova encomenda comprometeria o utilizador e exigiria a sua confirmação.

def conditional_workflow(page):
    """Workflow with conditional branching."""
    # Step 1: Read status
    status = run_agent(
        "Read the order status. "
        "Return only: processing, delivered, or canceled.",
        page=page
    )

    # Branch based on result
    match status.strip().lower():
        case "processing":
            return run_agent("Click 'Track package' and note the displayed stage.", page=page)
        case "delivered":
            return run_agent("Note the displayed delivery date.", page=page)
        case "canceled":
            return run_agent("Note the displayed cancellation reason.", page=page)
        case _:
            raise ValueError(f"Unexpected status: {status!r}")

Paralelização

Quando as tarefas são independentes, não há necessidade de as processar sequencialmente. Extrair dados de três fichas de produto demora muito menos tempo se três agentes trabalharem simultaneamente, cada um no seu próprio separador. A versão assíncrona do Playwright e o asyncio.gather são suficientes: uma corrotina por URL, um new_page por corrotina e o fecho sistemático da página para evitar acumular separadores na memória. run_agent_async é o ciclo da Lição 4 reescrito com o cliente AsyncOpenAI e a API assíncrona do Playwright: a mesma lógica, com await antes de cada chamada. Tenha em mente que o paralelismo também multiplica o volume das suas chamadas à API, aumentando o risco de atingir os seus limites de taxa (Lição 11), e a carga sobre o site de destino — três separadores passam despercebidos, cinquenta muito menos.

import asyncio
from playwright.async_api import async_playwright

async def parallel_extraction(urls: list[str]):
    """Extracts data from multiple pages in parallel."""
    async with async_playwright() as pw:
        browser = await pw.chromium.launch(headless=True)

        async def extract_one(url: str):
            page = await browser.new_page(
                viewport={"width": 1280, "height": 720}
            )
            try:
                await page.goto(url)
                result = await run_agent_async(
                    "Extract the product title and price.", page=page
                )
            finally:
                await page.close()
            return {"url": url, "data": result}

        results = await asyncio.gather(
            *[extract_one(url) for url in urls]
        )

    return results

# Run
urls = [
    "https://shop.example.com/product/1",
    "https://shop.example.com/product/2",
    "https://shop.example.com/product/3",
]
data = asyncio.run(parallel_extraction(urls))

Pontos-chave

  • Divida os fluxos de trabalho em etapas atómicas com critérios de sucesso explícitos
  • Repita automaticamente as etapas que podem ser repetidas com segurança, nunca as que criam dados
  • Utilize um contexto partilhado para transferir dados entre etapas
  • Os fluxos de trabalho condicionais adaptam-se ao conteúdo da página; os ramos que comprometem o utilizador exigem a sua confirmação
  • Paralelize tarefas independentes para poupar tempo