Syntaxe des références de blocs

Les références de blocs sont le fondement du flux de données dans les workflows Scrydon. Comprendre comment référencer correctement les sorties d'un bloc comme entrées d'un autre est essentiel pour créer des workflows fonctionnels.

Règles de référence de base

1. Utiliser les noms de blocs, pas les ID de blocs

# Block definition
email-sender:
  type: agent
  name: "Email Generator"
  # ... configuration

# Reference the block
next-block:
  inputs:
    userPrompt: "Process this: <emailgenerator.content>"

# Block definition
email-sender:
  type: agent
  name: "Email Generator"
  # ... configuration

# ❌ Don't reference by block ID
next-block:
  inputs:
    userPrompt: "Process this: <email-sender.content>"

2. Convertir les noms au format de référence

Pour créer une référence de bloc :

Prenez le nom du bloc : « Email Generator »
Convertissez en minuscules : « email generator »
Supprimez les espaces et les caractères spéciaux : « emailgenerator »
Ajoutez la propriété : <emailgenerator.content>

3. Utiliser les propriétés correctes

Différents types de blocs exposent différentes propriétés :

Blocs Agent : .content (la réponse IA)
Blocs Fonction : .output (la valeur de retour)
Blocs API : .output (les données de réponse)
Blocs Outil : .output (le résultat de l'outil)

Exemples de références

Références de blocs courantes

# Agent block outputs
<agentname.content>           # Primary AI response
<agentname.tokens>            # Token usage information
<agentname.cost>              # Estimated cost
<agentname.tool_calls>        # Tool execution details

# Function block outputs  
<functionname.output>         # Function return value
<functionname.error>          # Error information (if any)

# API block outputs
<apiname.output>              # Response data
<apiname.status>              # HTTP status code
<apiname.headers>             # Response headers

# Tool block outputs
<toolname.output>             # Tool execution result

Noms de blocs à plusieurs mots

# Block name: "Data Processor 2"
<dataprocessor2.output>

# Block name: "Email Validation Service"  
<emailvalidationservice.output>

# Block name: "Customer Info Agent"
<customerinfoagent.content>

Cas de référence spéciaux

Bloc de démarrage

Le bloc de démarrage est toujours référencé comme <start.input> quel que soit son nom réel.

# Starter block definition
my-custom-start:
  type: starter
  name: "Custom Workflow Start"
  # ... configuration

# Always reference as 'start'
agent-1:
  inputs:
    userPrompt: <start.input>  # ✅ Correct
    # userPrompt: <customworkflowstart.input>  # ❌ Wrong

Variables de boucle

À l'intérieur des blocs de boucle, des variables spéciales sont disponibles :

# Available in loop child blocks
<loop.index>          # Current iteration (0-based)
<loop.currentItem>    # Current item being processed (forEach loops)
<loop.items>          # Full collection (forEach loops)

Variables parallèles

À l'intérieur des blocs parallèles, des variables spéciales sont disponibles :

# Available in parallel child blocks
<parallel.index>          # Instance number (0-based)
<parallel.currentItem>    # Item for this instance
<parallel.items>          # Full collection

Exemples de références complexes

Accès aux données imbriquées

Pour référencer des objets complexes, utilisez la notation pointée :

# If an agent returns structured data
data-analyzer:
  type: agent
  name: "Data Analyzer"
  inputs:
    responseFormat: |
      {
        "schema": {
          "type": "object",
          "properties": {
            "analysis": {"type": "object"},
            "summary": {"type": "string"},
            "metrics": {"type": "object"}
          }
        }
      }

# Reference nested properties
next-step:
  inputs:
    userPrompt: |
      Summary: <dataanalyzer.analysis.summary>
      Score: <dataanalyzer.metrics.score>
      Full data: <dataanalyzer.content>

Références multiples dans du texte

email-composer:
  type: agent
  inputs:
    userPrompt: |
      Create an email with the following information:
      
      Customer: <customeragent.content>
      Order Details: <orderprocessor.output>
      Support Ticket: <ticketanalyzer.content>
      
      Original request: <start.input>

Références dans les blocs de code

Lorsqu'on utilise des références dans des blocs de fonction, elles sont remplacées par des valeurs JavaScript :

data-processor:
  type: function
  inputs:
    code: |
      // References are replaced with actual values
      const customerData = <customeragent.content>;
      const orderInfo = <orderprocessor.output>;
      const originalInput = <start.input>;
      
      // Process the data
      return {
        customer: customerData.name,
        orderId: orderInfo.id,
        processed: true
      };

Validation des références

Scrydon valide toutes les références lors de l'importation d'un YAML :

Références valides

Le bloc existe dans le workflow
La propriété est appropriée pour le type de bloc
Pas de dépendances circulaires
Formatage syntaxique correct

Erreurs courantes

Bloc introuvable : le bloc référencé n'existe pas
Mauvaise propriété : utiliser .content sur un bloc de fonction
Fautes de frappe : noms de blocs ou propriétés mal orthographiés
Références circulaires : un bloc se référence lui-même directement ou indirectement

Bonnes pratiques

Utiliser des noms de blocs descriptifs : rend les références plus lisibles
Être cohérent : utiliser la même convention de nommage tout au long
Vérifier les références : s'assurer que tous les blocs référencés existent
Éviter l'imbrication profonde : garder les chaînes de références gérables
Documenter les flux complexes : ajouter des commentaires pour expliquer les relations de référence

Syntaxe des références de blocs

Sur cette page