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

Първи работен поток: навигация и взаимодействие

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

Урокът е пренаписан на 3 ноември 2026 г. въз основа на ръководството на OpenAI за Computer use и рецептите за интеграция на Computer use: агентът използва инструмента computer от Responses API, обработчик на действия, моделиран според документацията (групирани действия, keypress, scroll_x/scroll_y, пътища за drag), и верижно свързване чрез previous_response_id, заменяйки код, написан за API на Anthropic. Източници: Computer use · Integration recipes.

Сглобяване на частите

Вече имате цикъла в ума си и средата е конфигурирана. Сега трябва да ги обедините в работеща програма: агент, който отваря онлайн енциклопедия, търси термин, отваря първия резултат и докладва заглавието на страницата, до която е достигнал. Сценарият изглежда скромен, но той ангажира фундаменталните жестове – навигация, писане, кликване, четене на информация – и всичко, което ще построите след това, ще бъде просто по-дълга вариация на това.

Обработчикът на действия

Моделът взема решения, но не изпълнява нищо сам: той връща списък с действия, а Вашият код ги превръща в жестове на Playwright, последователно. Тази функция следва обработчика, публикуван от OpenAI в неговите рецепти за интеграция, опростен за браузър.

import time

KEYS = {
    "ENTER": "Enter", "RETURN": "Enter", "ESC": "Escape", "ESCAPE": "Escape",
    "TAB": "Tab", "SPACE": "Space", "BACKSPACE": "Backspace", "DELETE": "Delete",
    "UP": "ArrowUp", "DOWN": "ArrowDown", "LEFT": "ArrowLeft", "RIGHT": "ArrowRight",
    "CTRL": "Control", "CONTROL": "Control", "SHIFT": "Shift", "ALT": "Alt",
    "CMD": "Meta", "META": "Meta",
}
BUTTONS = {"left": "left", "right": "right", "wheel": "middle"}

def execute_actions(page, actions):
    """Executes the actions from a computer_call in order."""
    for action in actions:
        if action.type in ("click", "double_click", "drag", "move", "scroll") and getattr(action, "keys", None):
            raise ValueError("Mouse action with modifier key: not handled here")
        match action.type:
            case "click":
                button = getattr(action, "button", "left")
                if button not in BUTTONS:  # back and forward don't exist in Playwright
                    raise ValueError(f"Unsupported button: {button}")
                page.mouse.click(action.x, action.y, button=BUTTONS[button])
            case "double_click":
                page.mouse.dblclick(action.x, action.y)
            case "drag":
                points = [(p.x, p.y) for p in action.path]
                page.mouse.move(*points[0])
                page.mouse.down()
                for x, y in points[1:]:
                    page.mouse.move(x, y)
                page.mouse.up()
            case "move":
                page.mouse.move(action.x, action.y)
            case "scroll":
                page.mouse.move(action.x, action.y)
                page.mouse.wheel(action.scroll_x, action.scroll_y)
            case "keypress":
                page.keyboard.press("+".join(KEYS.get(k, k) for k in action.keys))
            case "type":
                page.keyboard.type(action.text)
            case "wait":
                time.sleep(2)
            case "screenshot":
                continue  # screenshot is taken after each batch of actions
            case _:
                raise ValueError(f"Unsupported action: {action.type}")

Два избора заслужават обяснение. Имената на клавишите и бутоните, върнати от модела (ENTER, CTRL, wheel…), не са това, което Playwright очаква (Enter, Control, middle…): таблиците за съпоставка, взети от документацията, запълват празнотата, а бутоните back и forward, които API също може да поиска, се отхвърлят, както е в обработчика на OpenAI. И непознато действие поражда грешка, вместо да бъде игнорирано мълчаливо: рязкото спиране е по-добро от агент, който си мисли, че е действал, когато не го е направил.

Пълният цикъл

След това агентът оркестрира цикъла. Първото извикване изпраща задачата; ако то съдържа само заявка за екранна снимка, просто връщате екрана. Всяка екранна снимка се връща към модела като резултат от извикването, което я е поискало, реферирана чрез нейния call_id, а previous_response_id свързва завъртанията заедно.

import base64

from openai import OpenAI
from playwright.sync_api import sync_playwright

client = OpenAI()
MODEL = "gpt-6.1-sol"
MAX_TURNS = 15

def launch_agent(task: str, start_url: str = "https://en.wikipedia.org"):
    """Launches a Computer Use agent on a given task."""
    pw = sync_playwright().start()
    browser = pw.chromium.launch(headless=False)  # False to observe
    page = browser.new_page(viewport={"width": 1280, "height": 720})
    page.goto(start_url)
    page.wait_for_load_state("networkidle")

    try:
        response = client.responses.create(
            model=MODEL, tools=[{"type": "computer"}], input=task,
        )
        for turn in range(MAX_TURNS):
            call = next((i for i in response.output if i.type == "computer_call"), None)
            if call is None:
                print(f"Task complete: {response.output_text}")
                return response.output_text

            if call.pending_safety_checks:  # see lesson 12
                raise RuntimeError("Pending safety checks: human intervention required")
            for action in call.actions:
                print(f"  Action: {action.type}")
            execute_actions(page, call.actions)
            screenshot = base64.b64encode(page.screenshot()).decode("utf-8")

            response = client.responses.create(
                model=MODEL,
                tools=[{"type": "computer"}],
                previous_response_id=response.id,
                input=[{
                    "type": "computer_call_output",
                    "call_id": call.call_id,
                    "output": {
                        "type": "computer_screenshot",
                        "image_url": f"data:image/png;base64,{screenshot}",
                        "detail": "original",
                    },
                }],
            )
        raise RuntimeError("Maximum number of turns reached: check the page state")
    finally:
        browser.close()
        pw.stop()

Три предпазни мерки вече са налице. MAX_TURNS ограничава цикъла: без този лимит, дезориентиран агент би изразходвал бюджета Ви до изтощение. Извикване с чакащи проверки за сигурност (pending_safety_checks) спира всичко, както в официалния пример на OpenAI: урок 12 показва как те да бъдат валидирани от човек. И нормалното приключване се сигнализира от липсата на computer_call: моделът е спрял да действа и Ви отговаря, а Вие извличате заглавието на страницата от output_text.

Стартиране на работния поток

if __name__ == "__main__":
    launch_agent(
        "Search for 'Computer Use' in Wikipedia's search engine, "
        "open the first result, and give me the title of the page. "
        "Use the computer tool to act on the interface."
    )

С headless=False, шоуто е поучително: прозорецът се отваря, кликът попада в полето за търсене, текстът се появява, първата връзка се отваря и заглавието се връща във Вашата конзола. Наблюдавайте го да работи два или три пъти, преди да преминете към по-амбициозни задачи; ще видите точно къде агентът се колебае и какво трябва да адресират Вашите инструкции.

Многократна функция за остатъка от курса

Следващите уроци работят върху вече отворена страница – след влизане в системата, по средата на работен поток. Те разчитат на run_agent(task, page=page): същият цикъл, извлечен от launch_agent, с опционални instructions, връщани при всяко завъртане (урок 5 обяснява защо).

def run_agent(task: str, page, instructions: str | None = None, max_turns: int = MAX_TURNS) -> str:
    """Computer Use loop on an already-open page; returns the final message."""
    request = {"model": MODEL, "tools": [{"type": "computer"}]}
    if instructions:
        request["instructions"] = instructions  # to be returned on each request

    response = client.responses.create(**request, input=task)
    for turn in range(max_turns):
        call = next((i for i in response.output if i.type == "computer_call"), None)
        if call is None:
            return response.output_text
        if call.pending_safety_checks:
            raise RuntimeError("Pending safety checks: human intervention required")

        execute_actions(page, call.actions)
        screenshot = base64.b64encode(page.screenshot()).decode("utf-8")
        response = client.responses.create(
            **request,
            previous_response_id=response.id,
            input=[{
                "type": "computer_call_output",
                "call_id": call.call_id,
                "output": {
                    "type": "computer_screenshot",
                    "image_url": f"data:image/png;base64,{screenshot}",
                    "detail": "original",
                },
            }],
        )
    raise RuntimeError("Maximum number of turns reached: check the page state")

Три неуспеха, с които ще се сблъскате

Агентът систематично ли кликва до целта си? Виновникът почти винаги е несъответствие в мащаба между изпратената екранна снимка и страницата, върху която кликвате: преоразмерена снимка, мащабиране на браузъра, екран с висока плътност. Координатите на модела се отнасят до изображението, което е получил; ако го смалявате, конвертирайте неговите координати в обратната посока.

Агентът дали се върти в кръг и повтаря един и същи жест? Лимитът на завъртанията в крайна сметка ще го спре, но е по-добре да откриете цикъла по-рано: ако една и съща екранна снимка се връща няколко пъти подред, агентът не прави прогрес и прекъсването му Ви спестява ненужни извиквания.

Агентът действа ли върху страница, която все още е празна? На тежък сайт page.goto() се връща, преди рендирането да приключи, и първата екранна снимка показва само бял фон. Изчакайте липсата на мрежова активност, преди да направите снимката:

page.goto(url)
page.wait_for_load_state("networkidle")

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

  • Агентът за Computer Use комбинира обработчик на действия, контролен цикъл и верижно свързване на отговори
  • Първото извикване изпраща задачата; всяка екранна снимка се връща в computer_call_output със същия call_id
  • Обработчикът изпълнява действията последователно и отхвърля това, което не знае как да направи
  • Винаги ограничавайте броя на завъртанията, спирайте при pending_safety_checks и използвайте headless=False по време на разработка
  • run_agent(task, page=page) използва повторно този цикъл за вече отворена страница; това е което следващите уроци използват