Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Első munkafolyamat: navigálás és interakció

4. lecke 14 közül Frissítve 2026. november 3. Fejlesztő
Ezen az oldalon
  1. Az elemek összeillesztése
  2. A műveletkezelő
  3. A teljes ciklus
  4. A munkafolyamat indítása
  5. Újrafelhasználható függvény a tanfolyam hátralévő részéhez
  6. Három hiba, amivel találkozni fogsz
  7. Főbb megállapítások

A leckét 2026. november 3-án írtuk át az OpenAI Computer use útmutatója és a Computer use integration recipes alapján: az ágens a Responses API computer eszközét használja, egy olyan műveletkezelőt, amely a dokumentációra épül (csoportosított műveletek, keypress, scroll_x/scroll_y, drag útvonalak), és a fordulókat a previous_response_id láncolja össze, kiváltva az Anthropic API-hoz írt kódot. Források: Computer use · Integration recipes.

Az elemek összeillesztése

Már fejben van a ciklus, és a környezet is konfigurálva. Most egyetlen működő programmá kell egyesítened őket: egy ágenssé, amely megnyit egy online enciklopédiát, keres egy kifejezést, megnyitja az első találatot, majd visszajelenti az elért oldal címét. A forgatókönyv szerénynek tűnhet, de ez задейálja az alapvető gesztusokat – navigálás, gépelés, kattintás, információolvasás –, és minden, amit ezután építesz, csupán ennek egy hosszabb variációja lesz.

A műveletkezelő

A modell dönt, de maga nem hajt végre semmit: egy műveletlistát ad vissza, a te kódod pedig sorban Playwright gesztusokká fordítja azokat. Ez a függvény az OpenAI integrációs receptjeiben közzétett kezelőt követi, böngészőre egyszerűsítve.

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

Két választás magyarázatra szorul. A modell által visszaadott billentyű- és gombnevek (ENTER, CTRL, wheel…) nem egyeznek meg azzal, amit a Playwright elvár (Enter, Control, middle…): a dokumentációból vett leképezési táblák hidalják át ezt a szakadékot, a back és forward gombokat pedig, amelyeket az API szintén kérhet, az OpenAI kezelőjéhez hasonlóan elutasítjuk. Egy ismeretlen művelet esetén pedig hiba keletkezik ahelyett, hogy csendben figyelmen kívül hagynánk: egy határozott leállás jobb, mint egy ágens, amely azt hiszi, cselekedett, pedig nem.

A teljes ciklus

Az ágens ezután irányítja a ciklust. Az első hívás elküldi a feladatot; ha csak képernyőkép-kérést tartalmaz, egyszerűen visszaadod a képernyőt. Minden képernyőkép a modelltől visszajön annak a hívásnak az eredményeként, amely kérte azt, a call_id hivatkozással, a previous_response_id pedig összeláncolja a fordulókat.

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

Három biztonsági intézkedés már helyén van. A MAX_TURNS korlátozza a ciklust: e határ nélkül egy zavarodott ágens a kimerülésig emésztené fel a keretedet. A függőben lévő biztonsági ellenőrzéseket (pending_safety_checks) tartalmazó hívás mindent leállít, akárcsak az OpenAI hivatalos példájában: a 12. lecke mutatja be, hogyan validáltathatod ezeket emberrel. A normál befejezést pedig egy computer_call hiánya jelzi: a modell abbahagyta a cselekvést, és neked válaszol, így az oldal címét az output_text-ből nyerheted ki.

A munkafolyamat indítása

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

A headless=False beállítással a bemutató tanulságos: az ablak megnyílik, a kattintás a keresőmezőbe landol, megjelenik a szöveg, az első link megnyílik, és a cím visszatér a konzolodban. Figyeld meg, ahogy két-három alkalommal lefut, mielőtt ambiciózusabb feladatokra térnél; pontosan látni fogod, hol habozik az ágens, és mire kell kitérnie az utasításaidnak.

Újrafelhasználható függvény a tanfolyam hátralévő részéhez

A következő leckék egy már megnyitott oldalon dolgoznak – bejelentkezés után, egy munkafolyamat közepén. Ezek a run_agent(task, page=page) függvényre támaszkodnak: ugyanaz a ciklus, amelyet kiemeltünk a launch_agent-ből, opcionális instructions paraméterrel, amely minden fordulóban visszaadható (az 5. lecke magyarázza el, miért).

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

Három hiba, amivel találkozni fogsz

Az ágens szisztematikusan a cél mellett kattint? A bűnös szinte mindig a küldött képernyőkép és az oldal közötti méretarány-eltérés: átméretezett képernyőkép, böngésző nagyítás, nagy sűrűségű kijelző. A modell koordinátái a kapott képre vonatkoznak; ha kicsinyíted azt, a koordinátákat ellenkező irányba kell konvertálnod.

Az ágens körbe-körbe jár és ismétli ugyanazt a gesztust? A fordulókör-limit végül megállítja, de jobb hamarabb észlelni a hurkot: ha ugyanaz a képernyőkép többször egymás után visszatér, az ágens nem halad előre, és a megszakításával felesleges hívásokat spórolsz meg.

Az ágens egy még üres oldalon cselekszik? Egy nehézkes oldalon a page.goto() a renderelés befejezése előtt tér vissza, és az első képernyőkép csak fehér hátteret mutat. Várd meg a hálózati inaktivitást, mielőtt elkészítenéd a képet:

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

Főbb megállapítások

  • Egy Computer Use ágens egy műveletkezelőt, egy vezérlőciklust és válaszok láncolását egyesíti
  • Az első hívás elküldi a feladatot; minden képernyőkép egy computer_call_output-ban tér vissza, ugyanazzal a call_id-vel
  • A kezelő sorban hajtja végre a műveleteket, és elutasítja, amit nem tud kezelni
  • Mindig korlátozd a fordulók számát, állj meg pending_safety_checks esetén, és fejlesztés közben használd a headless=False beállítást
  • A run_agent(task, page=page) újrafelhasználja ezt a ciklust egy már megnyitott oldalhoz; ezt használják a következő leckék is