Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Premier flux : naviguer et interagir

Lektion 4 av 14 Uppdaterad 3 november 2026 Utvecklare
På denna sida
  1. Assembler les pièces
  2. Le gestionnaire d’actions
  3. La boucle complète
  4. Lancer le flux
  5. Une fonction réutilisable pour la suite du cours
  6. Trois échecs que tu rencontreras
  7. Viktiga punkter

Leçon réécrite le 3 novembre 2026 sur la base du guide Computer use d’OpenAI et des recettes d’intégration Computer use : l’agent utilise l’outil computer de l’API Responses, un gestionnaire d’actions modélisé sur la documentation (actions groupées, keypress, scroll_x/scroll_y, trajets drag) et l’enchaînement via previous_response_id, remplaçant le code écrit pour l’API d’Anthropic. Sources : Computer use · Recettes d’intégration.

Assembler les pièces

Tu as la boucle en tête et l’environnement configuré. Il te faut maintenant les assembler pour créer un programme fonctionnel : un agent qui ouvre une encyclopédie en ligne, recherche un terme, ouvre le premier résultat et te renvoie le titre de la page atteinte. Le scénario semble modeste, mais il mobilise les gestes fondamentaux — navigation, frappe, clic, lecture d’informations — et tout ce que tu construiras ensuite ne sera qu’une variation plus longue de ceci.

Le gestionnaire d’actions

Le modèle décide, mais n’exécute rien lui-même : il renvoie une liste d’actions, et ton code les traduit en gestes Playwright, dans l’ordre. Cette fonction suit le gestionnaire publié par OpenAI dans ses recettes d’intégration, simplifié pour un navigateur.

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

Deux choix méritent une explication. Les noms de touches et de boutons renvoyés par le modèle (ENTER, CTRL, wheel…) ne correspondent pas à ce que Playwright attend (Enter, Control, middle…) : les tables de correspondance, tirées de la documentation, comblent l’écart, et les boutons back et forward, que l’API peut également demander, sont rejetés comme dans le gestionnaire d’OpenAI. Enfin, une action inconnue déclenche une erreur plutôt que d’être silencieusement ignorée : un arrêt net vaut mieux qu’un agent qui croit avoir agi alors que ce n’est pas le cas.

La boucle complète

L’agent orchestre ensuite le cycle. Le premier appel envoie la tâche ; s’il ne contient qu’une demande de capture d’écran, tu retournes simplement l’écran. Chaque capture d’écran revient au modèle comme résultat de l’appel qui l’a demandée, référencée par son call_id, et previous_response_id relie les tours entre eux.

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

Trois garde-fous sont déjà en place. MAX_TURNS borne la boucle : sans cette limite, un agent désorienté consumerait ton budget jusqu’à épuisement. Un appel avec des vérifications de sécurité en attente (pending_safety_checks) stoppe tout, comme dans l’exemple officiel d’OpenAI : la leçon 12 montre comment les faire valider par un humain. Et la fin normale est signalée par l’absence de computer_call : le modèle a cessé d’agir et te répond, et tu récupères le titre de la page depuis output_text.

Lancer le flux

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

Avec headless=False, le spectacle est instructif : la fenêtre s’ouvre, le clic atterrit dans le champ de recherche, le texte apparaît, le premier lien s’ouvre, et le titre revient dans ta console. Regarde-le s’exécuter deux ou trois fois avant de passer à des tâches plus ambitieuses ; tu verras précisément où l’hésitation de l’agent se situe et ce que tes instructions doivent adresser.

Une fonction réutilisable pour la suite du cours

Les leçons suivantes travaillent sur une page déjà ouverte — après une connexion, au milieu d’un flux. Elles s’appuient sur run_agent(task, page=page) : la même boucle, extraite de launch_agent, avec des instructions optionnelles renvoyées à chaque tour (la leçon 5 explique pourquoi).

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

Trois échecs que tu rencontreras

L’agent clique-t-il systématiquement à côté de sa cible ? Le coupable est presque toujours un problème d’échelle entre la capture d’écran envoyée et la page sur laquelle tu cliques : capture redimensionnée, zoom du navigateur, écran haute densité. Les coordonnées du modèle se réfèrent à l’image qu’il a reçue ; si tu la réduis, convertis ses coordonnées dans le sens inverse.

L’agent tourne-t-il en rond et répète-t-il le même geste ? La limite de tours finira par l’arrêter, mais il vaut mieux détecter la boucle plus tôt : si la même capture d’écran revient plusieurs fois de suite, l’agent ne progresse pas, et l’interrompre t’évite des appels inutiles.

L’agent agit-il sur une page encore vide ? Sur un site lourd, page.goto() revient avant la fin du rendu, et la première capture ne montre qu’un fond blanc. Attends l’inactivité du réseau avant de prendre la photo :

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

Viktiga punkter

  • Un agent Computer Use combine un gestionnaire d’actions, une boucle de contrôle et un enchaînement de réponses
  • Le premier appel envoie la tâche ; chaque capture d’écran revient dans un computer_call_output avec le même call_id
  • Le gestionnaire exécute les actions dans l’ordre et rejette ce qu’il ne sait pas faire
  • Limite toujours le nombre de tours, arrête-toi sur pending_safety_checks et utilise headless=False durant le développement
  • run_agent(task, page=page) réutilise cette boucle pour une page déjà ouverte ; c’est ce que les leçons suivantes utilisent