Automatizarea fluxurilor de lucru în mai mulți pași
Pe această pagină
Lecție actualizată la 3 noiembrie 2026 conform ghidurilor de integrare Computer Use de la OpenAI: agentul nu mai gestionează autentificarea; validarea comenzilor și ramurile care angajează utilizatorul (recenzii, comenzi noi) necesită confirmare umană; orchestratorul verifică acum criteriul
success_text_contains, ignorat anterior, semnalează pașii eșuați în loc să îi sară și nu reia niciodată un pas care creează date. Sursă: Confirmation and consent.
Orchestarea sarcinilor complexe
Fluxurile de lucru din lumea reală rareori constau într-o singură acțiune. Popularea unui CRM implică navigarea între pagini, găsirea unui contact, actualizarea informațiilor acestuia și apoi crearea unei oportunități – patru operațiuni înlănțuite, fiecare putând eșua din motive proprii. Încredințarea întregului bloc unui agent într-un singur prompt funcționează uneori, dar nu veți ști niciodată unde s-a produs defecțiunea. Această lecție vă învață să structurați aceste automatizări în mai mulți pași astfel încât fiecare verigă să fie observabilă și reexecutabilă.
Arhitectură bazată pe pași
Începeți prin a descompune fluxul de lucru în pași atomici, fiecare având un obiectiv clar și un criteriu de succes. Acest criteriu este ceea ce distinge o listă de sarcini de un flux de lucru real: fără el, orchestratorul nu poate spune dacă agentul a reușit efectiv sau s-a oprit pe o pagină de eroare. În exemplul de mai jos, deschiderea modulului este verificată prin URL, iar căutarea prin prezența numelui contactului pe ecran. Autentificarea nu este inclusă aici: codul dumneavoastră a gestionat acest lucru anterior, fără a expune parola modelului (Lecția 8). Pasul final are "retry": False deoarece creează date: reexecutarea acestuia după un eșec parțial ar putea crea un duplicat.
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
},
]
Orchestratorul
Acum trebuie să executați această listă. Orchestratorul parcurge pașii secvențial, încadrând fiecare într-o buclă de reîncercare: un pas care generează o excepție sau nu își îndeplinește criteriul de succes este reîncercat de până la max_retries ori, cu excepția cazului în care este marcat ca nereexecutabil. Acest detaliu contează în producție, deoarece multe eșecuri ale agenților vizuali sunt tranzitorii – o pagină lentă, o randare incompletă la momentul capturii de ecran. Un pas care eșuează definitiv oprește fluxul de lucru, deoarece pașii următori depind de el. În final, orchestratorul returnează un jurnal structurat indicând, pentru fiecare pas, statutul său și numărul de încercări consumate: primul dumneavoastră instrument de diagnostic.
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
Transmiterea datelor între pași
Adesea, un pas produce date necesare pasului următor: prețul citit pe o pagină de coș trebuie verificat la pasul de plată; numărul dosarului creat în pasul 2 servește ca referință în pasul 5. Un context partajat rezolvă această nevoie fără a transforma codul dumneavoastră într-un haos de variabile globale. Exemplul de mai jos se oprește intenționat înainte de plată: OpenAI clasifică confirmarea unei tranzacții financiare ca o acțiune care necesită validarea utilizatorului în momentul execuției. Clasa de mai jos stochează perechi cheie-valoare și expune o metodă inject care înlocuiește markerii {key} într-un șablon de prompt, permițându-vă să scrieți sarcinile ca șabloane parametrizate.
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)
Fluxuri de lucru condiționale
Secvențele liniare își ating rapid limitele, deoarece pasul următor poate depinde de rezultatul anterior. Modelul de reținut este acesta: cereți mai întâi agentului să citească o stare, constrângându-l să răspundă cu o valoare dintr-un set închis, apoi realizați ramificarea în Python. Pentru urmărirea comenzilor, un statut „în procesare“ duce la urmărirea pachetului, „livrat“ la obținerea datei de livrare, „anulat“ la obținerea motivului. Constrângerile de format din prompt sunt esențiale: fără ele, agentul returnează o propoziție pe care comparațiile dumneavoastră o vor rata regulat. Toate cele trei ramuri rămân doar pentru citire: postarea unei recenzii sau re-comandarea ar angaja utilizatorul și ar necesita confirmarea acestuia.
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}")
Paralelizare
Când sarcinile sunt independente, nu este nevoie să le procesați secvențial. Extracția datelor din trei fișe de produs durează mult mai puțin timp dacă trei agenți lucrează simultan, fiecare în propria sa filă. Versiunea async a Playwright și asyncio.gather sunt suficiente: o corutină per URL, un new_page per corutină și închiderea sistematică a paginii pentru a evita acumularea filelor în memorie. run_agent_async este bucla din Lecția 4 rescrisă cu clientul AsyncOpenAI și API-ul async al Playwright: aceeași logică, cu await înainte de fiecare apel. Rețineți că paralelismul multiplică, de asemenea, throughput-ul apelurilor API, crescând riscul de a atinge limitele de rată (Lecția 11) și încărcarea pe site-ul țintă – trei file trec neobservate, cincizeci mult mai puțin.
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))
Puncte cheie
- Descompuneți fluxurile de lucru în pași atomici cu criterii de succes explicite
- Reexecutați automat pașii care pot fi reîncercați în siguranță, niciodată pe cei care creează date
- Utilizați un context partajat pentru a transmite date între pași
- Fluxurile de lucru condiționale se adaptează conținutului paginii; ramurile care angajează utilizatorul necesită confirmarea acestuia
- Paralelizați sarcinile independente pentru a economisi timp