# While

Répète une ou plusieurs actions directement connectées tant qu'une condition reste vraie. Le nœud possède les sorties explicites **Loop**, **Done** et **Timeout**, avec des limites d'itérations et de durée.

## Sorties

| Sortie | Quand est-elle utilisée ? |
| --- | --- |
| **Loop** | La condition est vraie. Chaque nœud directement connecté à cette sortie est exécuté une fois pendant l'itération. |
| **Done** | La condition devient fausse, y compris avant la première itération. |
| **Timeout** | Le maximum d'itérations ou la durée totale est atteint alors que la condition est encore vraie. |

## Configuration

| Champ | Description |
| --- | --- |
| Condition | Expression structurée évaluée avant chaque itération, par exemple `input.output_text != "ready"`, `state.attempts < 5` ou `loop.iteration < 10`. La boucle continue tant qu'elle est vraie. |
| **Max iterations** | Limite de sécurité obligatoire. 10 par défaut, plafond technique de 1 000. |
| **Delay between iterations** | Pause avant le passage suivant. 1 seconde par défaut ; les valeurs inférieures à 0,1 seconde sont limitées. |
| **Maximum total duration** | Durée réelle maximale de toute la boucle. 300 secondes par défaut, plafond de 24 heures. |

Utilisez `last_output` pour lire le résultat courant du corps de Loop. Si ce résultat est du JSON, ajoutez le chemin de la propriété, par exemple `last_output.choice != "ready"` ou `last_output.items.0.status == "done"`.

Le panneau affiche une estimation maximale des exécutions du corps. Le nombre réel d'appels API ou modèle dépend des nœuds coûteux connectés à **Loop**.

## Exemple complet : tirer un jour jusqu'à obtenir lundi

Cet exemple tire un jour au hasard. Le workflow répète le nœud Code jusqu'à ce que sa sortie JSON contienne `"lundi"`.

### 1. Nœud Code

Ajoutez un nœud **Code** après **Start**, puis utilisez :

```python
import json
import random

days = ["lundi", "mardi", "mercredi"]
response = {"choice": random.choice(days)}
print(json.dumps(response, ensure_ascii=False))
```

Le JSON affiché avec `print` devient la sortie du nœud Code, par exemple :

```json
{"choice": "mardi"}
```

### 2. Condition du While

Configurez le nœud While ainsi :

```text
Continuer tant que : last_output.choice != "lundi"
Max iterations : 10
Delay between iterations : 1 seconde
Maximum total duration : 20 secondes
```

`last_output.choice` lit la propriété `choice` du dernier résultat JSON produit par Code. La condition signifie donc : **continuer la boucle tant que le jour obtenu n'est pas lundi**.

N'utilisez pas `input.output_text.choice` ici. `input.output_text` correspond au texte brut reçu par le workflow, pas à la sortie structurée courante du corps de la boucle.

### 3. Branchements

```text
Start → Code → While
          ↑        ├─ Loop ──┘
                   ├─ Done → End
                   └─ Timeout → Alert ou End
```

- **Loop → Code** tire un nouveau jour, puis Code renvoie son nouveau résultat vers While.
- **Done → End** est utilisée dès que Code renvoie `{"choice": "lundi"}`.
- **Timeout** est utilisée si lundi n'a pas été obtenu avant d'atteindre une limite de sécurité configurée.

### 4. Déroulement d'une exécution

Pour la suite `mardi → mercredi → lundi` :

1. Code renvoie `{"choice": "mardi"}`. La condition est vraie : **Loop** relance Code.
2. Code renvoie `{"choice": "mercredi"}`. La condition reste vraie : la boucle continue.
3. Code renvoie `{"choice": "lundi"}`. La condition devient fausse : While sort par **Done**.

La trace peut donc afficher plusieurs entrées **While · Loop** et **Code · Iteration** avant l'entrée finale **Done**. C'est le comportement attendu.

## Exemple de polling

Attendre qu'un traitement asynchrone soit prêt :

```text
Start → HTTP Request (créer le job) → While
                                       ├─ Loop → HTTP Request (GET statut)
                                       ├─ Done → Agent → End
                                       └─ Timeout → Alert → End
```

Configuration :

```text
Condition : input.output_text != "ready"
Max iterations : 20
Délai : 2 secondes
Durée maximale : 120 secondes
```

## Traces d'exécution

Le test du workflow affiche chaque itération séparément : numéro, entrée/sortie des nœuds du corps, délai d'attente, temps écoulé, motif de sortie et branche finale Done ou Timeout.

## Compatibilité et précautions

- Les anciens nœuds While continuent à fonctionner avec leur syntaxe de condition d'arrêt (`empty`, `not_empty`, `contains:valeur`). Leur modification migre le nœud vers la nouvelle logique « continuer tant que » et les sorties explicites ; reconnectez les branches si nécessaire.
- Connectez **Timeout** à une vraie stratégie de récupération : Alert, Send Email, réponse de secours ou End.
- Les boucles multiplient les appels API et les coûts. Gardez des limites basses et un délai adapté au service appelé.
- L'état écrit dans le corps reste disponible pendant tout le même run du workflow.

---

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