Utilisation de l’ordinateur

L’utilisation de l’ordinateur permet à un modèle d’interagir avec les interfaces d’un navigateur et d’un bureau. Utilisez cette fonctionnalité pour remplir des formulaires, tester des parcours utilisateur ou accomplir des tâches dans des applications via leur interface.

Vous fournissez l’environnement et exécutez les demandes du modèle. Celui-ci s’appuie sur des captures d’écran et d’autres résultats d’outils pour décider de la suite. Choisissez comment le connecter à votre application :

• Exécution de code : le modèle écrit du code qui utilise une bibliothèque comme PyAutoGUI ou Playwright pour interagir avec l’interface. Un seul appel peut combiner des actions, des boucles ou de la logique conditionnelle.
• L’outil computer : le modèle renvoie des actions structurées de souris et de clavier que votre application convertit en entrées pour le navigateur ou le bureau.

Si vous exposez déjà des opérations sur l’interface via l’appel de fonction ou des outils MCP distants, vous pouvez conserver cette interface. Consultez Utilisez vos propres outils d’interaction avec l’interface pour comprendre les différences dans la manière dont ces intégrations exécutent les outils et renvoient les résultats.

Utilisez l’exécution de code

Une intégration fondée sur l’exécution de code fournit au modèle un outil de type fonction qui accepte un script. Votre application exécute ce script dans un environnement de navigateur ou de bureau isolé et en renvoie la sortie, y compris les captures d’écran. Maintenez l’environnement disponible entre les appels afin que le modèle puisse poursuivre le travail déjà effectué.

Exécutez l’application d’exemple

L’application d’exemple CUA comprend des implémentations JavaScript/Playwright et Python/PyAutoGUI, avec des tâches locales et une console partagée :

1. Suivez les instructions de configuration de l’implémentation choisie dans un environnement isolé.
2. Choisissez un scénario intégré et lancez une exécution.
3. Examinez les actions, les captures d’écran et l’état final pour déterminer si la tâche a réussi.

Consultez le README de l’application pour l’installation, les autorisations d’accès au bureau et les environnements pris en charge. Lisez Exécutez les tâches en toute sécurité avant d’adapter l’application à des sites ou comptes réels.

Connectez votre propre environnement d’exécution

L’exemple suivant montre la boucle d’appels à l’API pour un environnement d’exécution que vous fournissez. Python et Ruby envoient du code Python à un environnement d’exécution de bureau qui utilise PyAutoGUI ; JavaScript utilise Playwright pour piloter un navigateur. Chaque client expose un outil de type fonction standard et renvoie du texte ou des images avec le call_id d’origine.

La fonction utilitaire execute_in_sandbox ou executeInSandbox envoie du code à votre environnement d’exécution et en renvoie les observations. Elle doit préserver la session du navigateur ou du bureau, faire respecter les limites d’exécution et appliquer vos règles d’autorisation. Il s’agit d’exemples d’intégration, distincts de l’exécution de l’application d’exemple.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72import json
import uuid

from openai import OpenAI
from openai.types.responses import (
    FunctionToolParam,
    ResponseInputParam,
)

def run_computer_use(endpoint, prompt, model="gpt-6-astra"):
    client = OpenAI()
    session_id = str(uuid.uuid4())
    tools: list[FunctionToolParam] = [
        {
            "type": "function",
            "name": "exec_py",
            "description": (
                "Run Python in a persistent desktop. Variables persist across calls. "
                "PyAutoGUI operations are synchronous. Available: pyautogui, time, "
                "log(value), and display(PIL_image). Inspect the screen with "
                "display(pyautogui.screenshot()) before acting. Use screenshot "
                "coordinates and check the screen after a short group of actions. "
                "Keep screenshots in memory and PyAutoGUI's fail-safe enabled."
            ),
            "parameters": {
                "type": "object",
                "properties": {"code": {"type": "string"}},
                "required": ["code"],
                "additionalProperties": False,
            },
            "strict": True,
        }
    ]
    next_input: ResponseInputParam = [{"role": "user", "content": prompt}]
    previous_response_id = None

    for turn in range(20):
        response = client.responses.create(
            model=model,
            tools=tools,
            input=next_input,
            previous_response_id=previous_response_id,
        )
        if response.status != "completed":
            raise RuntimeError(f"Response stopped with status: {response.status}")

        calls = [item for item in response.output if item.type == "function_call"]
        if not calls and any(
            item.type == "message" and item.phase != "commentary"
            for item in response.output
        ):
            print(response.output_text)
            return
        if turn == 19:
            raise RuntimeError(
                "The task reached the 20-response limit. Inspect the last result."
            )

        next_input = []
        for call in calls:
            if call.name != "exec_py":
                raise ValueError(f"Unexpected tool: {call.name}")
            code = json.loads(call.arguments)["code"]
            output = execute_in_sandbox(code, session_id, endpoint)
            next_input.append(
                {
                    "type": "function_call_output",
                    "call_id": call.call_id,
                    "output": output,
                }
            )
        previous_response_id = response.id

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74import { randomUUID } from "node:crypto";
import OpenAI from "openai";

async function runComputerUse(endpoint, prompt, model = "gpt-6-astra") {
  const client = new OpenAI();
  const sessionId = randomUUID();

  const tools = [
    {
      type: "function",
      name: "exec_js",
      description: `Run JavaScript in a persistent browser. Available: Playwright's
browser, context, and page objects; console.log(value); and display(base64Image).
Save reusable variables on globalThis. Inspect a screenshot before acting and
check the screen after a short group of actions. Keep screenshots in memory.
Use top-level await for async operations. Return images with display() and concise
text with console.log(). The context viewport is 1440x900.`,
      parameters: {
        type: "object",
        properties: { code: { type: "string" } },
        required: ["code"],
        additionalProperties: false,
      },
      strict: true,
    },
  ];

  let nextInput = [{ role: "user", content: prompt }];
  let previousResponseId;

  for (let turn = 0; turn < 20; turn++) {
    const response = await client.responses.create({
      model,
      tools,
      input: nextInput,
      previous_response_id: previousResponseId,
      reasoning: { effort: "low" },
    });
    if (response.status !== "completed") {
      throw new Error(`Response stopped with status: ${response.status}`);
    }
    const calls = response.output.filter(
      (item) => item.type === "function_call"
    );
    if (
      calls.length === 0 &&
      response.output.some(
        (item) => item.type === "message" && item.phase !== "commentary"
      )
    ) {
      console.log(response.output_text);
      return;
    }
    if (turn === 19) {
      throw new Error(
        "The task reached the 20-response limit. Inspect the last result."
      );
    }

    nextInput = [];
    for (const call of calls) {
      if (call.name !== "exec_js")
        throw new Error(`Unexpected tool: ${call.name}`);
      const { code } = JSON.parse(call.arguments);
      const output = await executeInSandbox(code, sessionId, endpoint);
      nextInput.push({
        type: "function_call_output",
        call_id: call.call_id,
        output,
      });
    }
    previousResponseId = response.id;
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57require "json"
require "openai"
require "securerandom"

def run_computer_use(endpoint, prompt)
  client = OpenAI::Client.new
  session_id = SecureRandom.uuid
  tools = [
    {
      type: :function,
      name: "exec_py",
      description: "Run Python in a persistent desktop. Variables persist across calls. PyAutoGUI operations are synchronous. Available: pyautogui, time, log(value), and display(PIL_image). Inspect the screen with display(pyautogui.screenshot()) before acting. Use screenshot coordinates and check the screen after a short group of actions. Keep screenshots in memory and PyAutoGUI's fail-safe enabled.",
      parameters: {
        type: :object,
        properties: { code: { type: :string } },
        required: ["code"],
        additionalProperties: false
      },
      strict: true
    }
  ]
  next_input = []
  next_input << {
    role: :user,
    content: prompt
  }
  history = {}
  20.times do |turn|
    response = client.responses.create(
      model: "gpt-6-astra", tools: tools, input: next_input, previous_response_id: history[:id]
    )
    raise "Response stopped with status: #{response.status}" unless response.status == OpenAI::Responses::ResponseStatus::COMPLETED

    calls = response.output.grep(OpenAI::Responses::ResponseFunctionToolCall)
    if calls.empty? && response.output.any? { |item| item.is_a?(OpenAI::Responses::ResponseOutputMessage) && item.phase != :commentary }
      puts(response.output_text)
      return response
    end
    raise "The task reached the 20-response limit" if turn == 19

    next_input.clear
    calls.each do |call|
      raise "Unexpected tool: #{call.name}" unless call.name == "exec_py"

      code = JSON.parse(call.arguments).fetch("code")
      raise "Expected Python source text" unless code.is_a?(String)

      output = execute_in_sandbox(code, session_id, endpoint)
      next_input << {
        type: :function_call_output,
        call_id: call.call_id,
        output: output
      }
    end
    history[:id] = response.id
  end
end

Pour obtenir un adaptateur client complet et connaître le format attendu des sorties texte et image, consultez Connectez votre service d’exécution. L’interface du service présentée dans ces exemples appartient à votre application ; ce n’est pas un point de terminaison hébergé par OpenAI.

Préservez l’état et renvoyez les observations

Maintenez la session du navigateur ou du bureau active entre les appels. Un espace de noms Python ou JavaScript persistant permet aussi de conserver les variables. Décrivez les objets et les fonctions utilitaires disponibles dans la définition de l’outil afin que le modèle sache ce qu’il peut utiliser.

Fournissez au modèle une capture d’écran actuelle lorsque l’état de l’interface est inconnu. Après une courte série d’actions, renvoyez une autre capture pour qu’il puisse vérifier le résultat. Conservez les images en mémoire et utilisez detail: "original" pour préserver la résolution. Si vous réduisez la taille d’une capture d’écran, convertissez les coordonnées du modèle dans le système de coordonnées de l’environnement avant d’exécuter les actions. Consultez Capture d’écran et résolution.

La conversation API et l’environnement d’exécution ont chacun leur propre état. Conservez les appels d’outils et leurs sorties dans la conversation, et maintenez l’environnement correspondant disponible dans votre application. Poursuivre une réponse ne restaure ni la session du navigateur, ni l’état de connexion, ni les variables de l’environnement d’exécution.

Utilisez l’outil computer

Utilisez cette autre solution lorsque votre intégration attend des actions structurées plutôt que du code généré. Pour suivre l’approche recommandée, commencez par l’exécution de code.

Pour essayer cette approche, suivez la même procédure de configuration de l’application d’exemple, sélectionnez le mode Natif et exécutez un scénario intégré. Utilisez un modèle qui prend en charge l’outil computer.

L’échange avec l’API comporte trois étapes : envoyer une tâche, exécuter les actions renvoyées et renvoyer une capture d’écran. Les extraits de code présentés ici utilisent une page dotée d’une commande Afficher les filtres et d’un champ de recherche. Adaptez cette tâche à votre propre interface lors de l’intégration de l’outil.

Pour configurer l’environnement et implémenter les gestionnaires d’actions, utilisez les exemples pratiques d’intégration.

Envoyez la tâche

Activez computer dans le tableau tools et décrivez le résultat souhaité :

1
2
3
4
5
6
7
8
9
10
11
12import OpenAI from "openai";

const client = new OpenAI();

const response = await client.responses.create({
  model: "gpt-5.6-sol",
  tools: [{ type: "computer" }],
  input:
    "Check whether the Filters panel is open. If it is not open, click Show filters. Then type penguin in the search box. Use the computer tool for UI interaction.",
});

console.log(JSON.stringify(response.output, null, 2));

1
2
3
4
5
6
7
8
9
10
11from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5.6-sol",
    tools=[{"type": "computer"}],
    input="Check whether the Filters panel is open. If it is not open, click Show filters. Then type penguin in the search box. Use the computer tool for UI interaction.",
)

print(response.output)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22package main

import (
	"context"
	"fmt"

	"github.com/openai/openai-go/v3"
	"github.com/openai/openai-go/v3/responses"
)

func main() {
	client := openai.NewClient()
	response, err := client.Responses.New(context.Background(), responses.ResponseNewParams{
		Model: "gpt-5.6-sol",
		Tools: []responses.ToolUnionParam{{OfComputer: &responses.ComputerToolParam{}}},
		Input: responses.ResponseNewParamsInputUnion{OfString: openai.String("Check whether the Filters panel is open. If it is not open, click Show filters. Then type penguin in the search box. Use the computer tool for UI interaction.")},
	})
	if err != nil {
		panic(err)
	}
	fmt.Println(response.Output)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.core.JsonValue;
import com.openai.models.responses.ResponseCreateParams;
import java.util.List;
import java.util.Map;

ResponseCreateParams params =
    ResponseCreateParams.builder()
        .model("gpt-5.6-sol")
        .input(
            "Open the Filters panel if needed, then search for penguin. Use the computer tool for UI interaction.")
        .putAdditionalBodyProperty("tools", JsonValue.from(List.of(Map.of("type", "computer"))))
        .build();

client.responses().create(params).output().forEach(System.out::println);

1
2
3
4
5
6
7
8
9
10require "openai"

client = OpenAI::Client.new
response = client.responses.create(
  model: "gpt-5.6-sol",
  input: "Open the Filters panel if needed, then search for penguin. Use the computer tool for UI interaction.",
  tools: [{ type: :computer }]
)

puts(response.output)

Exécutez les actions demandées

Un computer_call contient un tableau actions ordonné. Par exemple, cet appel sélectionne le champ de recherche et y saisit penguin :

1
2
3
4
5
6
7
8
9
10
11
12
13{
  "output": [
    {
      "type": "computer_call",
      "call_id": "call_002",
      "actions": [
        { "type": "click", "button": "left", "x": 405, "y": 157 },
        { "type": "type", "text": "penguin" }
      ],
      "status": "completed"
    }
  ]
}

Votre gestionnaire d’actions convertit ces demandes en entrées pour le navigateur ou le système d’exploitation. Exécutez les actions autorisées dans l’ordre, puis capturez l’écran mis à jour. Le modèle peut demander click, double_click, drag, move, scroll, keypress, type, wait ou screenshot.

Le premier appel peut ne contenir qu’une action screenshot. Dans ce cas, capturez l’écran actuel et renvoyez-le sans modifier l’interface. La valeur status: "completed" d’un appel signifie que le modèle a fini de générer cet appel ; votre application doit encore l’exécuter.

Consultez les exemples de gestionnaires d’actions pour les correspondances de touches, les trajectoires de glissement et les touches de modification.

Renvoyez la capture d’écran

Renvoyez un computer_call_output dont le call_id correspond à l’appel que vous avez traité. Utilisez previous_response_id pour poursuivre la conversation avec le modèle :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24import OpenAI from "openai";

const client = new OpenAI();

async function sendComputerScreenshot(response, callId, screenshotBase64) {
  const output = {
    type: "computer_screenshot",
    image_url: `data:image/png;base64,${screenshotBase64}`,
    detail: "original",
  };

  return await client.responses.create({
    model: "gpt-5.6-sol",
    tools: [{ type: "computer" }],
    previous_response_id: response.id,
    input: [
      {
        type: "computer_call_output",
        call_id: callId,
        output,
      },
    ],
  });
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22from openai import OpenAI

client = OpenAI()


def send_computer_screenshot(response, call_id, screenshot_base64):
    return client.responses.create(
        model="gpt-5.6-sol",
        tools=[{"type": "computer"}],
        previous_response_id=response.id,
        input=[
            {
                "type": "computer_call_output",
                "call_id": call_id,
                "output": {
                    "type": "computer_screenshot",
                    "image_url": f"data:image/png;base64,{screenshot_base64}",
                    "detail": "original",
                },
            }
        ],
    )

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33package main

import (
	"context"
	"fmt"

	"github.com/openai/openai-go/v3"
	"github.com/openai/openai-go/v3/responses"
)

func main() {
	client := openai.NewClient()
	response, err := sendComputerScreenshot(client, "resp_abc123", "call_abc123", "<base64 bytes here>")
	if err != nil {
		panic(err)
	}
	fmt.Println(response.Output)
}

func sendComputerScreenshot(client openai.Client, responseID string, callID string, screenshotBase64 string) (*responses.Response, error) {
	screenshot := responses.ResponseComputerToolCallOutputScreenshotParam{
		ImageURL: openai.String("data:image/png;base64," + screenshotBase64),
	}
	screenshot.SetExtraFields(map[string]any{"detail": "original"})
	return client.Responses.New(context.Background(), responses.ResponseNewParams{
		Model:              "gpt-5.6-sol",
		Tools:              []responses.ToolUnionParam{{OfComputer: &responses.ComputerToolParam{}}},
		PreviousResponseID: openai.String(responseID),
		Input: responses.ResponseNewParamsInputUnion{OfInputItemList: responses.ResponseInputParam{
			responses.ResponseInputItemParamOfComputerCallOutput(callID, screenshot),
		}},
	})
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.core.JsonValue;
import com.openai.models.responses.ResponseComputerToolCallOutputScreenshot;
import com.openai.models.responses.ResponseCreateParams;
import com.openai.models.responses.ResponseInputItem;
import java.util.List;
import java.util.Map;

String responseId = "resp_abc123";

String computerCallId = "call_abc123";

String screenshotBase64 = "<base64 bytes here>";

ResponseCreateParams params =
    ResponseCreateParams.builder()
        .model("gpt-5.6-sol")
        .input(
            ResponseCreateParams.Input.ofResponse(
                List.of(
                    ResponseInputItem.ofComputerCallOutput(
                        ResponseInputItem.ComputerCallOutput.builder()
                            .callId(computerCallId)
                            .output(
                                ResponseComputerToolCallOutputScreenshot.builder()
                                    .imageUrl("data:image/png;base64," + screenshotBase64)
                                    .putAdditionalProperty("detail", JsonValue.from("original"))
                                    .build())
                            .build()))))
        .previousResponseId(responseId)
        .putAdditionalBodyProperty("tools", JsonValue.from(List.of(Map.of("type", "computer"))))
        .build();

client.responses().create(params).output().forEach(System.out::println);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21require "openai"

client = OpenAI::Client.new
response = client.responses.create(
  model: "gpt-5.6-sol",
  previous_response_id: "resp_abc123",
  input: [
    {
      type: :computer_call_output,
      call_id: "call_abc123",
      output: {
        type: :computer_screenshot,
        image_url: "data:image/png;base64,<base64 bytes here>",
        detail: :original
      }
    }
  ],
  tools: [{ type: :computer }]
)

puts(response.output)

Les mêmes recommandations concernant les captures d’écran et l’état s’appliquent à cette boucle. Maintenez l’environnement disponible pendant que previous_response_id poursuit la conversation avec le modèle.

Continuez jusqu’à ce que le modèle cesse de renvoyer des éléments computer_call. Examinez le reste de la sortie pour y repérer une réponse, une demande d’aide ou un autre appel d’outil, puis vérifiez le résultat dans l’application. Dans cet exemple, le panneau Filtres devrait être ouvert et le champ de recherche devrait contenir penguin.

Consultez Répétez la boucle d’utilisation de l’ordinateur pour obtenir la structure de la boucle, y compris les fonctions utilitaires nécessaires aux actions et aux captures d’écran.

Exécutez les tâches en toute sécurité

L’utilisation de l’ordinateur peut avoir des effets sur des comptes et des données réels. Appliquez ces mesures de contrôle dans votre application et votre environnement d’exécution, ainsi que dans les instructions du modèle :

• Restreignez l’environnement. Utilisez un navigateur isolé ou une machine virtuelle et une liste de sites et d’actions autorisés. Limitez les accès au strict nécessaire pour la tâche.
• Traitez le contenu à l’écran comme non fiable. Le texte d’une page, d’un document ou d’un résultat d’outil ne peut ni accorder une autorisation ni prévaloir sur les instructions de l’utilisateur.
• Confirmez les actions aux conséquences importantes. Laissez aux utilisateurs le contrôle des achats, de la transmission de données, des modifications destructrices et des autres actions difficiles à annuler. La saisie d’informations sensibles dans un formulaire constitue une transmission.
• Encadrez et vérifiez l’exécution. Fixez des limites de nombre d’étapes, de durée ou de coût, prévoyez la possibilité d’annuler l’exécution et vérifiez le résultat réel au lieu de vous fier uniquement à la réponse finale du modèle.

Consultez les consignes relatives à la confirmation et au consentement pour connaître les exigences précises d’approbation et les modalités de reprise en main par un humain, ainsi que pour trouver des exemples de prompts.

Prochaines étapes

• Utilisez les exemples d’intégration pour configurer l’environnement, mettre en place les gestionnaires d’actions, capturer l’écran et créer des adaptateurs pour les services d’exécution.
• Suivez les instructions de migration depuis computer-use-preview pour mettre à jour une intégration plus ancienne.
• Explorez l’application d’exemple CUA pour découvrir des flux de travail complets dans un navigateur et sur un bureau.