@lyrra/mcp-server 1.1.3 → 1.1.5

package/src/resources/block-types.ts

@@ -1,298 +0,0 @@
-export const BLOCK_TYPES_RESOURCE = {
-  uri: 'lyrra://block-types',
-  name: 'Documentation des types de blocs EduFlow',
-  description: 'Documentation complète de tous les types de blocs disponibles dans LYRRA Studio EduFlow, avec la structure de contenu attendue, des exemples et les règles de connexion.',
-  mimeType: 'application/json',
-  content: {
-    overview: `LYRRA Studio EduFlow supporte 29 types de blocs organisés en 7 catégories.
-Chaque parcours est un graphe orienté : les blocs sont des nœuds, reliés par des edges (connexions).
-Un parcours DOIT avoir exactement 1 bloc "start" et au moins 1 bloc "end".`,
-
-    categories: {
-      content: {
-        name: 'Contenu',
-        types: ['text', 'audio', 'video', 'pdf', 'image', 'presentation', 'browser'],
-        description: 'Blocs pour présenter du contenu aux apprenants.',
-      },
-      assessment: {
-        name: 'Évaluation',
-        types: ['quiz', 'evaluation', 'voice_assessment', 'self_assessment'],
-        description: 'Blocs pour évaluer les connaissances des apprenants.',
-      },
-      interactive: {
-        name: 'Interactif',
-        types: ['form', 'mindmap', 'timeline', 'chart', 'glossary'],
-        description: 'Blocs interactifs pour engager les apprenants.',
-      },
-      flow_control: {
-        name: 'Contrôle de flux',
-        types: ['start', 'end', 'split', 'merge', 'loop', 'timer', 'subflow'],
-        description: 'Blocs pour structurer le parcours (branchement, boucles, etc.).',
-      },
-      accessibility: {
-        name: 'Accessibilité (DYS)',
-        types: ['dys_reader', 'dys_image_zones', 'dys_reading_practice', 'dys_clock'],
-        description: 'Blocs adaptés pour les apprenants dyslexiques/dyscalculiques.',
-      },
-      output: {
-        name: 'Sortie',
-        types: ['certification', 'email'],
-        description: 'Blocs pour générer des documents ou envoyer des notifications.',
-      },
-    },
-
-    blocks: {
-      start: {
-        name: 'Début',
-        description: 'Point de départ du parcours. Chaque flux doit avoir exactement UN bloc Start.',
-        content: { message: 'string (optionnel) - Message d\'accueil' },
-        rules: ['Un seul bloc start par parcours', 'Pas de connexion entrante', 'Au moins une connexion sortante'],
-        example: { type: 'start', title: 'Début du parcours', content: { message: 'Bienvenue !' } },
-      },
-      end: {
-        name: 'Fin',
-        description: 'Point de fin du parcours. Peut avoir plusieurs blocs End.',
-        content: {
-          message: 'string (optionnel) - Message de fin',
-          certificate: 'boolean (optionnel) - Génère un certificat',
-          redirectUrl: 'string (optionnel) - URL de redirection',
-        },
-        rules: ['Peut avoir plusieurs blocs end', 'Pas de connexion sortante', 'Au moins une connexion entrante'],
-        example: { type: 'end', title: 'Fin', content: { message: 'Félicitations !', certificate: true } },
-      },
-      text: {
-        name: 'Texte',
-        description: 'Affiche du contenu HTML enrichi. TOUJOURS utiliser format="html".',
-        content: {
-          text: 'string (requis) - Contenu HTML (<h1>, <p>, <ul>, <strong>, etc.)',
-          format: 'string (requis) - TOUJOURS "html"',
-        },
-        rules: ['TOUJOURS format="html"', 'JAMAIS de Markdown', 'Utiliser des balises HTML standard'],
-        example: {
-          type: 'text', title: 'Introduction',
-          content: { text: '<h2>Bienvenue</h2><p>Ce module couvre...</p>', format: 'html' },
-        },
-      },
-      audio: {
-        name: 'Audio',
-        description: 'Intègre un projet audio LYRRA avec texte synchronisé.',
-        content: {
-          projectId: 'string (requis) - ID du projet LYRRA',
-          showTranscript: 'boolean (optionnel, défaut: true)',
-          showChapters: 'boolean (optionnel, défaut: true)',
-        },
-      },
-      video: {
-        name: 'Vidéo',
-        description: 'Intègre une vidéo YouTube, Vimeo ou uploadée.',
-        content: {
-          videoUrl: 'string (requis) - URL de la vidéo',
-          autoplay: 'boolean (optionnel)',
-          showControls: 'boolean (optionnel, défaut: true)',
-        },
-      },
-      pdf: {
-        name: 'PDF',
-        description: 'Affiche un document PDF intégré.',
-        content: { pdfUrl: 'string (requis) - URL du fichier PDF' },
-      },
-      image: {
-        name: 'Image',
-        description: 'Affiche une image avec légende optionnelle.',
-        content: {
-          imageUrl: 'string (requis) - URL de l\'image',
-          caption: 'string (optionnel) - Légende',
-          alt: 'string (optionnel) - Texte alternatif',
-        },
-      },
-      quiz: {
-        name: 'Quiz',
-        description: 'Question unique avec branchement conditionnel possible.',
-        content: {
-          quizType: '"multiple_choice" | "true_false" | "ordering"',
-          question: 'string (requis) - La question',
-          answers: 'array - [{text, isCorrect, feedback?}]',
-          answerMode: '"text" | "image"',
-          branchingMode: '"binary" | "per-answer" (optionnel)',
-          explanation: 'string (optionnel) - Explication après réponse',
-          shuffleAnswers: 'boolean (optionnel)',
-          maxAttempts: 'number (optionnel)',
-        },
-        rules: [
-          'branchingMode="binary" : 2 sorties (correct/incorrect)',
-          'branchingMode="per-answer" : une sortie par réponse',
-          'Sans branchement : une seule sortie',
-        ],
-      },
-      evaluation: {
-        name: 'Évaluation',
-        description: 'Évaluation complète avec plusieurs questions et scoring.',
-        content: {
-          questions: 'array - [{type, question, answers?, correctAnswer?, points}]',
-          passingScore: 'number (optionnel) - Score minimum pour réussir (%)',
-          showResults: 'boolean (optionnel) - Montrer les résultats',
-          maxAttempts: 'number (optionnel)',
-          timeLimit: 'number (optionnel) - Temps en secondes',
-        },
-      },
-      form: {
-        name: 'Formulaire',
-        description: 'Formulaire avec champs personnalisés et logique conditionnelle.',
-        content: {
-          fields: 'array - [{type, label, required?, options?, placeholder?}]',
-          submitLabel: 'string (optionnel)',
-          rules: 'array (optionnel) - Logique IF/ELSE pour le routage',
-        },
-      },
-      chart: {
-        name: 'Graphique',
-        description: 'Graphique interactif.',
-        content: {
-          chartType: '"bar" | "line" | "pie" | "scatter" | "radar" | "area" | "doughnut"',
-          data: 'object - {labels[], datasets[{label, data[]}]}',
-          title: 'string (optionnel)',
-        },
-      },
-      timeline: {
-        name: 'Frise chronologique',
-        description: 'Frise avec événements datés.',
-        content: {
-          events: 'array - [{date, title, description, imageUrl?}]',
-          orientation: '"horizontal" | "vertical" (optionnel)',
-        },
-      },
-      mindmap: {
-        name: 'Carte mentale',
-        description: 'Carte mentale interactive.',
-        content: {
-          nodes: 'array - [{id, label, parentId?, color?}]',
-          centerLabel: 'string - Label du nœud central',
-        },
-      },
-      glossary: {
-        name: 'Glossaire',
-        description: 'Liste de termes et définitions.',
-        content: {
-          terms: 'array - [{term, definition, examples?}]',
-          sortAlphabetically: 'boolean (optionnel, défaut: true)',
-        },
-      },
-      split: {
-        name: 'Embranchement',
-        description: 'Sépare le flux en branches parallèles.',
-        content: { branches: 'number (optionnel) - Nombre de branches (défaut: 2)' },
-        rules: ['Au moins 2 connexions sortantes', 'Généralement suivi d\'un bloc merge'],
-      },
-      merge: {
-        name: 'Fusion',
-        description: 'Rejoint les branches parallèles.',
-        content: {},
-        rules: ['Au moins 2 connexions entrantes', 'Utilisé après un bloc split'],
-      },
-      loop: {
-        name: 'Boucle',
-        description: 'Permet de répéter une séquence de blocs.',
-        content: {
-          maxIterations: 'number (optionnel) - Nombre max de répétitions',
-          condition: 'string (optionnel) - Condition de sortie',
-        },
-      },
-      timer: {
-        name: 'Minuteur',
-        description: 'Bloc avec contrainte de temps.',
-        content: {
-          duration: 'number (requis) - Durée en secondes',
-          action: '"pause" | "skip" | "redirect" - Action à l\'expiration',
-          warningAt: 'number (optionnel) - Avertissement X secondes avant la fin',
-        },
-      },
-      subflow: {
-        name: 'Sous-parcours',
-        description: 'Intègre un autre parcours EduFlow.',
-        content: { subflowId: 'string (requis) - ID du parcours à intégrer' },
-      },
-      certification: {
-        name: 'Certification',
-        description: 'Génère un certificat PDF personnalisé.',
-        content: {
-          templateId: 'string (optionnel) - ID du template Word',
-          variables: 'object (optionnel) - Variables de substitution',
-        },
-      },
-      email: {
-        name: 'Email',
-        description: 'Envoie un email automatique.',
-        content: {
-          subject: 'string (requis) - Objet de l\'email',
-          body: 'string (requis) - Corps HTML de l\'email',
-          to: '"participant" | "creator" | string - Destinataire',
-        },
-      },
-      voice_assessment: {
-        name: 'Évaluation vocale',
-        description: 'L\'étudiant enregistre sa voix pour évaluation.',
-        content: {
-          prompt: 'string (requis) - Consigne de lecture/parole',
-          referenceText: 'string (optionnel) - Texte de référence pour comparaison',
-          maxDuration: 'number (optionnel) - Durée max en secondes',
-        },
-      },
-      self_assessment: {
-        name: 'Auto-évaluation',
-        description: 'L\'étudiant s\'évalue sur des critères définis.',
-        content: {
-          criteria: 'array - [{label, scale}]',
-          instructions: 'string (optionnel)',
-        },
-      },
-      presentation: {
-        name: 'Présentation',
-        description: 'Diaporama avec slides.',
-        content: {
-          slides: 'array - [{title, content, imageUrl?}]',
-          autoAdvance: 'boolean (optionnel)',
-          advanceInterval: 'number (optionnel) - Secondes entre slides',
-        },
-      },
-      browser: {
-        name: 'Navigateur',
-        description: 'Intègre une page web dans un iframe.',
-        content: { url: 'string (requis) - URL de la page à intégrer' },
-      },
-      dys_reader: {
-        name: 'Lecteur DYS',
-        description: 'Texte adapté pour la dyslexie.',
-        content: {
-          text: 'string (requis) - Texte à afficher',
-          fontSize: 'number (optionnel) - Taille de police (défaut: 18)',
-          lineSpacing: 'number (optionnel) - Interligne (défaut: 2)',
-          syllableHighlight: 'boolean (optionnel) - Colorer les syllabes',
-        },
-      },
-      dys_image_zones: {
-        name: 'Zones d\'image DYS',
-        description: 'Image avec zones cliquables.',
-        content: {
-          imageUrl: 'string (requis)',
-          zones: 'array - [{x, y, width, height, label, description}]',
-        },
-      },
-      dys_reading_practice: {
-        name: 'Pratique lecture DYS',
-        description: 'Exercice de lecture adapté.',
-        content: {
-          text: 'string (requis)',
-          difficulty: '"easy" | "medium" | "hard"',
-        },
-      },
-      dys_clock: {
-        name: 'Horloge DYS',
-        description: 'Exercice de lecture de l\'heure.',
-        content: {
-          targetTime: 'string (requis) - Heure cible (format HH:MM)',
-          difficulty: '"easy" | "medium" | "hard"',
-        },
-      },
-    },
-  },
-};

package/src/resources/flow-schema.ts

@@ -1,148 +0,0 @@
-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/server-factory.ts

@@ -1,109 +0,0 @@
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { LyrraClient } from './client.js';
-
-// Tool factory functions
-import { createAuthTools } from './tools/auth.js';
-import { createEduflowTools } from './tools/eduflow.js';
-import { createBlocksTools } from './tools/blocks.js';
-import { createConnectionsTools } from './tools/connections.js';
-import { createParticipantsTools } from './tools/participants.js';
-import { createAnalyticsTools } from './tools/analytics.js';
-import { createAiDesignerTools } from './tools/ai-designer.js';
-import { createPresentationTools } from './tools/presentation.js';
-import { createStoreTools } from './tools/store.js';
-import { createProjectsTools } from './tools/projects.js';
-import { createResourcesTools } from './tools/resources.js';
-import { createAdminTools } from './tools/admin.js';
-
-// Resources
-import { BLOCK_TYPES_RESOURCE } from './resources/block-types.js';
-import { FLOW_SCHEMA_RESOURCE } from './resources/flow-schema.js';
-
-type ToolDef = { description: string; inputSchema: any; handler: (args: any) => Promise<any> };
-
-function registerToolsOnServer(server: McpServer, tools: Record<string, ToolDef>) {
-  for (const [name, tool] of Object.entries(tools)) {
-    server.tool(
-      name,
-      tool.description,
-      tool.inputSchema.shape
-        ? Object.fromEntries(
-            Object.entries(tool.inputSchema.shape).map(([key, schema]: [string, any]) => [key, schema])
-          )
-        : {},
-      async (args: any) => {
-        try {
-          const result = await tool.handler(args);
-          return {
-            content: [{ type: 'text' as const, text: JSON.stringify(result, null, 2) }],
-          };
-        } catch (error: any) {
-          return {
-            content: [{ type: 'text' as const, text: `Erreur: ${error.message}` }],
-            isError: true,
-          };
-        }
-      }
-    );
-  }
-}
-
-/**
- * Create and configure an MCP server with all tools registered.
- * @param client - LyrraClient to use for API calls. If not provided, uses default (env vars).
- */
-export function createMcpServer(client?: LyrraClient): McpServer {
-  const c = client || new LyrraClient();
-
-  const server = new McpServer({
-    name: 'lyrra-studio',
-    version: '1.0.0',
-    description: 'Serveur MCP pour piloter LYRRA Studio - Plateforme EdTech de création de parcours pédagogiques, conversion PDF→Audio, et store d\'audiobooks.',
-  });
-
-  const allTools: Record<string, ToolDef> = {
-    ...createAuthTools(c),
-    ...createEduflowTools(c),
-    ...createBlocksTools(c),
-    ...createConnectionsTools(c),
-    ...createParticipantsTools(c),
-    ...createAnalyticsTools(c),
-    ...createAiDesignerTools(c),
-    ...createPresentationTools(c),
-    ...createStoreTools(c),
-    ...createProjectsTools(c),
-    ...createResourcesTools(c),
-    ...createAdminTools(c),
-  };
-
-  registerToolsOnServer(server, allTools);
-
-  // Resources
-  server.resource(
-    'block-types',
-    BLOCK_TYPES_RESOURCE.uri,
-    { description: BLOCK_TYPES_RESOURCE.description, mimeType: BLOCK_TYPES_RESOURCE.mimeType },
-    async () => ({
-      contents: [{
-        uri: BLOCK_TYPES_RESOURCE.uri,
-        mimeType: BLOCK_TYPES_RESOURCE.mimeType,
-        text: JSON.stringify(BLOCK_TYPES_RESOURCE.content, null, 2),
-      }],
-    })
-  );
-
-  server.resource(
-    'flow-construction-guide',
-    FLOW_SCHEMA_RESOURCE.uri,
-    { description: FLOW_SCHEMA_RESOURCE.description, mimeType: FLOW_SCHEMA_RESOURCE.mimeType },
-    async () => ({
-      contents: [{
-        uri: FLOW_SCHEMA_RESOURCE.uri,
-        mimeType: FLOW_SCHEMA_RESOURCE.mimeType,
-        text: JSON.stringify(FLOW_SCHEMA_RESOURCE.content, null, 2),
-      }],
-    })
-  );
-
-  return server;
-}

package/src/tools/admin.ts

@@ -1,128 +0,0 @@
-import { z } from 'zod';
-import { LyrraClient } from '../client.js';
-import { client as defaultClient } from '../client.js';
-
-export function createAdminTools(c: LyrraClient) {
-  return {
-  // --- 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 c.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 c.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 c.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 c.get('/gamification/stats');
-    },
-  },
-
-  gamification_objectives: {
-    description: 'Récupérer les prochains objectifs de gamification à atteindre.',
-    inputSchema: z.object({}),
-    handler: async () => {
-      return c.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 c.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 c.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 c.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 c.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 c.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 c.post(`/webhooks/${webhookId}/test`, {});
-    },
-  },
-  };
-}
-
-// Backward compatibility for stdio mode
-export const adminTools = createAdminTools(defaultClient);