> ## Documentation Index
> Fetch the complete documentation index at: https://docs.plazbot.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Acciones del Agente
> Agregar acciones al Agente de IA
Este documento describe como se puede agregar acciones al Agente de IA, como por ejemplo:
* Asignar un agente humano al contacto.
* Desasignar un agente del contacto.
* Asignar o remover una etapa al contacto.
* Asignar o remover una etiqueta al contacto.
* Asignar o remover una segmentacion al contacto.
* Marcar como resuelto.
* Apagar el agente de IA para la sesion.
* Gestionar eventos (crear, actualizar, listar, confirmar, cancelar, eliminar).
* Asignar una secuencia al contacto.
**Campos de la Accion**
| Campo | Tipo | Descripcion |
| ----------------- | ---------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `intent` | `string` | Identificador unico de la intencion de la accion. Se usa para detectar que esta solicitando el usuario (por ejemplo, `"asignar_soporte"`). |
| `reference` | `string` | Descripcion detallada del contenido de la intencion. Se utiliza para poder darle informacion al agente y sepa la intencion del usuario, como por ejemplo: **"Quiero hablar con un agente humano"**. |
| `tags` | `string[]` | Son referencias para poder entender mas la informacion dentro de la accion. Complementa la `reference` con contexto adicional. |
| `enabled` | `boolean` | Indica si la accion esta activada (`true`) o no (`false`). |
| `requiredFields` | `array` | Campos que el agente debe recopilar del usuario antes de ejecutar la accion. Funciona igual que en los servicios. |
| `responseMessage` | `string` | Mensaje que el agente debe de responder al usuario. Soporta variables con formato `{{variable}}`, `{variable}` o `@variable`. |
| `responseJson` | `boolean` | Indica si el agente debe de responder con un JSON estructurado (`true`) o un mensaje de texto plano (`false`). Solo aplica en el orquestador clasico. |
| `responseExact` | `boolean` | Indica si el `responseMessage` debe enviarse **exactamente** al usuario sin reformulacion del LLM (`true`). Solo aplica en modo Tool Calling. Por defecto `false`. |
| `action` | `array` | Listado de acciones que se ejecutaran. Cada accion tiene un `type` y un `value`. |
El agente de IA ejecutara las acciones en orden, esto quiere decir que si puso dos asignaciones, el agente de IA asignara la primera asignacion y luego la segunda asignacion. Por lo que prevalecera la ultima accion ejecutada.
***
## Tipos de Accion
Cada accion dentro del arreglo `action` tiene un `type` que define que operacion se ejecutara y un `value` que define el parametro de la operacion.
### Acciones de Asignacion
| Tipo | Descripcion | Valor (`value`) |
| ----------------- | ---------------------------------------- | --------------------------- |
| `action.asign` | Asigna un agente humano al contacto. | Email del agente a asignar. |
| `action.unassign` | Desasigna al agente humano del contacto. | No requiere valor. |
### Acciones de Etapas
| Tipo | Descripcion | Valor (`value`) |
| --------------------- | ------------------------------------- | -------------------------------------------------- |
| `action.stage` | Asigna una etapa al contacto. | Nombre de la etapa (debe existir en el workspace). |
| `action.stage.remove` | Remueve la etapa actual del contacto. | No requiere valor. |
### Acciones de Segmentacion
| Tipo | Descripcion | Valor (`value`) |
| ---------------------------- | -------------------------------------------- | --------------------------------------------------------- |
| `action.segmentation` | Asigna una segmentacion al contacto. | Nombre de la segmentacion (debe existir en el workspace). |
| `action.segmentation.remove` | Remueve la segmentacion actual del contacto. | No requiere valor. |
### Acciones de Etiquetas
| Tipo | Descripcion | Valor (`value`) |
| ------------------- | --------------------------------------------- | ----------------------------------------------------- |
| `action.tag` | Agrega una etiqueta al contacto. | Nombre de la etiqueta (debe existir en el workspace). |
| `action.tag.remove` | Remueve una etiqueta especifica del contacto. | Nombre de la etiqueta a remover. |
### Acciones de Estado
| Tipo | Descripcion | Valor (`value`) |
| ---------------------- | --------------------------------------------------------- | ------------------------------------------------- |
| `action.solved` | Marca la conversacion como resuelta o pendiente. | `"true"` para resolver, `"false"` para reabrir. |
| `action.agentshutdown` | Desactiva o activa el agente de IA para la sesion actual. | `"true"` para desactivar, `"false"` para activar. |
### Acciones de Eventos (Calendario)
| Tipo | Descripcion | Valor (`value`) |
| ---------------------- | ------------------------------------------- | -------------------------------------- |
| `action.event.add` | Crea un nuevo evento/cita en el calendario. | Nombre descriptivo del tipo de evento. |
| `action.event.update` | Actualiza un evento existente. | - |
| `action.event.list` | Lista los eventos del contacto. | - |
| `action.event.confirm` | Confirma un evento pendiente. | - |
| `action.event.cancel` | Cancela un evento existente. | - |
| `action.event.delete` | Elimina un evento del calendario. | - |
### Acciones de Secuencias
| Tipo | Descripcion | Valor (`value`) |
| ----------------- | ---------------------------------------------- | ----------------------------- |
| `action.secuence` | Asigna una secuencia automatizada al contacto. | ID de la secuencia a iniciar. |
***
## Referencia Detallada de Cada Accion
### `action.asign` - Asignar Agente Humano
Asigna un agente humano al contacto. El contacto aparecera en la bandeja del agente asignado.
```json theme={null}
{
"type": "action.asign",
"value": "agente@empresa.com"
}
```
**Que sucede al ejecutarse:**
* Busca al usuario por email dentro del workspace.
* Asigna el contacto a ese agente.
* Envia un email de notificacion al agente asignado.
* Crea una entrada en la bandeja de entrada (inbox) del agente.
* Registra la asignacion en el historial del contacto.
* Emite evento en tiempo real (SignalR) para actualizar la interfaz.
El `value` debe ser el **email exacto** del agente registrado en el workspace. Si el email no coincide con ningun miembro del equipo, la accion no se ejecutara.
### `action.unassign` - Desasignar Agente
Remueve al agente humano asignado del contacto.
```json theme={null}
{
"type": "action.unassign",
"value": ""
}
```
**Que sucede al ejecutarse:**
* Limpia el agente asignado, nombre del agente y fecha de asignacion.
* Registra la desasignacion en el historial del contacto.
***
### `action.stage` - Asignar Etapa
Asigna una etapa (fase) al contacto. Las etapas deben estar previamente configuradas en el workspace.
```json theme={null}
{
"type": "action.stage",
"value": "prospecto"
}
```
**Que sucede al ejecutarse:**
* Busca la etapa por nombre en la configuracion del workspace (`masterOfStages`).
* Asigna el ID de la etapa al contacto.
* Registra el cambio de etapa en el historial.
El `value` debe coincidir **exactamente** con el nombre de una etapa configurada en el workspace. Si no existe, la accion no se ejecutara.
### `action.stage.remove` - Remover Etapa
Remueve la etapa actualmente asignada al contacto.
```json theme={null}
{
"type": "action.stage.remove",
"value": ""
}
```
***
### `action.segmentation` - Asignar Segmentacion
Asigna una segmentacion al contacto. Las segmentaciones deben estar previamente configuradas en el workspace.
```json theme={null}
{
"type": "action.segmentation",
"value": "cliente_premium"
}
```
**Que sucede al ejecutarse:**
* Busca la segmentacion por nombre en la configuracion del workspace (`masterOfSegmentation`).
* Asigna el ID de la segmentacion al contacto.
* Registra el cambio en el historial.
### `action.segmentation.remove` - Remover Segmentacion
Remueve la segmentacion actualmente asignada al contacto.
```json theme={null}
{
"type": "action.segmentation.remove",
"value": ""
}
```
***
### `action.tag` - Agregar Etiqueta
Agrega una etiqueta al contacto. Un contacto puede tener multiples etiquetas simultaneamente.
```json theme={null}
{
"type": "action.tag",
"value": "interesado"
}
```
**Que sucede al ejecutarse:**
* Busca la etiqueta por nombre en la configuracion del workspace (`masterOfTags`).
* Agrega la etiqueta a la lista del contacto (evita duplicados).
* Registra el cambio en el historial.
A diferencia de `action.stage` y `action.segmentation` que reemplazan el valor actual, `action.tag` **agrega** la etiqueta a las existentes. Un contacto puede tener multiples etiquetas al mismo tiempo.
### `action.tag.remove` - Remover Etiqueta
Remueve una etiqueta especifica del contacto.
```json theme={null}
{
"type": "action.tag.remove",
"value": "interesado"
}
```
***
### `action.solved` - Marcar como Resuelto
Marca la conversacion del contacto como resuelta o la reabre.
```json theme={null}
{
"type": "action.solved",
"value": "true"
}
```
**Que sucede al ejecutarse:**
* Si `value` es `"true"`:
* Marca la conversacion como resuelta (`isSolved = true`).
* Registra la fecha de resolucion.
* Si el workspace tiene la opcion **"Limpiar datos al resolver"** activada (`fCleanContactDataOnSolve`), se limpian automaticamente: segmentacion, etapa y etiquetas del contacto.
* Si `value` es `"false"`:
* Reabre la conversacion (`isSolved = false`).
Si el workspace tiene activada la opcion de limpiar datos al resolver, al marcar como resuelto se eliminaran la segmentacion, etapa y etiquetas del contacto automaticamente. Ten esto en cuenta al disenar tu flujo de acciones.
***
### `action.agentshutdown` - Desactivar Agente IA
Desactiva o reactiva el agente de IA para la sesion actual del contacto. Esto es util cuando se transfiere la conversacion a un agente humano y se necesita que el bot deje de responder.
```json theme={null}
{
"type": "action.agentshutdown",
"value": "true"
}
```
| Valor | Comportamiento |
| --------- | --------------------------------------------------------------------------- |
| `"true"` | Desactiva el agente de IA. No respondera hasta que se reactive manualmente. |
| `"false"` | Reactiva el agente de IA para el contacto. |
Si se desactiva el agente con `"true"`, no volvera a contestar hasta que se reactive de forma manual desde la interfaz o con otra accion que envie `"false"`. Usalo con precaucion.
***
### `action.secuence` - Asignar Secuencia
Asigna una secuencia automatizada al contacto. Las secuencias permiten ejecutar una serie de pasos programados (mensajes, esperas, acciones) de forma automatica.
```json theme={null}
{
"type": "action.secuence",
"value": "seq_abc123"
}
```
**Que sucede al ejecutarse:**
* Busca la secuencia por ID.
* Obtiene el primer paso de la secuencia.
* Asigna la secuencia al contacto con estado activo.
* El orquestador de secuencias continuara ejecutando los pasos automaticamente.
El `value` debe ser el **ID de la secuencia**, no su nombre. Puedes obtener el ID de la secuencia desde la seccion de Secuencias en el panel de Plazbot.
***
## Acciones de Eventos (Calendario)
Las acciones de tipo `action.event.*` permiten gestionar citas, reuniones y eventos directamente desde el agente de IA. Si el workspace tiene integrado **Google Calendar**, los eventos se sincronizan automaticamente.
Cuando configuras al menos una accion de tipo `action.event.add`, el sistema inyecta automaticamente una herramienta de **consulta de disponibilidad** (`check_availability`) para que el agente pueda verificar horarios libres antes de agendar.
### `action.event.add` - Crear Evento
Crea un nuevo evento o cita en el calendario del contacto.
**Parametros recopilados del usuario (via `requiredFields`):**
| Parametro | Aliases aceptados | Descripcion |
| ------------ | -------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------- |
| Titulo | `titulo`, `title`, `nombre_evento` | Titulo del evento. |
| Descripcion | `descripcion`, `description`, `detalle` | Descripcion o motivo del evento. |
| Fecha inicio | `fecha`, `date`, `appointment_datetime`, `startDate`, `fecha_inicio` | Fecha y hora de inicio. |
| Fecha fin | `fecha_fin`, `endDate`, `end_date` | Fecha y hora de fin (opcional). |
| Color | `color` | Color del evento (por defecto: `#0284c7`). |
| Duracion | `durationMinutes` | Duracion en minutos (por defecto: `30`). Se puede definir tambien en el campo `durationMinutes` de la accion. |
```json theme={null}
{
"intent": "agendar_cita",
"reference": "El usuario quiere agendar una cita o reunion",
"enabled": true,
"requiredFields": [
{
"name": "fecha",
"description": "Fecha y hora deseada para la cita",
"type": "datetime"
},
{
"name": "titulo",
"description": "Motivo o titulo de la cita",
"type": "string"
}
],
"responseMessage": "Tu cita '{{titulo}}' ha sido agendada para el {{fecha}}.",
"responseExact": true,
"action": [
{
"type": "action.event.add",
"value": "cita",
"durationMinutes": 30
}
]
}
```
**Que sucede al ejecutarse:**
* Valida que no existan conflictos de horario con otros eventos.
* Crea el evento local con los datos recopilados.
* Si el workspace tiene **Google Calendar** integrado, sincroniza el evento automaticamente.
* Retorna informacion del evento creado al agente.
El sistema valida automaticamente conflictos de horario. Si ya existe un evento en el horario solicitado, la creacion fallara y el agente informara al usuario sobre el conflicto.
### `action.event.update` - Actualizar Evento
Actualiza un evento existente del contacto.
**Parametros recopilados del usuario:**
| Parametro | Aliases aceptados | Descripcion |
| ------------- | -------------------------------------------- | --------------------------------- |
| ID del evento | `event_id`, `eventId`, `id_evento` | ID del evento a actualizar. |
| Titulo | `titulo`, `title`, `nombre_evento` | Nuevo titulo (opcional). |
| Fecha inicio | `fecha`, `date`, `startDate`, `fecha_inicio` | Nueva fecha de inicio (opcional). |
| Fecha fin | `fecha_fin`, `endDate`, `end_date` | Nueva fecha de fin (opcional). |
**Que sucede al ejecutarse:**
* Busca el evento por ID.
* Actualiza los campos proporcionados (valida conflictos si cambia la fecha).
* Sincroniza los cambios con Google Calendar si aplica.
### `action.event.list` - Listar Eventos
Lista todos los eventos del contacto asociados al agente actual.
```json theme={null}
{
"type": "action.event.list",
"value": ""
}
```
**Que sucede al ejecutarse:**
* Filtra eventos por agente (cada agente solo ve sus propios eventos).
* Retorna la lista formateada con: titulo, fecha, estado y detalles.
* El agente puede presentar la informacion al usuario de forma conversacional.
### `action.event.confirm` - Confirmar Evento
Confirma un evento que esta pendiente.
```json theme={null}
{
"type": "action.event.confirm",
"value": ""
}
```
**Parametros recopilados del usuario:**
| Parametro | Aliases aceptados | Descripcion |
| ------------- | --------------------- | --------------------------------------------------------------------------------- |
| ID del evento | `event_id`, `eventId` | ID del evento a confirmar. Si no se especifica, confirma el ultimo evento creado. |
**Que sucede al ejecutarse:**
* Busca el evento por ID (o usa el ultimo si no se especifica).
* Cambia el estado del evento a `"confirmed"`.
* Registra la fecha de confirmacion.
### `action.event.cancel` - Cancelar Evento
Cancela un evento existente sin eliminarlo.
```json theme={null}
{
"type": "action.event.cancel",
"value": ""
}
```
**Que sucede al ejecutarse:**
* Cambia el estado del evento a `"cancelled"`.
* Registra la fecha de cancelacion.
* Sincroniza el cambio con Google Calendar si aplica.
### `action.event.delete` - Eliminar Evento
Elimina un evento del calendario de forma permanente.
```json theme={null}
{
"type": "action.event.delete",
"value": ""
}
```
**Parametros recopilados del usuario:**
| Parametro | Aliases aceptados | Descripcion |
| ------------- | --------------------- | ------------------------------------------------------------------------- |
| ID del evento | `event_id`, `eventId` | ID del evento a eliminar. Si se envia `"last"`, elimina el ultimo evento. |
**Que sucede al ejecutarse:**
* Busca el evento por ID.
* Si el evento esta sincronizado con Google Calendar, lo elimina tambien de Google.
* Remueve el evento del array de eventos del contacto de forma permanente.
***
## Herramienta de Disponibilidad (Auto-inyectada)
Cuando el agente tiene configurada al menos una accion `action.event.add`, el sistema inyecta automaticamente la herramienta `check_availability`. El agente de IA la utiliza antes de crear un evento para verificar horarios disponibles.
**Parametros que recibe la herramienta:**
| Parametro | Tipo | Descripcion |
| ------------------ | -------- | -------------------------------------------------------------------------------------------- |
| `date` | `string` | Fecha a consultar en formato `YYYY-MM-DD`. |
| `duration_minutes` | `number` | Duracion de la cita en minutos (por defecto usa el `durationMinutes` de `action.event.add`). |
**Respuesta de la herramienta:**
```json theme={null}
{
"available": true,
"message": "Horarios disponibles para el 2026-02-16",
"date": "2026-02-16",
"businessHours": "09:00 - 18:00 | 19:00 - 21:00",
"timezone": "America/Lima (UTC-5:00)",
"slots": ["09:00", "09:30", "10:00", "10:30", "11:00"],
"totalSlots": 16
}
```
La herramienta utiliza la configuracion de **horario comercial** (`businessHoursConfig`) del workspace para calcular los slots disponibles. Asegurate de tener configurados los horarios de atencion correctamente.
***
## Campos Requeridos en Acciones
Las acciones soportan `requiredFields`, que funcionan de la misma forma que en los servicios. Esto es util cuando la accion necesita datos del usuario antes de ejecutarse (por ejemplo, una fecha para agendar un evento).
```json theme={null}
{
"intent": "agendar_cita",
"reference": "El usuario quiere agendar una cita o reunion",
"enabled": true,
"requiredFields": [
{
"name": "fecha",
"description": "Fecha deseada para la cita",
"promptHint": "Cual es la fecha que prefieres para la cita?",
"type": "datetime"
},
{
"name": "motivo",
"description": "Motivo de la cita",
"type": "string"
}
],
"responseMessage": "Tu cita ha sido agendada para el {{fecha}}.",
"responseExact": true,
"action": [
{
"type": "action.event.add",
"value": "cita"
}
]
}
```
**Tipos de campos soportados:**
| Tipo | Descripcion |
| ------------- | ------------------ |
| `string` | Texto libre. |
| `number` | Valor numerico. |
| `boolean` | Verdadero o falso. |
| `datetime` | Fecha y hora. |
| `array` | Lista de valores. |
| `arrayobject` | Lista de objetos. |
Las variables recopiladas en `requiredFields` se pueden usar en el `responseMessage` con los formatos `{{variable}}`, `{variable}` o `@variable`.
***
## Tipos de Respuesta
Las acciones del agente tienen configuraciones que determinan como responde despues de ejecutar las acciones:
### responseExact (Tool Calling)
Cuando el agente esta en modo **Tool Calling** (`useToolCalling: true`), el resultado de una accion normalmente pasa al LLM, que reformula el mensaje antes de enviarlo al usuario. Con `responseExact: true`, el `responseMessage` se envia **directamente** al usuario sin pasar por el LLM.
| Valor | Comportamiento |
| ------- | ------------------------------------------------------------------------------------------------------- |
| `true` | Ejecuta las acciones + envia el `responseMessage` exacto al usuario (con variables sustituidas). |
| `false` | Ejecuta las acciones + el LLM genera una respuesta basada en el resultado (comportamiento por defecto). |
**Ejemplo con responseExact = true:**
```
Usuario: "Quiero hablar con soporte"
Bot: [Ejecuta acciones: action.asign → soporte@empresa.com]
Bot: "He transferido tu conversacion al equipo de soporte. Te atenderan en breve."
(exactamente el responseMessage configurado)
```
**Ejemplo con responseExact = false:**
```
Usuario: "Quiero hablar con soporte"
Bot: [Ejecuta acciones: action.asign → soporte@empresa.com]
Bot: "Entendido, he asignado tu caso a nuestro equipo de soporte tecnico. Ellos se pondran en contacto contigo muy pronto para ayudarte."
(el LLM reformula el mensaje)
```
### responseJson (Orquestador Clasico)
Controla el formato de la respuesta cuando se consume via API/SDK. Solo aplica en el orquestador clasico (sin Tool Calling).
| Valor | Formato de Respuesta |
| ------- | -------------------- |
| `false` | Texto plano. |
| `true` | JSON estructurado. |
**Ejemplo con responseJson = false:**
```json theme={null}
{
"success": true,
"answer": "Gracias por tu consulta, un ejecutivo te contactara pronto."
}
```
**Ejemplo con responseJson = true:**
```json theme={null}
{
"success": true,
"answer": {
"message": "Gracias por tu consulta, un ejecutivo te contactara pronto.",
"actionsExecuted": [
{
"type": "action.tag",
"value": "comercial"
},
{
"type": "action.stage",
"value": "prospecto"
}
]
}
}
```
En modo **Tool Calling**, la respuesta siempre incluye `actionsExecuted` en el resultado del tool, independientemente del valor de `responseJson`.
***
## Casos de Uso Comunes
### 1. Transferir a Agente Humano
Asigna un agente humano, desactiva el bot y responde con mensaje fijo.
```json theme={null}
{
"intent": "contactar_soporte",
"reference": "El usuario quiere contactar con soporte tecnico o hablar con un humano",
"tags": ["soporte", "ayuda", "humano"],
"enabled": true,
"responseMessage": "He transferido tu conversacion al equipo de soporte. Te atenderan en breve.",
"responseExact": true,
"action": [
{
"type": "action.asign",
"value": "soporte@empresa.com"
},
{
"type": "action.agentshutdown",
"value": "true"
}
]
}
```
### 2. Clasificar Lead Automaticamente
Etiqueta y segmenta al contacto segun la intencion detectada. El LLM genera la respuesta.
```json theme={null}
{
"intent": "solicitar_informacion",
"reference": "El usuario solicita informacion sobre productos o servicios",
"tags": ["informacion", "productos"],
"enabled": true,
"responseMessage": "",
"responseExact": false,
"action": [
{
"type": "action.tag",
"value": "lead_caliente"
},
{
"type": "action.segmentation",
"value": "interesado"
},
{
"type": "action.stage",
"value": "prospecto"
}
]
}
```
### 3. Agendar Cita con Campos Requeridos
El agente recopila los datos necesarios, crea el evento y responde con mensaje exacto.
```json theme={null}
{
"intent": "agendar_reunion",
"reference": "El usuario quiere agendar una reunion o cita",
"tags": ["cita", "calendario", "reunion"],
"enabled": true,
"requiredFields": [
{
"name": "fecha",
"description": "Fecha y hora de la reunion",
"promptHint": "Para cuando te gustaria agendar la reunion?",
"type": "datetime"
},
{
"name": "nombre_cliente",
"description": "Nombre del cliente",
"type": "string"
}
],
"responseMessage": "Listo {{nombre_cliente}}, tu reunion ha sido agendada para el {{fecha}}.",
"responseExact": true,
"action": [
{
"type": "action.event.add",
"value": "reunion",
"durationMinutes": 30
},
{
"type": "action.tag",
"value": "reunion_agendada"
}
]
}
```
### 4. Resolver Conversacion y Etiquetar
Marca la conversacion como resuelta y agrega una etiqueta de cierre.
```json theme={null}
{
"intent": "finalizar_conversacion",
"reference": "El usuario indica que ya no necesita mas ayuda o quiere cerrar la conversacion",
"tags": ["cerrar", "finalizar", "gracias"],
"enabled": true,
"responseMessage": "Gracias por contactarnos. Hemos marcado tu conversacion como resuelta.",
"responseExact": true,
"action": [
{
"type": "action.tag",
"value": "atendido"
},
{
"type": "action.solved",
"value": "true"
}
]
}
```
### 5. Accion para API/Webhook (JSON)
Respuesta JSON estructurada para integraciones externas via API/SDK.
```json theme={null}
{
"intent": "registrar_lead",
"reference": "Registro automatico de lead en sistema externo",
"tags": ["lead", "crm"],
"enabled": true,
"responseMessage": "Registro completado exitosamente",
"responseExact": false,
"responseJson": true,
"action": [
{
"type": "action.tag",
"value": "lead_registrado"
}
]
}
```
***
## Flujo de Ejecucion
El siguiente diagrama muestra como se procesan las acciones dentro del flujo del agente:
El usuario envia un mensaje. El LLM analiza el `reference` y `tags` de cada accion para determinar si alguna coincide con la intencion del usuario.
Si la accion tiene `requiredFields`, el agente recopila los datos necesarios del usuario de forma conversacional antes de ejecutar.
El sistema ejecuta cada accion del arreglo `action` en orden secuencial. Cada accion actualiza el contacto, emite eventos en tiempo real y registra el cambio en el historial.
Segun la configuracion: si `responseExact` es `true`, envia el `responseMessage` textual. Si es `false`, el LLM genera una respuesta natural basada en el resultado de las acciones.
El ciclo de ejecucion soporta hasta **8 iteraciones** de tool calling. Si el agente necesita ejecutar multiples herramientas (por ejemplo, verificar disponibilidad y luego crear un evento), lo hara dentro de este ciclo de forma automatica.