Wer deine Anwendung nutzt, kann Anforderungen ergänzen oder die Richtung ändern, während das Modell noch antwortet.
Mit Modellen der GPT-6-Familie kannst du laufende Antworten über eine WebSocket-Verbindung zur Responses API steuern. GPT-5.6 und frühere Modelle unterstützen diese Funktion nicht.
Eine neue Anweisung ändert keine Ausgaben, die der Server bereits an deine Anwendung gesendet hat. Sie macht frühere Aktionen nicht rückgängig und bricht bereits gestartete Tools nicht ab.
Für das Java-Beispiel brauchst du Java 17 oder höher. Wie du die Verbindung herstellst und wie die Datenübertragung grundsätzlich funktioniert, erfährst du im Leitfaden zum WebSocket-Modus. Die genauen Ereignisdefinitionen findest du in der Referenz zu WebSocket-Ereignissen der Responses API.
Eine neue Anweisung senden
Starte eine Antwort mit response.create. Sobald du das zugehörige Ereignis response.created erhältst, sende response.steer über dieselbe Verbindung. Verwende die ID dieser Antwort als previous_response_id:
{
"type": "response.steer",
"previous_response_id": "resp_1",
"input": "Keep the scope small enough for one developer to finish in two weeks."
}
Das Ereignis akzeptiert nur die Felder type, previous_response_id und input. Übergib in input eine Zeichenfolge oder ein nicht leeres Array von Nutzernachrichten mit unterstützten Inhaltstypen.
Mit response.steer.accepted bestätigt die API, dass sie die Eingabe in die Warteschlange aufgenommen hat:
{
"type": "response.steer.accepted",
"sequence_number": 4,
"steer": {
"id": "steer_0123456789abcdef0123456789abcdef",
"previous_response_id": "resp_1"
}
}
Die Bestätigung sagt nur aus, dass die Eingabe in der Warteschlange liegt. Ob das Modell sie bereits umgesetzt hat, geht daraus nicht hervor. Die API erstellt automatisch eine neue Antwort, die deine Anweisung berücksichtigt, es sei denn, sie benötigt von deiner Anwendung ein Tool-Ergebnis oder eine Genehmigung.
Bevor der Server die Antwort automatisch fortsetzt, schließt er das aktuelle Ausgabeelement und alle bereits laufenden Aufrufe gehosteter Tools ab. Lies die Ereignisse weiter, um die Antwort mit deiner neuen Anweisung zu erhalten. Sende kein weiteres response.create.
Wenn die neue Anweisung die ursprüngliche Antwort unterbricht, endet diese mit response.incomplete und incomplete_details.reason: "steered". Wird die ursprüngliche Antwort vorher regulär abgeschlossen, behält sie den Status „abgeschlossen“. Die neue Anweisung kann trotzdem eine Fortsetzung auslösen.
Automatische Fortsetzungen übernehmen die Einstellungen der ursprünglichen Anfrage. Die Limits für Token und Tool-Aufrufe gelten für jede Antwort separat.
Ein vollständiges Beispiel ausführen
Das .NET SDK bietet keinen WebSocket-Client für die Responses API. Daher gibt es für dieses Beispiel keine SDK-Variante in C#.
import 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())Das Beispiel sendet die neue Anweisung nach dem ersten Ereignis response.created. Sende sie in deiner Anwendung, sobald jemand eine neue Anweisung eingibt. Verwende für weitere Anweisungen die ID der Fortsetzung, sobald du das zugehörige Ereignis response.created erhältst.
Tool-Ergebnisse oder eine Genehmigung zurückgeben
Wenn die Antwort das Ergebnis eines clientseitigen Tools oder eine Genehmigung benötigt, lässt die API die neue Anweisung in der Warteschlange. Setze den üblichen Ablauf für Tool-Aufrufe oder Genehmigungen über dieselbe Verbindung fort.
Die ursprüngliche Antwort kann beispielsweise mit einem Aufruf von get_project_status enden. Die folgenden Ereignisdaten zeigen nur die relevanten Felder:
{
"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\"}"
}
]
}
}
Nach Abschluss der ursprünglichen Antwort sendet die API response.steer.pending für angenommene Anweisungen, für die noch Eingaben fehlen. Das Feld required_input gibt an, welche Tool-Ergebnisse oder Genehmigungen die API benötigt, bevor sie die Anweisung umsetzen kann:
{
"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"
}
]
}
Sende die erforderliche Eingabe mit response.create über dieselbe Verbindung und setze previous_response_id auf resp_1. Sende die bereits angenommene Anweisung nicht erneut. Für ein explizit gesendetes response.create gelten die darin angegebenen Tools, Anweisungen und sonstigen Einstellungen.
Die Kommentare in diesem JSONC-Beispiel zeigen, wo der Server die Anweisung aus der Warteschlange einfügt:
{
"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.",
},
],
}
Du kannst Tool-Ergebnisse zurückgeben, ohne auf response.steer.pending zu warten. Hat der Server bereits ein passendes response.create erhalten, kann er fortfahren, ohne vorher diese Benachrichtigung zu senden.
Fehler und Verbindungsabbrüche behandeln
response.steer.failed bedeutet, dass die API die Eingabe zur Steuerung der Antwort nicht angewendet hat und sie auch später nicht automatisch anwenden wird. Das Ereignis gibt die ursprünglichen Werte von input und previous_response_id unter steer zurück. Ein error-Objekt beschreibt den Fehler.
Verfolge angenommene Anweisungen anhand von steer.id. Tritt später ein Fehler auf, enthält das Fehlerereignis dieselbe ID.
Häufige Fehlercodes:
invalid_input: Verwende nur die unterstützten Ereignisfelder und übergib als Eingabe ausschließlich Nutzernachrichten.steering_not_supported: Möglicherweise unterstützen das Modell, die gewählten Anfrageparameter oder beide die Steuerung laufender Antworten nicht.response_not_found: Die Antwort, die du steuern möchtest, muss über dieselbe WebSocket-Verbindung noch verfügbar sein.too_many_pending_steers: Es sind zu viele Anweisungen in der Warteschlange. Gib erforderliche Tool-Ergebnisse oder Genehmigungen mitresponse.createzurück. Falls keine erforderlich sind, warte auf die automatische Fortsetzung, bevor du weitere Anweisungen sendest. Sende bereits angenommene Anweisungen nicht erneut.
Anweisungen in der Warteschlange sind nur über die aktuelle Verbindung verfügbar. Die API speichert sie nicht zusammen mit der ursprünglichen Antwort. Protokolliere die gesendeten Anweisungen und gleiche sie mit den Antwortereignissen und dem Verlauf ab, bevor du sie erneut sendest. Verlasse dich nicht darauf, dass ausstehende Anweisungen nach einem Verbindungsabbruch noch vorliegen. Weitere Informationen findest du in den Hinweisen zur Wiederherstellung nach einem WebSocket-Verbindungsabbruch.