# Sous-workflows

La famille `automation` permet à un flux de travail d'en invoquer un autre. C'est ainsi qu'une étape partagée par cinq automatisations devient une automatisation que les cinq autres appellent, au lieu de cinq copies qui divergent.

Deux opérateurs : `call` invoque une cible, `return` renvoie un résultat.

## Appeler un sous-workflow

`automation/call` invoque une automatisation qui déclare un [déclencheur `automation-call`](/fr/docs/trigger-manual-chained).

```yaml
- name: enrich
  type: automation
  operator: call
  props:
    name: enrich-lead
    inputData: { email: '{{trigger.data.record.email}}' }
    mode: sync
    maxDepth: 10
```

| Propriété   | Description                                                              |
| ----------- | ------------------------------------------------------------------------ |
| `name`      | **Obligatoire.** Nom de l'automatisation cible, en kebab-case.           |
| `inputData` | Entrée clé-valeur remise à l'appelé. Il la lit à `{{trigger.input.*}}`.  |
| `mode`      | `sync` (attend l'appelé, par défaut) ou `async` (déclenche et poursuit). |
| `maxDepth`  | Garde de récursion, 1–100. Par défaut **10**.                            |

:::callout
**`waitForCompletion` et `timeout` sont acceptés mais ignorés.** Tous deux passent la validation du schéma et aucun n'est lu à l'exécution — un appel écrit avec `waitForCompletion: true` n'en est pas synchrone pour autant. Utilisez **`mode`** : `sync` attend, `async` non.
:::

`maxDepth` arrête une chaîne qui s'appelle elle-même, directement ou par intermédiaires. L'appelé voit sa profondeur actuelle à `{{trigger.depth}}`, et l'automatisation qui l'a invoqué à `{{trigger.caller}}`.

## Renvoyer un résultat

`automation/return` remet une sortie à l'appelant. Il n'a de sens que dans une automatisation dont le déclencheur est `automation-call`.

```yaml
- name: done
  type: automation
  operator: return
  props:
    data:
      score: '{{computeScore.result}}'
      tier: '{{classify.result}}'
```

| Propriété | Description                                                               |
| --------- | ------------------------------------------------------------------------- |
| `data`    | **Obligatoire.** Sortie clé-valeur renvoyée à l'automatisation appelante. |

`data` est la seule propriété, et elle est obligatoire — une action `return` sans elle échoue au décodage de la configuration. Chez le parent, le résultat arrive sous `steps.{name}.result.*` : l'appel ci-dessus se relit donc via `{{enrich.result.score}}`.

:::callout
**La propriété est `data`, pas `output`.** `output` est bien un nom de propriété réel — sur [`flow/stop`](/fr/docs/automation-flow-control), qui termine une exécution au lieu d'en revenir. Les deux se confondent aisément et se comportent différemment : `return` remet une valeur à un appelant, `stop` arrête.
:::

## Composition ou gestion d'échec

`automation/call` invoque une cible qui _déclare_ un déclencheur `automation-call` et (en mode `sync`) attend son résultat. Pour réagir à un flux qui a **échoué**, utilisez plutôt le [déclencheur `automation-failure`](/fr/docs/trigger-manual-chained) : il s'active après coup, sur une exécution que vous n'avez pas lancée, et ne peut pas l'influencer.

| Vous voulez                                            | Utilisez                                                      |
| ------------------------------------------------------ | ------------------------------------------------------------- |
| Réutiliser une étape dans plusieurs automatisations    | `automation/call` avec `mode: sync`.                          |
| Lancer un traitement long sans bloquer cette exécution | `automation/call` avec `mode: async`.                         |
| Être notifié quand une autre automatisation casse      | Un déclencheur `automation-failure`.                          |
| Récupérer d'une étape en échec dans _cette_ exécution  | La [tentative](/fr/docs/automation-retry-failure) par action. |

## Pages connexes

- [Contrôle de flux](/fr/docs/automation-flow-control) — branchement, itération et `flow/stop`.
- [Déclencheurs manuels et chaînés](/fr/docs/trigger-manual-chained) — le déclencheur `automation-call` visé ici.
- [Nouvelle tentative et échec](/fr/docs/automation-retry-failure) — la récupération avant qu'une exécution ne soit déclarée en échec.
- [Présentation des actions](/fr/docs/automation-actions-overview) — propriétés de base et carte des familles.
- [Exécutions d'automatisation](/fr/docs/automation-runs) — suivre une exécution parente et ses enfants.