Lähe põhisisu juurde
Eesti— Vali keel
Menüü

Arhitektuur: ekraanitõmmised, toimingud ja interaktsioonitsükkel

Õppetund 2 / 14 Värskendatud 3. november 2026 Arendajatele
Sellel lehel
  1. Taju-tegevuse tsükkel
  2. Lähtepunkt: ekraanitõmmis
  3. Analüüs ja otsus
  4. Toimingute repertuaar
  5. Täielik voog
  6. Tsükli käigu hind
  7. Peamised punktid

Õppetund kirjutati ümber 3. novembril 2026, tuginedes OpenAI Computer use juhendile ja Computer use integration recipes’ile: See kursus põhines varem Anthropicu API-l (import anthropic, tööriist computer_20241022). Nüüd kasutab see OpenAI Responses API computer tööriista, kus toimingud on rühmitatud computer_call-i ja ekraanitõmmised tagastatakse computer_call_output kaudu. Eemaldasime eelmisest versioonist allikata tokenite arvud ja kestuse hinnangud. Allikad: Computer use · Integration recipes.

Taju-tegevuse tsükkel

Kogu Computer Use’i arhitektuur taandub ühele tsüklile: vaatle → otsusta → tegutse → vaatle. Kuni see tsükkel ei ole sinu peas selge, jäävad sinu automatiseeringud ebastabiilseks; kui see aga klõpsab, on ülejäänu pelgalt torustik.

Erinevus Seleniumi skriptist seisneb selles, kus asub teadmine. Selenium täidab pimesi eelmääratud jada: klõpsa siin, siis seal, siis trüki see. Computer Use valib järgmise sammu alles pärast eelmise tulemuse nägemist. Ilmub hüpikaken, lehe laadimine võtab kauem aega või nupu silt muutub üleöö: kõigil kolmel juhul näeb mudel tegelikku olukorda ja kohandub, samas kui skript jätkab tühjusesse retsiteerimist.

OpenAI computer tööriistaga toimub vahetus kolmes etapis: sa saadad ülesande, täidad mudeli tagastatud toimingud ja saadad seejärel tagasi ekraanitõmmise. Sinu rakendus hoiab hiirt ja klaviatuuri; mudel teeb ainult otsuseid.

Lähtepunkt: ekraanitõmmis

Iga käik tugineb praeguse ekraaniseisundi pildile. See ekraanitõmmis pärineb Playwrighti juhitud brauserist – kõige levinum juhtum veebiautomatiseerimisel –, virtuaalsest töölauast töölauarakenduse automatiseerimisel või Dockeri konteinerist, mis isoleerib agenti. OpenAI soovitab kõigil juhtudel kasutada isoleeritud brauserit või virtuaalmasinat.

import base64

def capture_screen(page) -> str:
    """Tee ekraanitõmmis Playwrightiga ja tagasta PNG-pilt base64-kodeeringus."""
    return base64.b64encode(page.screenshot()).decode("utf-8")

Ekraanitõmmis saadetakse mudelile tagasi PNG-andmeURL-ina. See loeb pildisisendina, mõjutades seega iga käigu hinda: akna suurus, mille sa jäädvustad, on tegelik disainiparameeter.

Analüüs ja otsus

Mudel saab ülesande, vestlusajaloo ja viimase ekraanitõmmise. Selle vastus ei ole lause, vaid computer_call üksus, mis kannab järjestatud loendit täidetavatest toimingutest. Siin on näide OpenAI dokumentatsioonist, mis valib otsinguvälja ja trükib seejärel sõna:

{
  "type": "computer_call",
  "call_id": "call_002",
  "actions": [
    { "type": "click", "button": "left", "x": 405, "y": 157 },
    { "type": "type", "text": "penguin" }
  ],
  "status": "completed"
}

Olulised on kaks detaili. Esimene päring võib sisaldada ainult screenshot toimingut: mudel palub enne tegutsemist ekraani näha ja sina tagastad ekraanitõmmise ilma midagi muutmata. Samuti tähendab status: "completed", et mudel on lõpetanud päringu genererimise, mitte et toimingud on tehtud: nende täitmine on sinu ülesanne.

Toimingute repertuaar

Mudelile kättesaadav sõnavara on tahtlikult piiratud; kombineerituna katavad need primitiivid enamiku sellest, mida inimene teeb hiire ja klaviatuuriga.

ToimingKirjeldusVäljad
clickKlõpsa positsioonilx, y, button (left, right, wheel, back, forward)
double_clickTopeltklõpsx, y
dragLohista mööda radapath (punktide loend)
moveLiiguta kursoritx, y
scrollKerigex, y, scroll_x, scroll_y
keypressKlahv või kombinatsioonkeys (nt ["CTRL", "A"])
typeTrüki tekstitext
waitLase lehel laaduda—
screenshotTaotle uut ekraanitõmmist—

Täielik voog

Kokku panduna loovad need elemendid järgmise tsükli, mis on modelleeritud OpenAI dokumentatsiooni põhjal. Niikaua kui vastus sisaldab computer_call-i, täidad selle toimingud, jäädvustad ekraani ja tagastad ekraanitõmmise computer_call_output-is, kasutades sama call_id-d; previous_response_id seob iga käigu eelmisega.

from openai import OpenAI

client = OpenAI()

def computer_use_loop(page, task: str):
    """Computer Use'i tsükkel Responses API computer tööriistaga."""
    response = client.responses.create(
        model="gpt-6.1-sol",
        tools=[{"type": "computer"}],
        input=task,
    )

    while True:
        call = next(
            (item for item in response.output if item.type == "computer_call"),
            None,
        )
        if call is None:
            return response.output_text  # rohkem toiminguid ei taotleta: ülesanne on tehtud

        execute_actions(page, call.actions)  # sinu toimingute käitleja (4. õppetund)
        screenshot = capture_screen(page)

        response = client.responses.create(
            model="gpt-6.1-sol",
            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",
                },
            }],
        )

Sellel tsüklil pole veel kaitsepiiranguid: tootmises piira käikude arvu, kestust ja kulu; peatu, kui päring sisaldab ootel ohutuskontrolle (pending_safety_checks); ja kontrolli tegelikku tulemust, usaldamata ainult mudeli lõppsõnumit. Need on OpenAI ohutusjuhised, mida käsitletakse 12. õppetunnis.

Tsükli käigu hind

Iga Responses API päringu eest võetakse tasu sisend- ja väljundtokenite eest ning iga ekraanitõmmis loeb pildisisendina; majutatud keskkonna eest võib arvestada eraldi tasu. Ülesande hind sõltub seega käikude arvust, ekraanitõmmise suurusest ja mudelist – ja see kasvab kiiremini kui käikude arv, sest isegi previous_response_id kasutamisel arvestatakse kõigi eelmiste vastuste sisendtokenid ahelas iga päringu korral uuesti sisendina. OpenAI pakub pildikulude kalkulaatorit ja avaldab iga päringu kasutusstatistika: mõõda oma töövoogudel enne eelarve planeerimist. Seleniumi skript teeb alati sama asja kiiremini ja odavamalt – aga sa pead selle ümber kirjutama järgmine kord, kui vorm muutub, mida agent ei nõua.

Peamised punktid

  • Tsükkel ülesanne → toimingud → ekraanitõmmis on Computer Use’i süda; sinu rakendus täidab toimingud
  • OpenAI puhul deklareeri tööriist Responses API-s käsuga tools=[{"type": "computer"}]
  • computer_call kannab järjestatud loendit toimingutest (click, type, scroll, keypress jne), mis tuleb täita järjestikku
  • Ekraanitõmmis tagastatakse mudelile computer_call_output-is sama call_id-ga, aheldatuna previous_response_id kaudu
  • Iga käik maksab tokeneid ja pilti: piira käike ja mõõda enne eelarvestamist