@lyrra/mcp-server 1.1.3 → 1.1.5

package/src/tools/ai-designer.ts

@@ -1,97 +0,0 @@
-import { z } from 'zod';
-import { LyrraClient } from '../client.js';
-import { client as defaultClient } from '../client.js';
-
-export function createAiDesignerTools(c: LyrraClient) {
-  return {
-  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 c.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 c.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 c.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 c.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 c.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 c.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 c.get(`/flows/${flowId}/chatbot/conversation`, 'eduflow');
-    },
-  },
-  };
-}
-
-// Backward compatibility for stdio mode
-export const aiDesignerTools = createAiDesignerTools(defaultClient);

package/src/tools/analytics.ts

@@ -1,49 +0,0 @@
-import { z } from 'zod';
-import { LyrraClient } from '../client.js';
-import { client as defaultClient } from '../client.js';
-
-export function createAnalyticsTools(c: LyrraClient) {
-  return {
-  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 c.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 c.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 c.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 c.get('/analytics/my-stats');
-    },
-  },
-  };
-}
-
-// Backward compatibility for stdio mode
-export const analyticsTools = createAnalyticsTools(defaultClient);

package/src/tools/auth.ts

@@ -1,39 +0,0 @@
-import { z } from 'zod';
-import { LyrraClient } from '../client.js';
-import { client as defaultClient } from '../client.js';
-
-export function createAuthTools(c: LyrraClient) {
-  return {
-    auth_login: {
-      description: 'Se connecter à LYRRA Studio avec email et mot de passe. ⚠️ NE PAS utiliser si LYRRA_CLIENT_SECRET est configuré — l\'authentification est alors automatique via API Key. Utiliser uniquement si aucune clé API n\'est définie.',
-      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 c.post('/auth/login', { email, password });
-        if (result.token) c.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 c.get('/auth/me');
-      },
-    },
-
-    auth_list_api_keys: {
-      description: 'Lister toutes les clés API de l\'utilisateur connecté.',
-      inputSchema: z.object({}),
-      handler: async () => {
-        return c.get('/api-keys');
-      },
-    },
-  };
-}
-
-// Backward compatibility for stdio mode
-export const authTools = createAuthTools(defaultClient);

package/src/tools/blocks.ts

@@ -1,186 +0,0 @@
-import { z } from 'zod';
-import { LyrraClient } from '../client.js';
-import { client as defaultClient } 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 function createBlocksTools(c: LyrraClient) {
-  return {
-  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 c.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 c.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 c.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 c.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. Envoie aussi les edges (connexions) si fournis.',
-    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)'),
-      edges: z.array(z.object({
-        id: z.string().describe('ID de la connexion'),
-        source: z.string().describe('ID du bloc source'),
-        target: z.string().describe('ID du bloc cible'),
-        label: z.string().optional(),
-      })).optional().describe('Connexions entre blocs'),
-    }),
-    handler: async ({ flowId, blocks, edges }: any) => {
-      return c.put(`/flows/${flowId}/blocks`, { blocks, edges: edges || [] }, '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 c.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 c.put(`/flows/${flowId}/blocks`, { blocks: mappedBlocks }, 'eduflow');
-      await c.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 c.post(`/blocks/${blockId}/generate-tts`, { flowId }, 'eduflow');
-    },
-  },
-  };
-}
-
-// Backward compatibility for stdio mode
-export const blocksTools = createBlocksTools(defaultClient);

package/src/tools/connections.ts

@@ -1,83 +0,0 @@
-import { z } from 'zod';
-import { LyrraClient } from '../client.js';
-import { client as defaultClient } from '../client.js';
-
-export function createConnectionsTools(c: LyrraClient) {
-  return {
-  connection_list: {
-    description: `Lister toutes les connexions (edges) d'un parcours EduFlow. Chaque connexion relie un bloc source à un bloc cible.
-Règles de connexion :
-- Le bloc "start" ne peut avoir QUE des connexions sortantes
-- Le bloc "end" ne peut avoir QUE des connexions entrantes
-- Un bloc "split" doit avoir au moins 2 connexions sortantes
-- Un bloc "merge" doit avoir au moins 2 connexions entrantes
-- Un bloc "quiz" peut avoir des connexions conditionnelles (branchement selon la réponse)`,
-    inputSchema: z.object({
-      flowId: z.string().uuid().describe('ID du parcours'),
-    }),
-    handler: async ({ flowId }: { flowId: string }) => {
-      const flow = await c.get(`/flows/${flowId}`, 'eduflow');
-      return {
-        edges: flow.edges || [],
-        blocks: (flow.blocks || []).map((b: any) => ({ id: b.id, type: b.type, title: b.title })),
-      };
-    },
-  },
-
-  connection_add: {
-    description: 'Ajouter une connexion entre deux blocs. Le parcours est un graphe orienté : source → target.',
-    inputSchema: z.object({
-      flowId: z.string().uuid().describe('ID du parcours'),
-      source: z.string().describe('ID du bloc source (d\'où part la connexion)'),
-      target: z.string().describe('ID du bloc cible (où arrive la connexion)'),
-      label: z.string().optional().describe('Label affiché sur la connexion (ex: "Bonne réponse", "Mauvaise réponse")'),
-      animated: z.boolean().optional().describe('Animer la connexion visuellement'),
-    }),
-    handler: async ({ flowId, source, target, label, animated }: any) => {
-      const flow = await c.get(`/flows/${flowId}`, 'eduflow');
-      const edges = flow.edges || [];
-      const newEdge = {
-        id: `e-${source}-${target}`,
-        source,
-        target,
-        label: label || '',
-        animated: animated || false,
-      };
-      // Check for duplicate
-      const exists = edges.some((e: any) => e.source === source && e.target === target);
-      if (exists) {
-        return { success: false, error: 'Cette connexion existe déjà' };
-      }
-      edges.push(newEdge);
-      await c.put(`/flows/${flowId}`, { edges }, 'eduflow');
-      return { success: true, edge: newEdge, totalEdges: edges.length };
-    },
-  },
-
-  connection_remove: {
-    description: 'Supprimer une connexion entre deux blocs.',
-    inputSchema: z.object({
-      flowId: z.string().uuid().describe('ID du parcours'),
-      edgeId: z.string().optional().describe('ID de la connexion à supprimer'),
-      source: z.string().optional().describe('Alternative : ID du bloc source'),
-      target: z.string().optional().describe('Alternative : ID du bloc cible'),
-    }),
-    handler: async ({ flowId, edgeId, source, target }: any) => {
-      const flow = await c.get(`/flows/${flowId}`, 'eduflow');
-      let edges = flow.edges || [];
-      if (edgeId) {
-        edges = edges.filter((e: any) => e.id !== edgeId);
-      } else if (source && target) {
-        edges = edges.filter((e: any) => !(e.source === source && e.target === target));
-      } else {
-        return { success: false, error: 'Fournir edgeId OU source+target' };
-      }
-      await c.put(`/flows/${flowId}`, { edges }, 'eduflow');
-      return { success: true, remainingEdges: edges.length };
-    },
-  },
-  };
-}
-
-// Backward compatibility for stdio mode
-export const connectionsTools = createConnectionsTools(defaultClient);

package/src/tools/eduflow.ts

@@ -1,150 +0,0 @@
-import { z } from 'zod';
-import { LyrraClient } from '../client.js';
-import { client as defaultClient } from '../client.js';
-import { config } from '../config.js';
-
-export function createEduflowTools(c: LyrraClient) {
-  return {
-  eduflow_list: {
-    description: 'Lister tous les parcours EduFlow de l\'utilisateur. Retourne id, titre, statut, nombre de blocs, dates.',
-    inputSchema: z.object({}),
-    handler: async () => {
-      return c.get('/flows', 'eduflow');
-    },
-  },
-
-  eduflow_get: {
-    description: 'Récupérer les détails complets d\'un parcours EduFlow : blocs, connexions (edges), objectifs, paramètres de gamification, présentation, etc.',
-    inputSchema: z.object({
-      flowId: z.string().uuid().describe('ID du parcours EduFlow'),
-    }),
-    handler: async ({ flowId }: { flowId: string }) => {
-      return c.get(`/flows/${flowId}`, 'eduflow');
-    },
-  },
-
-  eduflow_get_urls: {
-    description: 'Obtenir tous les liens utiles d\'un parcours EduFlow : prévisualisation, édition, page publique, analytics, lien participant. À utiliser quand l\'utilisateur demande un lien ou une URL.',
-    inputSchema: z.object({
-      flowId: z.string().uuid().describe('ID du parcours EduFlow'),
-    }),
-    handler: async ({ flowId }: { flowId: string }) => {
-      const base = config.frontendUrl;
-      return {
-        preview: `${base}/eduflow/flows/${flowId}/play`,
-        public: `${base}/eduflow/flows/${flowId}/public`,
-        edit: `${base}/eduflow/edit/${flowId}`,
-        presentation: `${base}/eduflow/edit/${flowId}/presentation`,
-        analytics: `${base}/eduflow/flows/${flowId}/analytics`,
-      };
-    },
-  },
-
-  eduflow_create: {
-    description: 'Créer un nouveau parcours EduFlow. Les blocs "start" et "end" sont automatiquement créés et connectés.',
-    inputSchema: z.object({
-      title: z.string().describe('Titre du parcours'),
-      description: z.string().optional().describe('Description du parcours'),
-      language: z.enum(['fr', 'en', 'es', 'it', 'de']).optional().describe('Langue du parcours (défaut: fr)'),
-    }),
-    handler: async (args: { title: string; description?: string; language?: string }) => {
-      const result = await c.post('/flows', args, 'eduflow');
-      const flowId = result?.flow?.id;
-      if (flowId) {
-        const startId = `start-1`;
-        const endId = `end-1`;
-        const blocks = [
-          { id: startId, type: 'start', title: 'Début', content: {}, order: 0, positionX: 250, positionY: 50 },
-          { id: endId, type: 'end', title: 'Fin', content: {}, order: 1, positionX: 250, positionY: 300 },
-        ];
-        const edges = [
-          { id: `edge-${startId}-${endId}`, source: startId, target: endId },
-        ];
-        await c.put(`/flows/${flowId}/blocks`, { blocks, edges }, 'eduflow');
-      }
-      return result;
-    },
-  },
-
-  eduflow_update: {
-    description: 'Mettre à jour les propriétés d\'un parcours EduFlow (titre, description, edges, gamification, objectifs, présentation, etc.).',
-    inputSchema: z.object({
-      flowId: z.string().uuid().describe('ID du parcours'),
-      title: z.string().optional().describe('Nouveau titre'),
-      description: z.string().optional().describe('Nouvelle description'),
-      edges: z.array(z.object({
-        id: z.string(),
-        source: z.string().describe('ID du bloc source'),
-        target: z.string().describe('ID du bloc cible'),
-        label: z.string().optional().describe('Label de la connexion'),
-        animated: z.boolean().optional(),
-      })).optional().describe('Connexions entre blocs (remplace toutes les connexions existantes)'),
-      objectives: z.any().optional().describe('Objectifs pédagogiques {globalObjective, steps[]}'),
-      gamification: z.any().optional().describe('Configuration gamification {badges, missions, leaderboard, certifications}'),
-      presentationEnabled: z.boolean().optional().describe('Activer/désactiver la page de présentation'),
-      presentationData: z.any().optional().describe('Données de la page de présentation'),
-      chatbotEnabled: z.boolean().optional().describe('Activer/désactiver le chatbot IA'),
-      facialVerificationEnabled: z.boolean().optional().describe('Activer/désactiver la vérification faciale'),
-      deadline: z.string().optional().describe('Date limite ISO 8601'),
-      language: z.enum(['fr', 'en', 'es', 'it', 'de']).optional().describe('Langue du parcours'),
-    }),
-    handler: async ({ flowId, ...data }: any) => {
-      return c.put(`/flows/${flowId}`, data, 'eduflow');
-    },
-  },
-
-  eduflow_delete: {
-    description: 'Supprimer définitivement un parcours EduFlow et tous ses blocs, connexions, participants.',
-    inputSchema: z.object({
-      flowId: z.string().uuid().describe('ID du parcours à supprimer'),
-    }),
-    handler: async ({ flowId }: { flowId: string }) => {
-      return c.delete(`/flows/${flowId}`, 'eduflow');
-    },
-  },
-
-  eduflow_duplicate: {
-    description: 'Dupliquer un parcours EduFlow existant avec tous ses blocs et connexions.',
-    inputSchema: z.object({
-      flowId: z.string().uuid().describe('ID du parcours à dupliquer'),
-    }),
-    handler: async ({ flowId }: { flowId: string }) => {
-      return c.post(`/flows/${flowId}/duplicate`, {}, 'eduflow');
-    },
-  },
-
-  eduflow_change_status: {
-    description: 'Changer le statut d\'un parcours : draft (brouillon), published (publié, accessible aux étudiants), archived (archivé).',
-    inputSchema: z.object({
-      flowId: z.string().uuid().describe('ID du parcours'),
-      status: z.enum(['draft', 'published', 'archived']).describe('Nouveau statut'),
-    }),
-    handler: async ({ flowId, status }: { flowId: string; status: string }) => {
-      return c.patch(`/flows/${flowId}/status`, { status }, 'eduflow');
-    },
-  },
-
-  eduflow_export: {
-    description: 'Exporter un parcours EduFlow au format JSON (contient blocs, connexions, paramètres).',
-    inputSchema: z.object({
-      flowId: z.string().uuid().describe('ID du parcours à exporter'),
-    }),
-    handler: async ({ flowId }: { flowId: string }) => {
-      return c.get(`/flows/${flowId}/export`, 'eduflow');
-    },
-  },
-
-  eduflow_get_public: {
-    description: 'Récupérer les informations publiques d\'un parcours (page de présentation, objectifs). Ne nécessite pas d\'authentification.',
-    inputSchema: z.object({
-      flowId: z.string().uuid().describe('ID du parcours'),
-    }),
-    handler: async ({ flowId }: { flowId: string }) => {
-      return c.get(`/flows/${flowId}/public`, 'eduflow');
-    },
-  },
-  };
-}
-
-// Backward compatibility for stdio mode
-export const eduflowTools = createEduflowTools(defaultClient);