Preskoči na glavni sadržaj
Hrvatski— Odaberite jezik
Izbornik

Automatiziraj višekoračne radne tokove

Lekcija 9 od 14 Ažurirano 3. studenoga 2026. Programer
Na ovoj stranici
  1. Orkestriranje složenih zadataka
  2. Arhitektura temeljena na koracima
  3. Orkestrator
  4. Prosljeđivanje podataka između koraka
  5. Uvjetni radni tokovi
  6. Paralelizacija
  7. Ključne točke

Lekcija ažurirana 3. studenog 2026. prema smjernicama OpenAI-ja za integraciju računalne upotrebe: agent više ne rukuje prijavom; validacija naredbi i grane koje obvezuju korisnika (recenzije, nove narudžbe) zahtijevaju ljudsku potvrdu; orkestrator sada provjerava kriterij success_text_contains koji je prethodno ignorirao, označava neuspjele korake umjesto da ih preskače i nikada ne ponavlja korak koji stvara podatke. Izvor: Potvrda i pristanak.

Orkestriranje složenih zadataka

Stvarni radni tokovi rijetko se sastoje od jedne radnje. Popunjavanje CRM-a uključuje navigaciju između stranica, pronalaženje kontakta, ažuriranje njegovih podataka, a zatim kreiranje prilike – četiri povezane operacije od kojih svaka može iz vlastitih razloga zatajiti. Predavanje cijelog tog bloka agentu u jednom promptu ponekad funkcionira, ali nikada nećeš znati gdje je došlo do kvara. Ova lekcija uči te kako strukturirati ove višekoračne automatizacije tako da svaka karika bude vidljiva i moguća za ponovno pokretanje.

Arhitektura temeljena na koracima

Započni razbijanjem radnog toka na atomske korake, od kojih svaki ima jasan cilj i kriterij uspjeha. Taj kriterij razlikuje popis obaveza od pravog radnog toka: bez njega tvoj orkestrator ne može utvrditi je li agent zapravo uspio ili se zaustavio na stranici s greškom. U primjeru ispod, otvaranje modula verificira se URL-om, a pretraživanje prisutnošću imena kontakta na zaslonu. Prijava ovdje nije uključena: tvoj kod to je riješio unaprijed, bez izlaganja lozinke modelu (Lekcija 8). Završni korak ima "retry": False jer stvara podatke: njegovo ponavljanje nakon djelomičnog kvara moglo bi stvoriti duplikat.

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
    },
]

Orkestrator

Sada trebaš izvršiti ovaj popis. Orkestrator prolazi kroz korake sekvencijalno, omatajući svaki u petlju za ponovni pokušaj: korak koji podigne iznimku ili ne ispuni svoj kriterij uspjeha pokušava se ponoviti do max_retries puta, osim ako nije označen kao nepovratan. Ovaj detalj je ključan u produkciji jer su mnogi kvarovi vizualnih agenata prolazni – spora stranica, nepotpuno iscrtavanje u trenutku snimanja zaslona. Korak koji konačno ne uspije zaustavlja radni tok jer svi naredni koraci ovise o njemu. Na kraju, orkestrator vraća strukturirani zapis koji za svaki korak navodi njegov status i broj potrošenih pokušaja: tvoj prvi dijagnostički alat.

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

Prosljeđivanje podataka između koraka

Često jedan korak proizvodi podatke potrebne za sljedeći: cijena pročitana na stranici košarice mora se verificirati u koraku plaćanja; broj predmeta kreiran u 2. koraku služi kao referenca u 5. koraku. Dijeljeni kontekst rješava tu potrebu bez pretvaranja tvog koda u zamku globalnih varijabli. Primjer ispod namjerno staje prije plaćanja: OpenAI klasificira potvrdu financijske transakcije kao radnju koja zahtijeva validaciju korisnika u trenutku izvršenja. Donja klasa pohranjuje parove ključ-vrijednost i izlaže metodu inject koja zamjenjuje oznake {ključ} u predlošku prompta, omogućujući ti da svoje zadatke pišeš kao parametrizirane predloške.

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)

Uvjetni radni tokovi

Linearne sekvence brzo dosežu svoja ograničenja jer sljedeći korak može ovisiti o prethodnom rezultatu. Uzorak koji trebaš zapamtiti je ovaj: prvo zatraži od agenta da očita stanje ograničavajući ga da odgovori vrijednošću iz zatvorenog skupa, a zatim granaj u Pythonu. Za praćenje narudžbi status „u obradi“ vodi do praćenja paketa, „isporučeno“ do dohvaćanja datuma isporuke, a „otkazano“ do dohvaćanja razloga. Ograničenja formata u promptu su ključna: bez njih agent vraća rečenicu koju tvoje usporedbe redovito promašuju. Sve tri grane ostaju samo za čitanje: objavljivanje recenzije ili ponovna narudžba obvezali bi korisnika i zahtijevali njegovu potvrdu.

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

Paralelizacija

Kada su zadaci neovisni, nema potrebe za njihovim sekvencijalnim procesuiranjem. Izvlačenje podataka iz tri lista proizvoda traje znatno kraće ako tri agenta rade istovremeno, svaki u svojoj kartici. Playwrightova async verzija i asyncio.gather su dovoljni: jedna korutina po URL-u, jedna new_page po korutini i sustavno zatvaranje stranica kako bi se izbjeglo nakupljanje kartica u memoriji. run_agent_async je petlja iz Lekcije 4 prepisana s klijentom AsyncOpenAI i Playwrightovim async API-jem: ista logika, s await ispred svakog poziva. Imaj na umu da paralelizam također množi propusnost tvojih API poziva, povećavajući rizik od dosezanja ograničenja stope (Lekcija 11), kao i opterećenje ciljne stranice – tri kartice prolaze nezapaženo, pedeset mnogo manje.

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

Ključne točke

  • Razbij radne tokove na atomske korake s eksplicitnim kriterijima uspjeha
  • Automatski ponavljaj korake koje je sigurno ponoviti, nikada one koji stvaraju podatke
  • Koristi dijeljeni kontekst za prosljeđivanje podataka između koraka
  • Uvjetni radni tokovi prilagođavaju se sadržaju stranice; grane koje obvezuju korisnika zahtijevaju njegovu potvrdu
  • Paraleliziraj neovisne zadatke radi uštede vremena