Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Pirmasis darbo eigos scenarijus: naršymas ir sąveika

Paskaita 4 iš 14 Atnaujinta 2026 m. lapkričio 3 d. Kūrėjas
Šiame puslapyje
  1. Detalių surinkimas
  2. Veiksmų tvarkyklė
  3. Pilnas ciklas
  4. Darbo eigos scenarijaus paleidimas
  5. Pakartotinai naudojama funkcija likusiai kurso daliai
  6. Trys nesėkmės, su kuriomis susidursi
  7. Svarbiausi punktai

Pamoka perrašyta 2026 m. lapkričio 3 d. remiantis „OpenAI“ Computer use vadovu ir Computer use integration recipes: agentas naudoja computer įrankį iš „Responses API“, veiksmų tvarkyklę, sukurtą pagal dokumentaciją (sugrupuoti veiksmai, keypress, scroll_x/scroll_y, drag keliai), ir grandininį ryšį per previous_response_id, pakeičiant kodą, rašytą „Anthropic“ API. Šaltiniai: Computer use · Integration recipes.

Detalių surinkimas

Jau turi galvoje ciklą ir sukonfigūravai aplinką. Dabar tau reikia sujungti jas į veikiantį programos kodą: agentą, kuris atidaro internetinę enciklopediją, ieško termino, atidaro pirmąjį rezultatą ir praneša pasiekto puslapio pavadinimą. Scenarijus atrodo kuklus, tačiau jis apima pagrindinius gestus – naršymą, rašymą, spustelėjimą, informacijos skaitymą – ir viskas, ką kursite toliau, bus tik ilgesnė šio varianto versija.

Veiksmų tvarkyklė

Modelis priima sprendimus, tačiau pats nieko nevykdo: jis grąžina veiksmų sąrašą, o tavo kodas juos eilės tvarka paverčia „Playwright“ gestais. Ši funkcija remiasi „OpenAI“ paskelbta tvarkykle jų integracijos receptuose, supaprastinta naršyklei.

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

Du pasirinkimai nusipelno paaiškinimo. Klavišų ir mygtukų pavadinimai, kuriuos grąžina modelis (ENTER, CTRL, wheel…), nėra tie, kurių tikisi „Playwright“ (Enter, Control, middle…): atotrūkį užpildo atvaizdavimo lentelės, paimtos iš dokumentacijos, o mygtukai back ir forward, kuriuos API taip pat gali prašyti, atmetami kaip ir „OpenAI“ tvarkyklėje. Be to, nežinomas veiksmas išmeta klaidą, o ne yra tyliai ignoruojamas: griežtas sustabdymas yra geriau nei agentas, kuris mano veikęs, nors iš tiesų nieko nepadarė.

Pilnas ciklas

Tada agentas organizuoja ciklą. Pirmasis kvietimas siunčia užduotį; jei jame yra tik ekrano kopijos prašymas, tiesiog grąžini ekraną. Kiekviena ekrano kopija grįžta modeliui kaip to kvietimo, kuris jos paprašė, rezultatas, nurodytas per call_id, o previous_response_id sujungia ėjimus.

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

Jau įdiegtos trys apsaugos priemonės. MAX_TURNS riboja ciklą: be šios ribos pasimetęs agentas eikvotų tavo biudžetą iki visiško išsekimo. Kvietimas su laukiančiais saugos patikrinimais (pending_safety_checks) viską sustabdo, kaip ir oficialiame „OpenAI“ pavyzdyje: 12 pamokoje parodoma, kaip juos patvirtinti žmogui. O normalų užbaigimą signalizuoja computer_call nebuvimas: modelis nustojo veikti ir atsako tau, o tu gauni puslapio pavadinimą iš output_text.

Darbo eigos scenarijaus paleidimas

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

Nustačius headless=False, procesas tampa pamokomas: langas atsidaro, spustelėjimas taikliai nusileidžia paieškos laukelyje, atsiranda tekstas, atidaroma pirmoji nuoroda, o pavadinimas grįžta tavo konsolėje. Stebėk, kaip tai veikia du ar tris kartus, prieš pereidamas prie ambicingesnių užduočių; tiksliai pamatysi, kur agentas dvejoja ir ką tavo instrukcijos turėtų spręsti.

Pakartotinai naudojama funkcija likusiai kurso daliai

Kitose pamokose dirbama su jau atidarytu puslapiu – prisijungus arba darbo eigos viduryje. Jos remiasi run_agent(task, page=page): tuo pačiu ciklu, išskirtu iš launch_agent, su papildomomis instructions, grąžinamomis kiekviename ėjime (5 pamoka paaiškina, kodėl).

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

Trys nesėkmės, su kuriomis susidursi

Ar agentas sistemingai spustelėja šalia savo taikinio? Kaltininkas beveik visada yra mastelio neatitikimas tarp siunčiamos ekrano kopijos ir puslapio, kuriame spustelėji: pakeisto dydžio ekrano kopija, naršyklės mastelis, didelio tankio ekranas. Modelio koordinatės nurodo gautą vaizdą; jei jį sumažini, konvertuok jo koordinates priešinga kryptimi.

Ar agentas sukasi ratu ir kartoja tą patį gestą? Ėjimų riba galiausiai jį sustabdys, tačiau geriau ciklą aptikti anksčiau: jei tas pats ekrano vaizdas grįžta kelis kartus iš eilės, agentas nepasiekia pažangos, o jo nutraukimas sutaupys nereikalingų kvietimų.

Ar agentas veikia dar tuščiame puslapyje? Sunkioje svetainėje page.goto() grįžta prieš baigiantis atvaizdavimui, o pirmoji ekrano kopija rodo tik baltą foną. Palauk, kol tinklo veikla nurims, prieš darydamas nuotrauką:

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

Svarbiausi punktai

  • „Computer Use“ agentas sujungia veiksmų tvarkyklę, valdymo ciklą ir atsakymų grandininį ryšį
  • Pirmasis kvietimas siunčia užduotį; kiekviena ekrano kopija grįžta per computer_call_output su tuo pačiu call_id
  • Tvarkyklė vykdo veiksmus eilės tvarka ir atmeta tai, ko nemoka daryti
  • Visada ribok ėjimų skaičių, sustabdyk esant pending_safety_checks ir kūrimo metu naudok headless=False
  • run_agent(task, page=page) pakartotinai naudoja šį ciklą jau atidarytam puslapiui; būtent tai naudosimosi tolesnėse pamokose