Автоматизиране на многоетапни работни потоци
На тази страница
Урокът е актуализиран на 3 ноември 2026 г. съгласно насоките на OpenAI за интеграция на Computer Use: агентът вече не обработва влизането в системата; валидирането на команди и разклоненията, които ангажират потребителя (рецензии, нови поръчки), изискват човешко потвърждение; оркестраторът вече проверява критерия
success_text_contains, който преди игнорираше, маркира неуспешните стъпки вместо да ги пропуска и никога не повтаря стъпка, която създава данни. Източник: Потвърждение и съгласие.
Оркестриране на сложни задачи
Реалните работни потоци рядко се състоят от едно единствено действие. Попълването на CRM система включва навигация между страници, намиране на контакт, актуализиране на информацията му и след това създаване на възможност – четири свързани операции, всяка от които може да се провали по свои собствени причини. Предаването на целия този блок на агент с една единствена подкана понякога работи, но никога няма да разберете къде точно се е случил сривът. Този урок Ви учи как да структурирате тези многоетапни автоматизации така, че всяка връзка да бъде наблюдаема и възпроизводима.
Архитектура, базирана на стъпки
Започнете, като разделите работния поток на атомарни стъпки, всяка с ясна цел и критерий за успех. Този критерий е това, което отличава списъка със задачи от истински работен поток: без него Вашият оркестратор не може да разбере дали агентът действително е успял, или е спрял на страница с грешка. В примера по-долу отварянето на модула се проверява чрез URL адреса, а търсенето – чрез наличието на името на контакта на екрана. Влизането не е включено тук: Вашият код се е справил с това предварително, без да излага паролата на модела (Урок 8). Последната стъпка има "retry": False, защото създава данни: повторното ѝ изпълнение след частичен неуспех би могло да създаде дубликат.
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
},
]
Оркестраторът
Сега трябва да изпълните този списък. Оркестраторът преминава последователно през стъпките, обгръщайки всяка от тях в цикъл за повторен опит: стъпка, която предизвиква изключение или не отговаря на критерия си за успех, се опитва отново до max_retries пъти, освен ако не е маркирана като невъзпроизводима. Този детайл е важен в производствена среда, защото много неуспехи на визуалните агенти са преходни – бавна страница, непълно изобразяване в момента на скрийншота. Стъпка, която се провали окончателно, спира работния поток, тъй като следващите стъпки зависят от нея. Накрая, оркестраторът връща структуриран дневник, показващ за всяка стъпка нейния статус и броя на използваните опити: Вашият първи диагностичен инструмент.
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
Предаване на данни между стъпките
Често една стъпка произвежда данни, необходими за следващата: цената, прочетена на страницата на количката, трябва да бъде проверена при стъпката за плащане; номерът на случая, създаден в стъпка 2, служи като референция в стъпка 5. Споделен контекст решава тази нужда, без да превръща кода Ви в клубко от глобални променливи. Примерът по-долу умишлено спира преди плащането: OpenAI класифицира потвърждаването на финансова транзакция като действие, изискващо валидиране от потребителя в момента на изпълнение. Класът по-долу съхранява двойки ключ-стойност и излага метод inject, който замества маркерите {key} в шаблон на подкана, позволявайки Ви да пишете задачите си като параметризирани шаблони.
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)
Условни работни потоци
Линейните последователности бързо достигат своите граници, защото следващата стъпка може да зависи от предишния резултат. Моделът, който трябва да запомните, е следният: първо поискайте от агента да прочете състояние, като го ограничите да отговори със стойност от затворено множество, след което направете разклонение в Python. За проследяване на поръчки статус „в обработка“ води до проследяване на пратката, „доставен“ – до извличане на датата на доставка, „отменен“ – до извличане на причината. Ограниченията за форматиране в подканата са от съществено значение: без тях агентът връща изречение, което Вашите сравнения редовно ще пропускат. И трите разклонения остават само за четене: публикуването на рецензия или повторното поръчване би ангажирало потребителя и би изисквало неговото потвърждение.
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}")
Паралелизация
Когато задачите са независими, няма нужда да ги обработвате последователно. Извличането на данни от три листа с продукти отнема много по-малко време, ако три агента работят едновременно, всеки в свой собствен раздел. Асинхронната версия на Playwright и asyncio.gather са достатъчни: една корутина за URL адрес, един new_page за корутина и систематично затваряне на страницата, за да се избегне натрупването на раздели в паметта. run_agent_async е цикълът от Урок 4, пренаписан с клиента AsyncOpenAI и асинхронния API на Playwright: същата логика, с await преди всяко извикване. Имайте предвид, че паралелизмът също умножава пропускателната способност на Вашите API извиквания, увеличавайки риска да достигнете лимитите си за честота (Урок 11), както и натоварването върху целевия сайт – три раздела остават незабелязани, петдесет – много по-малко.
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))
Ключови изводи
- Разделяйте работните потоци на атомарни стъпки с изрични критерии за успех
- Автоматично повтаряйте стъпки, които могат да бъдат изпълнени отново безопасно, но никога тези, които създават данни
- Използвайте споделен контекст за предаване на данни между стъпките
- Условните работни потоци се адаптират към съдържанието на страницата; разклоненията, които ангажират потребителя, изискват неговото потвърждение
- Паралелизирайте независими задачи, за да спестите време