design pattern planning

💡 Prompt Prêt à l’Emploi : Agent de Planification Adaptative

Contexte :

Ce système en 4 étapes configure un agent capable de planifier, exécuter séquentiellement, et re-planifier si nécessaire. Il illustre le mécanisme complet du pattern Planning : génération du plan → exécution étape par étape → vérification → adaptation.

Étape 1 — Génération du Plan :

Tu es un planificateur stratégique.

**Objectif à atteindre :**
[OBJECTIF]

**Contexte disponible :**
[CONTEXTE]

**Outils disponibles :**
[LISTE_OUTILS]

**Instructions :**
1. Décompose cet objectif en étapes SÉQUENTIELLES et CONCRÈTES
2. Pour chaque étape, définis :
   - Un ID unique (step_1, step_2, ...)
   - Une action précise (verbe + objet)
   - Les dépendances (quelles étapes précédentes sont nécessaires)
   - L'outil à utiliser (si applicable)
   - Le critère de succès (comment savoir que l'étape est réussie)
3. Ordonne les étapes selon leurs dépendances
4. Limite le plan à 8 étapes maximum

**Format de sortie (JSON) :**
{
  "objectif": "...",
  "nb_etapes": 5,
  "plan": [
    {
      "id": "step_1",
      "action": "Récupérer les données du client depuis le CRM",
      "dependances": [],
      "outil": "api_crm",
      "critere_succes": "Objet client avec email et historique non vide",
      "timeout_ms": 5000
    },
    {
      "id": "step_2",
      "action": "Analyser l'historique des commandes",
      "dependances": ["step_1"],
      "outil": null,
      "critere_succes": "Liste des anomalies identifiées",
      "timeout_ms": 10000
    }
  ]
}

Étape 2 — Exécution Séquentielle (pseudo-code) :

const plan = await appelLLM(promptPlanification);
const resultats = {};

for (const etape of plan.plan) {
  // Vérifier que toutes les dépendances sont résolues
  const dependancesOK = etape.dependances.every(
    dep => resultats[dep]?.succes === true
  );
  
  if (!dependancesOK) {
    // → Déclencher la re-planification (Étape 4)
    return await rePlanifier(plan, resultats, etape);
  }

  // Construire le contexte avec les résultats précédents
  const contexteEtape = etape.dependances.map(
    dep => `Résultat de ${dep}: ${JSON.stringify(resultats[dep].donnees)}`
  ).join('\n');

  // Exécuter l'étape
  const resultat = await executerEtape(etape, contexteEtape);
  resultats[etape.id] = resultat;

  // Vérifier le critère de succès
  if (!resultat.succes) {
    return await rePlanifier(plan, resultats, etape);
  }
}

return syntheseFinale(resultats);

Étape 3 — Prompt d’Exécution par Étape :

Tu exécutes UNE SEULE étape d'un plan.

**Étape à exécuter :**
[ETAPE_COURANTE]

**Résultats des étapes précédentes :**
[RESULTATS_PRECEDENTS]

**Instructions :**
1. Réalise UNIQUEMENT l'action décrite dans cette étape
2. Utilise l'outil spécifié si applicable
3. Vérifie toi-même le critère de succès
4. Si tu ne peux PAS réussir cette étape, explique pourquoi

**Format de sortie (JSON) :**
{
  "etape_id": "step_2",
  "succes": true,
  "donnees": { ... },
  "critere_verifie": true,
  "notes": "Anomalie détectée : double facturation sur commande #4521"
}

Étape 4 — Re-planification Adaptative :

Tu es un re-planificateur.

**Plan initial :**
[PLAN_INITIAL]

**Étapes déjà réalisées :**
[RESULTATS_OBTENUS]

**Étape en échec :**
[ETAPE_ECHOUEE]

**Raison de l'échec :**
[RAISON_ECHEC]

**Instructions :**
1. Analyse pourquoi l'étape a échoué
2. Propose un plan RÉVISÉ qui :
   - Conserve les étapes réussies
   - Remplace ou contourne l'étape en échec
   - Ajoute des étapes correctives si nécessaire
3. Si l'objectif est inatteignable, explique pourquoi et propose un objectif alternatif

**Format de sortie (JSON) :**
{
  "plan_revise": [...],
  "modifications": "Ajout d'une étape de vérification manuelle avant step_3",
  "objectif_atteignable": true
}

Flux complet :

Variables à personnaliser :

• [OBJECTIF] : L’objectif final en langage naturel (ex : « Migrer la table users vers le schéma v3 »)
• [CONTEXTE] : Informations de contexte utiles (état actuel du système, contraintes, etc.)
• [LISTE_OUTILS] : Les outils/API disponibles (ex : « api_crm, api_stripe, base_postgres, envoi_email »)
• [ETAPE_COURANTE] : L’objet JSON de l’étape en cours d’exécution
• [RESULTATS_PRECEDENTS] : Les résultats JSON des étapes déjà exécutées
• [PLAN_INITIAL] : Le plan JSON complet généré à l’étape 1
• [ETAPE_ECHOUEE] : L’étape qui a échoué avec ses détails
• [RAISON_ECHEC] : Le message d’erreur ou la raison de l’échec

Résultat attendu :

Exécution complète et tracée de l’objectif, avec un log de chaque étape (succès/échec + données). En cas d’échec partiel, un plan révisé est automatiquement généré et exécuté. Temps total ≈ somme des étapes + 1-2s de planification.