Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

První pracovní postup: navigace a interakce

Lekce 4 z 14 Aktualizováno 3. listopadu 2026 Vývojář
Na této stránce
  1. Složení dílů dohromady
  2. Obslužný program akcí
  3. Kompletní smyčka
  4. Spuštění pracovního postupu
  5. Opakovaně použitelná funkce pro zbytek kurzu
  6. Tři selhání, na která narazíš
  7. Klíčové poznatky

Lekce přepsána 3. listopadu 2026 na základě příručky Computer use od OpenAI a receptů pro integraci Computer use: agent využívá nástroj computer z API Responses, obslužný program akcí modelovaný podle dokumentace (skupinové akce, keypress, scroll_x/scroll_y, dráhy pro drag) a řetězení prostřednictvím previous_response_id, čímž nahrazuje kód psaný pro API Anthropic. Zdroje: Computer use · Recepty pro integraci.

Složení dílů dohromady

Máš v hlavě smyčku a prostředí nakonfigurované. Teď musíš tyto části spojit do funkčního programu: agenta, který otevře online encyklopedii, vyhledá termín, otevře první výsledek a nahlásí název stránky, na kterou se dostal. Scénář vypadá skromně, ale zapojuje základní gesta – navigaci, psaní, klikání, čtení informací – a vše, co postavíš dál, bude jen delší variací tohoto základu.

Obslužný program akcí

Model rozhoduje, ale sám nic neprovádí: vrací seznam akcí a tvůj kód je postupně převádí na gesta v Playwrightu. Tato funkce následuje obslužný program zveřejněný OpenAI v jeho receptech pro integraci, zjednodušený pro prohlížeč.

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

Dvě volby si zaslouží vysvětlení. Názvy kláves a tlačítek vrácené modelem (ENTER, CTRL, wheel…) nejsou tím, co očekává Playwright (Enter, Control, middle…): mapovací tabulky převzaté z dokumentace tento rozdíl překlenují a tlačítka back a forward, která může API také požadovat, jsou zamítnuta stejně jako v obslužném programu OpenAI. Neznámá akce vyvolá chybu místo toho, aby byla tiše ignorována: tvrdé zastavení je lepší než agent, který si myslí, že jednal, když ve skutečnosti ne.

Kompletní smyčka

Agent poté orchestruje cyklus. První volání odešle úkol; pokud obsahuje pouze žádost o snímek obrazovky, jednoduše vrátíš obrazovku. Každý snímek se vrátí modelu jako výsledek volání, které jej požadovalo, odkazovaný svým call_id, a previous_response_id propojuje jednotlivá kola dohromady.

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

Tři ochranné mechanismy jsou již na místě. MAX_TURNS ohraničuje smyčku: bez tohoto limitu by dezorientovaný agent vyčerpal tvůj rozpočet až do úplného vyčerpání. Volání s čekajícími kontrolami bezpečnosti (pending_safety_checks) vše zastaví, stejně jako v oficiálním příkladu OpenAI: lekce 12 ukazuje, jak je nechat validovat člověkem. A normální dokončení je signalizováno nepřítomností computer_call: model přestal jednat a odpovídá ti, takže získáš název stránky z output_text.

Spuštění 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 představení poučné: okno se otevře, kliknutí dopadne do vyhledávacího pole, objeví se text, otevře se první odkaz a název se vrátí v tvé konzoli. Nech to proběhnout dvakrát nebo třikrát, než přejdeš k ambicióznějším úkolům; uvidíš přesně tam, kde agent váhá a co by měly tvé instrukce řešit.

Opakovaně použitelná funkce pro zbytek kurzu

Následující lekce pracují s již otevřenou stránkou – po přihlášení, uprostřed pracovního postupu. Spoléhají na run_agent(task, page=page): stejnou smyčku extrahovanou z launch_agent, s volitelnými instructions vracenými v každém kole (lekce 5 vysvětluje proč).

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

Tři selhání, na která narazíš

Kliká agent systematicky vedle svého cíle? Pachatelem je téměř vždy nesoulad měřítka mezi odeslaným snímkem obrazovky a stránkou, na kterou klikáš: změněná velikost snímku, přiblížení prohlížeče, obrazovka s vysokou hustotou pixelů. Souřadnice modelu odkazují na obrázek, který obdržel; pokud jej zmenšíš, musíš převést jeho souřadnice opačným směrem.

Točí se agent v kruhu a opakuje stejné gesto? Limit kol ho nakonec zastaví, ale je lepší detekovat smyčku dříve: pokud se stejný snímek obrazovky vrátí několikrát za sebou, agent nepostupuje vpřed a jeho přerušení ti ušetří zbytečná volání.

Jedná agent na stránce, která je stále prázdná? Na náročných stránkách page.goto() vrátí řízení dříve, než skončí vykreslování, a první snímek ukazuje pouze bílé pozadí. Počkej na nečinnost sítě, než pořídíš obrázek:

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

Klíčové poznatky

  • Agent Computer Use kombinuje obslužný program akcí, řídicí smyčku a řetězení odpovědí
  • První volání odešle úkol; každý snímek se vrátí v computer_call_output se stejným call_id
  • Obslužný program provádí akce v pořadí a odmítá to, co neumí zpracovat
  • Vždy omez počet kol, zastav při pending_safety_checks a během vývoje používej headless=False
  • run_agent(task, page=page) znovu využívá tuto smyčku pro již otevřenou stránku; to je to, co používají následující lekce