Prejsť na hlavný obsah
Slovenčina— Vyberte jazyk
Menu

Prvý pracovný postup: navigácia a interakcia

Lekcia 4 z 14 Aktualizované 3. novembra 2026 Vývojár
Na tejto strane
  1. Spájanie dielov dohromady
  2. Obslužný program akcií
  3. Kompletný cyklus
  4. Spustenie pracovného postupu
  5. Opakovateľná funkcia pre zvyšok kurzu
  6. Tri zlyhania, na ktoré narazíš
  7. Kľúčové poznatky

Lekcia prepísaná 3. novembra 2026 na základe príručky Computer use od OpenAI a receptov na integráciu Computer use: agent používa nástroj computer z API Responses, obslužný program akcií modelovaný podľa dokumentácie (zoskupené akcie, keypress, scroll_x/scroll_y, dráhy drag) a reťazenie prostredníctvom previous_response_id, čím nahádza kód písaný pre API Anthropic. Zdroje: Computer use · Integration recipes.

Spájanie dielov dohromady

Máš v hlave cyklus a prostredie nakonfigurované. Teraz ich potrebuješ spojiť do fungujúceho programu: agenta, ktorý otvorí online encyklopédiu, vyhľadá pojem, otvorí prvý výsledok a nahlási názov stránky, na ktorú sa dostal. Scenár sa zdá byť skromný, ale zapája základné gestá – navigáciu, písanie, klikanie, čítanie informácií – a všetko, čo nasledujúce postavíš, bude len dlhšou variáciou tohto.

Obslužný program akcií

Model rozhoduje, ale nič nevykonáva sám: vracia zoznam akcií a tvoj kód ich postupne prekladá do gest Playwright. Táto funkcia nasleduje obslužný program zverejnený OpenAI v jeho receptoch na integráciu, zjednodušený pre prehliadač.

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

Dve voľby si zaslúžia vysvetlenie. Názvy klávesov a tlačidiel vrátené modelom (ENTER, CTRL, wheel…) nie sú tým, čo očakáva Playwright (Enter, Control, middle…): mapovacie tabuľky, prevzaté z dokumentácie, premostia túto medzeru a tlačidlá back a forward, ktoré môže API tiež požadovať, sú odmietnuté rovnako ako v obslužnom programe OpenAI. A neznáma akcia vyvolá chybu namiesto toho, aby bola ticho ignorovaná: tvrdé zastavenie je lepšie ako agent, ktorý si myslí, že konal, keď v skutočnosti neurobil nič.

Kompletný cyklus

Agent následne orchestruje cyklus. Prvý volanie odosiela úlohu; ak obsahuje iba požiadavku na snímku obrazovky, jednoducho vrátiš obrazovku. Každá snímka obrazovky sa vráti modelu ako výsledok volania, ktoré ju požadovalo, odkazujúc sa na jej call_id, a previous_response_id spája jednotlivé ťahy dokopy.

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

Tri ochranné mechanizmy sú už na mieste. MAX_TURNS ohraničuje cyklus: bez tohto limitu by dezorientovaný agent spotreboval tvoj rozpočet až do vyčerpania. Volanie s čakajúcimi kontrolami bezpečnosti (pending_safety_checks) všetko zastaví, ako v oficiálnom príklade OpenAI: lekcia 12 ukazuje, ako ich nechať overiť človekom. A normálne dokončenie je signalizované absenciou computer_call: model prestal konať a odpovedá ti, pričom názov stránky získaš z output_text.

Spustenie pracovného postupu

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

S nastavením headless=False je predstavenie poučné: okno sa otvorí, kliknutie dopadne do vyhľadávacieho poľa, objaví sa text, otvorí sa prvý odkaz a názov sa vráti do tvojej konzoly. Nechaj to bežať dva alebo trikrát, než prejdeš k ambicióznejším úlohám; presne uvidíš, kde agent váha a čomu by mali tvoje inštrukcie venovať pozornosť.

Opakovateľná funkcia pre zvyšok kurzu

Nasledujúce lekcie pracujú s už otvorenou stránkou – po prihlásení, uprostred pracovného postupu. Spoliehajú sa na run_agent(task, page=page): ten istý cyklus, extrahovaný z launch_agent, s voliteľnými instructions vracanými pri každom ťahu (lekcia 5 vysvetľuje prečo).

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

Tri zlyhania, na ktoré narazíš

Kliká agent systematicky vedľa svojho cieľa? Vinníkom je takmer vždy nesúlad mierky medzi odoslanou snímkou obrazovky a stránkou, na ktorú klikáš: zmenšená snímka, priblíženie prehliadača, obrazovka s vysokou hustotou pixelov. Súradnice modelu sa vzťahujú na obrázok, ktorý dostal; ak ho zmenšíš, musíš previesť jeho súradnice opačným smerom.

Točí sa agent v kruhu a opakuje rovnaké gesto? Limit ťahov ho nakoniec zastaví, ale je lepšie odhaliť slučku skôr: ak sa tá istá snímka obrazovky vráti niekoľkokrát za sebou, agent nepostupuje vpred a jeho prerušenie ti ušetrí zbytočné volania.

Koná agent na stránke, ktorá je stále prázdna? Na náročnej stránke sa page.goto() vráti skôr, než sa dokončí vykresľovanie, a prvá snímka zobrazuje iba biely podklad. Počkaj na nečinnosť siete, než urobíš obrázok:

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

Kľúčové poznatky

  • Agent Computer Use kombinuje obslužný program akcií, riadiaci cyklus a reťazenie odpovedí
  • Prvé volanie odosiela úlohu; každá snímka obrazovky sa vracia v computer_call_output s rovnakým call_id
  • Obslužný program vykonáva akcie v poradí a odmieta to, čo nevie spracovať
  • Vždy obmedz počet ťahov, zastav pri pending_safety_checks a počas vývoja používaj headless=False
  • run_agent(task, page=page) opätovne využíva tento cyklus pre už otvorenú stránku; toto využívajú nasledujúce lekcie