> ## Documentation Index
> Fetch the complete documentation index at: https://docs.getnexor.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Funciones programadas

> Crea funciones JavaScript programadas, elige la cohorte de leads que reciben, ejecútalas de forma segura y revisa su historial.

Las Funciones programadas ejecutan JavaScript aislado según una programación cron. Cada ejecución programada recibe una cohorte actualizada y limitada a la organización, y puede llamar APIs externas o poner en cola cambios controlados en Nexor.

Usa una Función programada cuando la lógica deba correr según el reloj y sea más clara en código, por ejemplo para volver a puntuar leads antiguos, sincronizar una cohorte cada noche o distribuir leads sin asignar. Usa una [Cloud Function](/docs/es/guides/advanced/cloud-functions) cuando el código deba dispararse por un evento de Nexor.

<Warning>
  **Ejecutar** y **Ejecutar ahora** hacen ejecuciones reales, no simulaciones. Las solicitudes HTTP se envían y los efectos guardados se aplican cuando la función termina correctamente. Usa endpoints de prueba, limita la cohorte y revisa la vista previa antes de ejecutar.
</Warning>

## Crea una función

En el dashboard, los roles Owner, Admin y Partner de la organización pueden crear, editar, ejecutar, pausar, borrar el historial o eliminar Funciones programadas.

<Steps>
  <Step title="Elige un punto de partida">
    Abre **Desarrolladores → Funciones programadas** y selecciona **Nueva función**. Empieza en blanco o elige **Re-puntuar leads estancados**, **Etiquetar inactivos** o **Repartir sin asignar**.
  </Step>

  <Step title="Define la programación">
    Ingresa un nombre, elige una frecuencia, confirma la zona horaria y continúa. Puedes editar la expresión cron y la zona horaria después.
  </Step>

  <Step title="Define el alcance de consulta">
    Selecciona los leads, Agentes de IA y hosts que necesita el código. Limita la consulta de leads y define el máximo que se carga por ejecución.
  </Step>

  <Step title="Escribe y guarda el código">
    Implementa `onSchedule(ctx)`, agrega variables de entorno para los secretos y guarda para desplegar el código y la programación actuales.
  </Step>

  <Step title="Previsualiza, ejecuta y monitorea">
    Revisa la cohorte, ejecuta con una entrada controlada e inspecciona la salida. Deja la función activa solo cuando el resultado, los registros, las solicitudes y los efectos coincidan con tu intención.
  </Step>
</Steps>

Las plantillas iniciales son ejemplos editables, no modos de ejecución. Revisa su consulta, IDs, límites y código antes de guardar.

| Plantilla                       | Comportamiento inicial                                                                  |
| ------------------------------- | --------------------------------------------------------------------------------------- |
| **En blanco**                   | Carga leads y ejecuta un cuerpo vacío de `onSchedule(ctx)`.                             |
| **Re-puntuar leads estancados** | Selecciona leads sin contacto reciente y reduce un puntaje guardado en metadata.        |
| **Etiquetar inactivos**         | Selecciona leads sin contacto reciente y agrega una etiqueta `inactive`.                |
| **Repartir sin asignar**        | Selecciona leads sin asignación y los distribuye entre los IDs de usuario que ingreses. |

## Configura la programación

El editor ofrece frecuencias predefinidas de cada 5 minutos, cada 15 minutos, cada hora, cada 4 horas y una vez al día. Selecciona **Personalizada** para escribir una expresión cron de cinco campos.

La zona horaria controla cuándo corren las expresiones basadas en el calendario. Por ejemplo, `0 9 * * *` significa las 09:00 en la zona horaria elegida para la función, que no siempre coincide con la del navegador. La vista previa pide al servidor que calcule las próximas ejecuciones para que puedas comprobar ambos valores juntos.

<Tip>
  Pausa una función mientras cambias una integración externa o investigas errores. La pausa evita nuevas ejecuciones programadas, pero una ejecución ya iniciada puede terminar.
</Tip>

## Selecciona el alcance de consulta

Nexor resuelve el alcance de consulta justo antes de cada ejecución. La función solo recibe datos de la misma organización.

La consulta de leads permite filtrar por:

* leads activos, históricos o todos;
* Agente y etapa;
* campaña;
* usuario asignado o leads sin asignación;
* búsqueda por nombre, correo o teléfono;
* una ventana móvil de creación en horas o días; y
* orden y límite de leads por ejecución.

El lote predeterminado es de 50 leads y puede configurarse entre 1 y 500. Una consulta puede reducirlo aún más. **Previsualizar cohorte** muestra el total de coincidencias y una muestra, mientras que el límite configurado controla cuántas filas llegan a `ctx.leads` durante una ejecución.

Los Agentes de IA y los hosts humanos son grupos opcionales. Inclúyelos solo si el código lee `ctx.agents` o `ctx.hosts`; de lo contrario, esos arreglos están vacíos.

## Lee el contexto de ejecución

Cada ejecución programada recibe un objeto `ctx` con esta estructura:

| Campo               | Contenido                                                  |
| ------------------- | ---------------------------------------------------------- |
| `ctx.event`         | El nombre de evento fijo `schedule.tick`.                  |
| `ctx.client_id`     | La organización propietaria de la función.                 |
| `ctx.scheduled_for` | La ocurrencia programada representada por esta ejecución.  |
| `ctx.timezone`      | La zona horaria IANA de la función.                        |
| `ctx.cron`          | La expresión cron guardada.                                |
| `ctx.leads`         | La cohorte limitada de leads resuelta desde la consulta.   |
| `ctx.agents`        | Los Agentes de IA activos cuando ese grupo está incluido.  |
| `ctx.hosts`         | Los hosts humanos activos cuando ese grupo está incluido.  |
| `ctx.effects`       | Acciones de Nexor guardadas y limitadas a la organización. |

El entorno también incluye `env`, `axios`, `fetch`, `console` y `helpers`. `helpers.uuid()` crea un UUID, `helpers.now()` devuelve el timestamp actual y `helpers.daysAgo(n)` devuelve un timestamp relativo a la ejecución.

## Escribe efectos controlados

Los efectos se guardan mientras corre el JavaScript. Nexor los aplica después de una ejecución correcta y limita cada cambio a la organización propietaria de la función.

```javascript theme={null}
export default async function onSchedule(ctx) {
  for (const lead of ctx.leads) {
    if (!lead.tags.includes("reviewed")) {
      ctx.effects.tagLead(lead.id, ["reviewed"]);
    }
  }

  return { reviewed: ctx.leads.length };
}
```

Estos son los efectos disponibles:

| Efecto                                          | Acción                                                   |
| ----------------------------------------------- | -------------------------------------------------------- |
| `upsertLead(lead)`                              | Crea un lead o encuentra uno por correo o teléfono.      |
| `updateLead(leadId, patch)`                     | Fusiona campos compatibles en un lead.                   |
| `updateMetadata(leadId, patch)`                 | Fusiona claves en la metadata del lead.                  |
| `assignLead(leadId, userId)`                    | Asigna un lead a un usuario humano.                      |
| `assignToWorkflow(leadId, workflowId, reason?)` | Inscribe un lead en un Agente.                           |
| `tagLead(leadId, tags)`                         | Agrega una o más etiquetas.                              |
| `setLeadStatus(leadId, statusKey, workflowId?)` | Mueve un lead a un estado.                               |
| `deactivateWorkflowRun(leadId)`                 | Detiene las ejecuciones activas del Agente para el lead. |
| `updateEnvironmentVariable(key, value)`         | Reemplaza una variable de entorno existente.             |

Si la función genera un error o alcanza el timeout, sus efectos guardados no se aplican. Las llamadas ya realizadas con `axios` o `fetch` no se pueden revertir, por lo que las escrituras externas deben ser idempotentes.

## Usa variables de entorno

Cloud Functions y Funciones programadas usan las mismas variables de entorno de la organización. Lee un valor como `env.NAME` y nunca pongas un token directamente en el código de la función.

El dashboard oculta los valores guardados: la lista muestra el nombre, no el valor. Crear, reemplazar o eliminar una variable vuelve a desplegar todas las Cloud Functions guardadas y todas las Funciones programadas activas para mantener sus bindings actualizados.

<Warning>
  `updateEnvironmentVariable(key, value)` rota un secreto existente como un efecto real. Su valor se oculta en los detalles guardados de la ejecución, pero el cambio afecta a otras funciones que usan la misma variable.
</Warning>

## Ejecuta y revisa de forma segura

Guarda y despliega los cambios pendientes antes de seleccionar **Ejecutar**. El diálogo ofrece dos tipos de entrada:

* **Cohorte real** resuelve la consulta guardada justo antes de ejecutar.
* **Contexto personalizado** envía el JSON que ingreses en vez de resolver la cohorte guardada.

Ambos modos ejecutan el código desplegado, envían solicitudes HTTP reales y pueden aplicar efectos reales. Un contexto personalizado cambia la entrada, pero no convierte la ejecución en una simulación.

El historial guarda el origen, estado, duración, cantidad de candidatos, efectos aplicados y fallidos, salida de consola, vistas previas de solicitudes HTTP, resultado devuelto y errores. El resumen de salud usa ejecuciones programadas recientes; las manuales siguen visibles, pero no cambian el cálculo de disponibilidad programada.

Borrar el historial elimina permanentemente todas las ejecuciones guardadas de esa función. Eliminar una Función programada también borra su historial y no se puede deshacer.

## Usa la API pública

Las claves REST pueden usar los endpoints de Funciones programadas. Las claves MCP necesitan `workflows:read` para lecturas y vistas previas, y `workflows:write` para crear, actualizar, ejecutar, eliminar y borrar el historial.

<CardGroup cols={2}>
  <Card title="Listar Funciones programadas" icon="list" href="/docs/es/api/scheduled-functions/list-scheduled-functions">
    Lee las funciones disponibles para la organización.
  </Card>

  <Card title="Crear una Función programada" icon="plus" href="/docs/es/api/scheduled-functions/create-scheduled-function">
    Crea el código, la programación, la zona horaria y la configuración de consulta.
  </Card>

  <Card title="Previsualizar una programación" icon="calendar-clock" href="/docs/es/api/scheduled-functions/preview-schedule">
    Valida el cron y la zona horaria contra las próximas ejecuciones.
  </Card>

  <Card title="Previsualizar una cohorte" icon="users" href="/docs/es/api/scheduled-functions/preview-cohort">
    Cuenta y muestra una muestra de los leads elegidos por una consulta.
  </Card>

  <Card title="Ejecutar una Función programada" icon="play" href="/docs/es/api/scheduled-functions/run-scheduled-function">
    Inicia una ejecución real cuyos efectos pueden aplicarse.
  </Card>

  <Card title="Listar ejecuciones" icon="scroll-text" href="/docs/es/api/scheduled-functions/list-runs">
    Revisa el historial de ejecuciones de forma programática.
  </Card>
</CardGroup>
