Премини към основното съдържание
Български— Изберете език
Меню

Автоматизиране на многоетапни работни потоци

Урок 9 от 14 Обновен 3 ноември 2026 г. Програмист
На тази страница
  1. Оркестриране на сложни задачи
  2. Архитектура, базирана на стъпки
  3. Оркестраторът
  4. Предаване на данни между стъпките
  5. Условни работни потоци
  6. Паралелизация
  7. Ключови изводи

Урокът е актуализиран на 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))

Ключови изводи

  • Разделяйте работните потоци на атомарни стъпки с изрични критерии за успех
  • Автоматично повтаряйте стъпки, които могат да бъдат изпълнени отново безопасно, но никога тези, които създават данни
  • Използвайте споделен контекст за предаване на данни между стъпките
  • Условните работни потоци се адаптират към съдържанието на страницата; разклоненията, които ангажират потребителя, изискват неговото потвърждение
  • Паралелизирайте независими задачи, за да спестите време