Pirmasis darbo eigos scenarijus: naršymas ir sąveika
Šiame puslapyje
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,dragkeliai), ir grandininį ryšį perprevious_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_outputsu tuo pačiucall_id - Tvarkyklė vykdo veiksmus eilės tvarka ir atmeta tai, ko nemoka daryti
- Visada ribok ėjimų skaičių, sustabdyk esant
pending_safety_checksir kūrimo metu naudokheadless=False run_agent(task, page=page)pakartotinai naudoja šį ciklą jau atidarytam puslapiui; būtent tai naudosimosi tolesnėse pamokose