Awtomatizza flussi ta' xogħol b'diversi passi
F'din il-paġna
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_containsli 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