Para ver el índice completo de la documentación, consulta llms.txt. Para ver la versión en Markdown de una página de la documentación, agrega .md al final de la URL de esa página.
Navegación principal
Nov 20, 2026 API

Seguimiento del tiempo y respuestas asíncronas del usuario en agentes personales

Cómo crear agentes que tengan en cuenta los plazos y sigan trabajando mientras esperan una respuesta del usuario

Autor: Kevin Whinnery

Seguimiento del tiempo y respuestas asíncronas del usuario en agentes personales

Si estás creando un agente personal similar a un dot, a menudo querrás que le entregue los resultados al usuario dentro de un plazo determinado.

Supongamos que en 15 minutos tengo una reunión con un posible cliente. Le pido a mi agente que investigue a la empresa y prepare un informe breve que me deje tres minutos para leerlo antes de la reunión. Más o menos con ese margen suelo prepararme para las reuniones durante la jornada laboral 😬.

El agente se da cuenta de que no le dije si la reunión es para hacer una evaluación técnica o para hablar de precios. De eso depende qué detalles conviene investigar y qué información incluir en el informe.

El agente decide preguntarme cuál es el objetivo de la reunión. ¿Cómo puede aprovechar el tiempo que queda mientras espera, incorporar mi respuesta si llega y entregar un informe útil incluso si nunca respondo?

Seguimiento del tiempo y respuestas asíncronas del usuario

El seguimiento del tiempo, una función que se incorporó hace poco a la API de agentes, le recuerda periódicamente al modelo qué hora es para que pueda ajustar su trabajo al plazo de entrega. Las herramientas de función asíncronas permiten que el agente siga trabajando mientras la aplicación espera la respuesta del usuario final.

Si faltan 15 minutos para la reunión, el agente tiene 12 minutos para preparar mi informe. A medida que se acerca la hora de entrega, puede dar prioridad a verificar los hallazgos mejor sustentados y redactar el informe antes de iniciar otra línea de investigación. Si le das un plazo más amplio, el modelo sabrá que tiene tiempo para investigar más a fondo.

Una solicitud como “Tengo una reunión en 15 minutos. Entrégame un informe cuando falten tres minutos para que pueda revisarlo” fija el plazo de entrega. El seguimiento del tiempo mantiene al modelo al tanto de la hora mientras espera los resultados de las búsquedas o la respuesta del usuario.

4:00p. m.
Entrega del informe a las 4:12
InicioEntrega del informeReunión
Agente
Investigando sobre la empresa
Pregunta para ti
Tema de la reunión sin definir
Notas
Pied Piper
Informe para la reunión
Antecedentes de la empresa
Anuncios recientes

Para ver cómo funciona, vamos a configurar un agente que ayude a los usuarios a prepararse para sus reuniones. En la ilustración, a las 16:00 UTC le pido un informe para las 16:12, antes de una reunión que empieza a las 16:15. Veremos cómo configurar el agente, mantenerlo al tanto de la hora, responder a sus llamadas a herramientas y procesar el resultado final.

Puedes ir directamente al código completo del ejemplo en el lenguaje de programación que prefieras.

Crear el agente

Para ayudar al usuario a prepararse para una reunión, el agente necesita investigar a la empresa, preguntar por los detalles de la reunión que aún desconoce y llevar la cuenta del tiempo que le queda para preparar el informe. Para eso necesita acceso a la búsqueda web, una herramienta asíncrona para hacerle preguntas al usuario y la función de seguimiento del tiempo.

Creamos un agente con esta configuración mediante el método del SDK para crear agentes:

  • Establece experimental.time_awareness en true para que el modelo reciba recordatorios periódicos de la hora actual.
  • Habilita la herramienta integrada web_search en modo live para que el agente pueda buscar información actualizada en la web.
  • Define una herramienta de función llamada request_user_input_async. Establece async en true para que el agente pueda seguir trabajando mientras tu aplicación recoge la respuesta.

Asigna a OPENAI_API_KEY una clave de un proyecto con acceso a la API de agentes. Sigue la guía de bibliotecas del SDK para instalar un SDK oficial y crear el objeto client que se usa a continuación. Consulta los requisitos previos de la guía de inicio rápido de la API de agentes para conocer los permisos necesarios.

Crear el agente de preparación de reuniones
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,
                },
            },
        ],
    )

Iniciar una tarea con un plazo de entrega

Ahora podemos pedirle al agente que nos ayude a preparar una reunión con un cliente. La solicitud indica de qué empresa se trata, a qué hora empieza la reunión y cuándo hay que entregar el informe. El agente decide qué investigar y si necesita pedir una aclaración.

Inicia una sesión con el método del SDK para crear sesiones y recibe las actualizaciones a medida que el agente trabaja.

Tu aplicación tendrá que convertir expresiones de tiempo como “dentro de 15 minutos” y “cuando queden tres minutos para revisarlo” en marcas de tiempo absolutas para que el modelo y la aplicación utilicen las mismas referencias temporales. Este código le indica al agente que la reunión empieza dentro de 15 minutos y le pide que entregue el informe dentro de 12 minutos.

Iniciar la sesión de preparación de la reunión
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,
)

Mostrar una pregunta pendiente

Cuando el agente pregunta por el objetivo de la reunión, la aplicación debe mostrar la pregunta mientras el agente sigue investigando a la empresa. Recoger la respuesta en una tarea independiente permite que la aplicación siga recibiendo las actualizaciones del agente.

Cuando el modelo pide una aclaración mediante una llamada a una herramienta, el código de tu aplicación se encarga de recoger la respuesta del usuario.

Revisa el flujo de eventos de la sesión para detectar eventos agent.session.turn.item.done que contengan una llamada a la función request_user_input_async. Lee la pregunta y las opciones de respuesta que se sugieran en item.arguments. La lista required_actions de la sesión describe las acciones que bloquean la ejecución. Si esperas a que aparezca una entrada en esa lista, podrías pasar por alto una pregunta asíncrona.

Guarda el ID de la sesión y los identificadores turn_id y call_id de la llamada para asociar la respuesta con la pregunta. Lleva un registro de las preguntas pendientes para mostrar y procesar cada una una sola vez. Cuando termine la ejecución del agente, cancela los manejadores que esperan esas respuestas:

Procesar una pregunta pendiente
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 pregunta llega en un evento de llamada a función:

{
  "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"
  }
}

Devolver el resultado de la herramienta

La respuesta del usuario ayuda al agente a orientar el informe según el objetivo de la reunión. Incluso si el usuario nunca responde, el agente necesita tiempo para terminar de redactar el informe. Por eso, la aplicación cierra las preguntas sin respuesta a las 16:10, dos minutos antes de la entrega.

Mientras el agente siga en ejecución, devuelve un resultado de la herramienta por cada llamada pendiente:

  • Cuando el usuario responda, establece status en answered y coloca en answer el texto que escribió o la opción que seleccionó.
  • Cuando venza el plazo para responder, si la llamada con el mismo call_id sigue pendiente y el usuario no ha respondido, devuelve {"status":"no_answer"}.

Envía el resultado mediante el método del SDK para eventos de sesión y usa los identificadores guardados para asociarlo con la pregunta. Sigue leyendo el flujo de eventos mientras envías el resultado. Si el agente termina antes, cierra la pregunta pendiente en la interfaz.

Devolver la respuesta o indicar que venció el plazo
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),
        }
    ],
)

Recuperar y entregar la respuesta

Entrega un informe breve en cuanto esté listo y deja al usuario al menos tres minutos para leerlo antes de la reunión. Si el plazo vence antes, devuelve el último informe completo o indica que todavía no hay hallazgos verificados.

Cuando llegue el evento agent.session.turn.completed, recupera los elementos guardados con el método del SDK para listar los elementos de un turno. Busca el mensaje completo del agente cuyo campo phase tenga el valor final_answer.

Si el flujo se cierra antes de tiempo, consulta la lista de turnos de la sesión para comprobar el estado guardado. Consulta la documentación sobre recuperación del flujo de eventos para saber cómo volver a conectarte y recuperar el trabajo guardado.

Recuperar el informe final
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 ""

Código completo del ejemplo

A continuación encontrarás, para cada lenguaje, un ejemplo con todo el proceso de preparación de la reunión en un solo archivo. Incluye la configuración del cliente, las respuestas asíncronas, el temporizador de entrega y la liberación de recursos. Cada script lee OPENAI_API_KEY del entorno y acepta respuestas desde la terminal.

Ejemplo completo de preparación de una reunión
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())

Seguimiento del tiempo en un bucle de la API de respuestas

Si tu agente personal usa un bucle de la API de respuestas que programaste tú, la aplicación debe mantener al modelo al tanto del tiempo que le queda para preparar el informe. Calcula la hora de entrega una sola vez. Luego, antes de cada solicitud al modelo, agrega un recordatorio con la hora actual, incluso en las solicitudes que envían resultados de herramientas.

Los siguientes pasos implementan la misma tarea de preparación de reuniones. Cada solicitud a la API de respuestas incluye un recordatorio con la hora actual para el modelo. Un temporizador de la aplicación permanece activo durante todo el bucle para asegurar la entrega aunque una solicitud o una herramienta tarde demasiado.

1. Fijar la hora de la reunión y el plazo de entrega del informe

Indícale al agente qué empresa debe investigar y a qué hora debe entregar el informe. Conserva las mismas instrucciones generales y la herramienta asíncrona para hacer preguntas para que el modelo decida si necesita una aclaración.

La reunión empieza dentro de 15 minutos, el informe debe entregarse dentro de 12 y la aplicación cierra las preguntas sin respuesta 10 minutos después del inicio de la tarea. Mantén esos plazos fijos durante toda la tarea.

Configurar la tarea de preparación de la reunión con la API de respuestas
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. Agregar la hora actual antes de cada solicitud al modelo

El modelo necesita saber qué hora es cada vez que decide cómo proceder. Usa la misma función auxiliar para la solicitud inicial y para todas las solicitudes posteriores. Así, la hora se actualiza en un solo lugar del código.

Justo antes de llamar a la API de respuestas, agrega la hora UTC actual como mensaje de desarrollador, después del mensaje del usuario o de los resultados de las herramientas. Envía las instrucciones y las herramientas en cada solicitud. El plazo original permanece en el historial de la conversación.

Actualizar la hora y crear una respuesta
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. Recoger la respuesta del usuario mientras continúa la investigación

Cuando el agente pregunte por el objetivo de la reunión, muestra la pregunta y recoge lo que responda el usuario en una tarea independiente de la generación de respuestas. Esa tarea devuelve la respuesta del usuario en cuanto llega, o no_answer si se acaba el tiempo. Usa el call_id original para asociar el resultado con la pregunta correspondiente.

Recoger de forma asíncrona el resultado de una solicitud de aclaración
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. Procesar las preguntas y las respuestas completas

Inicia la tarea que recoge la respuesta del usuario en cuanto llegue la pregunta completa por el flujo de la respuesta. Sigue leyendo los eventos mientras el usuario piensa qué responder para que el modelo pueda continuar su investigación en la web.

Cuando el modelo termine de generar una respuesta, guarda su ID para la siguiente solicitud y conserva cualquier informe completo para entregarlo. El manejador de eventos también registra los ID de las respuestas para liberar recursos al final.

Leer las preguntas del flujo de eventos y las respuestas completas
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. Continuar el bucle con los resultados disponibles

Si el usuario responde durante la investigación, la siguiente versión del informe debe tener en cuenta su respuesta. Cada vez que el modelo termine de generar una respuesta, reúne los resultados de herramientas que estén listos y envíalos mediante la función auxiliar, que agrega un nuevo recordatorio de la hora. Usa el ID de la última respuesta completa del modelo como valor de previous_response_id, incluso si el resultado corresponde a una pregunta de una respuesta anterior.

Envía las solicitudes en secuencia para que cada una parta del estado más reciente de la conversación. Si el informe está completo y no hay ningún resultado listo, entrégalo y cierra las preguntas pendientes. En caso contrario, continúa el trabajo con la hora actualizada, sin esperar a que el usuario responda.

Continuar la investigación e incorporar las respuestas del usuario
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. Cumplir el plazo de entrega aunque haya una solicitud en curso

Un temporizador de la aplicación impone el plazo de entrega del informe para que el usuario tenga tiempo de revisarlo. Aplica el temporizador a todo el bucle, incluidas las solicitudes a la API y la lectura del flujo de eventos.

Al vencer el plazo, detén la solicitud activa y entrega el informe guardado o indica que todavía no hay hallazgos verificados. Cierra los manejadores que siguen esperando respuestas del usuario y elimina las respuestas almacenadas después de la entrega.

Entregar a tiempo y liberar los recursos de la tarea
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())

Conclusión

A veces, los agentes personales deben terminar una tarea dentro de un plazo determinado. Lo ideal es que pidan aclaraciones para mejorar el resultado, pero incluso si no las reciben, tienen que poder hacer un trabajo útil.

Le dimos al agente un plazo y habilitamos el seguimiento del tiempo para ayudarlo a decidir si convenía investigar más, verificar un hallazgo o terminar de redactar el informe. Gracias a las herramientas de función asíncronas, pudo seguir investigando mientras el usuario pensaba qué responder. Incluso si la pregunta queda sin respuesta, el agente cuenta con suficiente contexto para redactar un informe útil para la reunión.

ChatGPT y otros arneses de ejecución de agentes usan este patrón para seguir trabajando mientras le piden una aclaración al usuario. Esperamos que el seguimiento del tiempo en la API de agentes te ayude a implementar este patrón por tu cuenta. ¡Cuéntanos qué creas!