Aqbeż għall-kontenut ewlieni
Malti— Agħżel lingwa
Menu

Awtomatizza flussi ta' xogħol b'diversi passi

Lezzjoni 9 / 14 Aġġornat 3 ta’ Novembru 2026 Zviluppatur
F'din il-paġna
  1. Orkestrazzjoni ta’ kompiti kumplessi
  2. Arkitettura bbażata fuq il-passi
  3. L-orkestratur
  4. Trasferiment ta’ data bejn il-passi
  5. Flussi ta’ xogħol kondizzjonali
  6. Parallelizzazzjoni
  7. Punti Ewlenin

Lezzjoni aġġornata fit-3 ta’ Novembru 2026 skont il-linji gwida ta’ OpenAI għall-integrazzjoni tal-Użu tal-Kompjuter: l-aġent ma jimmaniġġjax il-login; il-validazzjoni tal-kmandi u l-friegħi li jimpjegaw lill-utent (reviżjonijiet, ordnijiet ġodda) jeħtieġu konferma umana; l-orkestratur issa jiċċekkja l-kriterju success_text_contains li kien jinjora qabel, jimmarka l-passi falluti minflok ma jaqbiżhom, u qatt ma jerġa’ jdoqq pass li joħloq data. Sors: Confirmation and consent.

Orkestrazzjoni ta’ kompiti kumplessi

Il-flussi ta’ xogħol fid-dinja reali rari jikkonsistu f’azzjoni waħda. Biex timla CRM, trid tnaviga bejn il-paġni, issib kuntatt, taġġorna l-informazzjoni tiegħu, u mbagħad toħloq opportunità—erba’ operazzjonijiet imqabbda, li kull wieħed minnhom jista’ jfalli għal raġunijiet differenti. Li tagħti dan il-blokk kollu lil aġent f’prompt wieħed taħdem xi kultant, iżda qatt ma tkun taf fejn seħħ il-ħsara. Din il-lezzjoni tgħallmek kif tistruttura dawn l-awtomatizzazzjonijiet b’diversi passi sabiex kull rabta tkun osservabbli u tista’ terġa’ tiġi eżegwita.

Arkitettura bbażata fuq il-passi

Ibda billi taqsam il-fluss ta’ xogħol f’passi atomiċi, kull wieħed b’objettiv ċar u kriterju ta’ suċċess. Dan il-kriterju huwa dak li jiddistingwi lista ta’ kompiti minn fluss ta’ xogħol veru: mingħajru, l-orkestratur tiegħek ma jistax jgħid jekk l-aġent irnexxielux verament jew jekk waqafx fuq paġna ta’ żball. Fl-eżempju hawn taħt, il-ftuħ tal-modulu jiġi vverifikat mill-URL, u t-tfittxija mill-preżenza tal-isem tal-kuntatt fuq l-iskrin. Il-login mhuwiex inkluż hawn: il-kodiċi tiegħek immaniġġja dan qabel, mingħajr ma esponiet il-password lill-mudell (Lezzjoni 8). L-aħħar pass għandu "retry": False għax joħloq data: li terġa’ tdoqqu wara falliment parzjali jista’ joħloq 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
    },
]

L-orkestratur

Issa trid tesegwixxi din il-lista. L-orkestratur jgħaddi mill-passi sekwenzjalment, u jpoġġi kull wieħed f’loop ta’ retry: pass li jqajjem eċċezzjoni jew ifalli l-kriterju ta’ suċċess tiegħu jiġi ppruvat mill-ġdid sa max_retries darbiet, sakemm ma jkunx immarkat bħala mhux riproducibbli. Dan id-dettall huwa importanti fil-produzzjoni, għax ħafna fallimenti ta’ aġenti viżwali huma tranżitorji—paġna bil-mod, rendering mhux komplut fil-ħin tas-screenshot. Pass li jfalli b’mod definittiv iwaqqaf il-fluss ta’ xogħol, peress li l-passi sussegwenti jiddependu fuqu. Fl-aħħar nett, l-orkestratur jirritorna log strutturat li jindika, għal kull pass, l-istatus tiegħu u n-numru ta’ tentattivi użati: l-ewwel għodda dijanjostika tiegħek.

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

Trasferiment ta’ data bejn il-passi

Spiss, pass wieħed jipproduċi data meħtieġa għall-pass li jmiss: il-prezz moqri fuq paġna tal-karrett għandu jiġi vverifikat fil-pass tal-ħlas; in-numru tal-każ maħluq fil-pass 2 jservi bħala referenza fil-pass 5. Kuntest kondiviż isolvi din il-ħtieġa mingħajr ma jħawwad il-kodiċi tiegħek f’taqbida ta’ varjabbli globali. L-eżempju hawn taħt jieqaf intenzjonalment qabel il-ħlas: OpenAI tikklassifika l-konferma ta’ tranżazzjoni finanzjarja bħala azzjoni li teħtieġ validazzjoni mill-utent fil-mument tal-eżekuzzjoni. Il-klassi hawn taħt taħżen pari key-value u tesponi metodu inject li jissostitwixxi l-markaturi {key} f’mudell ta’ prompt, u jħallik tikteb il-kompiti tiegħek bħala mudelli parametrizzati.

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)

Flussi ta’ xogħol kondizzjonali

Is-sekwenzi lineari malajr jilħqu l-limiti tagħhom, għax il-pass li jmiss jista’ jiddependi mir-riżultat ta’ qablu. Il-mudell li għandek iżżomm f’moħħok huwa dan: l-ewwel itlob lill-aġent jaqra stat billi tillimitah biex iwieġeb b’valur minn sett magħluq, imbagħad agħmel branching f’Python. Għat-traċċar tal-ordnijiet, status ta’ “processing” iwassal għat-traċċar tal-pakkett, “delivered” għall-irkupru tad-data tal-konsenja, u “canceled” għall-irkupru tar-raġuni. Ir-restrizzjonijiet tal-format fil-prompt huma essenzjali: mingħajrhom, l-aġent jirritorna sentenza li l-komparazzjonijiet tiegħek regolarment se jitilfu. It-tliet friegħi jibqgħu read-only: li tippubblika reviżjoni jew terġa’ tordna jimpjega lill-utent u jeħtieġ il-konferma tiegħu.

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

Parallelizzazzjoni

Meta l-kompiti huma indipendenti, m’hemmx bżonn li tipproċessahom sekwenzjalment. L-estrazzjoni tad-data minn tliet skedi tal-prodotti tieħu ħafna inqas ħin jekk tliet aġenti jaħdmu simultanjament, kull wieħed fit-tab tiegħu stess. Il-verżjoni asinkrona ta’ Playwright u asyncio.gather huma biżżejjed: coroutine waħda għal kull URL, new_page waħda għal kull coroutine, u għeluq sistematiku tal-paġna biex tevita li takkumula tabs fil-memorja. run_agent_async huwa l-loop mil-Lezzjoni 4 miktub mill-ġdid bil-klijent AsyncOpenAI u l-API asinkrona ta’ Playwright: l-istess loġika, b’await qabel kull sejħa. Żomm f’moħħok li l-parallelizmu jimmultiplika wkoll it-throughput tas-sejħiet tal-API tiegħek, u jżid ir-riskju li tilħaq il-limiti tar-rata tiegħek (Lezzjoni 11), u t-tagħbija tiegħek fuq is-sit fil-mira—tliet tabs jgħaddu inosservati, ħamsin ferm inqas.

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

Punti Ewlenin

  • Aqsam il-flussi ta’ xogħol f’passi atomiċi b’kriterji ta’ suċċess espliċiti
  • Erġa’ doqq awtomatikament il-passi li jistgħu jiġu ppruvati mill-ġdid b’mod sikur, qatt dawk li joħolqu data
  • Uża kuntest kondiviż biex tgħaddi d-data bejn il-passi
  • Il-flussi ta’ xogħol kondizzjonali jadattaw għall-kontenut tal-paġna; il-friegħi li jimpjegaw lill-utent jeħtieġu l-konferma tiegħu
  • Ipparallelizza kompiti indipendenti biex tiffranka l-ħin