For the complete documentation index, see llms.txt. Markdown versions of documentation pages are available by appending .md to the page URL.
Navegación principal
Theme

Sugerencias

GPT-Live

Realtime API

Desarrollar aplicaciones de voz

Conexiones

Procesamiento de audio

Panel de la API
Prueba ChatGPT

Delegación y herramientas en GPT-Live

Conecta un agente de backend y devuelve resultados verificados a la conversación en vivo.

GPT-Live delega el razonamiento y el uso de herramientas a un backend mientras gestiona la conversación de voz. El trabajo del backend puede ejecutarse con el modelo de Responses que configures o, si delegas al cliente, con cualquier modelo, agente o servicio que opere tu aplicación. En ambos modos, tu aplicación se encarga de los permisos, las confirmaciones, los registros del negocio y el estado de las tareas.

En la guía de prompts, consulta cómo orientar al modelo en vivo para que delegue tareas y use herramientas.

Los ejemplos de eventos de esta página usan connection, que representa una conexión ya establecida mediante el WebSocket principal de Live o un canal lateral, como se describe en las guías de conexión. En una conexión principal, espera a recibir session.started antes de llamar a una función auxiliar de eventos. Un canal lateral ya vinculado pertenece a una sesión en curso.

Elige un modo de delegación

Con la delegación a Responses, GPT-Live llama al modelo de Responses que elijas, le proporciona el contexto de la conversación y devuelve los resultados del backend a la conversación en vivo. Con la delegación al cliente, tu aplicación prepara el contexto, ejecuta un agente o flujo de trabajo y envía los resultados a GPT-Live.

Empieza con la delegación a Responses si quieres que GPT-Live gestione las solicitudes. Elige la delegación al cliente cuando necesites ejecutar tu propio flujo de trabajo o revisar los resultados antes de enviarlos a GPT-Live.

Aspecto Elige la delegación a Responses si… Elige la delegación al cliente si…
Esfuerzo de implementación Quieres que GPT-Live prepare las solicitudes al backend, gestione las conexiones y devuelva los resultados a la conversación. Quieres implementar y gestionar esos componentes por tu cuenta.
Revisión de los resultados del backend Los resultados del backend pueden enviarse directamente a GPT-Live. Tu aplicación debe validar los resultados, ocultar datos sensibles, combinar resultados o descartarlos antes de que lleguen a GPT-Live.
Capacidades del backend Tu flujo de trabajo se ajusta a la configuración y las herramientas de Responses que admite GPT-Live. Necesitas otro backend, varios modelos o funciones de la API que la configuración administrada no ofrece.
Control del contexto El contexto de la conversación que proporciona GPT-Live se ajusta a tu aplicación. Necesitas elegir exactamente qué historial, memoria y estado de la aplicación incluir en cada solicitud al backend.
Política de ejecución Un modelo configurado y un ciclo de llamadas a herramientas son adecuados para la tarea. Necesitas reglas propias para dirigir el trabajo entre código y modelos, alternativas en caso de fallo, puntos de control o presupuestos que abarquen varios pasos del backend.

Por ejemplo, un asistente de viajes puede enviar las consultas sobre el estado de los vuelos al servicio de una aerolínea y los cambios de itinerario a un agente de planificación independiente. La aplicación elige a qué backend llamar y qué resultado verificado devolver a GPT-Live.

En ambos modos, tu aplicación registra el progreso de la tarea y comprueba los permisos y las confirmaciones que debe dar el usuario antes de ejecutar herramientas personalizadas. GPT-Live puede seguir hablando mientras tu aplicación revisa un resultado del backend. Si tu aplicación necesita controlar cuándo escucha el audio el usuario, agrega controles de reproducción.

La delegación al cliente también requiere que tu aplicación conserve el contexto de la conversación. El evento de delegación contiene metadatos y omite el texto de la tarea. Usa los eventos de transcripción y el estado de la aplicación para preparar la solicitud al backend.

Compara la latencia, la tasa de éxito de las tareas y el costo con tu propia carga de trabajo al evaluar tu agente de voz. Para obtener orientación específica para tu arquitectura actual, consulta Migrar a GPT-Live.

Elige el modo al crear la sesión. Para cambiar de modo, inicia una sesión nueva.

Modo de delegación

Configura la delegación a Responses

Agrega esta configuración de delegación al crear tu sesión de Live. Elige el modelo de Responses independientemente del modelo de voz:

export const session = {
  model: "gpt-live-1",
  delegation: {
    type: "responses",
    responses: {
      model: "gpt-6-luna",
      instructions: "[Your backend prompt]",
    },
  },
};

Empieza con gpt-6-luna o prueba gpt-6-sol para tareas de backend más complejas. Compara la calidad de las respuestas y la latencia en tus tareas antes de elegir un modelo para el backend.

Registra las herramientas compatibles en delegation.responses.tools. Configura delegation.responses.tool_choice con "auto" para que el backend elija una herramienta, "required" para exigir una llamada a una herramienta o "none" para desactivar las llamadas a herramientas. También puedes seleccionar una función por su nombre.

Configura delegation.responses.parallel_tool_calls con true para permitir varias llamadas a herramientas en una respuesta o con false para que las llamadas sean secuenciales. Tu aplicación ejecuta las funciones personalizadas y comprueba sus dependencias y las aprobaciones requeridas. Esta configuración se aplica después de que GPT-Live delega la tarea. Usa el prompt del modelo en vivo para indicar cuándo debe delegar.

Al crear la sesión, la configuración de Responses requiere un model para el backend. Además de las herramientas que se describen a continuación, permite configurar max_output_tokens (con un valor mínimo de 16 si se especifica), service_tier y los parámetros de reasoning y text que admita el modelo de backend seleccionado. Consulta Reducir la latencia del backend para saber qué parámetros puedes ajustar.

Si el Modo rápido está disponible para tu modelo y proyecto, considera usarlo en las llamadas que requieran baja latencia. En GPT-Live, selecciónalo con delegation.responses.service_tier: "priority".

Envía session.update con los cambios en session.delegation.responses para actualizar el modelo de backend, las instrucciones, las herramientas, tool_choice u otros parámetros compatibles durante la conversación. Los parámetros que omitas conservan sus valores actuales.

Para cambiar entre la delegación a Responses y la delegación al cliente, crea una sesión de Live nueva. Si actualizas delegation con el valor null, seleccionas el modo cliente, por lo que enviar esa actualización a una sesión de Responses en curso produce el error immutable_field_update.

Estos parámetros usan conceptos conocidos de Responses, pero Live solo admite un subconjunto de la API independiente de Responses. Live proporciona el contexto de la conversación e inicia el trabajo delegado. Configura el backend a través de la sesión. El comando response.create de Live usa esa configuración y no acepta el cuerpo de una solicitud independiente de Responses.

Agrega herramientas alojadas

Agrega la búsqueda web, la búsqueda de archivos, el intérprete de código, la Terminal alojada en la nube o la generación de imágenes a delegation.responses.tools. Consulta las guías enlazadas para conocer la configuración, los modelos compatibles y los recursos necesarios. Responses ejecuta estas herramientas y devuelve sus resultados automáticamente.

Para la terminal, usa un contenedor alojado, con Habilidades si lo deseas. Si acabas de cargar Habilidades, espera hasta que se pueda leer la versión que indicaste antes de iniciar la sesión de Live. Si usas la terminal local, tu aplicación debe ejecutar las llamadas. Live no admite domain_secrets para la terminal.

Agrega MCP y otras herramientas

La delegación a Responses también admite MCP, la búsqueda de herramientas, las llamadas programáticas a herramientas, las funciones y herramientas personalizadas, el uso de la computadora, la terminal local y la aplicación de parches. Consulta las guías enlazadas para configurar cada herramienta. Devuelve los resultados de tu aplicación y las decisiones de aprobación mediante el flujo de continuación de Live.

Live pasa a Responses los valores de MCP que proporciones en authorization y headers, pero los omite de la configuración de sesión que devuelve a tu aplicación. No necesitas volver a enviarlos cuando actualices otros parámetros, como las instrucciones. Si reemplazas delegation.responses.tools, vuelve a incluir las credenciales de MCP.

Maneja los errores de configuración

Live valida la configuración de Responses de forma asíncrona después del inicio y cada vez que cambia. session.started y session.updated se emiten sin esperar a que termine la validación. Escucha los eventos error con el código responses_validation_failed y revisa el mensaje para identificar el parámetro incompatible o el recurso inaccesible. La sesión permanece abierta y los cambios de configuración no se revierten. Corrígelos con session.update.

Por ejemplo, si el campo version de una Habilidad tiene un valor numérico como 1, se produce un error no fatal responses_validation_failed en session.start o session.update. El mensaje de error identifica el campo no válido y el tipo esperado sin esperar a response.create. Usa error.client_event_id para asociar el error con el evento de configuración. Para recuperarte del error en la misma sesión, elimina la configuración no válida de la herramienta con session.update. Especifica las versiones como cadenas, por ejemplo, "1".

La validación no garantiza que la herramienta pueda ejecutarse más adelante. El acceso a los recursos y la disponibilidad de las herramientas pueden cambiar, así que sigue manejando los errores del backend durante el trabajo delegado. Al configurar herramientas alojadas, es posible que se inicialicen recursos, como contenedores, durante la validación.

Orienta la conversación en vivo desde tu aplicación

La delegación a Responses gestiona el flujo de trabajo del backend, pero tu aplicación también puede enviar contexto directamente al modelo GPT-Live. Si supervisas la llamada mediante un WebSocket de canal lateral o la conexión principal de eventos, puedes usar session.instructions.append, session.thinking.append o session.commentary.append con delegation_id: null. Por ejemplo, un control de seguridad basado en la transcripción puede agregar una instrucción para reorientar la conversación. Esto guía al modelo en vivo sin cambiar el prompt del backend de Responses ni cancelar el trabajo en curso.

Gestiona la delegación a Responses

Cuando Responses se encarga del trabajo, session.delegation.created contiene target: "responses" y un response_id. Los eventos posteriores de Responses llegan dentro de un evento contenedor response.event:

{
  "type": "response.event",
  "event_id": "event_response_1",
  "delegation_id": "item_9tA2cB6n2V8c4X1z7Q5r9",
  "event": {
    "type": "response.output_text.delta",
    "sequence_number": 4,
    "item_id": "msg_123",
    "output_index": 0,
    "content_index": 0,
    "delta": "The forecast is",
    "logprobs": []
  }
}

Cuando el tipo de evento de nivel superior sea response.event, selecciona el manejador según envelope.event.type. Guarda el delegation_id del evento externo para asociar el evento del backend con su delegación. Tu manejador también puede recibir otros eventos anidados del ciclo de vida de Responses además de los que se muestran aquí.

Estos eventos anidados incluyen el progreso de las herramientas alojadas, las citas, los archivos y las imágenes generadas. Para recopilar los resultados, lee los eventos individuales de elementos de salida e imágenes parciales. Las instantáneas reenviadas del ciclo de vida omiten los arreglos de salida. Usa las API de archivos o contenedores de Responses que correspondan para descargar los archivos. Para eventos con imágenes o artefactos de gran tamaño, usa una conexión WebSocket o de canal lateral, ya que el límite de tamaño de los mensajes de un canal de datos WebRTC puede ser menor.

El audio de la conversación en vivo y el trabajo delegado avanzan de forma independiente. Que el backend haya completado una respuesta no garantiza que el usuario la haya escuchado. Usa la transcripción de salida y el audio de Live para la parte hablada de la interacción.

Devuelve resultados de herramientas y aprobaciones

Para las herramientas que requieren datos de tu aplicación, recopila las llamadas completadas a partir de los eventos anidados response.output_item.done. Ejecuta la acción autorizada o verifica la aprobación y luego envía el elemento correspondiente con response.item.create:

Elemento recibido Elemento de resultado
function_call function_call_output
custom_tool_call custom_tool_call_output
computer_call computer_call_output
shell_call local shell_call_output
apply_patch_call apply_patch_call_output
tool_search_call con execution: "client" tool_search_output con execution: "client" y las herramientas encontradas en tools
mcp_approval_request mcp_approval_response

Asocia los resultados con las llamadas mediante call_id. Para las decisiones de aprobación de MCP, asigna a approval_request_id el id de la solicitud de aprobación y establece approve en true o false. Una llamada mcp_call completada no requiere por sí sola un resultado del cliente. Sigue el esquema de resultados de cada herramienta, incluidos los metadatos de caller para las llamadas programáticas a funciones y las confirmaciones de seguridad que requiera el uso de la computadora.

Envía los resultados de todas las llamadas pendientes y luego envía response.create. Agregar un elemento por sí solo no reanuda el trabajo del backend. Si faltan resultados, se produce el error tool_outputs_required, o function_call_outputs_required si solo faltan resultados de funciones. Se rechazan los resultados duplicados y los que tengan un tipo que no corresponda a la llamada.

Puedes enviar resultados y solicitar la continuación antes de que termine la respuesta actual del backend. Si se acepta response.create, el comando espera a que termine esa respuesta. No lo vuelvas a enviar. Si el backend emite más llamadas después, envía sus resultados y otro response.create.

Ejecuta una función personalizada y devuelve su resultado

Lee las llamadas a funciones completadas en los eventos anidados response.output_item.done. El elemento de función completo contiene call_id, name y arguments. El evento que indica que se terminaron de recibir los argumentos no basta para identificar la llamada.

Registra el ID de respuesta del evento anidado response.created junto con el delegation_id del evento externo. Recopila las llamadas a funciones de la respuesta a partir de response.output_item.done y usa esa lista para determinar qué resultados de herramientas debes enviar antes de continuar.

Los eventos reenviados del ciclo de vida, incluido response.completed, contienen response.output: [] incluso cuando hay llamadas a funciones que necesitan resultados. Estos eventos también tienen un arreglo tools vacío, instructions: null y ningún campo input. Lee los eventos individuales de elementos de salida para obtener las llamadas a funciones.

Después de ejecutar la operación autorizada, agrega el resultado como elemento de Responses:

export function sendUpdate(connection) {
  connection.send({
    type: "response.item.create",
    event_id: "tool_result_1",
    item: {
      type: "function_call_output",
      call_id: "call_123",
      output: '{"status":"confirmed","order_id":"order_123"}',
    },
  });
}

Luego, solicita explícitamente la continuación de la respuesta:

export function sendUpdate(connection) {
  connection.send({
    type: "response.create",
    event_id: "continue_1",
  });
}

Envía un resultado con response.item.create por cada llamada a función pendiente y luego envía response.create para continuar la respuesta del backend. response.item.create no emite una confirmación de éxito independiente. Sigue procesando los errores y los eventos anidados del ciclo de vida de Responses.

Ambos comandos requieren la delegación a Responses. El comando response.create de Live usa la configuración del backend almacenada en la sesión. Usa el contenido del evento que se muestra arriba y configura el modelo de backend y los demás parámetros a través de la sesión.

Empieza con el prompt que ya usas en el backend

Usa el prompt de tu agente de texto como punto de partida. Conserva las instrucciones de la tarea y las reglas del negocio en el backend y adapta las instrucciones que den por hecho que la interacción ocurre en un chat de texto o que el agente controla directamente lo que se dice en voz alta. Explica cómo manejar las transcripciones de voz y devolver resultados útiles. Haz que tu aplicación exija los permisos y las confirmaciones necesarios.

## Contexto de la conversación de voz
Ayudas a un asistente durante una conversación de voz en vivo. Las transcripciones
pueden contener errores, frases sin terminar y correcciones posteriores. Usa
el contexto más reciente y los registros verificados. Si algún dato que necesitas
sigue sin estar claro, pide que te lo aclaren en vez de adivinarlo.

## Instrucciones de la tarea
[Your task instructions, business rules, available tools,
and confirmation requirements.]

## Devuelve el resultado
Devuelve los datos pertinentes, el estado actual de la tarea y el siguiente paso.
Indica que una acción se completó solo después de que la herramienta o el servicio confirme que se realizó con éxito.
Si el resultado es incierto, dilo y explica qué falta comprobar.

Conserva en el backend las cargas de datos estructurados de gran tamaño, los resultados extensos de las herramientas y el contenido Markdown destinado a mostrarse en pantalla. Proporciona a GPT-Live los datos pertinentes y deja que elija cómo expresarlos. Si el resultado de una herramienta es conciso, no necesitas otra llamada al modelo para adaptarlo a una respuesta de voz.

Con la delegación al cliente, devuelve el resultado directamente a GPT-Live. Con la delegación a Responses, devuelve los resultados de herramientas o las aprobaciones que se requieran para que el backend continúe. Las herramientas alojadas continúan sin que la aplicación proporcione resultados.

Envía el tipo de actualización adecuado

Elige el evento según el uso que GPT-Live deba darle al contenido:

Qué quieres enviar Evento
Instrucciones para una conversación en vivo en curso, como comunicar un aviso o dejar de hablar session.instructions.append
Información para el razonamiento interno que el modelo puede usar para responder preguntas pertinentes sin anunciarla al recibirla session.thinking.append
Información que el modelo debe comunicar en voz alta con sus propias palabras a partir del texto agregado session.commentary.append

Los tres eventos usan un campo content de tipo cadena de texto simple, con un límite de 500 tokens por envío. Incluye delegation_id. Usa el ID original de la delegación al cliente para una actualización sobre esa tarea o null para el contexto general de la sesión. Un ID que no sea nulo debe identificar una delegación al cliente conocida. Las instrucciones siguen aplicándose a la sesión en vivo. Incluir un ID no las convierte en un prompt independiente para el backend.

Para un saludo inicial, incluye las instrucciones del saludo en un mensaje developer en session.input al crear la sesión. Después de session.started, envía las mismas instrucciones una sola vez mediante session.commentary.append, con el audio de entrada activo, un event_id único y delegation_id: null. El modelo puede parafrasear el texto. Un acuse de recibo no confirma que el modelo haya pronunciado el saludo ni que se haya reproducido el audio. Consulta Saludar antes de que hable la persona que llama para ver la secuencia completa y cómo controlar la reproducción desde la aplicación cuando necesites usar palabras exactas o verificar que el saludo se haya reproducido.

Una instrucción que agregues puede interrumpir lo que el modelo esté diciendo o haciendo. Úsala cuando la aplicación necesite reorientar la conversación. Aplica en el estado de la aplicación cualquier bloqueo relacionado de herramientas o acciones.

Para informar del progreso sin anunciarlo durante una tarea gestionada por el cliente:

export function sendUpdate(connection) {
  connection.send({
    type: "session.thinking.append",
    event_id: "availability_progress",
    delegation_id: "item_123",
    content: "Checking Thursday availability. No appointment has been booked.",
  });
}

Para una reserva confirmada, envía el resultado que debe escuchar el usuario:

export function sendUpdate(connection) {
  connection.send({
    type: "session.commentary.append",
    event_id: "appointment_result",
    delegation_id: "item_123",
    content: "Your appointment is confirmed for Thursday at 2:00 PM",
  });
}

Envía ese resultado solo después de que la reserva se haya realizado con éxito. Para una instrucción que se aplique a toda la sesión, usa session.instructions.append con delegation_id: null.

Por ejemplo, si tu aplicación bloquea una solicitud mediante sus controles de seguridad, puedes reorientar la conversación:

export function sendUpdate(connection) {
  connection.send({
    type: "session.instructions.append",
    event_id: "guardrail_block_17",
    delegation_id: null,
    content:
      "Stop speaking about that request. Briefly explain that you cannot help with it, then wait for the user.",
  });
}

La instrucción no cancela el trabajo del backend. Bloquea la acción afectada y gestiona el trabajo que ya esté en curso en tu aplicación.

Los acuses de recibo correspondientes son session.thinking.appended, session.commentary.appended y session.instructions.appended. Asocia su client_event_id con el event_id que enviaste. El acuse de recibo se emite cuando se estima que el contexto ya se incorporó, sin esperar a que el modelo termine de hablar o a que finalice la reproducción. Consulta Cuándo recibe el modelo el contexto para conocer los tiempos y el manejo de errores.

Envía datos y resúmenes breves del progreso que GPT-Live pueda usar en la conversación. El contenido que envíes con session.thinking.append puede influir en respuestas de voz posteriores. Conserva los secretos y el razonamiento privado del backend en tu aplicación.

Suprime las confirmaciones automáticas durante la ejecución de herramientas

Con la delegación al cliente, puedes cancelar una confirmación automática pendiente si envías una actualización silenciosa de contexto antes de que se genere la confirmación.

Configura delegation.acknowledgement_delay_ms al crear la sesión para darle tiempo a tu aplicación de enviar la actualización. Por ejemplo, usa esta configuración de delegación al cliente:

{
  "delegation": {
    "type": "client",
    "acknowledgement_delay_ms": 800
  }
}

En cuanto recibas session.delegation.created, envía session.thinking.append con content vacío. Usa un event_id único y copia event.delegation.id en delegation_id. Envía este evento antes de esperar el resultado del backend:

{
  "type": "session.thinking.append",
  "event_id": "event_quiet_progress_1",
  "delegation_id": "item_9tA2bF3h7K9m2P5q8R1s4",
  "content": ""
}

Continúa el trabajo del backend y, cuando el resultado verificado esté listo para comunicarse en voz alta, envíalo mediante session.commentary.append con el mismo ID de delegación. Si quieres proporcionar contexto sobre el progreso, incluir un mensaje que describa el estado, como "Lookup in progress.", en el evento de razonamiento también cancela la confirmación pendiente sin pedirle al modelo que anuncie la actualización.

Cada vez que agregas contenido de razonamiento o comentario, se cancelan todas las confirmaciones automáticas pendientes de la sesión, incluidas las de otras delegaciones. Esto no detiene el audio ya generado ni impide que el modelo hable por su cuenta. El retraso determina cuándo se solicita la confirmación automática. El modelo podría hablar antes. Consulta la referencia de la configuración de delegación al cliente y del evento para agregar contenido de razonamiento para conocer el contrato del evento.

Cuando recibas session.thinking.appended, asocia su client_event_id con el evento que enviaste. Esto confirma la entrega del contexto, pero no garantiza el silencio. Prueba el audio resultante con tu carga de trabajo y usa la reproducción controlada por la aplicación cuando necesites garantizar el silencio.

Envía actualizaciones precisas y útiles

Durante las tareas más largas, envía una actualización cuando haya un cambio relevante, por ejemplo, cuando se complete un paso, haya un retraso importante o el usuario deba responder una pregunta.

Usa session.thinking.append para informar del progreso en segundo plano en el modo cliente. Usa session.commentary.append cuando convenga comunicar la actualización en voz alta.

Para las actualizaciones de voz, envía session.commentary.append con contenido que refleje el estado verificado de la tarea:

Estado Ejemplo de contenido
En curso “Estoy consultando los horarios disponibles”.
Completada “Tu cita quedó reservada para el jueves a las dos de la tarde”.
Fallida “Ese horario ya no está disponible”.
Cancelación confirmada “Se canceló tu cita”.

Cuando el usuario modifique una solicitud, actualiza la tarea activa en tu aplicación. Por ejemplo, si cambia el día de viernes a jueves, usa el jueves para los pasos posteriores e ignora los resultados de la solicitud anterior para el viernes. Gestiona las cancelaciones en el backend y confirma que se hayan realizado antes de decirle al usuario que se canceló el trabajo. Si se interrumpe la conversación de voz, el trabajo del backend sigue en curso.

Antes de reintentar una llamada fallida a una herramienta, comprueba si la acción original ya se realizó. Por ejemplo, la pérdida de una respuesta no debería provocar una segunda reserva. Si el resultado es incierto, dilo y ofrece un siguiente paso útil.

Comparte el contexto de la interfaz

Proporciona a GPT-Live un resumen conciso de la página o la tarea actual, las selecciones pertinentes y los datos que ayuden a interpretar referencias como “esta opción”. Genera el resumen directamente a partir del estado de la aplicación. No necesitas otra llamada al modelo para darle formato.

Envía el contexto de la interfaz al inicio de la sesión y cuando cambie algún dato relevante. Omite las actualizaciones que no aporten cambios y, si se producen varios cambios en poco tiempo, agrúpalos en un breve resumen del estado más reciente. Indica de forma explícita los cambios en selecciones anteriores:

  • Contexto inicial: “El usuario está revisando una reserva en un restaurante para dos personas el 6 de agosto a las siete de la noche. Aún no se ha hecho la reserva”.
  • Corrección: “El horario seleccionado ahora es a las ocho de la noche. Antes era a las siete”.

En cualquiera de los dos modos de delegación, usa session.thinking.append con delegation_id: null para actualizar el contexto en segundo plano. Conserva el HTML completo, los árboles del DOM, las cargas JSON de gran tamaño y los registros de interacción en tu aplicación o backend. Trata el contenido de la página como datos de referencia y no como instrucciones.

Acepta datos ingresados por escrito

Envía al backend los valores ingresados por escrito, como los números de pedido. Identifícalos como datos proporcionados por el usuario para que el backend pueda usar el texto exacto.

Con la delegación a Responses, agrega un mensaje del usuario a la cola del backend:

export function sendUpdate(connection) {
  connection.send({
    type: "response.item.create",
    event_id: "typed_order_number",
    item: {
      type: "message",
      role: "user",
      content: [
        {
          type: "input_text",
          text: "My order number is A0042.",
        },
      ],
    },
  });
}

Envía response.create cuando quieras iniciar o continuar el trabajo del backend. Si el backend está esperando resultados de funciones, devuelve primero todos los resultados requeridos. Agregar texto a la cola no cancela por sí solo el trabajo que ya está en curso.

Agrega imágenes y contexto visual

Para ayudar a la persona que llama a hablar sobre una foto o una pantalla, envía la imagen y el contexto pertinente desde tu aplicación a un backend que pueda procesar imágenes. El backend interpreta la imagen y devuelve texto pertinente que GPT-Live puede usar en la conversación. El frontend de audio de Live no acepta imágenes directamente.

Con la delegación a Responses, configura un modelo de backend que pueda procesar imágenes. Agrega a la cola un elemento de entrada de imagen compatible con Responses mediante response.item.create y luego envía response.create para iniciar o reanudar el trabajo del backend. Antes de continuar, devuelve todos los resultados de herramientas y las aprobaciones que se requieran y estén pendientes. Consulta Gestionar la delegación a Responses.

Mantén la entrada de imágenes del backend separada de session.input, que proporciona al frontend de Live un historial de texto al inicio. Consulta Imágenes y visión para conocer los formatos de imagen compatibles y las limitaciones de los modelos.

Reduce la latencia del backend

Reduce el tiempo que transcurre desde que se solicita trabajo al backend hasta que se obtiene un resultado útil para la conversación. Mide la latencia en cada etapa para localizar los retrasos. Compara el tiempo hasta obtener una respuesta de voz útil y la tasa de éxito de las tareas en los mismos escenarios. Consulta la guía del Cookbook para evaluar agentes de voz para orientar la evaluación.

Delegación a Responses

Live mantiene conexiones WebSocket persistentes con Responses y prepara de antemano los parámetros conocidos de la solicitud. También puede reutilizar el estado de una respuesta anterior si la conexión activa y el estado lo permiten. Mide el tiempo de respuesta y el uso de caché reportado con tu carga de trabajo para evaluar el efecto.

Ajusta el backend mediante delegation.responses:

  • model: elige el modelo que se encargará del razonamiento y la selección de herramientas independientemente del modelo de voz.
  • reasoning.effort: equilibra el tiempo de razonamiento y la calidad del resultado con los valores que admita ese modelo.
  • service_tier: usa auto, default, flex o priority según lo que admita el modelo y el acceso de tu proyecto. auto sigue la configuración del proyecto. Evalúa el rendimiento y el costo del nivel de servicio que elijas.

Actualiza los parámetros compatibles durante la sesión con session.update. Las herramientas personalizadas siguen ejecutándose en tu aplicación, por lo que las llamadas lentas a servicios, las colas y el almacenamiento temporal de resultados de herramientas pueden retrasar la respuesta incluso cuando Live gestiona la conexión con Responses. Devuelve cuanto antes cada resultado requerido y continúa la respuesta del backend.

Reacciona a fragmentos de transcripción

Procesar fragmentos de transcripción en tu aplicación es opcional y funciona con ambos modos de delegación. Los fragmentos de transcripción del usuario y del asistente llegan por WebSocket o por el canal de datos WebRTC. Puedes procesarlos con la lógica de tu aplicación o con un modelo ligero para iniciar el trabajo antes de que llegue un evento de delegación. También puedes usar la propia transcripción para iniciar tareas a cargo de la aplicación.

Puedes usar este patrón de las siguientes maneras:

  • Reduce la espera. Inicia una consulta anticipada cuando haya suficiente información. Por ejemplo, comprueba la disponibilidad mientras el usuario sigue describiendo sus preferencias.
  • Aplica controles de seguridad. Revisa la transcripción a medida que llegue para detectar solicitudes o respuestas que requieran intervención. Consulta Aplicar controles de seguridad a la conversación.
  • Adapta la conversación. Detecta expresiones que sugieran confusión o frustración y ajusta la experiencia o envía una instrucción específica.
  • Actualiza la interfaz. Resalta los controles pertinentes, completa los campos sugeridos o muestra los resultados a medida que estén disponibles.

En las aplicaciones que se ejecutan en el navegador, usa el canal de datos WebRTC para los subtítulos y las actualizaciones locales de la interfaz. Cuando proceses las transcripciones en tu servidor para aplicar controles de seguridad, realizar comprobaciones con un modelo ligero o anticipar llamadas a herramientas, usa un WebSocket de canal lateral para recibir eventos y orientar directamente la misma sesión de GPT-Live.

Procesa el texto acumulado cuando llegue información nueva relevante. Un fragmento puede estar incompleto y lo que el usuario diga después puede cambiar la solicitud. Descarta los resultados desactualizados, coordina estas tareas con el trabajo que se delegue después para evitar acciones duplicadas y aplica tus comprobaciones habituales de permisos y confirmaciones antes de realizar acciones que tengan consecuencias.

Envía las conclusiones o instrucciones a GPT-Live mediante el evento que corresponda al tipo de actualización. Para tareas iniciadas fuera de una delegación al cliente, usa delegation_id: null. Tu aplicación aplica los cambios en la interfaz y gestiona la ejecución y cancelación de las herramientas.

Optimizaciones comunes

Ambos modos de delegación se benefician de las mismas mejoras en el backend:

  • Elige el modelo y el esfuerzo de razonamiento según la tarea. Compara las configuraciones que cumplan tus requisitos de precisión. Usa un esfuerzo de razonamiento menor cuando permita completar la tarea de manera confiable.
  • Devuelve respuestas concisas. Incluye los datos y el estado que GPT-Live necesita para continuar la conversación. Evita las explicaciones extensas y las llamadas adicionales al modelo cuyo único propósito sea reformular los resultados para comunicarlos en voz alta.
  • Reduce las demoras de las herramientas y las llamadas innecesarias. Inicia el trabajo autorizado cuando estén listos los datos de entrada, reutiliza los resultados mientras sigan siendo válidos y evita repetir consultas ya completadas.
  • Ejecuta las tareas independientes de forma concurrente. Las consultas independientes pueden ejecutarse al mismo tiempo. Respeta las dependencias y las confirmaciones que requiera cada acción. parallel_tool_calls permite que un modelo solicite varias llamadas. Tu aplicación sigue encargándose de programar y ejecutar sus funciones personalizadas.

Consulta Optimización de la latencia para obtener orientación general sobre Responses y Almacenamiento en caché de prompts para saber cómo reutilizar entradas estables.

Verifica la interacción completa

Comprueba que el backend haya completado la acción prevista y que el cliente haya reproducido la respuesta de voz esperada. Por ejemplo, después de que se realice una reserva con éxito, comprueba tanto el registro de la reserva como el audio reproducido. El backend puede terminar aunque se interrumpa la respuesta de voz, así que verifica ambos resultados por separado.

Registra cada acción de la aplicación con su propio ID de operación y cada cambio de solicitud con una revisión de la tarea, junto con el ID de delegación de GPT-Live. Usa esos registros para identificar el trabajo ya completado después de una reconexión o un reintento y descartar resultados de solicitudes desactualizadas.

Usa la guía Evaluar agentes de voz para realizar pruebas repetibles. Si ya usas un ciclo de llamadas a herramientas de Realtime o un backend encadenado, sigue la guía Migrar a GPT-Live.