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

# Fin

> Cierra una ruta del workflow con una salida declarada para que el workflow que lo invoca continúe por ella

El nodo **Fin** cierra una ruta del workflow y la asocia a una **salida** (output) que tú declaras. Cuando otro workflow invoca a este con el nodo [Workflow](/guides/nodos/workflow), esa salida se convierte en una ruta conectable en el workflow padre: así el padre sabe cómo terminó el hijo y continúa por la rama correspondiente.

<Note>
  Un workflow no necesita nodos Fin para funcionar. Si no declaras salidas, el workflow termina como siempre y el nodo Workflow que lo invoca sigue comportándose como un salto simple.
</Note>

## Qué es una salida

Una salida es el contrato de terminación del workflow. Cada salida tiene:

| Campo              | Para qué sirve                                                             |
| ------------------ | -------------------------------------------------------------------------- |
| **Nombre**         | El identificador técnico de la salida (por ejemplo, `pago_aprobado`).      |
| **Nombre visible** | El texto que se muestra en el nodo Fin y en el nodo Workflow del padre.    |
| **Descripción**    | Explica cuándo se toma esta salida. Se muestra en el panel del nodo Fin.   |
| **Tipo**           | **Éxito**, **Error** o **Neutral**. Define el color de la ruta y del nodo. |
| **Esquema**        | Las variables que el workflow devuelve al padre por esta salida.           |

### Tipos de salida

<CardGroup cols={3}>
  <Card title="Éxito" icon="circle-check">
    La ruta terminó como esperabas.
  </Card>

  <Card title="Error" icon="circle-xmark">
    La ruta terminó en un fallo controlado.
  </Card>

  <Card title="Neutral" icon="circle-minus">
    La ruta terminó en un desenlace que no es ni éxito ni error.
  </Card>
</CardGroup>

## Crear una salida

<Steps>
  <Step title="Abre el administrador de outputs">
    En el canvas del workflow, abre el menú de la barra superior y elige **Administrador de outputs**. También puedes hacerlo desde el propio nodo Fin: si el workflow aún no tiene salidas, su panel muestra el botón **Crear output**.

    Necesitas permiso de escritura sobre el canvas para verlo.
  </Step>

  <Step title="Completa los datos generales">
    Escribe el nombre, el nombre visible y la descripción, y elige el tipo de salida (**Éxito**, **Error** o **Neutral**).
  </Step>

  <Step title="Define el esquema">
    Agrega un campo por cada dato que el workflow devuelva: la **variable** es la clave que el padre va a leer, y el **nombre** es su etiqueta. También puedes pegar un JSON de ejemplo y generar el esquema a partir de él.
  </Step>

  <Step title="Guarda">
    La salida queda disponible para todos los nodos Fin del workflow y aparece de inmediato en los nodos Workflow que lo referencian.
  </Step>
</Steps>

## Usar el nodo Fin en el canvas

<Steps>
  <Step title="Arrastra el nodo">
    En el panel de nodos, abre el grupo **Fin** y arrastra el nodo al canvas.
  </Step>

  <Step title="Elige la salida">
    Haz clic en el nodo para abrir su panel y selecciona una de las salidas declaradas. El nodo toma el color y el título del tipo de esa salida — **Éxito**, **Error** o **Neutral** — y muestra su nombre visible. Mientras no elijas ninguna, se muestra como **Fin**.
  </Step>

  <Step title="Conecta la ruta">
    Conecta al nodo Fin cada rama que deba terminar con esa salida. Puedes tener varios nodos Fin apuntando a la misma salida.
  </Step>
</Steps>

El nodo Fin también incluye configuración de **Data Loss Prevention (DLP)** para enmascarar información sensible en los logs que genera.

## Consumir las salidas desde el workflow padre

Cuando un workflow declara salidas, el nodo [Workflow](/guides/nodos/workflow) que lo referencia las dibuja como puntos de conexión, uno por salida:

* **Conecta cada salida** a la rama que corresponda en el workflow padre.
* **Las variables del esquema** quedan disponibles en el selector de variables del padre como `$memory.response.<variable>`. Por ejemplo, un esquema con la variable `total` se lee como `{{$memory.response.total}}`.

<Tip>
  Declara una salida por cada desenlace que el workflow padre necesite distinguir. Si el padre solo necesita saber que el hijo terminó, una única salida neutral es suficiente.
</Tip>

## Eliminar una salida

Antes de eliminar, la plataforma revisa si algún workflow del proyecto tiene esa salida conectada en su nodo Workflow:

* **Si alguno la usa, la eliminación se bloquea.** El error te dice qué workflows la tienen conectada: desconecta la ruta en cada uno y vuelve a intentarlo.
* **Si ninguno la usa**, la salida se elimina junto con los nodos Fin que la tenían seleccionada y las rutas que llegaban a ellos.

<Note>
  La validación mira la conexión, no la referencia: un nodo Workflow que apunta a este workflow pero no tiene esa salida conectada no bloquea la eliminación.
</Note>

Si la eliminación falla, los nodos Fin se conservan y el workflow queda como estaba.

## Probar el workflow desde el Tester

Cuando el nodo Workflow tiene salidas conectadas, el workflow hijo se ejecuta **dentro** de la ejecución del padre: el padre espera a que termine y continúa por la salida que el hijo tomó. En el [Tester](/guides/getting-started/tester) esto se nota en dos cosas:

* Tus respuestas se envían al workflow hijo mientras esté en curso.
* El nodo no muestra el botón **"Ir al workflow"** ni el separador de inicio de ejecución, porque no se trata de una ejecución aparte a la que ir.

Un nodo Workflow sin salidas conectadas se comporta como siempre: redirige el flujo y el Tester sigue mostrando el botón para abrir el workflow destino.