# If / else

Aiguille l'exécution vers différentes branches selon des conditions évaluées sur la sortie du nœud précédent.

## Vue d'ensemble

Le nœud If/else évalue une liste ordonnée de conditions sur le payload entrant. La première condition vraie prend sa branche ; si aucune ne correspond, le flot sort par la branche **Else**. Chaque condition possède sa propre sortie nommée, ce qui permet de câbler directement le nœud aval à un cas précis.

Deux styles d'écriture :

- **Expressions** — style Common Expression Language : `input.event_type == "checkout"`, `input.score > 0.8`, `input.tags contains "vip"`.
- **Constructeur** — chemin JSON sur le payload, opérateur, valeur attendue.

Le payload est normalement la sortie parsée du nœud précédent (`input.foo.bar`). Les littéraux `42`, `"sales"`, `true`, `null` sont acceptés à droite.

## Autocomplétion contextuelle

Le champ d'expression suggère au fil de la saisie, en **trois étapes** qui suivent votre position dans l'expression :

1. **Champ** — les champs amont issus du schéma de sortie du nœud précédent (`input.output_text`, `input.output_parsed.<champ>`), chacun étiqueté avec son type (STRING, NUMBER, BOOLEAN, ENUM…).
2. **Opérateur** — filtré selon le type du champ sélectionné : les nombres reçoivent `==`, `!=`, `>`, `>=`, `<`, `<=` ; les booléens `==`, `!=` ; les enums `==`, `!=`, `in` ; les strings `==`, `!=`, `contains`, `in`.
3. **Valeur** — les littéraux du schéma : valeurs d'enum déjà quotées et prêtes à insérer, `true`/`false` pour les booléens.

L'étape champ propose aussi des **expressions prêtes à l'emploi** : pour un champ booléen vous pouvez choisir `flag == true` d'un coup, et pour un champ enum une expression `champ == 'valeur'` complète par valeur possible — pas besoin de mémoriser le schéma.

## Configuration

| Champ | Description |
| --- | --- |
| `conditions` | Liste ordonnée de cas : `caseName` (étiquette du handle), `expression` (ou `path`+`operator`+`value`), `handle` généré (`true`, `branch-1`, …). |
| `conditionMode` | `expression` (chaîne libre style CEL) ou `builder` (chemin + opérateur + valeur). |
| `conditionJoin` | `all` (ET) ou `any` (OU) — utilisé quand plusieurs lignes en mode builder. |
| Opérateurs | `==`, `!=`, `>`, `>=`, `<`, `<=`, `contains`, `in`, `exists`, `empty`, `not_empty`. |
| Sorties | `true` (1er match), `branch-1`, `branch-2`, … (matchs suivants), `false` (sinon). |

Sans condition structurée, le texte est envoyé à un LLM qui répond `true`/`false`. Utile pour des intentions floues (`"l'utilisateur demande un tarif"`).

## Aiguiller sur l'événement déclencheur

Le nœud If/else peut lire directement le payload du trigger entrant — sans passer par un Set state. Les opérandes `event.*` (et l'alias `webhook.*`, qui pointe sur le même payload) exposent `{ body, headers, query, method, path }` :

| Expression | Aiguille sur |
| --- | --- |
| `event.method == 'POST'` | Le verbe HTTP |
| `event.body.action == 'deleted'` | Un champ du corps de la requête |
| `event.query.format == 'pdf'` | Un paramètre de query-string |
| `event.headers.x-source contains 'github'` | Un en-tête entrant |

`event` est l'alias agnostique du trigger ; `webhook` désigne le même payload. Les deux fonctionnent en mode expression comme en mode constructeur (chemin + opérateur + valeur). L'autocomplétion propose un groupe **Trigger event** (method / path / query / headers / body) plus des choix prêts à l'emploi `event.method == 'VERB'` pour les verbes que le webhook accepte — vous séparez un même endpoint par méthode HTTP en un clic.

```
Webhook → If/else
   ├─ event.method == 'POST'    → Créer (Agent)
   ├─ event.method == 'DELETE'  → Soft-delete (Agent)
   └─ sinon                     → 405 (Respond to webhook)
```

## Exemple

Aiguillage d'un webhook selon le type d'événement :

```
Webhook → If/else
   ├─ event == "checkout.completed"     → Émettre facture (Agent)
   ├─ event == "subscription.canceled"  → Notifier ops (Slack MCP)
   └─ sinon                              → Logger & ignorer (Transform)
```

Lignes de condition :

| Nom du cas | Expression |
| --- | --- |
| Checkout | `input.type == "checkout.completed"` |
| Annulation | `input.type == "subscription.canceled"` |

La première ligne vraie est prise. Tout le reste sort par **Else**.

## Pièges

- L'ordre compte. Le nœud s'arrête à la première condition vraie.
- `input` désigne le JSON parsé du nœud précédent (`last_output_parsed`). Si le nœud amont a renvoyé du texte, utilisez `input.output_text`.
- Une branche non câblée arrête proprement le flot sur cette sortie.
- Le fallback LLM coûte un appel modèle : préférez des conditions structurées sur le chemin critique.
- Les comparaisons numériques convertissent en `float`. Comparer une chaîne non numérique renvoie `false`.

---

*Source: https://agentbuilder.systalink.sn/docs/node-if-else — human documentation.*
*Other language: [/docs-md/en/node-if-else.md](/docs-md/en/node-if-else.md).*
*Machine-readable index: [/llms.txt](/llms.txt).*