Exécution des agents

Définir un agent n’est que la première étape. Il faut ensuite comprendre ce qui se passe pendant une exécution, comment la conversation se poursuit au tour suivant et comment le workflow se déroule lorsqu’il se met en pause pour attendre une approbation ou le résultat d’un appel d’outil.

La boucle d’exécution de l’agent

Chaque exécution du SDK correspond à un tour pour l’application. Le moteur d’exécution répète les étapes suivantes jusqu’à ce qu’une condition d’arrêt soit remplie :

1. Il appelle le modèle de l’agent actif avec les données d’entrée préparées.
2. Il examine la sortie du modèle.
3. Si le modèle produit des appels d’outils, le moteur les exécute et poursuit la boucle.
4. Si le modèle passe la main à un autre agent spécialisé, le moteur poursuit la boucle avec cet agent.
5. Si le modèle fournit une réponse finale et qu’il ne reste aucun appel d’outil à exécuter, le moteur renvoie un résultat.

Cette boucle est au cœur du SDK. Les outils, les passages de relais, les approbations et la diffusion en continu s’appuient tous sur elle sans la remplacer.

Choisissez une stratégie de gestion de la conversation

Il existe quatre façons courantes de conserver l’état de la conversation d’un tour à l’autre :

Dans la plupart des applications, choisissez une seule stratégie par conversation. Si vous rejouez l’historique local tout en utilisant un état géré côté serveur, vous risquez de dupliquer le contexte, sauf si vous prenez soin de réconcilier les deux états.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16import { Agent, MemorySession, run } from "@openai/agents";

const agent = new Agent({
  name: "Tour guide",
  instructions: "Answer with compact travel facts.",
});

const session = new MemorySession();

const firstTurn = await run(agent, "What city is the Golden Gate Bridge in?", {
  session,
});
console.log(firstTurn.finalOutput);

const secondTurn = await run(agent, "What state is it in?", { session });
console.log(secondTurn.finalOutput);

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

from agents import Agent, Runner, SQLiteSession

agent = Agent(
    name="Tour guide",
    instructions="Answer with compact travel facts.",
)

session = SQLiteSession("conversation_123")


async def main() -> None:
    first_turn = await Runner.run(
        agent,
        "What city is the Golden Gate Bridge in?",
        session=session,
    )
    print(first_turn.final_output)

    second_turn = await Runner.run(
        agent,
        "What state is it in?",
        session=session,
    )
    print(second_turn.final_output)


if __name__ == "__main__":
    asyncio.run(main())

Privilégiez les sessions si vous souhaitez disposer d’une mémoire persistante, reprendre un workflow après une demande d’approbation ou laisser votre application contrôler le stockage.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20import { Agent, run } from "@openai/agents";
import OpenAI from "openai";

const agent = new Agent({
  name: "Assistant",
  instructions: "Reply very concisely.",
});

const client = new OpenAI();
const { id: conversationId } = await client.conversations.create({});

const first = await run(agent, "What city is the Golden Gate Bridge in?", {
  conversationId,
});
console.log(first.finalOutput);

const second = await run(agent, "What state is it in?", {
  conversationId,
});
console.log(second.finalOutput);

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

from agents import Agent, Runner

agent = Agent(
    name="Assistant",
    instructions="Reply very concisely.",
)


async def main() -> None:
    first = await Runner.run(
        agent,
        "What city is the Golden Gate Bridge in?",
    )
    print(first.final_output)

    second = await Runner.run(
        agent,
        "What state is it in?",
        previous_response_id=first.last_response_id,
    )
    print(second.final_output)


if __name__ == "__main__":
    asyncio.run(main())

Utilisez conversationId si plusieurs systèmes doivent partager une même conversation nommée. Utilisez previousResponseId si vous cherchez l’option la moins coûteuse pour passer d’une réponse à la suivante.

Suivez les exécutions en continu

La diffusion en continu utilise la même boucle d’exécution et les mêmes stratégies de gestion de l’état. La seule différence est que vous traitez les événements au fur et à mesure de l’exécution.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22import { Agent, run } from "@openai/agents";

const agent = new Agent({
  name: "Planet guide",
  instructions: "Answer with short facts.",
});

const stream = await run(agent, "Give me three short facts about Saturn.", {
  stream: true,
});

for await (const event of stream) {
  if (
    event.type === "raw_model_stream_event" &&
    event.data.type === "output_text_delta"
  ) {
    process.stdout.write(event.data.delta);
  }
}

await stream.completed;
console.log("\nFinal:", stream.finalOutput);

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

from openai.types.responses import ResponseTextDeltaEvent

from agents import Agent, Runner

agent = Agent(
    name="Planet guide",
    instructions="Answer with short facts.",
)


async def main() -> None:
    stream = Runner.run_streamed(
        agent,
        "Give me three short facts about Saturn.",
    )

    async for event in stream.stream_events():
        if event.type == "raw_response_event" and isinstance(
            event.data, ResponseTextDeltaEvent
        ):
            print(event.data.delta, end="", flush=True)

    print(f"\nFinal: {stream.final_output}")


if __name__ == "__main__":
    asyncio.run(main())

Suivez ces trois règles :

• Attendez la fin du flux avant de considérer que l’exécution a atteint son point d’arrêt.
• Si l’exécution se met en pause dans l’attente d’une approbation, traitez les demandes figurant dans interruptions et reprenez l’exécution à partir de state plutôt que d’ouvrir un nouveau tour utilisateur.
• Si vous annulez un flux en cours de tour et souhaitez poursuivre ce même tour ultérieurement, reprenez-le à partir de state.

Gérez les pauses et les échecs

Deux types de situations peuvent interrompre le déroulement normal d’une exécution :

• Les échecs d’exécution ou de validation, par exemple lorsque le nombre maximal de tours est atteint, qu’un garde-fou lève une exception ou qu’un outil renvoie une erreur.
• Les pauses prévues, par exemple lorsqu’une approbation humaine est demandée. L’exécution est alors interrompue volontairement et doit reprendre ultérieurement à partir du même état.

Lorsqu’une approbation est demandée, considérez que l’exécution en cours est en pause et reprenez le même tour. Vous préservez ainsi la cohérence du nombre de tours, de l’historique et des identifiants utilisés pour poursuivre la conversation côté serveur.

Étapes suivantes

Une fois la boucle d’exécution comprise, consultez le guide qui correspond à la prochaine partie du workflow que vous devez concevoir.