Primul flux de lucru: navigare și interacțiune
Pe această pagină
Lecție rescrisă la 3 noiembrie 2026 pe baza ghidului Computer use și a rețetelor de integrare Computer use integration recipes de la OpenAI: agentul utilizează instrumentul
computerdin API-ul Responses, un gestionar de acțiuni modelat după documentație (acțiuni grupate,keypress,scroll_x/scroll_y, traiectoriidrag) și înlănțuirea prinprevious_response_id, înlocuind codul scris pentru API-ul Anthropic. Surse: Computer use · Integration recipes.
Asamblarea pieselor
Aveți deja bucla în minte și mediul configurat. Acum trebuie să le reuniți într-un program funcțional: un agent care deschide o enciclopedie online, caută un termen, deschide primul rezultat și raportează titlul paginii la care a ajuns. Scenariul pare modest, dar implică gesturile fundamentale—navigare, tastare, clic, citirea informațiilor—iar tot ceea ce veți construi în continuare nu va fi decât o variație mai lungă a acestui model.
Gestionarul de acțiuni
Modelul decide, dar nu execută nimic singur: returnează o listă de acțiuni, iar codul dumneavoastră le traduce în gesturi Playwright, în ordine. Această funcție urmează gestionarul publicat de OpenAI în rețetele sale de integrare, simplificat pentru un browser.
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):
"""Execută acțiunile dintr-un computer_call în ordine."""
for action in actions:
if action.type in ("click", "double_click", "drag", "move", "scroll") and getattr(action, "keys", None):
raise ValueError("Acțiune mouse cu tastă modificatoare: nu este gestionată aici")
match action.type:
case "click":
button = getattr(action, "button", "left")
if button not in BUTTONS: # back și forward nu există în Playwright
raise ValueError(f"Buton neacceptat: {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 # captura de ecran este făcută după fiecare lot de acțiuni
case _:
raise ValueError(f"Acțiune neacceptată: {action.type}")
Două alegeri merită explicații. Numele tastelor și butoanelor returnate de model (ENTER, CTRL, wheel…) nu sunt cele pe care le așteaptă Playwright (Enter, Control, middle…): tabelele de mapare, preluate din documentație, fac legătura, iar butoanele back și forward, pe care API-ul le poate solicita de asemenea, sunt respinse ca în gestionarul OpenAI. Iar o acțiune necunoscută declanșează o eroare în loc să fie ignorată tacit: o oprire fermă este preferabilă unui agent care crede că a acționat când nu a făcut-o.
Bucla completă
Agentul orchestrează apoi ciclul. Primul apel trimite sarcina; dacă conține doar o cerere de captură de ecran, returnați simplu ecranul. Fiecare captură de ecran revine la model ca rezultat al apelului care a solicitat-o, referențiată prin call_id, iar previous_response_id leagă turele între ele.
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"):
"""Lansează un agent Computer Use pentru o sarcină dată."""
pw = sync_playwright().start()
browser = pw.chromium.launch(headless=False) # False pentru a observa
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"Sarcină completă: {response.output_text}")
return response.output_text
if call.pending_safety_checks: # vezi lecția 12
raise RuntimeError("Verificări de siguranță în așteptare: intervenție umană necesară")
for action in call.actions:
print(f" Acțiune: {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("Număr maxim de ture atins: verificați starea paginii")
finally:
browser.close()
pw.stop()
Trei măsuri de siguranță sunt deja în place. MAX_TURNS limitează bucla: fără această limită, un agent dezorientat v-ar consuma bugetul până la epuizare. Un apel cu verificări de siguranță în așteptare (pending_safety_checks) oprește totul, ca în exemplul oficial OpenAI: lecția 12 arată cum să le faceți validate de un om. Iar finalizarea normală este semnalată de absența unui computer_call: modelul a încetat să acționeze și vă răspunde, iar dumneavoastră recuperați titlul paginii din output_text.
Lansarea fluxului de lucru
if __name__ == "__main__":
launch_agent(
"Caută 'Computer Use' în motorul de căutare al Wikipedia, "
"deschide primul rezultat și dă-mi titlul paginii. "
"Folosește instrumentul computer pentru a acționa asupra interfeței."
)
Cu headless=False, spectacolul este instructiv: fereastra se deschide, clicul aterizează în câmpul de căutare, textul apare, primul link se deschide, iar titlul revine în consola dumneavoastră. Urmăriți-l rulând de două sau trei ori înainte de a trece la sarcini mai ambițioase; veți vedea precis unde ezită agentul și ce ar trebui să abordeze instrucțiunile dumneavoastră.
O funcție reutilizabilă pentru restul cursului
Lecțiile următoare lucrează pe o pagină deja deschisă—după o autentificare, în mijlocul unui flux de lucru. Ele se bazează pe run_agent(task, page=page): aceeași buclă, extrasă din launch_agent, cu instructions opționale returnate la fiecare tură (lecția 5 explică de ce).
def run_agent(task: str, page, instructions: str | None = None, max_turns: int = MAX_TURNS) -> str:
"""Bucle Computer Use pe o pagină deja deschisă; returnează mesajul final."""
request = {"model": MODEL, "tools": [{"type": "computer"}]}
if instructions:
request["instructions"] = instructions # de returnat la fiecare cerere
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("Verificări de siguranță în așteptare: intervenție umană necesară")
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("Număr maxim de ture atins: verificați starea paginii")
Trei eșecuri pe care le veți întâlni
Agentul face clic sistematic lângă ținta sa? Vinovatul este aproape întotdeauna o nepotrivire de scală între captura de ecran trimisă și pagina pe care faceți clic: captură redimensionată, zoom al browserului, ecran de înaltă densitate. Coordonatele modelului se referă la imaginea pe care a primit-o; dacă o micșorați, convertiți coordonatele sale în direcția opusă.
Agentul se învârte în cerc și repetă același gest? Limita de ture îl va opri eventual, dar este mai bine să detectați bucla mai devreme: dacă aceeași captură de ecran revine de mai multe ori la rând, agentul nu progresează, iar întreruperea sa vă economisește apeluri inutile.
Agentul acționează pe o pagină care este încă goală? Pe un site greu, page.goto() returnează înainte ca randarea să se termine, iar prima captură de ecran arată doar un fundal alb. Așteptați inactivitatea rețelei înainte de a face poza:
page.goto(url)
page.wait_for_load_state("networkidle")
Puncte cheie
- Un agent Computer Use combină un gestionar de acțiuni, o buclă de control și înlănțuirea răspunsurilor
- Primul apel trimite sarcina; fiecare captură de ecran revine într-un
computer_call_outputcu acelașicall_id - Gestionarul execută acțiunile în ordine și respinge ceea ce nu știe să facă
- Limitați întotdeauna numărul de ture, opriți-vă la
pending_safety_checksși folosițiheadless=Falseîn timpul dezvoltării run_agent(task, page=page)reutilizează această buclă pentru o pagină deja deschisă; aceasta este ceea ce folosesc lecțiile următoare