Pour accéder à l’index complet de la documentation, consultez llms.txt. Pour obtenir la version Markdown d’une page de documentation, ajoutez .md à la fin de l’URL de la page.
Navigation principale
Nov 20, 2026 API

Prise en compte du temps et saisie asynchrone pour les agents personnels

Comment créer des agents qui tiennent compte des contraintes de temps et poursuivent leur travail en attendant une réponse de l’utilisateur

Auteur: Kevin Whinnery

Prise en compte du temps et saisie asynchrone pour les agents personnels

Si vous créez un agent personnel semblable à un dot, vous souhaiterez souvent qu’il remette ses résultats à l’utilisateur dans un délai précis.

Imaginons que j’aie rendez-vous avec un client potentiel dans 15 minutes. Je demande à mon agent de se renseigner sur l’entreprise et de préparer une note de synthèse en me laissant trois minutes pour la lire avant la réunion. C’est à peu près le temps dont je dispose habituellement pour préparer mes réunions au cours d’une journée de travail 😬.

L’agent remarque que je n’ai pas précisé si la réunion porte sur une évaluation technique ou sur les tarifs. Or, les détails à examiner et les informations à inclure dans la note dépendent de cette distinction.

L’agent décide de me demander quel est l’objet de la réunion. Comment peut-il mettre à profit le temps qui reste, tenir compte de ma réponse si elle arrive et me remettre une note utile même si je ne réponds jamais ?

Prise en compte du temps et saisie asynchrone

Grâce à la prise en compte du temps, une fonctionnalité récemment ajoutée à l’API Agents, le modèle reçoit régulièrement un rappel de l’heure qu’il est et peut adapter son travail à l’échéance. Les outils de type fonction asynchrones permettent à l’agent de poursuivre son travail pendant que l’application attend une réponse de l’utilisateur final.

La réunion commence dans 15 minutes. L’agent dispose donc de 12 minutes pour préparer ma note. À l’approche de l’échéance, il peut donner la priorité à la vérification des informations les plus solides et à la rédaction de la note avant d’explorer une nouvelle piste. Si vous lui accordez un délai plus long, le modèle sait qu’il peut approfondir ses recherches et en mener d’autres.

Une demande comme « J’ai une réunion dans 15 minutes. Prépare-moi une note de synthèse et laisse-moi trois minutes pour la lire » fixe l’échéance. La prise en compte du temps permet au modèle de suivre l’heure pendant qu’il attend les résultats de recherche ou la réponse de l’utilisateur.

4:00de l’après-midi
Note à remettre à 16 h 12
DébutRemise de la noteRéunion
Agent
Recherches sur l’entreprise
Question pour vous
Sujet de la réunion non précisé
Notes
Pied Piper
Note de préparation à la réunion
Présentation de l’entreprise
Annonces récentes

Pour illustrer ce fonctionnement, nous allons configurer un agent qui aide les utilisateurs à préparer leurs réunions. Dans l’illustration, à 16 h UTC, je demande une note pour 16 h 12 en vue d’une réunion à 16 h 15. Nous verrons comment configurer l’agent, lui indiquer régulièrement l’heure, réagir à ses appels d’outils et traiter son résultat final.

Vous pouvez consulter directement le code complet de l’exemple dans le langage de votre choix.

Créez l’agent

Pour aider l’utilisateur à préparer une réunion, notre agent doit se renseigner sur l’entreprise, demander les précisions qui lui manquent sur la réunion et suivre le temps dont il dispose pour rédiger une note. Il lui faut donc un outil de recherche web, un outil asynchrone pour interroger l’utilisateur et la fonctionnalité de prise en compte du temps.

Pour créer un agent avec cette configuration, utilisez la méthode de création d’agent du SDK :

  • Définissez experimental.time_awareness sur true pour que le modèle reçoive régulièrement un rappel de l’heure.
  • Activez l’outil intégré web_search en mode live pour que l’agent puisse rechercher des informations à jour sur le web.
  • Définissez un outil de type fonction nommé request_user_input_async. Définissez async sur true pour que l’agent puisse poursuivre son travail pendant que votre application recueille la réponse.

Définissez OPENAI_API_KEY avec une clé provenant d’un projet ayant accès à l’API Agents. Suivez le guide des bibliothèques SDK pour installer un SDK officiel et créer le client utilisé ci-dessous. Consultez les prérequis du guide de démarrage rapide de l’API Agents pour connaître les autorisations nécessaires.

Création de l’agent de préparation des réunions
async def create_agent(client: AsyncOpenAI):
    return await client.beta.agents.create(
        name="Personal assistant",
        model="gpt-6.2-astra",
        experimental={"time_awareness": True},
        instructions=(
            "You are a personal assistant. Deliver useful, well-sourced answers "
            "within the user's time constraints. Ask for clarification when it "
            "would materially improve the result, and keep making progress while "
            "a reply is pending. State important uncertainties."
        ),
        tools=[
            {"type": "web_search", "mode": "live"},
            {
                "type": "function",
                "name": "request_user_input_async",
                "description": "Ask for missing context while continuing independent work.",
                "async": True,
                "parameters": {
                    "type": "object",
                    "properties": {
                        "question": {"type": "string"},
                        "choices": {"type": "array", "items": {"type": "string"}},
                    },
                    "required": ["question"],
                    "additionalProperties": False,
                },
            },
        ],
    )

Lancez une tâche avec une échéance

Nous pouvons maintenant demander à l’agent de préparer une réunion avec un client. La demande précise le nom de l’entreprise, l’heure de la réunion et l’heure de remise de la note. L’agent choisit les recherches à mener et décide s’il doit demander des précisions.

Démarrez une session avec la méthode de création de session du SDK et recevez les mises à jour en continu pendant que l’agent travaille.

Votre application doit convertir les indications de temps telles que « dans 15 minutes » et « trois minutes pour la lire » en horodatages absolus afin que le modèle et l’application utilisent les mêmes repères temporels. Ce code indique à l’agent que la réunion commence dans 15 minutes et lui demande de remettre la note dans 12 minutes.

Démarrage de la session de préparation de la réunion
now = datetime.now(UTC)
meeting = (now + timedelta(minutes=15)).isoformat(timespec="seconds")
delivery = (now + timedelta(minutes=12)).isoformat(timespec="seconds")
stream = await client.beta.agents.sessions.create(
    agent_id=agent.id,
    environment={"type": "none"},
    input=(
        f"I am meeting with Pied Piper (example.com) about our customer-support software at "
        f"{meeting}. Get me up to speed on their business, recent product "
        f"announcements, and questions I should ask. Send me a concise briefing by "
        f"{delivery} so I have time to read it before the meeting."
    ),
    stream=True,
    timeout=12 * 60,
)

Affichez une question en attente de réponse

Lorsque l’agent demande quel est l’objet de la réunion, l’application doit afficher la question pendant que les recherches sur l’entreprise se poursuivent. En recueillant la réponse dans une tâche distincte, l’application peut continuer à recevoir les mises à jour de l’agent.

C’est à votre application de recueillir la réponse de l’utilisateur lorsque le modèle demande des précisions au moyen d’un appel d’outil.

Surveillez le flux d’événements de la session pour repérer les événements agent.session.turn.item.done contenant un appel à la fonction request_user_input_async. Lisez la question et les éventuelles réponses proposées dans item.arguments. La liste required_actions de la session décrit les actions bloquantes. Si vous attendez qu’une entrée y apparaisse, vous risquez de manquer une question asynchrone.

Enregistrez l’identifiant de la session ainsi que les valeurs turn_id et call_id de l’appel pour associer la réponse à la question. Suivez les questions en attente afin de n’afficher et de ne traiter chacune qu’une seule fois. Annulez leurs gestionnaires de saisie à la fin de l’exécution de l’agent.

Traitement d’une question en attente
item = event.item
if (
    isinstance(item, AgentFunctionCallItem)
    and item.name == "request_user_input_async"
    and item.call_id not in questions
):
    questions[item.call_id] = asyncio.create_task(
        respond(
            client,
            event.session_id,
            item,
            replies,
            prompt_lock,
            reply_cutoff,
        )
    )

La question arrive sous la forme d’un événement d’appel de fonction :

{
  "type": "agent.session.turn.item.done",
  "item": {
    "type": "function_call",
    "name": "request_user_input_async",
    "arguments": {
      "question": "Is this meeting mainly a technical evaluation or a commercial discussion?",
      "choices": ["Technical evaluation", "Commercial discussion"]
    },
    "turn_id": "turn_789abcd",
    "call_id": "call_012ef34"
  }
}

Renvoyez le résultat de l’outil

La réponse de l’utilisateur permet à l’agent de cibler la note en fonction de l’objectif de la réunion. Même sans réponse, l’agent doit avoir le temps de terminer la rédaction. L’application ferme donc les questions restées sans réponse à 16 h 10, deux minutes avant la remise de la note.

Renvoyez un résultat d’outil par appel en attente tant que l’agent est en cours d’exécution :

  • À la réception d’une réponse, définissez status sur answered et placez le texte saisi ou l’option choisie dans answer.
  • À l’heure limite de réponse, si l’appel portant le même call_id est toujours en attente et que l’utilisateur n’a pas répondu, renvoyez {"status":"no_answer"}.

Envoyez le résultat avec la méthode du SDK qui crée un événement de session. Utilisez les identifiants enregistrés pour associer le résultat à la question. Continuez à lire le flux pendant l’envoi du résultat. Si l’agent termine plus tôt, fermez la question en attente dans l’interface.

Renvoi de la réponse ou signalement de l’expiration du délai
result = (
    {"status": "answered", "answer": answer} if answer else {"status": "no_answer"}
)
await client.beta.agents.sessions.events.create(
    session_id,
    events=[
        {
            "type": "agent.session.input.tool_result",
            "turn_id": call.turn_id,
            "call_id": call.call_id,
            "success": True,
            "output": json.dumps(result),
        }
    ],
)

Récupérez la réponse et transmettez-la

Remettez une note concise dès qu’elle est prête, en laissant à l’utilisateur au moins trois minutes pour la lire avant la réunion. Si l’échéance arrive avant, renvoyez la dernière note achevée ou indiquez qu’aucun résultat vérifié n’est disponible.

À la réception de agent.session.turn.completed, récupérez les éléments enregistrés avec la méthode du SDK qui liste les éléments d’un tour. Recherchez le message terminé de l’agent dont le champ phase vaut final_answer.

Si le flux se ferme prématurément, listez les tours de la session pour vérifier l’état enregistré. Consultez la section sur la reprise du flux pour vous reconnecter et récupérer le travail enregistré.

Récupération de la note finale
def final_text(item: AgentSessionItem | AgentOutputItem) -> str:
    if (
        item.type == "message"
        and item.role == "assistant"
        and item.status == "completed"
        and item.phase == "final_answer"
    ):
        return "\n".join(
            part.text for part in item.content if part.type == "output_text"
        )
    return ""


async def retrieve_answer(client: AsyncOpenAI, session_id: str, turn_id: str) -> str:
    async for item in client.beta.agents.sessions.turns.items.list(
        turn_id, session_id=session_id, order="desc"
    ):
        if text := final_text(item):
            return text
    return ""

Code complet de l’exemple

Pour chaque langage, l’exemple ci-dessous regroupe dans un seul fichier toutes les étapes de préparation d’une réunion, de la configuration du client à la libération des ressources, en passant par le traitement des réponses asynchrones et la minuterie de remise de la note. Chaque script lit la variable d’environnement OPENAI_API_KEY et accepte les réponses saisies dans le terminal.

Exemple complet de préparation d’une réunion
import asyncio
import json
import os
import sys
from contextlib import AsyncExitStack, suppress
from datetime import UTC, datetime, timedelta
from threading import Thread

from openai import AsyncOpenAI, ConflictError
from openai.types.beta import AgentFunctionCallItem, AgentOutputItem, AgentSessionItem

client = AsyncOpenAI(max_retries=0)


async def create_agent(client: AsyncOpenAI):
    return await client.beta.agents.create(
        name="Personal assistant",
        model="gpt-6.2-astra",
        experimental={"time_awareness": True},
        instructions=(
            "You are a personal assistant. Deliver useful, well-sourced answers "
            "within the user's time constraints. Ask for clarification when it "
            "would materially improve the result, and keep making progress while "
            "a reply is pending. State important uncertainties."
        ),
        tools=[
            {"type": "web_search", "mode": "live"},
            {
                "type": "function",
                "name": "request_user_input_async",
                "description": "Ask for missing context while continuing independent work.",
                "async": True,
                "parameters": {
                    "type": "object",
                    "properties": {
                        "question": {"type": "string"},
                        "choices": {"type": "array", "items": {"type": "string"}},
                    },
                    "required": ["question"],
                    "additionalProperties": False,
                },
            },
        ],
    )




def console_replies() -> asyncio.Queue[str]:
    loop = asyncio.get_running_loop()
    replies: asyncio.Queue[str] = asyncio.Queue()

    def read_lines():
        with os.fdopen(
            os.dup(sys.stdin.fileno()), encoding=sys.stdin.encoding
        ) as terminal:
            for line in terminal:
                try:
                    loop.call_soon_threadsafe(replies.put_nowait, line.strip())
                except RuntimeError:
                    return  # The session and its event loop have closed.

    # A pending terminal read must not keep the program open after delivery.
    Thread(target=read_lines, daemon=True).start()
    return replies


async def respond(client, session_id, call, replies, prompt_lock, cutoff):
    loop = asyncio.get_running_loop()
    try:
        async with asyncio.timeout_at(cutoff), prompt_lock:
            if loop.time() >= cutoff:
                raise TimeoutError
            print(call.arguments["question"], file=sys.stderr, flush=True)
            for choice in call.arguments.get("choices", []):
                print(f"  {choice}", file=sys.stderr, flush=True)
            reply = await replies.get()
            answer = reply if loop.time() < cutoff else ""
    except TimeoutError:
        answer = ""

    result = (
        {"status": "answered", "answer": answer} if answer else {"status": "no_answer"}
    )
    await client.beta.agents.sessions.events.create(
        session_id,
        events=[
            {
                "type": "agent.session.input.tool_result",
                "turn_id": call.turn_id,
                "call_id": call.call_id,
                "success": True,
                "output": json.dumps(result),
            }
        ],
    )


def final_text(item: AgentSessionItem | AgentOutputItem) -> str:
    if (
        item.type == "message"
        and item.role == "assistant"
        and item.status == "completed"
        and item.phase == "final_answer"
    ):
        return "\n".join(
            part.text for part in item.content if part.type == "output_text"
        )
    return ""


async def retrieve_answer(client: AsyncOpenAI, session_id: str, turn_id: str) -> str:
    async for item in client.beta.agents.sessions.turns.items.list(
        turn_id, session_id=session_id, order="desc"
    ):
        if text := final_text(item):
            return text
    return ""




async def main():
    async with client, AsyncExitStack() as cleanup:
        agent = await create_agent(client)
        cleanup.push_async_callback(client.beta.agents.delete, agent.id)
        sessions = client.beta.agents.sessions
        session_id = None
        active = False
        saved_answer = ""
        questions = {}
        prompt_lock = asyncio.Lock()
        replies = console_replies()
        loop = asyncio.get_running_loop()
        started = loop.time()
        reply_cutoff = started + 10 * 60
        try:
            async with asyncio.timeout_at(started + 12 * 60):
                now = datetime.now(UTC)
                meeting = (now + timedelta(minutes=15)).isoformat(timespec="seconds")
                delivery = (now + timedelta(minutes=12)).isoformat(timespec="seconds")
                stream = await client.beta.agents.sessions.create(
                    agent_id=agent.id,
                    environment={"type": "none"},
                    input=(
                        f"I am meeting with Pied Piper (example.com) about our customer-support software at "
                        f"{meeting}. Get me up to speed on their business, recent product "
                        f"announcements, and questions I should ask. Send me a concise briefing by "
                        f"{delivery} so I have time to read it before the meeting."
                    ),
                    stream=True,
                    timeout=12 * 60,
                )
                async with stream:
                    async for event in stream:
                        if event.type == "agent.session.created":
                            session_id = event.session.id
                            # A cancelled turn can take a moment to release its session.
                            cleanup_sessions = client.with_options(
                                max_retries=4, timeout=10
                            ).beta.agents.sessions
                            cleanup.push_async_callback(
                                cleanup_sessions.delete, session_id
                            )
                            active = True
                        elif event.type == "agent.session.turn.item.done":
                            item = event.item
                            if (
                                isinstance(item, AgentFunctionCallItem)
                                and item.name == "request_user_input_async"
                                and item.call_id not in questions
                            ):
                                questions[item.call_id] = asyncio.create_task(
                                    respond(
                                        client,
                                        event.session_id,
                                        item,
                                        replies,
                                        prompt_lock,
                                        reply_cutoff,
                                    )
                                )
                            saved_answer = final_text(item) or saved_answer
                        elif event.type == "agent.session.turn.completed":
                            active = False
                            for question in questions.values():
                                question.cancel()
                            # Allow the creation stream to finish releasing its connection.
                            with suppress(TimeoutError):
                                async with asyncio.timeout(1):
                                    async for _ in stream:
                                        continue
                            answer = await retrieve_answer(
                                client, event.session_id, event.turn.id
                            )
                            print(
                                answer
                                or saved_answer
                                or "No verified findings were available.",
                                flush=True,
                            )
                            return
                        elif event.type in (
                            "agent.session.failed",
                            "agent.session.environment.failed",
                            "agent.session.turn.failed",
                            "agent.session.turn.cancelled",
                            "error",
                        ):
                            active = False
                            raise RuntimeError(
                                f"Meeting briefing stopped: {event.type}"
                            )
                        for question in questions.values():
                            if question.done():
                                error = question.exception()
                                # A finished turn can reject a reply still in flight.
                                if error is not None and not isinstance(
                                    error, ConflictError
                                ):
                                    raise error
                raise RuntimeError("The event stream closed before the turn completed.")
        except TimeoutError:
            print(
                saved_answer or "No verified findings were available by the deadline.",
                flush=True,
            )
        finally:
            for question in questions.values():
                question.cancel()
            await asyncio.gather(*questions.values(), return_exceptions=True)
            if active and session_id:
                await sessions.events.create(
                    session_id, events=[{"type": "agent.session.input.cancel"}]
                )


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

Prise en compte du temps dans une boucle de l’API Responses

Si vous avez vous-même écrit la boucle d’appels à l’API Responses de votre agent personnel, votre application doit tenir le modèle informé du temps qui lui reste pour préparer la note. Calculez l’échéance une seule fois, puis ajoutez un rappel de l’heure avant chaque requête au modèle, y compris celles qui transmettent des résultats d’outils.

Les étapes ci-dessous mettent en œuvre la même tâche de préparation de réunion. Chaque requête à l’API Responses indique au modèle l’heure qu’il est. Une minuterie reste active dans l’application tout au long de la boucle pour assurer la remise de la note même si une requête ou un outil prend trop de temps.

1. Fixez l’heure de la réunion et l’échéance de la note

Indiquez à l’agent sur quelle entreprise il doit se renseigner et à quelle heure il doit remettre la note. Conservez les mêmes instructions générales et le même outil de questionnement asynchrone pour que le modèle décide s’il a besoin de précisions.

La réunion commence dans 15 minutes, la note est attendue dans 12 minutes et l’application ferme les questions restées sans réponse 10 minutes après le début de la tâche. Gardez ces échéances fixes tout au long de la tâche.

Configuration de la tâche de préparation de réunion avec l’API Responses
import asyncio
import json
import os
import sys
from contextlib import suppress
from dataclasses import dataclass, field
from datetime import UTC, datetime, timedelta
from threading import Thread

from openai import APITimeoutError, AsyncOpenAI, OpenAIError
from openai.types.responses import (
    Response,
    ResponseFunctionToolCall,
    ResponseInputItemParam,
    ToolParam,
)

instructions = (
    "You are a personal assistant. Deliver useful, well-sourced answers "
    "within the user's time constraints. Ask for clarification when it "
    "would materially improve the result, and keep making progress while "
    "a reply is pending. State important uncertainties."
)
tools: list[ToolParam] = [
    {"type": "web_search"},
    {
        "type": "function",
        "name": "request_user_input_async",
        "description": "Ask for missing context while continuing independent work.",
        "async": True,
        "strict": False,
        "parameters": {
            "type": "object",
            "properties": {
                "question": {"type": "string"},
                "choices": {"type": "array", "items": {"type": "string"}},
            },
            "required": ["question"],
            "additionalProperties": False,
        },
    },
]

@dataclass
class State:
    response_ids: list[str] = field(default_factory=list)
    questions: dict[str, asyncio.Task[ResponseInputItemParam]] = field(
        default_factory=dict
    )
    seen_calls: set[str] = field(default_factory=set)
    latest_response_id: str | None = None
    saved_answer: str = ""

def configure_task():
    now = datetime.now(UTC)
    started = asyncio.get_running_loop().time()
    meeting = (now + timedelta(minutes=15)).isoformat(timespec="seconds")
    delivery = (now + timedelta(minutes=12)).isoformat(timespec="seconds")
    reply_cutoff = started + 10 * 60
    delivery_cutoff = started + 12 * 60
    input_items = [
        {
            "role": "user",
            "content": (
                f"I am meeting with Pied Piper (example.com) about our customer-support software at "
                f"{meeting}. Get me up to speed on their business, recent product "
                f"announcements, and questions I should ask. Send me a concise briefing by "
                f"{delivery} so I have time to read it before the meeting."
            ),
        }
    ]
    return input_items, reply_cutoff, delivery_cutoff
2. Ajoutez l’heure avant chaque requête au modèle

Le modèle a besoin de connaître l’heure au moment de choisir sa prochaine action. Utilisez la même fonction pour envoyer la requête initiale et toutes les requêtes suivantes. Vous n’aurez ainsi qu’un seul endroit où actualiser l’heure.

Juste avant d’appeler l’API Responses, ajoutez l’heure UTC actuelle dans un message de développeur, après la saisie de l’utilisateur ou les résultats d’outils. Envoyez les instructions et les outils à chaque requête. L’échéance initiale reste dans l’historique de la conversation.

Actualisation de l’heure et création d’une réponse
async def start_response(input_items, previous_response_id, delivery_cutoff):
    remaining = delivery_cutoff - asyncio.get_running_loop().time()
    if remaining <= 0:
        raise TimeoutError
    current_time = datetime.now(UTC).isoformat(timespec="seconds")
    return await client.responses.create(
        model="gpt-6.2-astra",
        instructions=instructions,
        tools=tools,
        previous_response_id=previous_response_id,
        input=[
            *input_items,
            {"role": "developer", "content": f"Current time: {current_time}."},
        ],
        store=True,
        stream=True,
        timeout=remaining,
    )
3. Recueillez la réponse pendant les recherches

Lorsque l’agent demande quel est l’objet de la réunion, affichez la question et recueillez la réponse de l’utilisateur indépendamment de la génération de la réponse du modèle. Le gestionnaire de saisie renvoie la réponse de l’utilisateur dès qu’elle arrive, ou no_answer à l’heure limite. Il utilise le call_id d’origine pour associer le résultat à la bonne question.

Collecte asynchrone de la précision demandée
def console_replies() -> asyncio.Queue[str]:
    loop = asyncio.get_running_loop()
    replies: asyncio.Queue[str] = asyncio.Queue()

    def read_lines():
        with os.fdopen(
            os.dup(sys.stdin.fileno()), encoding=sys.stdin.encoding
        ) as terminal:
            for line in terminal:
                try:
                    loop.call_soon_threadsafe(replies.put_nowait, line.strip())
                except RuntimeError:
                    return

    Thread(target=read_lines, daemon=True).start()
    return replies

async def collect_reply(call, replies, prompt_lock, reply_cutoff):
    arguments = json.loads(call.arguments)
    answer = ""
    # An expired question keeps the empty answer and returns no_answer.
    with suppress(TimeoutError):
        async with asyncio.timeout_at(reply_cutoff), prompt_lock:
            if asyncio.get_running_loop().time() >= reply_cutoff:
                raise TimeoutError
            print(arguments["question"], file=sys.stderr, flush=True)
            for choice in arguments.get("choices", []):
                print(f"  {choice}", file=sys.stderr, flush=True)
            reply = await replies.get()
            if asyncio.get_running_loop().time() < reply_cutoff:
                answer = reply
    result = (
        {"status": "answered", "answer": answer} if answer else {"status": "no_answer"}
    )
    return {
        "type": "function_call_output",
        "call_id": call.call_id,
        "output": json.dumps(result),
    }
4. Traitez les questions et les réponses terminées

Démarrez le gestionnaire de saisie dès que la question complète arrive dans le flux de réponse. Continuez à lire les événements pendant que l’utilisateur réfléchit à sa réponse afin que le modèle puisse poursuivre ses recherches sur le web.

Lorsque le modèle termine une réponse, enregistrez son identifiant pour la requête suivante et conservez toute note achevée pour pouvoir la remettre à l’utilisateur. Le gestionnaire d’événements enregistre également les identifiants des réponses pour permettre leur suppression ultérieure.

Lecture des questions du flux et des réponses terminées
def final_text(response: Response) -> str:
    return "\n".join(
        part.text
        for item in response.output
        if item.type == "message"
        and item.status == "completed"
        and item.phase in (None, "final_answer")
        for part in item.content
        if part.type == "output_text"
    )

async def read_response(stream, state, replies, prompt_lock, reply_cutoff):
    async with stream:
        async for event in stream:
            if event.type == "response.created":
                state.response_ids.append(event.response.id)
            elif event.type == "response.output_item.done":
                call = event.item
                if (
                    isinstance(call, ResponseFunctionToolCall)
                    and call.name == "request_user_input_async"
                    and call.call_id not in state.seen_calls
                ):
                    state.seen_calls.add(call.call_id)
                    state.questions[call.call_id] = asyncio.create_task(
                        collect_reply(call, replies, prompt_lock, reply_cutoff)
                    )
            elif event.type == "response.completed":
                state.latest_response_id = event.response.id
                answer = final_text(event.response)
                state.saved_answer = answer or state.saved_answer
                # Give the transport a moment to finish after the terminal event.
                with suppress(TimeoutError):
                    async with asyncio.timeout(1):
                        async for _ in stream:
                            continue
                return answer
            elif event.type in ("response.failed", "response.incomplete", "error"):
                raise RuntimeError(f"Meeting briefing stopped: {event.type}")
    raise RuntimeError("The response stream closed before completion.")
5. Poursuivez la boucle avec les résultats disponibles

La version suivante de la note doit tenir compte de toute réponse de l’utilisateur reçue pendant les recherches. Après chaque réponse du modèle, recueillez les résultats d’outils disponibles et envoyez-les avec la fonction d’envoi des requêtes, qui ajoute un nouveau rappel de l’heure. Utilisez l’identifiant de la dernière réponse terminée comme valeur de previous_response_id, même lorsqu’un résultat correspond à une question posée dans une réponse antérieure.

Envoyez les requêtes l’une après l’autre pour que chacune s’appuie sur le dernier état de la conversation. Si la note est terminée et qu’aucun résultat d’outil n’est disponible, remettez-la à l’utilisateur et fermez les questions en attente. Sinon, poursuivez le travail en tenant compte de l’heure actualisée, sans attendre de réponse de l’utilisateur.

Poursuite des recherches et prise en compte des réponses
async def run_loop(input_items, state, replies, reply_cutoff, delivery_cutoff):
    prompt_lock = asyncio.Lock()
    while True:
        stream = await start_response(
            input_items, state.latest_response_id, delivery_cutoff
        )
        answer = await read_response(stream, state, replies, prompt_lock, reply_cutoff)
        await asyncio.sleep(0)  # Let ready input handlers finish.
        input_items = []
        for call_id, task in list(state.questions.items()):
            if task.done():
                input_items.append(task.result())
                del state.questions[call_id]
        if input_items:
            continue  # Incorporate replies that arrived during generation.
        if answer:
            return answer
        input_items = [
            {
                "role": "developer",
                "content": "Continue working on the briefing while replies are pending.",
            }
        ]
6. Respectez l’échéance même si une requête est en cours

Une minuterie dans l’application fait respecter l’heure de remise de la note pour que l’utilisateur dispose du temps prévu pour la lire. Appliquez cette minuterie à toute la boucle, y compris aux requêtes à l’API et à la lecture du flux.

À l’échéance, arrêtez la requête en cours et remettez la note enregistrée, ou indiquez qu’aucun résultat vérifié n’est disponible. Après la remise de la note, fermez les gestionnaires de saisie encore en attente et supprimez les réponses stockées.

Remise de la note à temps et libération des ressources de la tâche
async def main():
    state = State()
    replies = console_replies()
    input_items, reply_cutoff, delivery_cutoff = configure_task()
    async with client:
        try:
            async with asyncio.timeout_at(delivery_cutoff):
                answer = await run_loop(
                    input_items, state, replies, reply_cutoff, delivery_cutoff
                )
            print(answer, flush=True)
        except (TimeoutError, APITimeoutError):
            print(
                state.saved_answer
                or "No verified findings were available by the deadline.",
                flush=True,
            )
        finally:
            for task in state.questions.values():
                task.cancel()
            await asyncio.gather(*state.questions.values(), return_exceptions=True)
            for response_id in reversed(state.response_ids):
                try:
                    await client.responses.delete(response_id, timeout=10)
                except OpenAIError as error:
                    print(f"Could not delete {response_id}: {error}", file=sys.stderr)


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

Conclusion

Les agents personnels doivent parfois terminer leur travail dans un délai précis. Dans l’idéal, ils demandent des précisions pour améliorer le résultat. Même sans ces précisions, ils doivent pouvoir accomplir un travail utile.

Nous avons fixé une échéance à l’agent et activé la prise en compte du temps pour l’aider à décider s’il doit approfondir ses recherches, vérifier une information ou terminer la rédaction. Les outils de type fonction asynchrones lui ont permis de poursuivre ses recherches pendant que l’utilisateur réfléchissait à sa réponse. Même si la question reste sans réponse, l’agent dispose d’assez de contexte pour rédiger une note utile à la préparation de la réunion.

ChatGPT et d’autres harnais d’agents utilisent cette approche pour poursuivre le travail tout en demandant des précisions à l’utilisateur. Nous espérons que la prise en compte du temps dans l’API Agents vous aidera à mettre en œuvre cette approche dans vos propres applications. Montrez-nous ce que vous créez !