> ## Documentation Index
> Fetch the complete documentation index at: https://docs.diga.io/llms.txt
> Use this file to discover all available pages before exploring further.
# La Pieza de Diga
> Referencia completa de los triggers y acciones de Diga para conectar flujos con llamadas
## ¿Qué es la Pieza de Diga?
La pieza de Diga es el componente que conecta tus flujos con las llamadas de tus agentes. Proporciona triggers para reaccionar a eventos de llamadas y acciones para interactuar con el sistema de telefonía de Diga.
Inician un flujo cuando ocurre un evento en una llamada
Ejecutan operaciones dentro de un flujo en ejecución
## Triggers
### Pre-llamada
Se activa cuando una llamada empieza, **antes de que el agente salude**. Es el trigger para los [flujos pre-llamada](/es/build/flujos/flujos-pre-llamada). El agente espera la salida del flujo y la usa para personalizar la conversación antes de decir su primera palabra.
Un flujo pre-llamada **debe terminar con la acción [Devolver datos de llamada](#devolver-datos-de-llamada)** para que el agente reciba el texto adicional del prompt y las variables dinámicas. La pieza genérica **Respond** no funcionará — su respuesta nunca llega al agente.
#### Configuración
| Campo | Descripción |
| ------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Tiempo de espera (segundos)** | Tiempo máximo que el agente espera a este flujo antes de continuar (o abortar). Por defecto son **30 segundos** y está limitado a **55 segundos**. |
| **Abortar llamada si falla** | Si está activado, la llamada se cuelga cuando el flujo falla, agota el tiempo de espera o devuelve datos no válidos. Desactivado por defecto, en cuyo caso la llamada continúa sin la salida del flujo. |
#### Datos que recibe
Cuando se dispara este trigger, el flujo recibe los datos de la llamada que está empezando, que puedes usar para buscar el registro correcto:
| Campo | Descripción |
| ------------------- | ---------------------------------------------- |
| `call_id` | Identificador único de la llamada |
| `type` | Tipo de llamada (`inbound` o `outbound`) |
| `phone_number` | Número de teléfono del contacto |
| `contact_id` | Identificador del contacto |
| `agent_id` | Identificador del agente |
| `start_time` | Fecha y hora de inicio |
| `dynamic_variables` | Variables dinámicas ya definidas en la llamada |
Consulta [Flujos Pre-llamada](/es/build/flujos/flujos-pre-llamada) para la guía completa, incluido cómo crear, asignar y controlar llamadas con estos flujos.
***
### Llamada Finalizada
Se activa automáticamente cuando una llamada termina. Es el trigger principal para flujos **post-llamada**.
#### Datos que recibe
Cuando se dispara este trigger, el flujo recibe toda la información de la llamada:
| Campo | Descripción |
| ------------------- | ---------------------------------------------- |
| `call_id` | Identificador único de la llamada |
| `status` | Estado final de la llamada |
| `duration` | Duración en segundos |
| `type` | Tipo de llamada (`inbound` o `outbound`) |
| `end_reason` | Razón por la que terminó la llamada |
| `phone_number` | Número de teléfono del contacto |
| `contact_id` | Identificador del contacto |
| `agent_id` | Identificador del agente |
| `start_time` | Fecha y hora de inicio |
| `end_time` | Fecha y hora de fin |
| `dynamic_variables` | Variables dinámicas pasadas al agente |
| `messages` | Historial completo de mensajes (transcripción) |
Cada mensaje en el array `messages` incluye:
* `role` — Quién habló (`user` o `assistant`)
* `content` — El texto del mensaje
* `created_date` — Cuándo se envió
Puedes usar cualquiera de estos campos en las acciones de tu flujo. Por ejemplo, insertar la transcripción completa en un email o enviar la duración a una hoja de cálculo.
#### Configuración
Este trigger no requiere configuración adicional. Solo necesitas [asignar el flujo al agente](/es/build/flujos/asignar-agentes) para que se active.
Consulta [Flujos Post-llamada](/es/build/flujos/flujos-post-llamada) para la guía completa sobre cómo crear y asignar estos flujos.
***
### Llamada a Función
Se activa durante una llamada cuando el agente decide ejecutar una función. Es el trigger para flujos **durante llamada**. El agente lo usa como una herramienta más, de forma similar a las [integraciones](/es/build/integraciones/introduccion).
Consulta [Flujos Durante Llamada](/es/build/flujos/flujos-durante-llamada) para la guía completa sobre cómo crear y asignar estos flujos.
#### Configuración
| Campo | Descripción |
| ----------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| **Descripción de la función** | Instrucción en lenguaje natural que indica al agente cuándo usar esta función. Ejemplo: "Usa esta función cuando el usuario quiera consultar la disponibilidad de citas" |
| **Parámetros** | Los datos que el agente debe extraer de la conversación. Para cada parámetro defines: nombre, tipo de dato, si es obligatorio y una descripción |
| **Confirmación de usuario** | Si el agente debe pedir confirmación antes de ejecutar |
#### Parámetros
Los parámetros definen qué información extrae el agente de la conversación para enviarla al flujo. Por ejemplo, para un flujo de "Consultar disponibilidad":
| Parámetro | Tipo | Obligatorio | Descripción |
| ---------- | ----- | ----------- | -------------------------------------- |
| `fecha` | Texto | Sí | La fecha para consultar disponibilidad |
| `servicio` | Texto | No | El tipo de servicio solicitado |
El agente extrae estos valores automáticamente del contexto de la conversación y los envía al flujo.
##### Origen del valor
Cada parámetro tiene un **Origen del valor** que decide de dónde sale su valor:
* **Extraído por la IA** (por defecto): el agente extrae el valor de la conversación, usando la descripción del parámetro para saber qué buscar.
* **Variable dinámica**: el valor se toma directamente de una [variable dinámica](/es/build/agentes/variables-dinamicas) en lugar de extraerse. Al elegir esta opción, indica el **Nombre de la variable dinámica** (sin llaves, p. ej. `id_cliente`). No se le pide este parámetro al agente — Diga lo rellena automáticamente con las variables de la llamada.
Usa **Variable dinámica** para datos que ya tienes (definidos por la API o por un [flujo pre-llamada](/es/build/flujos/flujos-pre-llamada)), para que el agente no tenga que volver a pedirlos durante la conversación. Para un paso a paso y un ejemplo, consulta [Rellenar parámetros desde variables dinámicas](/es/build/flujos/flujos-durante-llamada#rellenar-parámetros-desde-variables-dinámicas).
#### Datos que recibe
| Campo | Descripción |
| ------------------- | -------------------------------------- |
| `call_id` | Identificador de la llamada en curso |
| `function_name` | Nombre de la función ejecutada |
| `arguments` | Los parámetros extraídos por el agente |
| `agent_id` | Identificador del agente |
| `contact_id` | Identificador del contacto |
| `dynamic_variables` | Variables dinámicas de la llamada |
| `timestamp` | Momento de la ejecución |
#### Cómo espera el agente
El agente **espera** a que el flujo termine y recibe la respuesta, y la usa para continuar la conversación.
**Ejemplo**: Consultar disponibilidad de citas. El agente pregunta la fecha, ejecuta el flujo, espera la respuesta y le dice al usuario los horarios disponibles.
**Importante**: El flujo debe incluir la acción **Devolver respuesta** como último paso para enviar datos de vuelta al agente. El tiempo máximo de espera es de 60 segundos.
Si el flujo tarda más de 60 segundos o no incluye la acción **Devolver respuesta**, el agente recibirá un error y continuará la conversación sin los datos.
#### Confirmación de usuario
Cuando activas la confirmación de usuario, el agente le explica al usuario qué acción va a realizar y le pide confirmación antes de ejecutar el flujo. Esto es útil para acciones sensibles como procesar pagos o hacer reservas.
**Ejemplo de conversación:**
```
Usuario: "Quiero reservar una cita para mañana a las 10"
Agente: "Perfecto, voy a reservar una cita para mañana jueves a las 10:00. ¿Confirmas?"
Usuario: "Sí, confirma"
Agente: [ejecuta el flujo]
```
## Acciones
### Hacer Llamada
Inicia una llamada saliente desde un flujo. Esta acción convierte cualquier flujo en un disparador de llamadas, permitiéndote crear campañas automatizadas o llamadas reactivas a eventos externos. Los flujos construidos en torno a esta acción se conocen como flujos **lanzadores de llamadas**.
#### Configuración
| Campo | Descripción |
| ----------------------- | --------------------------------------------------------------------------------------------------------------------------- |
| **Número de origen** | El número de teléfono de Diga desde el que se realizará la llamada. Se selecciona de los números disponibles en tu proyecto |
| **Número de destino** | El número al que se va a llamar. Puede ser un valor fijo o dinámico (datos de un paso anterior) |
| **Versión del agente** | La versión del agente que gestionará la llamada (opcional) |
| **Variables dinámicas** | Variables que se pasarán al agente durante la llamada (opcional) |
#### Casos de uso
Conecta un trigger de tu CRM (nuevo lead creado) con la acción de hacer llamada para contactar automáticamente a nuevos leads.
```
Trigger: Nuevo lead en HubSpot
→ Acción: Hacer llamada al número del lead
- Agente: "Agente de cualificación"
- Variables: nombre del lead, fuente, producto de interés
```
Usa un trigger de programación para llamar a clientes y recordarles sus citas.
```
Trigger: Programación (24h antes de cada cita)
→ Acción: Buscar citas del día siguiente
→ Acción: Hacer llamada a cada contacto
- Agente: "Agente de recordatorios"
- Variables: fecha de cita, servicio, dirección
```
Conecta un webhook con la acción de hacer llamada para contactar a usuarios que completan un formulario web.
```
Trigger: Webhook (formulario completado)
→ Acción: Hacer llamada al número del formulario
- Agente: "Agente de ventas"
- Variables: nombre, email, consulta
```
***
### Devolver Respuesta
Devuelve datos al agente durante una llamada. Esta acción es **obligatoria** en flujos durante llamada. Es el último paso del flujo y contiene la información que el agente necesita para continuar la conversación.
#### Configuración
| Campo | Descripción |
| --------------------- | ------------------------------------------------------------- |
| **Tipo de respuesta** | JSON o texto plano |
| **Contenido** | Los datos a devolver. Puede incluir datos de pasos anteriores |
#### Ejemplo
Un flujo que consulta disponibilidad de citas:
```
Trigger: Llamada a función (parámetros: fecha, servicio)
→ Acción: Consultar API de calendario (HTTP request)
→ Acción: Devolver respuesta
- Tipo: JSON
- Contenido: { "slots": ["10:00", "11:30", "15:00"], "service": "Consulta general" }
```
El agente recibe estos datos y le dice al usuario: "Tengo disponibilidad a las 10:00, 11:30 y 15:00 para una consulta general. ¿Cuál prefieres?"
***
### Devolver Datos de Llamada
Devuelve datos al agente **antes de que empiece la llamada**. Esta acción es **obligatoria** como último paso de un [flujo pre-llamada](/es/build/flujos/flujos-pre-llamada) — es lo que envía el prompt y las variables de vuelta al agente para que pueda comenzar la conversación.
No la confundas con **Devolver respuesta**. Devolver datos de llamada se ejecuta al *inicio* de una llamada (flujos pre-llamada); Devolver respuesta se ejecuta *durante* una llamada (flujos durante llamada).
#### Configuración
| Campo | Descripción |
| ------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Texto adicional del prompt** | Texto que se añade al prompt de sistema del agente para esta llamada. Puede contener marcadores `{{variable}}`. Opcional. |
| **Variables dinámicas** | Pares clave/valor que se fusionan con las variables dinámicas de la llamada. Tienen prioridad sobre los valores definidos a nivel de llamada. Opcional. |
#### Ejemplo
Un flujo pre-llamada que personaliza al agente a partir de una búsqueda en el CRM:
```
Trigger: Pre-llamada
→ Acción: Buscar contacto en HubSpot (por número de teléfono)
→ Acción: Devolver datos de llamada
- Texto adicional del prompt: "Estás hablando con un cliente premium recurrente. Sé atento."
- Variables dinámicas: { "nombre_cliente": "Jane Doe", "plan": "premium" }
```
El agente empieza la llamada conociendo ya el nombre y el plan del contacto, y puede usar `{{nombre_cliente}}` y `{{plan}}` en cualquier parte de su prompt, saludo o camino.
## Referenciar Datos entre Pasos
En cualquier acción, puedes usar datos de pasos anteriores. Haz clic en un campo de entrada para ver los datos disponibles de todos los pasos previos.
**Ejemplos de referencia:**
* Datos del trigger: transcripción, duración, parámetros de la función
* Datos de acciones anteriores: respuesta de una API, resultado de una consulta
Esto te permite construir flujos donde la información fluye naturalmente de un paso al siguiente.
## Siguientes Pasos
Pon en práctica estos triggers y acciones creando tu primer flujo.
Conecta tus flujos con agentes para activarlos.
Usa plantillas que ya incluyen la pieza de Diga configurada.
Compara flujos con integraciones directas en el agente.