Réorientation d’une réponse en cours

La réorientation d’une réponse en cours permet aux utilisateurs d’ajouter des exigences ou de changer de direction sans attendre la fin de la réponse.

Les modèles de la famille GPT-6 prennent en charge la réorientation sur une connexion WebSocket à l’API Responses. GPT-5.6 et les modèles antérieurs ne la prennent pas en charge.

La réorientation ne modifie pas le contenu déjà envoyé à votre application. Elle n’annule ni les actions précédentes ni l’exécution des outils déjà lancés.

L’exemple Java nécessite Java 17 ou une version ultérieure. Pour savoir comment établir la connexion et comprendre le fonctionnement général du transport, consultez le guide du mode WebSocket. Pour connaître la définition exacte de chaque événement, consultez la référence des événements WebSocket de l’API Responses.

Envoyez une consigne de réorientation

Lancez une réponse avec response.create. À la réception de son événement response.created, envoyez response.steer sur la même connexion en indiquant l’identifiant de cette réponse dans previous_response_id :

12345{
  "type": "response.steer",
  "previous_response_id": "resp_1",
  "input": "Keep the scope small enough for one developer to finish in two weeks."
}

L’événement accepte uniquement les champs type, previous_response_id et input. Donnez à input une chaîne de caractères ou un tableau non vide de messages utilisateur dont le contenu est d’un type pris en charge.

L’API confirme la mise en file d’attente de la consigne avec response.steer.accepted :

12345678{
  "type": "response.steer.accepted",
  "sequence_number": 4,
  "steer": {
    "id": "steer_0123456789abcdef0123456789abcdef",
    "previous_response_id": "resp_1"
  }
}

Cette confirmation indique seulement que la consigne est en file d’attente. Le modèle ne l’a pas nécessairement prise en compte. L’API crée automatiquement une nouvelle réponse qui intègre votre consigne, sauf si elle attend de votre application un résultat d’outil ou une approbation.

Avant de créer cette réponse de suivi automatique, le serveur termine l’élément de sortie en cours ainsi que les opérations déjà lancées par les outils hébergés. Continuez à lire les événements pour recevoir la réponse qui intègre votre consigne. N’envoyez pas de nouvel événement response.create.

Si la réorientation interrompt la réponse initiale, celle-ci se termine avec response.incomplete et incomplete_details.reason: "steered". Si la réponse initiale se termine normalement avant la réorientation, elle conserve son statut de réponse terminée et peut tout de même être suivie d’une réponse qui intègre la nouvelle consigne.

Les réponses de suivi automatiques héritent des paramètres de la requête initiale. Les limites de tokens et d’appels d’outils s’appliquent séparément à chaque réponse.

Exécutez un exemple complet

Le SDK .NET ne fournit pas de client WebSocket pour l’API Responses. Cet exemple n’a donc pas de variante utilisant le SDK C#.

Modifiez le plan d’un projet pendant sa génération

Python

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
74
75
76
77
78
79
80
81
82
83
84// Set OPENAI_API_KEY before running this example.
// Install the SDK and WebSocket transport: npm install openai ws

import OpenAI from "openai";
import { ResponsesWS } from "openai/resources/responses/ws";

const client = new OpenAI();
const ws = new ResponsesWS(client, {
  handshakeTimeout: 10_000,
});
let initialResponseId = "";
let successorResponseId = "";
let timeout;

try {
  const output = await new Promise((resolve, reject) => {
    timeout = setTimeout(() => {
      reject(new Error("Timed out waiting for the steered response."));
      ws.close();
    }, 120_000);
    ws.once("error", reject);
    ws.once("close", () => {
      reject(
        new Error("Connection closed before the steered response finished.")
      );
    });
    ws.on("event", (event) => {
      try {
        if (event.type === "response.created") {
          if (!initialResponseId) {
            initialResponseId = event.response.id;
            // Simulate a user adding instructions while the response runs.
            ws.send({
              type: "response.steer",
              previous_response_id: initialResponseId,
              input:
                "Keep the scope small enough for one developer to finish in two weeks.",
            });
          } else {
            successorResponseId = event.response.id;
          }
        } else if (
          ["response.steer.failed", "response.failed", "error"].includes(
            event.type
          )
        ) {
          reject(new Error(JSON.stringify(event)));
        } else if (
          event.type === "response.incomplete" &&
          (event.response.id !== initialResponseId ||
            event.response.incomplete_details?.reason !== "steered")
        ) {
          reject(new Error(JSON.stringify(event)));
        } else if (
          event.type === "response.completed" &&
          event.response.id === successorResponseId
        ) {
          let text = "";
          for (const item of event.response.output) {
            if (item.type !== "message") continue;
            for (const part of item.content) {
              if (part.type === "output_text") text += part.text;
            }
          }
          resolve(text);
        }
        // Acceptance only queues the input. Keep reading past the first response.
      } catch (error) {
        reject(error);
      }
    });
    ws.send({
      type: "response.create",
      store: false,
      model: "gpt-6-astra",
      reasoning: { effort: "medium" },
      input: "Draft a project plan for building a task-tracking app.",
    });
  });
  console.log(output);
} finally {
  clearTimeout(timeout);
  ws.close();
}

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
53import asyncio

from openai import AsyncOpenAI


async def main():
    client = AsyncOpenAI()
    initial_response_id = None
    successor_response_id = None

    async with client.responses.connect() as connection:
        await connection.response.create(
            model="gpt-6-astra",
            store=False,
            reasoning={"effort": "medium"},
            input="Draft a project plan for building a task-tracking app.",
        )
        async for event in connection:
            if event.type == "response.created":
                if initial_response_id is None:
                    initial_response_id = event.response.id
                    # Simulate a user adding instructions while the response runs.
                    await connection.response.steer(
                        previous_response_id=initial_response_id,
                        input="Keep the scope small enough for one developer to finish in two weeks.",
                    )
                else:
                    successor_response_id = event.response.id
            elif event.type in {"response.steer.failed", "response.failed", "error"}:
                raise RuntimeError(event.to_json())
            elif event.type == "response.incomplete":
                response = event.response
                if (
                    response.id != initial_response_id
                    or response.incomplete_details is None
                    or response.incomplete_details.reason != "steered"
                ):
                    raise RuntimeError(event.to_json())
            elif (
                event.type == "response.completed"
                and event.response.id == successor_response_id
            ):
                print(event.response.output_text)
                return
            # Acceptance only queues the input. Keep reading past the first response.
        raise RuntimeError("Connection closed before the steered response finished.")


async def run():
    await asyncio.wait_for(main(), timeout=120)


asyncio.run(run())

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
61ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
defer cancel()
client := openai.NewClient()
conn, err := client.Responses.Connect(ctx, responses.ResponseConnectionOptions{})
if err != nil {
	log.Fatal(err)
}
defer conn.Close()
if err := conn.Create(ctx, responses.ResponsesClientEventResponseCreateParam{
	Model: "gpt-6-astra",
	Reasoning: shared.ReasoningParam{
		Effort: shared.ReasoningEffortMedium,
	},
	Store: openai.Bool(false),
	Input: responses.ResponsesClientEventResponseCreateInputUnionParam{
		OfString: openai.String("Draft a project plan for building a task-tracking app."),
	},
}); err != nil {
	log.Fatal(err)
}
initialID, successorID := "", ""
for {
	event, err := conn.Recv(ctx)
	if err != nil {
		log.Fatal(err)
	}
	switch event.Type {
	case "response.created":
		id := event.OfResponsesServerEventResponseWsCreated.Response.ID
		if initialID == "" {
			initialID = id
			err := conn.Send(ctx, responses.ResponsesClientEventUnionParam{
				OfResponseSteer: &responses.ResponseSteerEventParam{
					PreviousResponseID: id,
					Input: responses.ResponseSteerInputUnionParam{
						OfString: openai.String("Keep the scope small enough for one developer to finish in two weeks."),
					},
				},
			})
			if err != nil {
				log.Fatal(err)
			}
		} else {
			successorID = id
		}
	case "response.steer.failed", "response.failed", "error":
		log.Fatal(event.RawJSON())
	case "response.incomplete":
		r := event.OfResponsesServerEventResponseWsIncomplete.Response
		if r.ID != initialID || r.IncompleteDetails.Reason != "steered" {
			log.Fatal(event.RawJSON())
		}
	case "response.completed":
		r := event.OfResponsesServerEventResponseWsCompleted.Response
		if successorID != "" && r.ID == successorID {
			fmt.Println(r.OutputText())
			return
		}
	}
	// Steering acceptance only queues input. Wait for the successor to complete.
}

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
67import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.responses.*;
import java.util.*;

var client = OpenAIOkHttpClient.fromEnv();

long deadline = System.nanoTime() + java.util.concurrent.TimeUnit.SECONDS.toNanos(120);
try (var conn =
    client.async().responses().connect().get(10, java.util.concurrent.TimeUnit.SECONDS)) {
  conn.send(
      ResponsesClientEvent.ofResponseCreate(
          ResponsesClientEvent.ResponseCreate.builder()
              .model("gpt-6-astra")
              .reasoning(
                  com.openai.models.Reasoning.builder()
                      .effort(com.openai.models.ReasoningEffort.MEDIUM)
                      .build())
              .store(false)
              .input("Draft a project plan for building a task-tracking app.")
              .build()));
  String initialId = null, successorId = null;
  while (true) {
    var event =
        conn.receive()
            .get(
                Math.max(1, deadline - System.nanoTime()),
                java.util.concurrent.TimeUnit.NANOSECONDS);
    if (event.responseCreated().isPresent()) {
      var id = event.responseCreated().orElseThrow().response().id();
      if (initialId == null) {
        initialId = id;
        conn.send(
            ResponsesClientEvent.ofResponseSteer(
                ResponseSteerEvent.builder()
                    .previousResponseId(id)
                    .input(
                        "Keep the scope small enough for one developer to finish in two weeks.")
                    .build()));
      } else {
        successorId = id;
      }
    } else if (event.responseSteerFailed().isPresent()
        || event.responseFailed().isPresent()
        || event.error().isPresent()) {
      throw new IllegalStateException(event.toString());
    } else if (event.responseIncomplete().isPresent()) {
      var response = event.responseIncomplete().orElseThrow().response();
      if (!response.id().equals(initialId)
          || !response
              .incompleteDetails()
              .flatMap(Response.IncompleteDetails::reason)
              .map(r -> r.toString().equals("steered"))
              .orElse(false)) throw new IllegalStateException(event.toString());
    } else if (event.responseCompleted().isPresent()
        && event.responseCompleted().orElseThrow().response().id().equals(successorId)) {
      event.responseCompleted().orElseThrow().response().output().stream()
          .flatMap(item -> item.message().stream())
          .flatMap(message -> message.content().stream())
          .flatMap(content -> content.outputText().stream())
          .forEach(text -> System.out.println(text.text()));
      break;
    }
    // Acceptance only queues input; follow the successor through completion.
  }
} finally {
  client.close();
}

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
45require "async"
require "openai"

client = OpenAI::Client.new
Sync do |task|
  task.with_timeout(120) do
    client.responses.connect(request_options: { timeout: 10 }) do |connection|
      connection.response.create(
        model: "gpt-6-astra", store: false, reasoning: { effort: "medium" },
        input: "Draft a project plan for building a task-tracking app."
      )
      state = {}
      while (event = connection.receive)
        case event
        when OpenAI::Responses::ResponseCreatedEvent
          response = event.response
          if !state[:initial_id]
            state[:initial_id] = response.id
            connection.send_event(
              type: "response.steer", previous_response_id: state[:initial_id],
              input: "Keep the scope small enough for one developer to finish in two weeks."
            )
          else
            state[:successor_id] = response.id
          end
        when OpenAI::Responses::ResponseSteerFailedEvent, OpenAI::Responses::ResponseFailedEvent, OpenAI::Responses::ResponsesServerEvent::ResponseWsError
          raise "Steering failed: #{event.to_json}"
        when OpenAI::Responses::ResponseIncompleteEvent
          response = event.response
          unless response.id == state[:initial_id] && response.incomplete_details&.reason.to_s == "steered"
            raise "Response incomplete: #{event.to_json}"
          end
        when OpenAI::Responses::ResponseCompletedEvent
          response = event.response
          next unless state[:successor_id] && response.id == state[:successor_id]

          puts(response.output_text)
          state[:completed] = true
          break
        end
      end
      raise "Connection closed before the steered response finished" unless state[:completed]
    end
  end
end

L’exemple envoie la nouvelle consigne après le premier événement response.created. Dans votre application, envoyez-la lorsque l’utilisateur la fournit. Pour réorienter la réponse de suivi à son tour, utilisez son identifiant dès la réception de son événement response.created.

Renvoyez les résultats d’outils ou l’approbation

Si la réponse nécessite le résultat d’un outil exécuté côté client ou une approbation, l’API laisse la consigne de réorientation en file d’attente. Poursuivez votre procédure habituelle d’exécution des outils ou d’approbation sur la même connexion.

Par exemple, la réponse initiale peut se terminer par un appel à get_project_status. Seuls les champs pertinents figurent dans les données ci-dessous :

123456789101112131415{
  "type": "response.completed",
  "response": {
    "id": "resp_1",
    "status": "completed",
    "output": [
      {
        "type": "function_call",
        "call_id": "call_project",
        "name": "get_project_status",
        "arguments": "{\"project\":\"task-tracker\"}"
      }
    ]
  }
}

Une fois la réponse initiale terminée, l’API envoie response.steer.pending pour signaler qu’une consigne de réorientation acceptée nécessite encore des données. Le champ required_input de cet événement indique les résultats d’outils ou les approbations que l’API doit recevoir avant de pouvoir appliquer la consigne :

12345678910111213141516{
  "type": "response.steer.pending",
  "sequence_number": 12,
  "steer": {
    "id": "steer_0123456789abcdef0123456789abcdef",
    "previous_response_id": "resp_1"
  },
  "reason": "waiting_for_required_input",
  "required_input": [
    {
      "type": "function_call_output",
      "call_id": "call_project",
      "name": "get_project_status"
    }
  ]
}

Renvoyez les données requises avec response.create sur la même connexion en attribuant à previous_response_id la valeur resp_1. Ne renvoyez pas la consigne de réorientation déjà acceptée. Un événement response.create envoyé explicitement utilise ses propres outils, instructions et autres paramètres.

Les commentaires de cet exemple JSONC indiquent où le serveur insère la consigne en attente :

123456789101112131415161718{
  "type": "response.create",
  "model": "gpt-6-astra",
  "previous_response_id": "resp_1",
  "input": [
    // The server implicitly prepends your accepted steer here:
    // "Keep the scope small enough for one developer to finish in two weeks."
    {
      "type": "function_call_output",
      "call_id": "call_project",
      "output": "Design is complete. Development has not started.",
    },
    {
      "role": "user",
      "content": "Show me the updated plan before starting any work.",
    },
  ],
}

Vous pouvez renvoyer les résultats d’outils sans attendre response.steer.pending. Si le serveur a déjà reçu l’événement response.create correspondant, il peut poursuivre sans envoyer cette notification au préalable.

Gérez les échecs et les déconnexions

response.steer.failed indique que l’API n’a pas appliqué la consigne de réorientation et qu’elle ne l’appliquera pas automatiquement par la suite. L’événement renvoie les valeurs d’origine de input et de previous_response_id dans steer, ainsi qu’un objet error qui décrit l’échec.

Suivez les consignes acceptées à l’aide de steer.id. En cas d’échec ultérieur, l’événement utilise le même identifiant.

Codes d’erreur courants :

invalid_input : utilisez uniquement les champs pris en charge par l’événement et fournissez des messages utilisateur en entrée.
steering_not_supported : le modèle, les paramètres de la requête ou les deux peuvent être incompatibles avec la réorientation.
response_not_found : la réponse ciblée doit encore être disponible sur la même connexion WebSocket.
too_many_pending_steers : trop de consignes de réorientation sont en attente. Renvoyez les résultats d’outils ou les approbations requis avec response.create. Si aucun résultat ni aucune approbation ne sont requis, attendez la réponse de suivi automatique avant d’envoyer d’autres consignes. Ne renvoyez pas les consignes déjà acceptées.

Les consignes de réorientation en attente n’existent que sur la connexion en cours. L’API ne les enregistre pas avec la réponse initiale. Consignez les instructions de réorientation que vous envoyez et comparez-les aux événements et à l’historique des réponses avant de les renvoyer. Ne présumez pas que les consignes en attente ont été conservées après la déconnexion. Consultez les consignes de reconnexion et de reprise en mode WebSocket.

Suggestions

Premiers pas

Notions fondamentales

SDK et CLI

Fournisseurs de services cloud

Ressources

Anciennes API

Choisissez un modèle

Texte et code

Rédaction de prompts

Raisonnement

Images

Temps réel et audio

Modèles spécialisés

API Agents

Agents SDK

ChatKit

Recherche et récupération d’informations

Connectez des outils et des sources de données

Créez des workflows qui font appel à des outils

Ordinateur et code

Médias

GPT-Live

Realtime API

Créer des applications vocales

Connexions

Traitement audio

Mise en production

Performances et qualité

Évaluation

Coût et débit

Sécurité et gouvernance

Infrastructure et accès

Opérations

Concepts clés

Planification

Développement

Tests et publication

Spécifications de conversion

Guides

Ressources

Identité

Utilisation du forfait ChatGPT

Guides

Envoi de fichiers

API

Mesure des performances

API pour les annonceurs

Référence de l’API

Premiers pas

Premiers pas

Notions de base

Explorer

Disponible sur

Versions

Workflows

Capacités

Sites

dots

Espace ChatGPT

Référence

Personnalisation

Fichier de configuration

Configuration des agents

Étendre les fonctionnalités de ChatGPT et de Codex

Linux

Windows

Workflows de développement

Extensions et automatisation

Environnements

Codex Cloud

Développer avec Codex

Intégrations tierces

Référence

Autorisations

Codex Security

Cybersécurité

Premiers pas

Configuration des fonctionnalités

Identité et accès