Blocs

Chaque bloc fait une seule chose. Ses réglages se trouvent dans l’inspecteur quand vous le sélectionnez ; ses ports sont sur le canevas, les entrées à gauche et les sorties à droite. Cette page liste chaque type, dans les groupes que reprend le sélecteur de blocs, puis explique les valeurs qui circulent entre les blocs, les modèles comme {{body.id}}, et les conditions.

Comment avance une exécutionCopy Anchor Link

• Un bloc s’exécute quand chaque entrée qui a un lien vers lui contient une valeur. Il envoie ensuite des valeurs par certaines de ses sorties, et seuls les blocs reliés à ces sorties s’exécutent ensuite.
• Démarrer s’exécute en premier. Les blocs Valeur et Lire une variable dans lesquels rien n’est relié s’exécutent aussi au début.
• Les blocs s’exécutent côte à côte quand ils le peuvent. Un bloc Afficher et attendre peut vous attendre pendant qu’un bloc Interroger continue.
• Plusieurs blocs peuvent échouer : Requête, Interroger, Outil, Flux, Évaluer et Écrire un fichier ont une sortie fail. Quand elle est reliée, l’échec en sort et l’exécution continue. Sinon, toute l’exécution échoue à ce bloc.
• L’exécution se termine quand plus rien ne tourne.

L’inspecteur de chaque bloc propose aussi Titre (affiché sur le bloc ; le nom du type quand il est vide) et En pause (les valeurs passent telles quelles). Un bloc en pause est atténué et ignoré : ce qui entre ressort directement par sa première sortie.

DéclencheursCopy Anchor Link

DémarrerCopy Anchor Link

L’endroit où commence une exécution : le bouton Exécuter, un agent (quand le flux est un outil), une planification, un webhook ou echolot flow run. Son inspecteur contient les Déclencheurs du flux ; voir Exécution et déclencheurs.

Un flux a exactement un bloc Démarrer. Il ne figure pas dans le sélecteur de blocs.

SortieCopy Anchor Link

Ce que l’exécution renvoie : à l’agent qui a appelé le flux, à la ligne de commande, à l’appelant du webhook ou à un flux parent. Un flux en a au plus un.

ActionsCopy Anchor Link

RequêteCopy Anchor Link

Envoie une requête enregistrée de l’espace de travail (HTTP, GraphQL ou une requête MCP) avec son auth, ses scripts, ses vérifications et l’environnement de l’exécution.

Une requête réussit quand elle répond 2xx et que ses vérifications, les tests de ses scripts et ses scripts passent tous, comme dans l’Exécution. Les variables qu’un flux transmet l’emportent sur celles de l’environnement pour cet envoi seulement.

Dans le flux Place a test order, la sortie success de Sign in est reliée à send de Create order : la commande n’est passée qu’après la réussite de la connexion, et le jeton que Sign in capture est déjà dans {{token}}.

OutilCopy Anchor Link

Exécute l’un des outils propres à Echolot, comme démarrer un mock, exécuter un dossier, analyser une spec ou appeler un outil d’un serveur MCP, avec les mêmes règles que pour les agents.

Un bloc Outil ne peut pas exécuter un autre flux ; utilisez pour cela un bloc Flux.

FluxCopy Anchor Link

Exécute un autre flux de l’espace de travail et envoie ce que son bloc Sortie a reçu.

Les flux peuvent s’exécuter les uns les autres sur 8 niveaux au plus. Les secrets ne circulent pas comme valeurs entre les flux : enregistrez-les plutôt comme variables.

PersonnesCopy Anchor Link

Les blocs Personnes mettent l’exécution en pause et vous posent une question. Dans l’app, une feuille s’ouvre ; si un agent a lancé l’exécution, la question va au client de l’agent ; en ligne de commande, elle est posée dans le terminal. Les exécutions lancées par des planifications et des webhooks n’ont personne à qui demander : un bloc Personnes y échoue, tout comme echolot flow run --no-input.

DemanderCopy Anchor Link

Demande des valeurs avec un petit formulaire.

La feuille propose Annuler et Continuer. Les réponses aux champs secret sont masquées dans le journal d’exécution.

Afficher et attendreCopy Anchor Link

Affiche un message, un code à copier et un lien à ouvrir, puis attend Continuer, ou qu’une valeur arrive sur until. Utilisez-le pour les connexions par appareil : affichez le code pendant qu’un bloc Interroger attend l’approbation.

Les cinq acceptent les modèles.

Quand until est relié, la feuille indique Le flux reprend de lui-même une fois la tâche terminée. Ne plus attendre la ferme et fait échouer le bloc.

ApprouverCopy Anchor Link

Vous demande d’approuver avant que le flux continue, avant une action irréversible.

L’approbation revient toujours à la personne. Quand un agent exécute un flux et répond à un bloc Approuver, Echolot vous pose d’abord la question. Dans Place a test order, le bloc Approuver Keep the order? demande Keep order {{body.id}} for CHF {{body.total.amount}}? avec la commande que la boutique vient de créer ; Refuser l’envoie à Cancel order.

LogiqueCopy Anchor Link

SiCopy Anchor Link

Envoie ce qui est entré vers true ou false selon une condition.

Morning stock check utilise Si Running low? avec value.body.items.some(p => p.stock.bern < 5) sur les produits que la boutique a renvoyés.

SelonCopy Anchor Link

Envoie ce qui est entré au premier cas dont la condition est remplie, sinon à default.

ÉvaluerCopy Anchor Link

Exécute du JavaScript sur ce qui est entré. La dernière expression est le résultat : ({ id: value.body.id }) ou a + b. Un code avec son propre return s’exécute comme le corps d’une fonction, et ce que donne return est le résultat. Une promesse est attendue. pm.test et pm.expect fonctionnent comme dans les scripts, et leurs résultats comptent comme les tests de l’exécution. Les lignes console.log vont dans le journal d’exécution.

// Inputs: pages. Joins the lists that Collect gathered.
return pages.flat();

DélaiCopy Anchor Link

Attend, puis transmet la valeur.

Ports : value en entrée, value en sortie.

BouclesCopy Anchor Link

RépéterCopy Anchor Link

Envoie index autant de fois que Nombre, en comptant à partir de 0, puis done.

Pour chaqueCopy Anchor Link

Envoie chaque élément d’une liste à tour de rôle, puis done. Il n’a aucun réglage.

CollecterCopy Anchor Link

Rassemble en une seule liste ce qui arrive pendant une boucle, et l’envoie quand la boucle est terminée. Il n’a aucun réglage.

Chaque tour d’une boucle se termine avant que le suivant commence, et les blocs qu’il atteint s’exécutent de nouveau à chaque tour. Les valeurs extérieures à la boucle, comme une entrée de Démarrer, restent disponibles à chaque tour.

InterrogerCopy Anchor Link

Envoie une requête enregistrée encore et encore jusqu’à ce qu’une condition soit remplie (une connexion approuvée, une tâche terminée) ou que l’échéance passe.

Contrairement à Requête, une réponse hors 2xx ne fait pas échouer Interroger : il renvoie jusqu’à ce que Jusqu’à soit vrai.

DonnéesCopy Anchor Link

ValeurCopy Anchor Link

Une valeur fixe : du texte, un nombre, true ou false, une liste ou un objet.

ModèleCopy Anchor Link

Du texte dont les {{name}} sont remplis à partir de l’objet entré et des variables de l’exécution.

Ports : values en entrée (un objet), text en sortie.

ExtraireCopy Anchor Link

Extrait des valeurs de ce qui est entré selon un chemin, une sortie chacune.

Les chemins sont la partie commune de JSONPath :

Définir une variableCopy Anchor Link

Enregistre des valeurs comme variables, pour que les blocs et requêtes suivants les lisent avec {{name}}.

Avec secret activé, la valeur va dans le trousseau, jamais dans un fichier, et elle est masquée dans le journal d’exécution et dans ce que voient les agents dès qu’elle quitte le bloc précédent. Quand path ne trouve rien, la variable garde son ancienne valeur : une réponse de jeton sans nouveau jeton d’actualisation n’efface donc pas celui que vous avez. Voir secrets.

Ports : value en entrée, value en sortie (ce qui est entré, transmis).

Lire une variableCopy Anchor Link

Lit une variable comme les requêtes la voient : celle de l’exécution d’abord, puis celle de l’environnement, de l’espace de travail et les variables globales.

SortieCopy Anchor Link

AfficherCopy Anchor Link

Transmet tel quel ce qui est entré, pour que vous puissiez le regarder : sélectionnez le bloc après une exécution et lisez Dernière exécution dans l’inspecteur.

Ports : value en entrée, value en sortie.

JournalCopy Anchor Link

Écrit une ligne dans le journal d’exécution.

Ports : value en entrée, value en sortie. Dans Place a test order, Order failed journalise Create order answered {{status}} quand la commande ne peut pas être passée.

VérifierCopy Anchor Link

Vérifie ce qui est entré. Chaque vérification est un résultat de test de l’exécution, et une vérification en échec fait échouer echolot flow run.

value.status === 200   // Answers 200
value.time < 2000      // Within two seconds

NotifierCopy Anchor Link

Affiche une notification macOS d’Echolot. macOS demande l’autorisation la première fois. En ligne de commande, la notification est imprimée à la place.

Ports : value en entrée, value en sortie. Morning stock check se termine par Notifier Restock, intitulé Restock Bern.

Écrire un fichierCopy Anchor Link

Écrit ce qui est entré dans un fichier à l’intérieur du dossier de l’espace de travail.

Un fichier déjà présent est remplacé. Les fichiers propres à l’espace de travail sont interdits : les dossiers requests, flows, environments, mocks, mcp-servers et specs, workspace.toml et les fichiers cachés. Pour le CSV, une liste d’objets devient une ligne par objet avec une colonne par clé ; tout le reste est écrit à raison d’une valeur par ligne.

Valeurs entre les blocsCopy Anchor Link

Les valeurs sont du JSON : texte, nombres, true et false, listes, objets ou null.

L’objet réponseCopy Anchor Link

Requête et Interroger envoient une réponse sous forme d’objet :

{
  "status": 201,
  "reason": "Created",
  "headers": { "content-type": "application/json", "location": "/v1/orders/ord_9Px3Kd" },
  "body": { "id": "ord_9Px3Kd", "total": { "amount": 449, "currency": "CHF" } },
  "time": 182.4,
  "url": "https://demo.echolot.dev/v1/orders"
}

• body est du JSON analysé quand la réponse est du JSON, du texte sinon, et null quand elle est vide.
• Les noms d’en-tête sont en minuscules. Un en-tête envoyé plusieurs fois est joint avec , .
• time est la durée de l’échange entier, en millisecondes.
• Un corps de plus de 8 Mo arrive sous la forme null avec "truncated": true. La réponse complète reste dans l’historique.

ModèlesCopy Anchor Link

Les réglages marqués « modèles autorisés » remplissent {{name}} à partir de ce qui est entré dans le bloc :

• {{status}}, {{body.id}} ou {{body.items[0].sku}} : une clé ou un chemin dans l’objet entré.
• {{value}} dans Journal, Notifier et Écrire un fichier : toute la valeur entrée.
• Les variables qu’un bloc Définir une variable a enregistrées avec la portée run.

Un nom qui ne correspond à rien reste tel quel : les propres {{variables}} d’un bloc Requête se résolvent donc encore depuis l’environnement à l’envoi. Les objets et les listes sont écrits sous forme de texte JSON.

ConditionsCopy Anchor Link

Si, Selon, Interroger et Vérifier acceptent une expression JavaScript qui est vraie ou fausse. value est ce qui est entré ; le Jusqu’à d’Interroger le lit sous le nom response, qui fonctionne aussi partout.

value.status == 200
response.status === 200 && !!(response.body && response.body.access_token)
value.body.items.length > 0

Une expression qui lève une erreur fait échouer le bloc (dans Vérifier, elle fait échouer cette vérification).

LimitesCopy Anchor Link

Pour qu’un mauvais lien ne puisse pas tourner indéfiniment, une exécution s’arrête après 10 000 exécutions de blocs ou une heure. Les exécutions lancées par des webhooks s’arrêtent après deux minutes.