Preskoči na glavni sadržaj
Hrvatski— Odaberite jezik
Izbornik

Prvi radni tijek: navigacija i interakcija

Lekcija 4 od 14 Ažurirano 3. studenoga 2026. Programer
Na ovoj stranici
  1. Sastavljanje dijelova
  2. Upravitelj radnji
  3. Potpuna petlja
  4. Pokretanje radnog tijeka
  5. Funkcija za ponovnu upotrebu za ostatak tečaja
  6. Tri neuspjeha s kojima ćeš se susresti
  7. Ključne točke

Lekcija je ponovno napisana 3. studenoga 2026. na temelju vodiča Computer use tvrtke OpenAI i recepata za integraciju Computer use: agent koristi alat computer iz Responses API-ja, upravitelj radnji modeliran prema dokumentaciji (grupirane radnje, keypress, scroll_x/scroll_y, putanje drag) i lančanje putem previous_response_id, zamjenjujući kod napisan za Anthropicov API. Izvori: Computer use · Recepti za integraciju.

Sastavljanje dijelova

Imaš petlju na umu i okruženje konfigurirano. Sada ih trebaš spojiti u radni program: agent koji otvara internetsku enciklopediju, traži pojam, otvara prvi rezultat i vraća naslov stranice do koje je stigao. Scenarij djeluje skromno, ali uključuje temeljne geste – navigaciju, tipkanje, klikanje, čitanje informacija – i sve što ćeš dalje graditi bit će samo duža varijacija ovoga.

Upravitelj radnji

Model donosi odluke, ali ništa ne izvršava sam: vraća popis radnji, a tvoj kod ih redom prevodi u Playwright geste. Ova funkcija slijedi upravitelja kojeg je objavio OpenAI u svojim receptima za integraciju, pojednostavljenog za preglednik.

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

Dva izbora zaslužuju objašnjenje. Nazivi tipki i gumba koje vraća model (ENTER, CTRL, wheel…) nisu ono što Playwright očekuje (Enter, Control, middle…): tablice mapiranja, preuzete iz dokumentacije, premošćuju jaz, a gumbi back i forward, koje API također može zatražiti, odbijeni su kao u OpenAI-evom upravitelju. Nepoznata radnja podiže pogrešku umjesto da bude tiho ignorirana: naglo zaustavljanje bolje je od agenta koji misli da je djelovao, a nije.

Potpuna petlja

Agent zatim orchestrira ciklus. Prvi poziv šalje zadatak; ako sadrži samo zahtjev za snimku zaslona, jednostavno vraćaš zaslon. Svaka snimka zaslona vraća se modelu kao rezultat poziva koji ju je zatražio, referencirana svojim call_id, a previous_response_id povezuje okrete.

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 sigurnosne mjere već su na snazi. MAX_TURNS ograničava petlju: bez ovog limita, dezorijentirani agent trošio bi tvoj budžet do iscrpljenosti. Poziv s pending sigurnosnim provjerama (pending_safety_checks) zaustavlja sve, kao u službenom primjeru OpenAI-ja: lekcija 12 pokazuje kako ih validirati od strane čovjeka. Normalno dovršenje signalizirano je odsutnošću computer_call: model je prestao djelovati i odgovara ti, a ti dohvaćaš naslov stranice iz output_text.

Pokretanje radnog tijeka

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 headless=False, prikaz je poučan: prozor se otvara, klik pada u polje za pretraživanje, tekst se pojavljuje, prva poveznica se otvara i naslov se vraća u tvoju konzolu. Promatraj kako se pokreće dva ili tri puta prije nego što prijeđeš na ambicioznije zadatke; vidjet ćeš točno gdje agent oklijeva i što tvoje upute trebaju riješiti.

Funkcija za ponovnu upotrebu za ostatak tečaja

Sljedeće lekcije rade na već otvorenoj stranici – nakon prijave, usred radnog tijeka. One se oslanjaju na run_agent(task, page=page): ista petlja, izdvojena iz launch_agent, s opcionalnim instructions koje se vraćaju u svakom okretu (lekcija 5 objašnjava zašto).

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 neuspjeha s kojima ćeš se susresti

Klika li agent sustavno pokraj svog cilja? Krivac je gotovo uvijek nepodudarnost razmjera između poslane snimke zaslona i stranice na koju klikćeš: promijenjena veličina snimke, zumiranje preglednika, zaslon visoke gustoće. Koordinate modela odnose se na sliku koju je primio; ako je smanjiš, pretvori njegove koordinate u suprotnom smjeru.

Vrti li se agent u krug i ponavlja istu gestu? Limit okreta će ga eventualno zaustaviti, ali bolje je ranije otkriti petlju: ako se ista snimka zaslona vraća nekoliko puta zaredom, agent ne napreduje, a njegovo prekidanje štedi ti nepotrebne pozive.

Djeluje li agent na stranici koja je još uvijek prazna? Na teškim stranicama, page.goto() se vraća prije nego što renderiranje završi, a prva snimka zaslona pokazuje samo bijelu pozadinu. Pričekaj neaktivnost mreže prije nego što napraviš sliku:

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

Ključne točke

  • Agent za korištenje računala kombinira upravitelja radnji, kontrolnu petlju i lančanje odgovora
  • Prvi poziv šalje zadatak; svaka snimka zaslona vraća se u computer_call_output s istim call_id
  • Upravitelj izvršava radnje redom i odbija ono što ne zna kako učiniti
  • Uvijek ograniči broj okreta, zaustavi se na pending_safety_checks i koristi headless=False tijekom razvoja
  • run_agent(task, page=page) ponovno koristi ovu petlju za već otvorenu stranicu; to koriste sljedeće lekcije