Révision automatique

La révision automatique approuve ou refuse les demandes d’approbation prises en charge à mesure que l’agent travaille, comme le fait la fonction d’approbation automatique de ChatGPT et de Codex. Configurez-la à l’aide du champ review lorsque vous créez une session pour votre agent. Ce réglage s’applique aux tours de l’agent principal et à tous les sous-agents qu’il crée au cours de ces tours.

Fonctionnement

La révision automatique permet à vos agents d’utiliser la fonctionnalité « Approuver à ma place » du harnais Codex. Pendant une session, une demande d’approbation peut survenir lorsque l’action que l’agent prévoit d’effectuer nécessite des autorisations supplémentaires. Voici quelques exemples d’actions susceptibles de déclencher une demande d’approbation :

• Les commandes shell et les entrées de terminal qui nécessitent une approbation, notamment en cas d’élévation de privilèges ou de commande potentiellement dangereuse.
• Les modifications de fichiers qui nécessitent une approbation.
• Les demandes d’autorisations supplémentaires, par exemple pour étendre l’accès au système de fichiers ou au réseau.
• Les demandes d’accès au réseau qui nécessitent une approbation et restent soumises aux restrictions réseau de l’environnement.
• Les appels d’outils MCP dont les règles d’approbation exigent une confirmation.

Un modèle de révision géré par OpenAI s’appuie sur le contexte de la conversation pour déterminer ce que ferait l’action, quels risques elle présente et si elle correspond à l’intention de l’utilisateur. Le modèle approuve ou refuse ensuite la demande.

Les tokens utilisés pour la révision sont facturés en plus de l’utilisation du modèle par votre agent.

Votre application continue de traiter les demandes d’accès à une origine dans le navigateur et les demandes de connexion à un compte. Les formulaires MCP qui nécessitent une saisie et les demandes qui dirigent l’utilisateur vers une URL suivent leur procédure habituelle. La révision automatique ne nécessite aucun nouveau gestionnaire d’événements d’approbation. Consultez la section Événements et éléments pour suivre la progression de l’agent et vérifier le résultat du tour.

Choisissez un mode de révision

Définissez le champ review de la session pour choisir le comportement souhaité :

Si vous omettez review, la valeur par défaut est "none". La session conserve ce réglage à sa reprise. Pour le modifier, envoyez "auto_review" ou "none". L’API refuse la valeur null. Si vous définissez review sur "none", votre application ne reçoit pas ces actions pour approbation manuelle.

Préparez l’environnement d’exécution

Pour une exécution hébergée par OpenAI, créez la session avec un nouvel environnement, éventuellement à partir d’un modèle d’environnement. La révision automatique n’est pas prise en charge si vous réutilisez un environnement hébergé existant au moyen de environment_id.

Pour une exécution auto-hébergée, configurez l’environnement auto-hébergé et assurez-vous de remplir les prérequis du bac à sable pour votre système d’exploitation avant d’activer la révision automatique. Le champ review ne suffit pas à configurer l’exécution en bac à sable dans votre environnement.

La révision automatique ne modifie pas les restrictions réseau de l’environnement. Configurez l’accès sortant dans les paramètres réseau de l’environnement. Ces restrictions s’appliquent même si l’accès à une origine a été approuvé dans le navigateur.

Créez une session avec la révision automatique

Définissez review sur "auto_review" lorsque vous créez une session. Cet exemple demande à l’agent d’exécuter npm install dans /workspace.

Après avoir configuré votre clé API et votre SDK, utilisez un agent existant et un modèle d’environnement qui fournit Node.js et un projet contenant /workspace/package.json. Remplacez les identifiants de l’agent et du modèle d’environnement de l’exemple par les vôtres.

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

const client = new OpenAI();
const session = await client.beta.agents.sessions.create({
  agent_id: "agt_123",
  environment: {
    type: "openai_hosted",
    environment_template_id: "envtmpl_123",
  },
  review: "auto_review",
  input: "Run npm install in /workspace.",
});
console.log(session.id);

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

client = OpenAI()
session = client.beta.agents.sessions.create(
    agent_id="agt_123",
    environment={
        "type": "openai_hosted",
        "environment_template_id": "envtmpl_123",
    },
    review="auto_review",
    input="Run npm install in /workspace.",
)
print(session.id)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22import (
	"context"
	"fmt"

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

client := openai.NewClient()
session, err := client.Beta.Agents.Sessions.New(context.Background(), openai.BetaAgentSessionNewParams{
	AgentID: openai.String("agt_123"),
	Environment: openai.EnvironmentParamUnion{
		OfParamOpenAIHosted: &openai.EnvironmentParamOpenAIHosted{
			EnvironmentTemplateID: openai.String("envtmpl_123"),
		},
	},
	Review: openai.BetaAgentSessionNewParamsReviewAutoReview,
	Input:  openai.BetaAgentSessionNewParamsInputUnion{OfString: openai.String("Run npm install in /workspace.")},
})
if err != nil {
	panic(err)
}
fmt.Println(session.ID)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.beta.agents.EnvironmentParam;
import com.openai.models.beta.agents.sessions.SessionCreateParams;

OpenAIClient client = OpenAIOkHttpClient.fromEnv();
var session =
    client
        .beta()
        .agents()
        .sessions()
        .create(
            SessionCreateParams.builder()
                .agentId("agt_123")
                .environment(
                    EnvironmentParam.OpenAIHosted.builder()
                        .environmentTemplateId("envtmpl_123")
                        .build())
                .review(SessionCreateParams.Review.AUTO_REVIEW)
                .input("Run npm install in /workspace.")
                .build());
System.out.println(session.id());

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

client = OpenAI::Client.new
session = client.beta.agents.sessions.create(
  agent_id: "agt_123",
  environment: {
    type: :openai_hosted,
    environment_template_id: "envtmpl_123"
  },
  review: :auto_review,
  input: "Run npm install in /workspace."
)
puts session.id

1
2
3
4
5
6
7
8
9
10
11
12
13curl --fail-with-body https://api.openai.com/v1/agents/sessions \
  -H "OpenAI-Beta: agents=v1" \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "agent_id": "agt_123",
    "environment": {
      "type": "openai_hosted",
      "environment_template_id": "envtmpl_123"
    },
    "review": "auto_review",
    "input": "Run npm install in /workspace."
  }'

Utilisez l’identifiant de session id renvoyé pour changer de mode de révision entre les tâches. Consultez la référence sur la création d’une session pour connaître les champs de la requête.

Votre projet doit avoir accès à la révision automatique. Si cette fonctionnalité est indisponible, l’API rejette les demandes d’activation et indique que review est le paramètre concerné.

Changez de mode de révision

Mettez à jour le champ review de la session entre les tâches. Avant de changer de mode, attendez que la tâche principale soit inactive et que l’envoi des entrées soit terminé. Cet exemple désactive la révision automatique. Remplacez sess_123 par l’identifiant de session renvoyé précédemment :

const updatedSession = await client.beta.agents.sessions.update("sess_123", {
  review: "none",
});
console.log(updatedSession.id);

updated_session = client.beta.agents.sessions.update("sess_123", review="none")
print(updated_session.id)

updatedSession, err := client.Beta.Agents.Sessions.Update(context.Background(), "sess_123", openai.BetaAgentSessionUpdateParams{
	Review: openai.BetaAgentSessionUpdateParamsReviewNone,
})
if err != nil {
	panic(err)
}
fmt.Println(updatedSession.ID)

import com.openai.models.beta.agents.sessions.SessionUpdateParams;

var updatedSession =
    client
        .beta()
        .agents()
        .sessions()
        .update(
            SessionUpdateParams.builder()
                .sessionId("sess_123")
                .review(SessionUpdateParams.Review.NONE)
                .build());
System.out.println(updatedSession.id());

updated_session = client.beta.agents.sessions.update("sess_123", review: :none)
puts updated_session.id

curl --fail-with-body https://api.openai.com/v1/agents/sessions/sess_123 \
  -X POST \
  -H "OpenAI-Beta: agents=v1" \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "review": "none"
  }'

La mise à jour renvoie 200 OK et la session mise à jour. Omettez review dans les autres mises à jour de la session pour conserver sa valeur. Pour réactiver la révision automatique, envoyez "review": "auto_review". Consultez la référence sur la mise à jour d’une session pour connaître les champs de la requête.

Si vous demandez un changement de mode alors que la tâche principale est active ou que l’envoi des entrées est encore en cours, l’API renvoie 409 Conflict. Elle n’applique aucune des modifications de cette requête. Réessayez une fois que la tâche est inactive et que l’envoi des entrées est terminé. Prévoyez le traitement de l’erreur 409 même après avoir vérifié l’état de la session, car de nouvelles entrées peuvent arriver avant la mise à jour. Vous pouvez envoyer la valeur actuelle du mode de révision même pendant l’exécution de la tâche.

Récupérez une session ou affichez la liste des sessions pour vérifier la valeur enregistrée dans le champ review. Si la réponse omet ce champ, considérez que sa valeur est "none".