@lyrra/mcp-server 1.0.0

package/src/resources/flow-schema.ts

@@ -0,0 +1,148 @@
+export const FLOW_SCHEMA_RESOURCE = {
+  uri: 'lyrra://flow-construction-guide',
+  name: 'Guide de construction d\'un parcours EduFlow',
+  description: 'Guide complet pour construire un parcours pédagogique dans LYRRA Studio : logique de construction, règles de connexion, bonnes pratiques.',
+  mimeType: 'application/json',
+  content: {
+    overview: `Un parcours EduFlow est un graphe orienté composé de blocs (nœuds) reliés par des edges (connexions).
+Le parcours définit le chemin que suivra l'apprenant, avec possibilité de branchements conditionnels.`,
+
+    construction_steps: [
+      {
+        step: 1,
+        title: 'Créer le parcours',
+        description: 'Utiliser eduflow_create avec un titre et une description. Un bloc "start" et un bloc "end" sont automatiquement créés.',
+        tool: 'eduflow_create',
+      },
+      {
+        step: 2,
+        title: 'Ajouter des blocs de contenu',
+        description: 'Créer des blocs entre start et end : text, video, audio, quiz, etc. Utiliser block_create pour chaque bloc.',
+        tool: 'block_create',
+      },
+      {
+        step: 3,
+        title: 'Connecter les blocs',
+        description: 'Relier les blocs avec connection_add. Chaque connexion va de source vers target.',
+        tool: 'connection_add',
+      },
+      {
+        step: 4,
+        title: 'Configurer les objectifs',
+        description: 'Définir les objectifs pédagogiques avec ai_generate_objectives ou ai_save_objectives.',
+        tool: 'ai_generate_objectives',
+      },
+      {
+        step: 5,
+        title: 'Créer la page de présentation',
+        description: 'Configurer la page publique avec presentation_update et presentation_toggle.',
+        tool: 'presentation_update',
+      },
+      {
+        step: 6,
+        title: 'Publier',
+        description: 'Changer le statut en "published" avec eduflow_change_status pour rendre le parcours accessible.',
+        tool: 'eduflow_change_status',
+      },
+    ],
+
+    connection_rules: {
+      general: [
+        'Le graphe doit être connexe : chaque bloc doit être atteignable depuis le bloc start',
+        'Pas de boucles infinies sans condition de sortie',
+        'Chaque chemin doit mener à au moins un bloc end',
+      ],
+      by_block_type: {
+        start: {
+          incoming: 0,
+          outgoing: '1+',
+          notes: 'Exactement 1 par parcours. Point d\'entrée unique.',
+        },
+        end: {
+          incoming: '1+',
+          outgoing: 0,
+          notes: 'Peut avoir plusieurs blocs end pour différentes fins.',
+        },
+        text: { incoming: '1+', outgoing: '1', notes: 'Flux linéaire.' },
+        audio: { incoming: '1+', outgoing: '1', notes: 'Flux linéaire.' },
+        video: { incoming: '1+', outgoing: '1', notes: 'Flux linéaire.' },
+        pdf: { incoming: '1+', outgoing: '1', notes: 'Flux linéaire.' },
+        image: { incoming: '1+', outgoing: '1', notes: 'Flux linéaire.' },
+        quiz: {
+          incoming: '1+',
+          outgoing: '1-N',
+          notes: 'Sans branchement: 1 sortie. binary: 2 sorties (correct/incorrect). per-answer: N sorties.',
+        },
+        evaluation: { incoming: '1+', outgoing: '1-2', notes: '1 sortie (toujours) ou 2 (réussite/échec).' },
+        form: { incoming: '1+', outgoing: '1-N', notes: 'Peut avoir des règles conditionnelles.' },
+        split: { incoming: '1', outgoing: '2+', notes: 'Crée des branches parallèles.' },
+        merge: { incoming: '2+', outgoing: '1', notes: 'Rejoint les branches. Correspond à un split.' },
+        loop: { incoming: '1+', outgoing: '2', notes: '1 sortie "continuer" + 1 sortie "quitter la boucle".' },
+        timer: { incoming: '1+', outgoing: '1-2', notes: '1 sortie normale + 1 sortie timeout (optionnel).' },
+        subflow: { incoming: '1+', outgoing: '1', notes: 'Le sous-parcours s\'exécute entièrement puis continue.' },
+        certification: { incoming: '1+', outgoing: '1', notes: 'Génère le certificat puis continue.' },
+        email: { incoming: '1+', outgoing: '1', notes: 'Envoie l\'email puis continue.' },
+      },
+    },
+
+    positioning: {
+      description: 'Les blocs ont des coordonnées X/Y pour l\'éditeur visuel.',
+      recommendations: [
+        'Espacer horizontalement de 300px entre les blocs séquentiels',
+        'Espacer verticalement de 150px pour les branches parallèles',
+        'Le bloc start en position (100, 300)',
+        'Flux de gauche à droite',
+      ],
+    },
+
+    patterns: {
+      linear: {
+        name: 'Parcours linéaire',
+        description: 'start → text → video → quiz → end',
+        usage: 'Parcours simple sans branchement.',
+      },
+      branching: {
+        name: 'Parcours avec branchement',
+        description: 'start → quiz → [correct: text_avancé → end] [incorrect: text_revision → quiz]',
+        usage: 'Adaptation au niveau de l\'apprenant.',
+      },
+      parallel: {
+        name: 'Parcours parallèle',
+        description: 'start → split → [branche1: text+video] [branche2: audio+pdf] → merge → end',
+        usage: 'L\'apprenant choisit son parcours.',
+      },
+      loop_pattern: {
+        name: 'Boucle d\'apprentissage',
+        description: 'start → text → quiz → [échec: loop → text] [succès: end]',
+        usage: 'Répétition jusqu\'à maîtrise.',
+      },
+      certification_pattern: {
+        name: 'Parcours certifiant',
+        description: 'start → text → evaluation → [réussi: certification → email → end] [échoué: end]',
+        usage: 'Parcours avec certificat de réussite.',
+      },
+    },
+
+    gamification: {
+      description: 'Configuration optionnelle pour engager les apprenants.',
+      options: {
+        badges: 'Badges débloqués par des actions (complétion, score parfait, etc.)',
+        missions: 'Objectifs à atteindre avec récompenses',
+        leaderboard: 'Classement entre participants',
+        certifications: 'Certificats PDF personnalisés',
+      },
+    },
+
+    best_practices: [
+      'Commencer par définir les objectifs pédagogiques avant de créer les blocs',
+      'Alterner les types de blocs (texte → vidéo → quiz) pour maintenir l\'engagement',
+      'Utiliser des quiz formatifs (sans score) entre les blocs de contenu',
+      'Limiter à 15-20 blocs par parcours pour ne pas surcharger',
+      'Toujours avoir un message d\'accueil dans le bloc start',
+      'Toujours avoir un message de félicitations dans le bloc end',
+      'Utiliser les labels sur les connexions pour les branchements (ex: "Bonne réponse")',
+      'Créer une version avant chaque modification majeure',
+      'Tester le parcours avec un participant test avant de publier',
+    ],
+  },
+};

package/src/tools/admin.ts

@@ -0,0 +1,122 @@
+import { z } from 'zod';
+import { client } from '../client.js';
+
+export const adminTools = {
+  // --- Versions ---
+  version_list: {
+    description: 'Lister toutes les versions d\'un parcours EduFlow.',
+    inputSchema: z.object({
+      flowId: z.string().uuid().describe('ID du parcours'),
+    }),
+    handler: async ({ flowId }: { flowId: string }) => {
+      return client.get(`/flows/${flowId}/versions`, 'eduflow');
+    },
+  },
+
+  version_create: {
+    description: 'Créer une nouvelle version (snapshot) du parcours. Permet de revenir en arrière si besoin.',
+    inputSchema: z.object({
+      flowId: z.string().uuid().describe('ID du parcours'),
+      versionLabel: z.string().optional().describe('Label de la version (ex: "v2.0 - Ajout quiz")'),
+    }),
+    handler: async ({ flowId, versionLabel }: any) => {
+      return client.post(`/flows/${flowId}/versions`, { versionLabel }, 'eduflow');
+    },
+  },
+
+  version_activate: {
+    description: 'Activer une version spécifique comme version publique du parcours.',
+    inputSchema: z.object({
+      flowId: z.string().uuid().describe('ID du parcours'),
+      versionId: z.string().uuid().describe('ID de la version à activer'),
+    }),
+    handler: async ({ flowId, versionId }: { flowId: string; versionId: string }) => {
+      return client.post(`/flows/${flowId}/versions/${versionId}/activate`, {}, 'eduflow');
+    },
+  },
+
+  // --- Gamification ---
+  gamification_stats: {
+    description: 'Récupérer les statistiques de gamification de l\'utilisateur (niveau, streak, badges, missions).',
+    inputSchema: z.object({}),
+    handler: async () => {
+      return client.get('/gamification/stats');
+    },
+  },
+
+  gamification_objectives: {
+    description: 'Récupérer les prochains objectifs de gamification à atteindre.',
+    inputSchema: z.object({}),
+    handler: async () => {
+      return client.get('/gamification/objectives');
+    },
+  },
+
+  // --- Activity ---
+  activity_history: {
+    description: 'Récupérer l\'historique d\'activité de l\'utilisateur avec pagination.',
+    inputSchema: z.object({
+      page: z.number().optional().describe('Page (défaut: 1)'),
+      limit: z.number().optional().describe('Nombre par page (défaut: 20)'),
+    }),
+    handler: async ({ page, limit }: any) => {
+      const params = new URLSearchParams();
+      if (page) params.set('page', String(page));
+      if (limit) params.set('limit', String(limit));
+      const query = params.toString() ? `?${params}` : '';
+      return client.get(`/activity${query}`);
+    },
+  },
+
+  activity_stats: {
+    description: 'Statistiques d\'utilisation par période (jour/semaine/mois).',
+    inputSchema: z.object({
+      period: z.enum(['day', 'week', 'month']).optional().describe('Période (défaut: week)'),
+    }),
+    handler: async ({ period }: { period?: string }) => {
+      const query = period ? `?period=${period}` : '';
+      return client.get(`/activity/stats${query}`);
+    },
+  },
+
+  // --- Webhooks ---
+  webhook_list: {
+    description: 'Lister les webhooks configurés pour recevoir des événements (block.completed, flow.completed, etc.).',
+    inputSchema: z.object({}),
+    handler: async () => {
+      return client.get('/webhooks');
+    },
+  },
+
+  webhook_create: {
+    description: 'Créer un webhook pour recevoir des notifications en temps réel sur des événements.',
+    inputSchema: z.object({
+      url: z.string().url().describe('URL du webhook (doit être accessible publiquement)'),
+      events: z.array(z.string()).describe('Événements à écouter (ex: ["block.completed", "flow.completed"])'),
+      name: z.string().optional().describe('Nom du webhook'),
+    }),
+    handler: async (data: any) => {
+      return client.post('/webhooks', data);
+    },
+  },
+
+  webhook_delete: {
+    description: 'Supprimer un webhook.',
+    inputSchema: z.object({
+      webhookId: z.string().uuid().describe('ID du webhook'),
+    }),
+    handler: async ({ webhookId }: { webhookId: string }) => {
+      return client.delete(`/webhooks/${webhookId}`);
+    },
+  },
+
+  webhook_test: {
+    description: 'Tester un webhook en envoyant un événement de test.',
+    inputSchema: z.object({
+      webhookId: z.string().uuid().describe('ID du webhook à tester'),
+    }),
+    handler: async ({ webhookId }: { webhookId: string }) => {
+      return client.post(`/webhooks/${webhookId}/test`, {});
+    },
+  },
+};

package/src/tools/ai-designer.ts

@@ -0,0 +1,91 @@
+import { z } from 'zod';
+import { client } from '../client.js';
+
+export const aiDesignerTools = {
+  ai_generate_plan: {
+    description: 'Générer automatiquement un plan/structure de parcours pédagogique à partir d\'un sujet et d\'objectifs. L\'IA propose une liste de blocs organisés.',
+    inputSchema: z.object({
+      flowId: z.string().uuid().describe('ID du parcours'),
+      topic: z.string().describe('Sujet du parcours (ex: "Les fractions en CM2")'),
+      targetAudience: z.string().optional().describe('Public cible (ex: "Élèves de CM2, 9-10 ans")'),
+      objectives: z.string().optional().describe('Objectifs pédagogiques souhaités'),
+      duration: z.string().optional().describe('Durée estimée (ex: "30 minutes")'),
+      context: z.string().optional().describe('Contexte additionnel pour l\'IA'),
+    }),
+    handler: async ({ flowId, ...data }: any) => {
+      return client.post(`/flows/${flowId}/chatbot/generate-plan`, data, 'eduflow');
+    },
+  },
+
+  ai_generate_block: {
+    description: 'Générer le contenu d\'un bloc spécifique avec l\'IA. Peut créer du texte enrichi, des quiz, des évaluations, des graphiques, etc.',
+    inputSchema: z.object({
+      flowId: z.string().uuid().describe('ID du parcours'),
+      blockType: z.string().describe('Type de bloc à générer (text, quiz, evaluation, chart, timeline, etc.)'),
+      instructions: z.string().describe('Instructions pour le contenu du bloc (ex: "Créer un quiz de 5 questions sur les fractions")'),
+      context: z.string().optional().describe('Contexte du parcours pour l\'IA'),
+    }),
+    handler: async ({ flowId, ...data }: any) => {
+      return client.post(`/flows/${flowId}/chatbot/generate-block`, data, 'eduflow');
+    },
+  },
+
+  ai_generate_presentation: {
+    description: 'Générer automatiquement la page de présentation du parcours (description, objectifs affichés, image, structure visible).',
+    inputSchema: z.object({
+      flowId: z.string().uuid().describe('ID du parcours'),
+      style: z.string().optional().describe('Style de présentation souhaité'),
+    }),
+    handler: async ({ flowId, ...data }: any) => {
+      return client.post(`/flows/${flowId}/chatbot/generate-presentation`, data, 'eduflow');
+    },
+  },
+
+  ai_generate_objectives: {
+    description: 'Générer automatiquement les objectifs pédagogiques du parcours à partir du contenu existant.',
+    inputSchema: z.object({
+      flowId: z.string().uuid().describe('ID du parcours'),
+    }),
+    handler: async ({ flowId }: { flowId: string }) => {
+      return client.post(`/flows/${flowId}/chatbot/generate-objectives`, {}, 'eduflow');
+    },
+  },
+
+  ai_save_objectives: {
+    description: 'Sauvegarder les objectifs pédagogiques (globaux et par étape) sur le parcours.',
+    inputSchema: z.object({
+      flowId: z.string().uuid().describe('ID du parcours'),
+      globalObjective: z.string().describe('Objectif global du parcours'),
+      steps: z.array(z.object({
+        id: z.string().describe('ID de l\'étape'),
+        title: z.string().describe('Titre de l\'objectif'),
+        description: z.string().optional().describe('Description détaillée'),
+        blockId: z.string().optional().describe('Bloc associé à cet objectif'),
+      })).describe('Liste des objectifs par étape'),
+    }),
+    handler: async ({ flowId, ...objectives }: any) => {
+      return client.post(`/flows/${flowId}/chatbot/save-objectives`, objectives, 'eduflow');
+    },
+  },
+
+  ai_chat_message: {
+    description: 'Envoyer un message au designer IA pour discuter de la conception du parcours, poser des questions, demander des modifications.',
+    inputSchema: z.object({
+      flowId: z.string().uuid().describe('ID du parcours'),
+      message: z.string().describe('Message à envoyer à l\'IA designer'),
+    }),
+    handler: async ({ flowId, message }: { flowId: string; message: string }) => {
+      return client.post(`/flows/${flowId}/chatbot/message`, { message }, 'eduflow');
+    },
+  },
+
+  ai_get_conversation: {
+    description: 'Récupérer l\'historique de conversation avec le designer IA pour un parcours.',
+    inputSchema: z.object({
+      flowId: z.string().uuid().describe('ID du parcours'),
+    }),
+    handler: async ({ flowId }: { flowId: string }) => {
+      return client.get(`/flows/${flowId}/chatbot/conversation`, 'eduflow');
+    },
+  },
+};

package/src/tools/analytics.ts

@@ -0,0 +1,43 @@
+import { z } from 'zod';
+import { client } from '../client.js';
+
+export const analyticsTools = {
+  analytics_overview: {
+    description: 'Tableau de bord global : nombre de projets, parcours EduFlow, apprenants, crédits utilisés, avec évolution par période.',
+    inputSchema: z.object({
+      period: z.enum(['day', 'week', 'month', 'semester', 'year']).optional().describe('Période d\'analyse (défaut: month)'),
+    }),
+    handler: async ({ period }: { period?: string }) => {
+      const query = period ? `?period=${period}` : '';
+      return client.get(`/analytics/overview${query}`);
+    },
+  },
+
+  analytics_flow_learners: {
+    description: 'Statistiques des apprenants pour un parcours spécifique : progression, scores, temps passé par apprenant.',
+    inputSchema: z.object({
+      flowId: z.string().uuid().describe('ID du parcours'),
+    }),
+    handler: async ({ flowId }: { flowId: string }) => {
+      return client.get(`/analytics/flow/${flowId}/learners`);
+    },
+  },
+
+  analytics_flow_dashboard: {
+    description: 'Dashboard analytics complet d\'un parcours : vue d\'ensemble, taux de complétion, blocs les plus/moins visités.',
+    inputSchema: z.object({
+      flowId: z.string().uuid().describe('ID du parcours'),
+    }),
+    handler: async ({ flowId }: { flowId: string }) => {
+      return client.get(`/flows/${flowId}/analytics`, 'eduflow');
+    },
+  },
+
+  analytics_my_stats: {
+    description: 'Mes statistiques personnelles : projets créés, parcours créés, temps total, crédits utilisés.',
+    inputSchema: z.object({}),
+    handler: async () => {
+      return client.get('/analytics/my-stats');
+    },
+  },
+};

package/src/tools/auth.ts

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+import { client } from '../client.js';
+
+export const authTools = {
+  auth_login: {
+    description: 'Se connecter à LYRRA Studio avec email et mot de passe. Retourne un token JWT.',
+    inputSchema: z.object({
+      email: z.string().email().describe('Adresse email du compte'),
+      password: z.string().describe('Mot de passe'),
+    }),
+    handler: async ({ email, password }: { email: string; password: string }) => {
+      const result = await client.post('/auth/login', { email, password });
+      if (result.token) client.setToken(result.token);
+      return result;
+    },
+  },
+
+  auth_get_profile: {
+    description: 'Récupérer le profil de l\'utilisateur connecté (nom, email, crédits, rôle, institution, etc.).',
+    inputSchema: z.object({}),
+    handler: async () => {
+      return client.get('/auth/me');
+    },
+  },
+
+  auth_list_api_keys: {
+    description: 'Lister toutes les clés API de l\'utilisateur connecté.',
+    inputSchema: z.object({}),
+    handler: async () => {
+      return client.get('/api-keys');
+    },
+  },
+};

package/src/tools/blocks.ts

@@ -0,0 +1,174 @@
+import { z } from 'zod';
+import { client } from '../client.js';
+
+const blockContentSchema = z.record(z.any()).describe(
+  'Contenu du bloc (structure variable selon le type). Utiliser la resource lyrra://block-types pour connaître la structure attendue.'
+);
+
+export const blocksTools = {
+  block_list_types: {
+    description: `Lister tous les types de blocs disponibles avec leur documentation complète.
+Types disponibles : text, audio, quiz, video, pdf, image, loop, evaluation, split, merge, timer, start, end, chart, timeline, dys_reader, dys_image_zones, dys_reading_practice, dys_clock, glossary, subflow, mindmap, form, certification, email, voice_assessment, presentation, browser, self_assessment.
+Utiliser plutôt la resource lyrra://block-types pour la documentation complète.`,
+    inputSchema: z.object({}),
+    handler: async () => {
+      return {
+        types: [
+          { type: 'start', name: 'Début', description: 'Point de départ du parcours. Un seul par flux.' },
+          { type: 'end', name: 'Fin', description: 'Point de fin du parcours. Peut avoir plusieurs fins.' },
+          { type: 'text', name: 'Texte', description: 'Contenu textuel/HTML enrichi. TOUJOURS utiliser format: "html".' },
+          { type: 'audio', name: 'Audio', description: 'Intègre un projet audio LYRRA avec texte synchronisé.' },
+          { type: 'video', name: 'Vidéo', description: 'Intègre une vidéo (URL YouTube/Vimeo ou fichier uploadé).' },
+          { type: 'pdf', name: 'PDF', description: 'Affiche un document PDF intégré.' },
+          { type: 'image', name: 'Image', description: 'Affiche une image avec légende optionnelle.' },
+          { type: 'quiz', name: 'Quiz', description: 'Question QCM/vrai-faux/ordonnancement avec branchement conditionnel.' },
+          { type: 'evaluation', name: 'Évaluation', description: 'Évaluation complète avec plusieurs questions et scoring.' },
+          { type: 'form', name: 'Formulaire', description: 'Formulaire avec champs personnalisés et logique conditionnelle.' },
+          { type: 'chart', name: 'Graphique', description: 'Graphique interactif (bar, line, pie, scatter, radar, area, doughnut).' },
+          { type: 'timeline', name: 'Frise chronologique', description: 'Frise avec événements datés.' },
+          { type: 'mindmap', name: 'Carte mentale', description: 'Carte mentale interactive avec nœuds et liens.' },
+          { type: 'glossary', name: 'Glossaire', description: 'Liste de termes et définitions.' },
+          { type: 'split', name: 'Embranchement', description: 'Sépare le flux en branches parallèles.' },
+          { type: 'merge', name: 'Fusion', description: 'Rejoint les branches parallèles.' },
+          { type: 'loop', name: 'Boucle', description: 'Permet de répéter une séquence de blocs.' },
+          { type: 'timer', name: 'Minuteur', description: 'Bloc avec temps limité, pause, rappel ou expiration.' },
+          { type: 'subflow', name: 'Sous-parcours', description: 'Intègre un autre parcours EduFlow comme bloc.' },
+          { type: 'certification', name: 'Certification', description: 'Génère un certificat PDF personnalisé.' },
+          { type: 'email', name: 'Email', description: 'Envoie un email automatique (certification, rappel).' },
+          { type: 'voice_assessment', name: 'Évaluation vocale', description: 'Enregistrement et évaluation de la voix de l\'étudiant.' },
+          { type: 'self_assessment', name: 'Auto-évaluation', description: 'L\'étudiant s\'évalue lui-même sur des critères définis.' },
+          { type: 'presentation', name: 'Présentation', description: 'Diaporama avec slides.' },
+          { type: 'browser', name: 'Navigateur', description: 'Intègre une page web dans un iframe.' },
+          { type: 'dys_reader', name: 'Lecteur DYS', description: 'Texte adapté pour la dyslexie avec police et espacement spéciaux.' },
+          { type: 'dys_image_zones', name: 'Zones d\'image DYS', description: 'Image avec zones cliquables pour la dyslexie.' },
+          { type: 'dys_reading_practice', name: 'Pratique lecture DYS', description: 'Exercice de lecture adapté dyslexie.' },
+          { type: 'dys_clock', name: 'Horloge DYS', description: 'Exercice de lecture de l\'heure pour la dyscalculie.' },
+        ],
+      };
+    },
+  },
+
+  block_get: {
+    description: 'Récupérer les détails complets d\'un bloc (type, contenu, position, conditions, commentaire).',
+    inputSchema: z.object({
+      flowId: z.string().uuid().describe('ID du parcours'),
+      blockId: z.string().uuid().describe('ID du bloc'),
+    }),
+    handler: async ({ flowId, blockId }: { flowId: string; blockId: string }) => {
+      return client.get(`/flows/${flowId}/blocks/${blockId}`, 'eduflow');
+    },
+  },
+
+  block_create: {
+    description: `Créer un nouveau bloc dans un parcours EduFlow. Le bloc est ajouté mais pas encore connecté (utiliser connection_add ensuite).
+IMPORTANT pour le type "text" : toujours utiliser content.format = "html" et du HTML dans content.text (pas de Markdown).`,
+    inputSchema: z.object({
+      flowId: z.string().uuid().describe('ID du parcours'),
+      type: z.enum([
+        'text', 'audio', 'quiz', 'video', 'pdf', 'image', 'loop', 'evaluation',
+        'split', 'merge', 'timer', 'start', 'end', 'chart', 'timeline',
+        'dys_reader', 'dys_image_zones', 'dys_reading_practice', 'dys_clock',
+        'glossary', 'subflow', 'mindmap', 'form', 'certification', 'email',
+        'voice_assessment', 'presentation', 'browser', 'self_assessment',
+      ]).describe('Type de bloc à créer'),
+      title: z.string().describe('Titre du bloc'),
+      content: blockContentSchema,
+      positionX: z.number().optional().describe('Position X dans l\'éditeur visuel (défaut: 0)'),
+      positionY: z.number().optional().describe('Position Y dans l\'éditeur visuel (défaut: 0)'),
+      order: z.number().optional().describe('Ordre d\'affichage'),
+    }),
+    handler: async ({ flowId, ...blockData }: any) => {
+      // Use batch update to add a single block
+      const flow = await client.get(`/flows/${flowId}`, 'eduflow');
+      const existingBlocks = flow.blocks || [];
+      const newBlock = {
+        id: crypto.randomUUID(),
+        ...blockData,
+        positionX: blockData.positionX ?? (existingBlocks.length * 300),
+        positionY: blockData.positionY ?? 200,
+        order: blockData.order ?? existingBlocks.length,
+      };
+      const allBlocks = [...existingBlocks.map((b: any) => ({
+        id: b.id, type: b.type, title: b.title,
+        content: b.content, positionX: b.positionX, positionY: b.positionY,
+        order: b.order, conditions: b.conditions, comment: b.comment,
+      })), newBlock];
+      await client.put(`/flows/${flowId}/blocks`, allBlocks, 'eduflow');
+      return { success: true, block: newBlock };
+    },
+  },
+
+  block_update: {
+    description: 'Mettre à jour un bloc existant (titre, contenu, position, conditions).',
+    inputSchema: z.object({
+      flowId: z.string().uuid().describe('ID du parcours'),
+      blockId: z.string().uuid().describe('ID du bloc à modifier'),
+      title: z.string().optional().describe('Nouveau titre'),
+      content: blockContentSchema.optional(),
+      positionX: z.number().optional().describe('Nouvelle position X'),
+      positionY: z.number().optional().describe('Nouvelle position Y'),
+      order: z.number().optional().describe('Nouvel ordre'),
+      conditions: z.any().optional().describe('Conditions de branchement'),
+      comment: z.string().optional().describe('Commentaire créateur'),
+    }),
+    handler: async ({ flowId, blockId, ...data }: any) => {
+      return client.put(`/flows/${flowId}/blocks/${blockId}`, data, 'eduflow');
+    },
+  },
+
+  block_batch_update: {
+    description: 'Mettre à jour plusieurs blocs en une seule opération. Utile pour repositionner ou réorganiser tous les blocs.',
+    inputSchema: z.object({
+      flowId: z.string().uuid().describe('ID du parcours'),
+      blocks: z.array(z.object({
+        id: z.string().describe('ID du bloc'),
+        type: z.string().describe('Type du bloc'),
+        title: z.string().describe('Titre'),
+        content: z.any().describe('Contenu'),
+        positionX: z.number().optional(),
+        positionY: z.number().optional(),
+        order: z.number().optional(),
+        conditions: z.any().optional(),
+        comment: z.string().optional(),
+      })).describe('Liste complète des blocs (REMPLACE tous les blocs existants)'),
+    }),
+    handler: async ({ flowId, blocks }: any) => {
+      return client.put(`/flows/${flowId}/blocks`, blocks, 'eduflow');
+    },
+  },
+
+  block_delete: {
+    description: 'Supprimer un bloc d\'un parcours. Les connexions liées sont automatiquement supprimées.',
+    inputSchema: z.object({
+      flowId: z.string().uuid().describe('ID du parcours'),
+      blockId: z.string().uuid().describe('ID du bloc à supprimer'),
+    }),
+    handler: async ({ flowId, blockId }: { flowId: string; blockId: string }) => {
+      // Get current flow, remove block, remove related edges, batch update
+      const flow = await client.get(`/flows/${flowId}`, 'eduflow');
+      const blocks = (flow.blocks || []).filter((b: any) => b.id !== blockId);
+      const edges = (flow.edges || []).filter(
+        (e: any) => e.source !== blockId && e.target !== blockId
+      );
+      const mappedBlocks = blocks.map((b: any) => ({
+        id: b.id, type: b.type, title: b.title,
+        content: b.content, positionX: b.positionX, positionY: b.positionY,
+        order: b.order, conditions: b.conditions, comment: b.comment,
+      }));
+      await client.put(`/flows/${flowId}/blocks`, mappedBlocks, 'eduflow');
+      await client.put(`/flows/${flowId}`, { edges }, 'eduflow');
+      return { success: true, remainingBlocks: blocks.length, remainingEdges: edges.length };
+    },
+  },
+
+  block_generate_tts: {
+    description: 'Générer l\'audio TTS (text-to-speech) pour un bloc texte. L\'audio est attaché au bloc.',
+    inputSchema: z.object({
+      flowId: z.string().uuid().describe('ID du parcours'),
+      blockId: z.string().uuid().describe('ID du bloc'),
+    }),
+    handler: async ({ flowId, blockId }: { flowId: string; blockId: string }) => {
+      return client.post(`/blocks/${blockId}/generate-tts`, { flowId }, 'eduflow');
+    },
+  },
+};