Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Pirmā darbplūsma: navigācija un mijiedarbība

Nodarbība 4 no 14 Atjaunota 2026. gada 3. novembris Programmētājs
Šajā lapā
  1. Daļu apvienošana
  2. Darbību apstrādātājs
  3. Pilnais cikls
  4. Darbplūsmas palaišana
  5. Atkārtoti izmantojama funkcija pārējam kursam
  6. Trīs kļūmes, ar kurām sastapsies
  7. Galvenās atziņas

Nodarbība pārrakstīta 2026. gada 3. novembrī, balstoties uz OpenAI Computer use rokasgrāmatu un Computer use integration recipes: aģents izmanto computer rīku no Responses API, darbību apstrādātāju, kas modelēts pēc dokumentācijas (grupētas darbības, keypress, scroll_x/scroll_y, drag ceļi), un ķēdēšanu, izmantojot previous_response_id, aizstājot kodu, kas rakstīts Anthropic API. Avoti: Computer use · Integration recipes.

Daļu apvienošana

Tev ir prātā cikls un vide ir konfigurēta. Tagad tev tās jāapvieno vienā funkcionējošā programmā: aģentā, kas atver tiešsaistes enciklopēdiju, meklē terminu, atver pirmo rezultātu un ziņo atpakaļ lapas nosaukumu, kurā tas nonāca. Scenārijs šķiet pieticīgs, taču tas iesaista fundamentālos žestus — navigāciju, rakstīšanu, klikšķināšanu, informācijas lasīšanu — un viss, ko veidosi tālāk, būs tikai garāka šī variācija.

Darbību apstrādātājs

Modelis pieņem lēmumus, bet pats neko neizpilda: tas atgriež darbību sarakstu, un tavs kods tās secīgi pārvērš Playwright žestos. Šī funkcija seko apstrādātājam, ko OpenAI publicējusi savās integrācijas receptēs, vienkāršojot to pārlūkprogrammai.

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

Divas izvēles ir pelnījušas skaidrojumu. Atslēgu un pogu nosaukumi, ko atgriež modelis (ENTER, CTRL, wheel…), nav tie, ko sagaida Playwright (Enter, Control, middle…): kartēšanas tabulas, kas ņemtas no dokumentācijas, aizpilda šo plaisu, un pogas back un forward, kuras API arī var pieprasīt, tiek noraidītas tāpat kā OpenAI apstrādātājā. Un nezināma darbība izraisa kļūdu, nevis tiek klusi ignorēta: ciets apstādinājums ir labāks par aģentu, kas domā, ka ir rīkojies, lai gan nav.

Pilnais cikls

Tālāk aģents organizē ciklu. Pirmais izsaukums nosūta uzdevumu; ja tas satur tikai ekrānuzņēmuma pieprasījumu, tu vienkārši atgriez ekrānu. Katrs ekrānuzņēmums atgriežas modelim kā tā izsaukuma rezultāts, kas to pieprasīja, atsaucojoties uz tā call_id, un previous_response_id saista gājienus kopā.

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

Trīs drošības mehānismi jau ir ieviesti. MAX_TURNS ierobežo ciklu: bez šī limita dezorientēts aģents iztērētu tavu budžetu līdz izsīkumam. Izsaukums ar gaidošajām drošības pārbaudēm (pending_safety_checks) aptur visu, tāpat kā OpenAI oficiālajā piemērā: 12. nodarbība parāda, kā panākt, lai tās apstiprina cilvēks. Un normālu pabeigšanu signalizē computer_call neesamība: modelis ir pārtraucis rīkoties un atbild tev, un tu iegūsti lapas nosaukumu no output_text.

Darbplūsmas palaišana

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

Ar headless=False šovs ir pamācošs: logs atveras, klikšķis trāpa meklēšanas laukā, parādās teksts, atveras pirmā saite, un nosaukums atgriežas tavā konsolē. Novēro tā darbību divas vai trīs reizes, pirms pāriet pie ambiciozākiem uzdevumiem; tu precīzi redzēsi, kur aģents vilcinās un kam tavām instrukcijām jāpievērš uzmanība.

Atkārtoti izmantojama funkcija pārējam kursam

Nākamās nodarbības strādā ar jau atvērtu lapu — pēc pieteikšanās, darbplūsmas vidū. Tās paļaujas uz run_agent(task, page=page): tas pats cikls, izdalīts no launch_agent, ar opcionālām instructions, kas atgriežas katrā gājienā (5. nodarbība skaidro, kāpēc).

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

Trīs kļūmes, ar kurām sastapsies

Vai aģents sistemātiski klikšķina blakus mērķim? vaininieks gandrīz vienmēr ir mēroga neatbilstība starp nosūtīto ekrānuzņēmumu un lapu, kurā klikšķini: mainīta izmēra ekrānuzņēmums, pārlūka tālummaiņa, augstas izšķirtspējas ekrāns. Modeļa koordinātas attiecas uz attēlu, ko tas saņēma; ja tu to samazini, konvertē tā koordinātas pretējā virzienā.

Vai aģents iet riņķos un atkārto to pašu žestu? Gājienu limits to galu galā apturēs, taču labāk ir noteikt cilpu ātrāk: ja viens un tas pats ekrānuzņēmums atgriežas vairākas reizes pēc kārtas, aģents neprogresē, un tā pārtraukšana ietaupa tev nevajadzīgus izsaukumus.

Vai aģents rīkojas lapā, kas vēl ir tukša? Smagā vietnē page.goto() atgriežas pirms renderēšanas pabeigšanas, un pirmais ekrānuzņēmums rāda tikai baltu fonu. Pagaidi tīkla neaktivitāti pirms attēla uzņemšanas:

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

Galvenās atziņas

  • Computer Use aģents apvieno darbību apstrādātāju, vadības ciklu un atbilžu ķēdēšanu
  • Pirmais izsaukums nosūta uzdevumu; katrs ekrānuzņēmums atgriežas computer_call_output ar to pašu call_id
  • Apstrādātājs izpilda darbības secībā un noraida to, ko nezina, kā izdarīt
  • Vienmēr ierobežo gājienu skaitu, apturi pie pending_safety_checks un izmanto headless=False izstrādes laikā
  • run_agent(task, page=page) atkārtoti izmanto šo ciklu jau atvērtai lapai; to izmantos nākamās nodarbības