Przejdź do głównej treści
Polski— Wybierz język
Menu

Pierwszy przepływ pracy: nawigacja i interakcja

Lekcja 4 z 14 Zaktualizowano 3 listopada 2026 Programista
Na tej stronie
  1. Składanie elementów w całość
  2. Handler akcji
  3. Pełna pętla
  4. Uruchamianie przepływu pracy
  5. Funkcja wielokrotnego użytku na potrzeby reszty kursu
  6. Trzy błędy, które napotkasz
  7. Kluczowe wnioski

Lekcja przepisana 3 listopada 2026 r. na podstawie przewodnika Computer use firmy OpenAI oraz przepisów integracyjnych Computer use: agent korzysta z narzędzia computer z API Responses, handlera akcji wzorowanego na dokumentacji (akcje grupowe, keypress, scroll_x/scroll_y, ścieżki drag) oraz łańcuchowania poprzez previous_response_id, zastępując kod napisany pod API Anthropic. Źródła: Computer use · Przepisy integracyjne.

Składanie elementów w całość

Masz już w głowie pętlę i skonfigurowane środowisko. Teraz musisz połączyć je w działający program: agenta, który otwiera internetową encyklopedię, wyszukuje hasło, otwiera pierwszy wynik i zgłasza tytuł strony, do której dotarł. Scenariusz wydaje się skromny, ale angażuje fundamentalne gesty – nawigację, wpisywanie tekstu, klikanie, odczytywanie informacji – a wszystko, co zbudujesz dalej, będzie jedynie dłuższą wersją tego procesu.

Handler akcji

Model podejmuje decyzje, ale sam nic nie wykonuje: zwraca listę akcji, a Twój kod tłumaczy je kolejno na gesty Playwright. Ta funkcja podąża za handlerem opublikowanym przez OpenAI w przepisach integracyjnych, uproszczonym pod kątem przeglądarki.

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}")

Dwa wybory wymagają wyjaśnienia. Nazwy klawiszy i przycisków zwracane przez model (ENTER, CTRL, wheel…) nie są tymi, których oczekuje Playwright (Enter, Control, middle…): tablice mapowania, zaczerpnięte z dokumentacji, niwelują tę różnicę, a przyciski „wstecz“ i „do przodu“, które API również może zażądać, są odrzucane – tak jak w handlerze OpenAI. Nieznana akcja powoduje błąd, zamiast być cicho ignorowaną: twarde zatrzymanie jest lepsze niż agent, który myśli, że działał, podczas gdy w rzeczywistości nic nie zrobił.

Pełna pętla

Agent orchestruje następnie cały cykl. Pierwsze wywołanie wysyła zadanie; jeśli zawiera ono tylko żądanie zrzutu ekranu, po prostu zwracasz obraz ekranu. Każdy zrzut ekranu wraca do modelu jako wynik wywołania, które go zażądało, referencjonowany przez swój call_id, a previous_response_id łączy kolejne tury rozmowy.

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()

Trzy zabezpieczenia są już na miejscu. MAX_TURNS ogranicza pętlę: bez tego limitu zdezorientowany agent zużyłby Twój budżet aż do wyczerpania. Wywołanie z oczekującymi sprawdzami bezpieczeństwa (pending_safety_checks) zatrzymuje wszystko, tak jak w oficjalnym przykładzie OpenAI: lekcja 12 pokazuje, jak uzyskać ich zatwierdzenie przez człowieka. Normalne zakończenie sygnalizowane jest brakiem computer_call: model przestał działać i odpowiada Ci, a Ty pobierasz tytuł strony z output_text.

Uruchamianie przepływu pracy

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."
    )

Dzięki ustawieniu headless=False pokaz jest pouczający: okno się otwiera, kliknięcie trafia w pole wyszukiwania, pojawia się tekst, otwiera się pierwszy link, a tytuł wraca w Twoim konsoli. Obserwuj działanie dwa lub trzy razy, zanim przejdziesz do bardziej ambitnych zadań; zobaczysz dokładnie, gdzie agent się waha i co powinny uwzględniać Twoje instrukcje.

Funkcja wielokrotnego użytku na potrzeby reszty kursu

Kolejne lekcje pracują na już otwartej stronie – po zalogowaniu, w środku przepływu pracy. Opierają się na run_agent(task, page=page): ta sama pętla, wyodrębniona z launch_agent, z opcjonalnymi instructions zwracanymi przy każdej turze (lekcja 5 wyjaśnia dlaczego).

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")

Trzy błędy, które napotkasz

Czy agent systematycznie klika obok swojego celu? Winowajcą jest prawie zawsze niedopasowanie skali między wysłanym zrzutem ekranu a stroną, na której klikasz: zmieniony rozmiar zrzutu, zoom przeglądarki, ekran o wysokiej gęstości pikseli. Współrzędne modelu odnoszą się do obrazu, który otrzymał; jeśli go zmniejszysz, przelicz jego współrzędne w odwrotnym kierunku.

Czy agent chodzi w kółko i powtarza ten sam gest? Limit tur w końcu go zatrzyma, ale lepiej wykryć pętlę wcześniej: jeśli ten sam zrzut ekranu wraca kilka razy z rzędu, agent nie robi postępów, a jego przerwanie oszczędzi Ci niepotrzebnych wywołań.

Czy agent działa na stronie, która jest wciąż pusta? Na ciężkiej stronie page.goto() zwraca kontrolę przed zakończeniem renderowania, a pierwszy zrzut ekranu pokazuje tylko białe tło. Poczekaj na brak aktywności sieciowej przed wykonaniem zdjęcia:

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

Kluczowe wnioski

  • Agent Computer Use łączy handler akcji, pętlę sterującą i łańcuchowanie odpowiedzi
  • Pierwsze wywołanie wysyła zadanie; każdy zrzut ekranu wraca w computer_call_output z tym samym call_id
  • Handler wykonuje akcje po kolei i odrzuca te, których nie potrafi obsłużyć
  • Zawsze ograniczaj liczbę tur, zatrzymuj działanie przy pending_safety_checks i używaj headless=False podczas rozwoju
  • run_agent(task, page=page) ponownie wykorzystuje tę pętlę dla już otwartej strony; z tego korzystają kolejne lekcje