Laufende Agent-Dialogrunde steuern (Vorschauversion)

Mit der Steuerung können Sie einen langfristig gehosteten Agent umleiten, während er noch funktioniert. Eine neue Eingabe wird hinter der aktiven Dialogrunde in die Warteschlange eingereiht, und der aktuell laufende Handler wird kooperativ beendet. Dieser Ansatz verhindert, dass die neue Dialogrunde abgelehnt wird oder dass zwei Runden gleichzeitig verarbeitet werden.

Aktivieren der Steuerung

Antwortprotokoll

steerable_conversations=True auf ResponsesServerOptions festlegen:

app = ResponsesAgentServerHost(
    options=ResponsesServerOptions(steerable_conversations=True),
)

Eine zweite Dialogrunde, die in einer bereits ausgelasteten Unterhaltung eingeht, wird in die Warteschlange gestellt, und der aktuelle Handler wird kooperativ abgebrochen. Dieser Ansatz verhindert, dass 409 conversation_locked zurückgegeben wird. Senden Sie das Follow-up als neue Antwort, wobei previous_response_id auf die laufende Antwort und dieselbe agent_session_id gesetzt ist.

Aufrufe und Aufgabengrundtypen

Übergeben steerable=True an @multi_turn_task:

@multi_turn_task(name="conv", steerable=True)
async def conv(ctx: TaskContext[dict]) -> dict:
    return await llm(ctx.input)

# A .start() against an in-flight chain queues instead of raising.
r1 = asyncio.create_task(conv.start(task_id="c1", input={"msg": "Plan a trip to Rome"}))
await asyncio.sleep(0.05)
r2 = asyncio.create_task(conv.start(task_id="c1", input={"msg": "Actually, Paris"}))
# r1 resolves with turn 1's outcome; r2 resolves with turn 2's outcome.

Ohne steerable=True löst ein gleichzeitiger .start() bei einer laufenden Kette einen TaskConflictError aus.

Aktive Dialogrunde beenden

Wenn etwas in die Warteschlange gestellt wird, signalisiert das Framework dem laufenden Handler dies über das Signal zum kooperativen Abbruch. Ein steuerbarer Handler sollte an sicheren Grenzen darauf prüfen und vorzeitig zurückkehren, damit die in der Warteschlange befindliche Dialogrunde übernehmen kann:

@multi_turn_task(name="conv", steerable=True)
async def conv(ctx: TaskContext[dict]) -> dict:
    for step in plan:
        if ctx.cancel.is_set() and ctx.pending_input_count > 0:
            # A newer turn is waiting - stop at this boundary and let it run.
            return partial_result
        await do_step(step)
    return final_result

Steuerung der Beobachtbarkeit auf den Kontext:

Die Reihenfolge wechselt mit einer Vorbedingung.

Wenn ein Client bezüglich einer Nachrichtensortierung schlussfolgert, übergeben Sie if_last_input_id, damit ein veralteter Aufrufer nicht angefügt werden kann, nachdem ein anderer Aufrufer die Kette erweitert hat. Es ist das Äquivalent der Eingabewarteschlange zu einem HTTP If-Match:

await conv.start(task_id="c1", input=new_msg, if_last_input_id=prev_input_id)

Wenn die zuletzt akzeptierte Eingabe der Kette nicht mehr zutrifft, löst der Aufruf LastInputIdPreconditionFailed aus.

Mit einer vollen Warteschlange umgehen

Die Steeringwarteschlange ist begrenzt. Wenn sie voll ist, wird von einer Warteschlangeneinreichung SteeringQueueFull ausgelöst. Zeigen Sie dem Benutzer ein klares „Bitte warten“-Signal an, anstatt die Eingabe im Hintergrund zu verwerfen:

try:
    run = await conv.start(task_id="c1", input=new_msg)
except SteeringQueueFull:
    return {"status": "busy", "detail": "Too many pending turns; try again shortly."}

Steuerbare Unterhaltungen erfolgen sequenziell, nicht verzweigt: Neuere Eingaben können hinter der aktiven Dialogrunde in die Warteschlange eingereiht werden oder sie unterbrechen, die Unterhaltung hat jedoch weiterhin genau eine letzten Dialogrunde und einen geordneten Verlauf.

Verwandte Inhalte

• Resilienz für gehostete Agenten mit langer Laufzeit
• API-Referenz für langlebige Agenten
• Bereitstellen eines steuerbaren Agents
• Einen Genehmigungsschritt mit Human-in-the-Loop hinzufügen
• Lang andauernde Arbeit nach einem Absturz wiederherstellen