Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Prvi delovni tok: krmarjenje in interakcija

Lekcija 4 od 14 Posodobljeno 3. november 2026 Razvijalec
Na tej strani
  1. Sestavljanje koščkov
  2. Obdelovalnik dejanj
  3. Celotna zanka
  4. Zagon delovnega toka
  5. Ponovno uporabna funkcija za preostanek tečaja
  6. Tri napake, na katere boš naletel
  7. Ključne ugotovitve

Lekcija je bila ponovno napisana 3. novembra 2026 na podlagi vodnika Computer use podjetja OpenAI in receptov za integracijo Computer use: agent uporablja orodje computer iz API-ja Responses, obdelovalnik dejanj, modeliran po dokumentaciji (združena dejanja, keypress, scroll_x/scroll_y, poti drag), in veriženje prek previous_response_id, kar nadomešča kodo, napisano za API Anthropic. Viri: Computer use · Recepti za integracijo.

Sestavljanje koščkov

Zanko imaš v mislih, okolje pa je konfigurirano. Zdaj ju moraš združiti v delujoč program: agent, ki odpre spletno enciklopedijo, poišče izraz, odpre prvi rezultat in poroča nazaj naslov strani, do katere je prišel. Scenarij se zdi skromen, a vključuje temeljna gibanja – krmarjenje, tipkanje, klikanje, branje informacij – vse, kar boš zgradil naprej, bo le daljša različica tega.

Obdelovalnik dejanj

Model odloča, sam pa ne izvrši ničesar: vrne seznam dejanj, tvoja koda pa jih zaporedoma prevede v geste Playwright. Ta funkcija sledi obdelovalniku, ki ga je OpenAI objavil v svojih receptih za integracijo, poenostavljenem za brskalnik.

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 izbiri si zaslužita razlago. Imena tipk in gumbov, ki jih vrne model (ENTER, CTRL, wheel…), niso tista, ki jih pričakuje Playwright (Enter, Control, middle…): preslikovalne tabele, prevzete iz dokumentacije, premostijo to vrzel, gumba back in forward, ki ju API prav tako lahko zahteva, pa sta zavrnjena, tako kot v obdelovalniku OpenAI. Neznano dejanje sproži napako, namesto da bi bilo tiho prezrto: trdna ustavitev je boljša od agenta, ki misli, da je deloval, pa ni.

Celotna zanka

Agent nato orkestrira cikel. Prvi klic pošlje nalogo; če vsebuje le zahtevo za posnetek zaslona, preprosto vrneš zaslon. Vsak posnetek zaslona se vrne modelu kot rezultat klica, ki ga je zahteval, nanj se sklicuje njegov call_id, previous_response_id pa povezuje posamezne poteze.

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 varovalke so že na mestu. MAX_TURNS omejuje zanko: brez te omejitve bi dezorientiran agent porabil tvoj proračun do popolne izčrpanosti. Klic s čakajočimi varnostnimi preverjanji (pending_safety_checks) vse ustavi, tako kot v uradnem primeru OpenAI: lekcija 12 prikazuje, kako jih potrdi človek. Normalno zaključek je signaliziran z odsotnostjo computer_call: model je prenehal delovati in ti odgovarja, naslov strani pa dobiš iz output_text.

Zagon delovnega toka

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

Z nastavitvijo headless=False je predstava poučna: okno se odpre, klik pristane v iskalnem polju, besedilo se pojavi, odpre se prva povezava in naslov se vrne v tvojo konzolo. Pusti ga teči dva ali trikrat, preden se lotiš bolj ambicioznih nalog; natančno boš videl, kje agent okleva in kaj morajo nasloviti tvoja navodila.

Ponovno uporabna funkcija za preostanek tečaja

Naslednje lekcije delujejo na že odprti strani – po prijavi, sredi delovnega toka. Zanašajo se na run_agent(task, page=page): isto zanko, izvlečeno iz launch_agent, z izbirnimi instructions, vrnjenimi ob vsaki potezi (lekcija 5 pojasnjuje zakaj).

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 napake, na katere boš naletel

Ali agent sistematično klikne poleg svojega cilja? Krivec je skoraj vedno neskladje meril med poslanim posnetkom zaslona in stranjo, na katero klikaš: spremenjena velikost posnetka, povečava brskalnika, zaslon z visoko ločljivostjo. Koordinate modela se nanašajo na sliko, ki jo je prejel; če jo pomanjšaš, pretvori njegove koordinate v nasprotno smer.

Ali agent hodi v kroge in ponavlja isto gesto? Omejitev števila potez ga bo sčasoma ustavila, a bolje je zanko zaznati prej: če se isti posnetek zaslona vrne večkrat zapored, agent ne napreduje in njegovo prekinitev ti prihrani nepotrebne klice.

Ali agent deluje na strani, ki je še vedno prazna? Na težkih spletnih mestih page.goto() vrne nadzor, preden se konča izrisovanje, in prvi posnetek zaslona prikazuje le belo ozadje. Počakaj na nedejavnost omrežja, preden posnameš sliko:

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

Ključne ugotovitve

  • Agent Computer Use združuje obdelovalnik dejanj, nadzorno zanko in veriženje odzivov
  • Prvi klic pošlje nalogo; vsak posnetek zaslona se vrne v computer_call_output z istim call_id
  • Obdelovalnik izvrši dejanja po vrstnem redu in zavrne tista, ki jih ne zna opraviti
  • Vedno omeji število potez, ustavi se ob pending_safety_checks in med razvojem uporabi headless=False
  • run_agent(task, page=page) ponovno uporabi to zanko za že odprto stran; to uporabljajo naslednje lekcije