@lyrra/mcp-server 1.1.2 → 1.1.5

package/dist/eduflow-block-docs.js

@@ -0,0 +1,438 @@
+/**
+ * MCP documentation for each EduFlow block type (aligned with the React designer).
+ * Types: apps/frontend/src/types/eduflow.ts, palette apps/frontend/src/lib/eduflow-designer-palette-blueprint.ts
+ */
+export const EDUFLOW_BLOCK_COMMON = `## Shared block data (JSON model)
+
+Each block in \`EduFlow.blocks[]\` includes:
+- \`id\` (UUID), \`type\` (string, e.g. \`quiz_mcq\`), \`position\`, \`connections\` (graph in/out)
+- optional \`isRequired\`, \`isLocked\` (institution-locked block), \`order\`, \`label\`, \`color\`, \`metadata\`
+
+**Object \`data\` (\`BlockData\`)** — shared:
+- \`title\`, \`description\` (rich HTML in the designer)
+- \`descriptionAudioUrl\`: TTS URL for the description (if generated)
+- \`content\`: text or HTML depending on type (e.g. question stem)
+- \`mediaUrl\`: primary media when applicable
+- \`settings\`: \`Record<string, unknown>\` — **type-specific parameters** (see per-block sections below)
+- \`scoring\`: max points, pass threshold, method (\`automatic\` | \`manual\` | \`peer\` | \`ai\`), optional rubric
+- \`timeLimit\` (seconds or minutes depending on screen — e.g. timer UI may use “minutes” while the field is \`timeLimit\`)
+- \`attempts\`: max attempts
+- \`feedback\`: \`onCorrect\`, \`onIncorrect\`, \`onPartial\`, \`showExplanation\`, \`explanation\`
+
+**Accessibility / adaptive replacement** (text, PDF, presentation, video, browser) in the side panel:
+- \`settings.accessibilityMode\`: \`auto\` | \`assist\` | \`manual\`
+- \`settings.forceAccessibleGame\`: boolean
+
+**API persistence**: blocks are saved on the EduFlow document via \`/api/eduflows/:id\` (JSON update).
+`;
+export const EDUFLOW_BLOCK_DOCS = [
+    {
+        id: 'start',
+        category: 'Structure',
+        label: 'Start',
+        summary: 'Entry point of the EduFlow path.',
+        configurationMd: `### Role
+Marks the beginning of the flow; often unique and institution-locked.
+
+### Specifics
+No required \`settings\`. Use title/description as the designer cue.
+
+### Graph
+One or more outputs to the following blocks.`,
+    },
+    {
+        id: 'end',
+        category: 'Structure',
+        label: 'End',
+        summary: 'Path completion / exit.',
+        configurationMd: `### Role
+Ends the path (certificate, wrap-up, exit).
+
+### Specifics
+No mandatory technical fields in the generic designer.
+
+### Graph
+Input(s) from the main path or branches.`,
+    },
+    {
+        id: 'subflow',
+        category: 'Structure',
+        label: 'Subflow',
+        summary: 'Reference or embed another EduFlow.',
+        configurationMd: `### Role
+Chains a submodule (another course or reusable segment).
+
+### Specifics
+Dedicated \`SubflowBlockEditor\`: link to an existing EduFlow (id, embed options). Exact \`settings\` fields depend on the editor (target flow selection, etc.).`,
+    },
+    {
+        id: 'loop',
+        category: 'Structure',
+        label: 'Loop',
+        summary: 'Repeat a segment based on a condition.',
+        configurationMd: `### settings
+- \`loopCondition\`: \`count\` | \`score\` | \`completion\`
+- \`maxIterations\`: integer (1–100, default 3)
+
+### Role
+Revisit a set of blocks until a criterion is met.`,
+    },
+    {
+        id: 'timer',
+        category: 'Structure',
+        label: 'Timer',
+        summary: 'Time limit for a step.',
+        configurationMd: `### data.timeLimit
+Shown in **minutes** in the designer UI (integer ≥ 1).
+
+> Note: the side panel may use a \`duration\` field on other screens; the main canvas uses \`timeLimit\`.`,
+    },
+    {
+        id: 'summary',
+        category: 'Structure',
+        label: 'Summary',
+        summary: 'Recap for the learner.',
+        configurationMd: `### Role
+Consolidation block (structured text, key points).
+
+### Specifics
+\`SummaryBlockEditor\`: rich content and internal options in \`settings\` / \`content\` per editor.`,
+    },
+    {
+        id: 'form',
+        category: 'Structure',
+        label: 'Form',
+        summary: 'Structured data collection (dynamic fields).',
+        configurationMd: `### settings.formFields
+Array of field objects: \`id\`, \`type\` (\`text\` | \`textarea\` | \`email\` | \`number\` | \`select\` | \`checkbox\` | \`radio\` | \`date\` | \`toggle\` | \`subtitle\` | \`file\`), \`label\`, \`placeholder\`, \`required\`, \`options\` (for select/radio), \`defaultValue\`, \`min\` / \`max\`, \`maxLength\`, \`description\`, \`autoFill\` (\`email\` | \`firstName\` | \`lastName\` | \`fullName\`).
+
+### Conditional rules
+\`settings.formRules\`: \`if\` / \`elseif\` / \`else\` rules with conditions on fields.
+
+### data
+Title, description; optional description audio if enabled on the flow.`,
+    },
+    {
+        id: 'split',
+        category: 'Structure',
+        label: 'Split (branch)',
+        summary: 'Multiple optional paths.',
+        configurationMd: `### settings
+- \`splitTitle\`: label shown (e.g. “Choose your path”)
+- \`numOutputs\`: number of branches (2–10)
+
+### Graph
+As many outputs as \`numOutputs\`.`,
+    },
+    {
+        id: 'merge',
+        category: 'Structure',
+        label: 'Merge',
+        summary: 'Join multiple branches.',
+        configurationMd: `### Role
+Convergence after a \`split\` or parallel paths.
+
+### Specifics
+No dedicated fields in the generic UI; title/description for the designer.`,
+    },
+    {
+        id: 'email',
+        category: 'Structure',
+        label: 'Email',
+        summary: 'Send email (template) in the flow.',
+        configurationMd: `### settings
+- \`emailSubject\`: subject line
+- \`emailTemplate\`: HTML body (placeholders e.g. \`{{name}}\`)`,
+    },
+    {
+        id: 'text',
+        category: 'Content',
+        label: 'Text',
+        summary: 'Rich content: article, instructions.',
+        configurationMd: `### data.content
+Body HTML (rich editor).
+
+### settings
+Typography / layout per \`TextBlockEditor\` (fonts, line height, etc. when exposed).`,
+    },
+    {
+        id: 'video',
+        category: 'Content',
+        label: 'Video',
+        summary: 'Video player (upload, YouTube, Vimeo, URL).',
+        configurationMd: `### Source
+\`settings\` control source type (\`upload\` | \`youtube\` | \`vimeo\` | \`url\`), IDs or URL, file metadata.
+
+### Appearance
+Player theme: \`app\` | \`cinema\` | \`glass\` | \`editorial\`; accent color; ratio \`16:9\` | \`21:9\` | \`4:3\` | \`1:1\`; corners \`soft\` | \`rounded\` | \`square\`; shadow \`soft\` | \`glow\` | \`dramatic\`.
+
+### Subtitles
+Tracks per language (fr, en, es, de, it) per editor.
+
+See \`apps/frontend/src/lib/video-block.ts\` for exported keys (\`getVideoBlockConfig\`).`,
+    },
+    {
+        id: 'podcast',
+        category: 'Content',
+        label: 'Podcast',
+        summary: 'Long-form podcast audio (episode / feed).',
+        configurationMd: `### Role
+Long audio playback linked to the podcasts module when configured.
+
+### data / settings
+Media URL, episode metadata in \`settings\` per block editor (series title, episode, artwork).`,
+    },
+    {
+        id: 'audio',
+        category: 'Content',
+        label: 'Audio',
+        summary: 'Audio track (outside podcast module).',
+        configurationMd: `### Role
+Simple audio playback (uploaded file or URL).
+
+### data / settings
+\`mediaUrl\` or upload; \`AudioBlockEditor\`: default volume, loop, waveform, subtitles/transcript when available.`,
+    },
+    {
+        id: 'image',
+        category: 'Content',
+        label: 'Image',
+        summary: 'Static or responsive image.',
+        configurationMd: `### data.mediaUrl or upload
+Image file; \`settings\`: caption, alt, size, clickable link per \`ImageBlockEditor\`.`,
+    },
+    {
+        id: 'pdf',
+        category: 'Content',
+        label: 'PDF',
+        summary: 'Embedded PDF document.',
+        configurationMd: `### Role
+Display / download document.
+
+### data / settings
+PDF URL, toolbar options, default page, embed mode (per \`PDFBlockEditor\`).`,
+    },
+    {
+        id: 'presentation',
+        category: 'Content',
+        label: 'Presentation',
+        summary: 'Slide deck.',
+        configurationMd: `### settings
+Slides: array of objects (title, content, media) managed by \`PresentationBlockEditor\`.`,
+    },
+    {
+        id: 'browser',
+        category: 'Content',
+        label: 'Embedded browser',
+        summary: 'iframe / webview to an external URL.',
+        configurationMd: `### settings
+Allowed URL, sandbox flags, height — via \`BrowserBlockEditor\`.`,
+    },
+    {
+        id: 'chart',
+        category: 'Content',
+        label: 'Chart',
+        summary: 'Chart (bars, line, etc.).',
+        configurationMd: `### settings
+Dataset (series, labels), chart type, colors — \`ChartBlockEditor\`.`,
+    },
+    {
+        id: 'timeline',
+        category: 'Content',
+        label: 'Timeline',
+        summary: 'Dated events on a line.',
+        configurationMd: `### settings
+Event list: date, title, description, media — \`TimelineBlockEditor\`.`,
+    },
+    {
+        id: 'mindmap',
+        category: 'Content',
+        label: 'Mind map',
+        summary: 'Hierarchical nodes and links.',
+        configurationMd: `### settings
+Tree structure (root node, children, styles) — \`MindmapBlockEditor\`.`,
+    },
+    {
+        id: 'visual_ai',
+        category: 'Content',
+        label: 'AI visual',
+        summary: 'AI-generated image or media.',
+        configurationMd: `### settings
+Prompt, style, provider, resulting image (URL or media id) — \`VisualAiBlockEditor\` / related modals.`,
+    },
+    {
+        id: 'quiz_mcq',
+        category: 'Interactive',
+        label: 'MCQ / quiz',
+        summary: 'Multiple choice, true/false, or ordering.',
+        configurationMd: `### Side panel (\`QuizBlockEditor\`)
+- \`settings.quizType\`: \`mcq\` | \`true_false\` | \`ordering\`
+- \`data.content\`: question stem (HTML/text)
+- \`settings.answers\`: array \`{ id, text, isCorrect }\` (MCQ, max 10 answers)
+- \`settings.orderingItems\`: array \`{ id, text, order }\` (ordering mode)
+- \`settings.shuffleAnswers\`: shuffle options
+- \`settings.correctAnswer\`: boolean (T/F mode)
+- \`settings.pointsPerCorrect\`, \`settings.partialScoring\`
+- \`data.attempts\`: max attempts
+- \`data.feedback\`: correct/incorrect messages, \`showExplanation\`, \`explanation\`
+
+### Canvas panel (extended MCQ)
+- \`settings.optionA\` … \`optionD\`: answer texts
+- \`settings.correctAnswer\`: \`A\` | \`B\` | \`C\` | \`D\`
+- \`settings.branchingMode\`: \`none\` | \`correct_incorrect\` | \`per_answer\` (graph branching)
+- \`settings.feedback\`: message after answer`,
+    },
+    {
+        id: 'quiz_open',
+        category: 'Interactive',
+        label: 'Open question',
+        summary: 'Free-text answer.',
+        configurationMd: `### Role
+Learner enters a long answer; manual or AI grading per product settings.
+
+### data
+\`content\`: prompt. \`settings\`: criteria, max length, rubric when present in UI.`,
+    },
+    {
+        id: 'phrase_reveal',
+        category: 'Interactive',
+        label: 'Phrase reveal',
+        summary: 'Words or chunks revealed progressively.',
+        configurationMd: `### settings / content
+Base text, splitting, animation — \`PhraseRevealBlockEditor\`.`,
+    },
+    {
+        id: 'self_assessment',
+        category: 'Interactive',
+        label: 'Self-assessment',
+        summary: 'Self-rated criteria grid.',
+        configurationMd: `### settings.criteria
+Array \`EduFlowSelfAssessmentCriterion\`: \`id\`, \`label\`, \`description\`, \`badgeOptions\` (if empty → free text per criterion).
+
+### Global response type
+\`settings.responseType\`: \`numeric\` | \`stars\` | \`text\` (see \`eduflow.ts\`).`,
+    },
+    {
+        id: 'voice_assessment',
+        category: 'Interactive',
+        label: 'Voice assessment',
+        summary: 'Pronunciation / recitation vs a reference.',
+        configurationMd: `### settings
+- \`referenceText\`: text to recite
+- \`minScore\`: minimum score (0–100%, default 70)`,
+    },
+    {
+        id: 'evaluation',
+        category: 'Interactive',
+        label: 'Evaluation / grading',
+        summary: 'Structured grading rubric.',
+        configurationMd: `### data.scoring
+\`maxPoints\`, \`passingScore\`, \`scoringMethod\`, \`rubric\` (criteria, levels, points).
+
+### settings
+Extra fields in \`EvaluationBlockEditor\` (scales, competencies).`,
+    },
+    {
+        id: 'poll',
+        category: 'Interactive',
+        label: 'Poll',
+        summary: 'Ungraded vote or opinion.',
+        configurationMd: `### settings
+- \`pollQuestion\`: question
+- \`pollOptions\`: multiline text, **one option per line**
+- \`showLiveResults\`: live results`,
+    },
+    {
+        id: 'dys_reader',
+        category: 'Accessibility',
+        label: 'DYS reader',
+        summary: 'Text with reading aids (syllables, TTS).',
+        configurationMd: `### settings
+- \`dysText\`: HTML shown
+- \`ttsEnabled\`: auto audio playback`,
+    },
+    {
+        id: 'dys_reading_practice',
+        category: 'Accessibility',
+        label: 'DYS reading practice',
+        summary: 'Guided reading exercise.',
+        configurationMd: `### settings
+Same as dys_reader: \`dysText\`, \`ttsEnabled\`.`,
+    },
+    {
+        id: 'dys_image_zones',
+        category: 'Accessibility',
+        label: 'DYS image zones',
+        summary: 'Clickable zones on an image for reading support.',
+        configurationMd: `### settings
+Zone definitions (coordinates, labels, audio) per DYS UI; often JSON in \`settings\`.`,
+    },
+    {
+        id: 'dys_clock',
+        category: 'Accessibility',
+        label: 'DYS teaching clock',
+        summary: 'Adapted time representation.',
+        configurationMd: `### settings
+Display format, speed, visual aids (see DYS editor).`,
+    },
+    {
+        id: 'glossary',
+        category: 'Accessibility',
+        label: 'Glossary',
+        summary: 'Terms and definitions in the path.',
+        configurationMd: `### settings.termsJson
+JSON string: array \`{ term, definition, quiz?: boolean }\`.`,
+    },
+    {
+        id: 'html',
+        category: 'Enterprise',
+        label: 'Embedded HTML / JS',
+        summary: 'Controlled HTML or script snippet.',
+        configurationMd: `### settings.htmlCode
+HTML (and possibly inline JS per security policy). Use with care (XSS).`,
+    },
+    {
+        id: 'certification',
+        category: 'Enterprise',
+        label: 'Certification (document)',
+        summary: 'Generate a certificate from a Word template.',
+        configurationMd: `### settings
+- \`templateUrl\`: URL of the .docx template
+- \`variablesJson\`: JSON mapping placeholders → learner fields (\`"{{NAME}}": "learner.lastName"\`, etc.)`,
+    },
+    {
+        id: 'signature',
+        category: 'Enterprise',
+        label: 'Signature',
+        summary: 'Handwritten or electronic signature.',
+        configurationMd: `### settings
+Signature canvas config, legal wording, consent text — per block editor.`,
+    },
+    {
+        id: 'facial_recognition',
+        category: 'Enterprise',
+        label: 'Facial recognition',
+        summary: 'Face-based identity check.',
+        configurationMd: `### settings
+Confidence threshold, GDPR consent, error messages — per implementation and AWS Rekognition on the backend.`,
+    },
+];
+const byId = new Map(EDUFLOW_BLOCK_DOCS.map((e) => [e.id, e]));
+export function renderEduflowBlockMarkdown(typeId) {
+    const e = byId.get(typeId);
+    if (!e) {
+        return `# Unknown block (\`${typeId}\`)\n\nNo dedicated sheet. See \`lyrra_eduflow_blocks_index\` and \`BlockType\` in the frontend.\n\n${EDUFLOW_BLOCK_COMMON}`;
+    }
+    return `# ${e.label} — type \`${e.id}\`
+
+**Category:** ${e.category}
+
+${e.configurationMd}
+
+---
+
+${EDUFLOW_BLOCK_COMMON}`;
+}
+export function eduflowBlockToolName(typeId) {
+    return `lyrra_eduflow_block_${typeId.replace(/[^a-zA-Z0-9_]/g, '_')}`;
+}

package/dist/index.js

@@ -1,21 +1,188 @@
 #!/usr/bin/env node
+/**
+ * Lyrra Studio MCP stdio server.
+ * Run: `npm run build && npm start` in apps/mcp-server (or `npm run dev`).
+ */
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { config } from './config.js';
-import { createMcpServer } from './server-factory.js';
-// --- Start server (stdio mode) ---
+import { z } from 'zod';
+import { getLyrraRequestAuthHeaders, requestOrigin } from './auth-session.js';
+import { callLyrraOperation } from './lyrra-http.js';
+import { fetchOpenApiJson, parseOpenApiOperations } from './openapi-parse.js';
+import { eduflowBlockDocToolCount, registerEduflowBlockDocumentationTools, } from './register-eduflow-block-tools.js';
+const MAX_DESC_CHARS = 12_000;
+const MAX_TOOLS_ENV = process.env.LYRRA_MCP_MAX_TOOLS;
+function truncateDesc(s) {
+    if (s.length <= MAX_DESC_CHARS)
+        return s;
+    return `${s.slice(0, MAX_DESC_CHARS)}\n\n[… truncated description — see OpenAPI / Swagger]`;
+}
+function zodShapeForOperation(op) {
+    const shape = {
+        query: z
+            .record(z.string(), z.unknown())
+            .optional()
+            .describe('Query parameters (key → value). Serialize complex values as JSON in a key if needed.'),
+        body: z
+            .unknown()
+            .optional()
+            .describe('JSON body (object or array) for POST, PUT, PATCH. Ignored for GET/DELETE.'),
+    };
+    for (const p of op.pathParamNames) {
+        shape[p] = z
+            .string()
+            .describe(`Value for path segment "${p}" in ${op.path}`);
+    }
+    return shape;
+}
+function formatToolResult(result) {
+    const snippet = result.bodyText.length > 120_000 ? `${result.bodyText.slice(0, 120_000)}\n… [truncated]` : result.bodyText;
+    const text = [
+        `HTTP ${result.status}`,
+        result.headers['content-type'] ? `Content-Type: ${result.headers['content-type']}` : '',
+        '',
+        snippet || '(empty body)',
+    ]
+        .filter(Boolean)
+        .join('\n');
+    return {
+        content: [{ type: 'text', text }],
+        isError: result.status >= 400,
+    };
+}
 async function main() {
-    if (!config.clientSecret) {
-        console.error('⚠️  LYRRA_CLIENT_SECRET non défini. Définissez la variable d\'environnement LYRRA_CLIENT_SECRET.');
+    process.stderr.write('[lyrra-mcp] Loading OpenAPI…\n');
+    const spec = await fetchOpenApiJson();
+    let ops = parseOpenApiOperations(spec);
+    const maxTools = MAX_TOOLS_ENV ? parseInt(MAX_TOOLS_ENV, 10) : NaN;
+    if (!Number.isNaN(maxTools) && maxTools > 0) {
+        ops = ops.slice(0, maxTools);
+        process.stderr.write(`[lyrra-mcp] LYRRA_MCP_MAX_TOOLS=${maxTools} — ${ops.length} tools registered.\n`);
+    }
+    process.stderr.write(`[lyrra-mcp] ${ops.length} operations → MCP tools.\n`);
+    const mcp = new McpServer({
+        name: 'lyrra-studio',
+        version: '1.0.0',
+        title: 'Lyrra Studio',
+    });
+    registerEduflowBlockDocumentationTools(mcp);
+    process.stderr.write(`[lyrra-mcp] EduFlow docs: ${eduflowBlockDocToolCount()} tools (index + per-block sheets).\n`);
+    mcp.registerTool('lyrra_meta', {
+        description: 'Configuration summary: API origin, registered tool count, useful environment variables (no secrets shown).',
+        inputSchema: z.object({}),
+    }, async () => {
+        let tokenMode = 'CLIENT_ID+SECRET';
+        if (process.env.LYRRA_ACCESS_TOKEN?.trim())
+            tokenMode = 'ACCESS_TOKEN';
+        const hn = process.env.LYRRA_MCP_HEADER_NAME?.trim() || process.env.LYRRA_HEADER_AUTH_NAME?.trim();
+        const hv = process.env.LYRRA_MCP_HEADER_SECRET?.trim() ||
+            process.env.LYRRA_MCP_HEADER_VALUE?.trim() ||
+            process.env.LYRRA_HEADER_AUTH_VALUE?.trim();
+        if (hn && hv)
+            tokenMode = 'HEADER_AUTH';
+        const text = [
+            `Request origin: ${requestOrigin()}`,
+            `OpenAPI tools registered: ${ops.length}`,
+            `EduFlow block doc tools: ${eduflowBlockDocToolCount()} (lyrra_eduflow_blocks_index + lyrra_eduflow_block_*)`,
+            `Token mode: ${tokenMode}`,
+            `LYRRA_API_URL: ${process.env.LYRRA_API_URL ? 'set' : 'missing'}`,
+            `LYRRA_OPENAPI_URL: ${process.env.LYRRA_OPENAPI_URL ? 'set' : 'default /api/openapi.json'}`,
+        ].join('\n');
+        return { content: [{ type: 'text', text }] };
+    });
+    mcp.registerTool('lyrra_search_operations', {
+        description: 'Search operations (operationId, method, path, start of description). Useful when the tool list is long.',
+        inputSchema: z.object({
+            q: z.string().min(1).describe('Search text (case-insensitive)'),
+            limit: z.number().int().min(1).max(80).optional().describe('Max results (default 30)'),
+        }),
+    }, async ({ q, limit }) => {
+        const lim = limit ?? 30;
+        const qq = q.toLowerCase();
+        const hits = ops
+            .filter((o) => o.operationId.toLowerCase().includes(qq) ||
+            o.path.toLowerCase().includes(qq) ||
+            o.method.toLowerCase().includes(qq) ||
+            o.description.toLowerCase().includes(qq))
+            .slice(0, lim);
+        const text = hits.length === 0
+            ? 'No operations found.'
+            : hits.map((o) => `${o.method} ${o.path}\n  operationId: ${o.operationId}`).join('\n\n');
+        return { content: [{ type: 'text', text }] };
+    });
+    const staticGuide = `# Lyrra Studio — MCP integration
+
+- Each tool named after an OpenAPI **operationId** calls **exactly** the documented endpoint.
+- **EduFlow blocks**: tools \`lyrra_eduflow_blocks_index\` then \`lyrra_eduflow_block_<type>\` (e.g. \`lyrra_eduflow_block_quiz_mcq\`) — full sheet: role, \`data\`, \`settings\`, graph.
+- API args: path segments \`{id}\` → required properties of the same name; \`query\`; \`body\` (JSON).
+- Auth: \`LYRRA_CLIENT_ID\` + \`LYRRA_CLIENT_SECRET\` (\`rak_…\`), or \`LYRRA_ACCESS_TOKEN\` (JWT).
+`;
+    mcp.registerResource('lyrra-mcp-guide', 'lyrra://flow-construction-guide', {
+        description: 'How to use the Lyrra MCP server',
+        mimeType: 'text/markdown',
+    }, async () => ({
+        contents: [{ uri: 'lyrra://flow-construction-guide', mimeType: 'text/markdown', text: staticGuide }],
+    }));
+    mcp.registerResource('lyrra-block-types', 'lyrra://block-types', {
+        description: 'Points to MCP tools lyrra_eduflow_block_* (per-type sheet) + persistence via eduflows API',
+        mimeType: 'text/markdown',
+    }, async () => ({
+        contents: [
+            {
+                uri: 'lyrra://block-types',
+                mimeType: 'text/markdown',
+                text: [
+                    '# EduFlow block types (MCP)',
+                    '',
+                    `1. Call **lyrra_eduflow_blocks_index** for documented types (${eduflowBlockDocToolCount() - 1} blocks).`,
+                    '2. Call **lyrra_eduflow_block_<type>** (e.g. `lyrra_eduflow_block_video`) for the full sheet: pedagogical role, `BlockData`, `settings`, connections.',
+                    '3. HTTP persistence: OpenAPI routes under `/api/eduflows/{id}/blocks` and flow save.',
+                    '',
+                    'Code reference: `apps/frontend/src/types/eduflow.ts`, palette `eduflow-designer-palette-blueprint.ts`.',
+                ].join('\n'),
+            },
+        ],
+    }));
+    for (const op of ops) {
+        const inputSchema = z.object(zodShapeForOperation(op));
+        const desc = truncateDesc(`${op.description}\n\n— HTTP ${op.method} \`${op.path}\``);
+        mcp.registerTool(op.operationId, {
+            description: desc,
+            inputSchema,
+        }, async (rawArgs) => {
+            const args = rawArgs;
+            const pathParams = {};
+            for (const name of op.pathParamNames) {
+                const v = args[name];
+                pathParams[name] = typeof v === 'string' ? v : String(v ?? '');
+            }
+            const query = args.query;
+            const body = args.body;
+            try {
+                const result = await callLyrraOperation(op.method, op.path, { pathParams, query, body });
+                return formatToolResult(result);
+            }
+            catch (e) {
+                const msg = e instanceof Error ? e.message : String(e);
+                return {
+                    content: [{ type: 'text', text: `Error: ${msg}` }],
+                    isError: true,
+                };
+            }
+        });
+    }
+    // Resolve credentials early (clear message if .env is incomplete)
+    try {
+        await getLyrraRequestAuthHeaders();
+        process.stderr.write('[lyrra-mcp] API credentials OK.\n');
     }
-    else {
-        console.error('✅ LYRRA Studio MCP connecté (authentification par API Key).');
+    catch (e) {
+        process.stderr.write(`[lyrra-mcp] Auth warning: ${e instanceof Error ? e.message : e}\n`);
     }
-    const server = createMcpServer();
     const transport = new StdioServerTransport();
-    await server.connect(transport);
+    await mcp.connect(transport);
 }
-main().catch((error) => {
-    console.error('Erreur fatale:', error);
+main().catch((e) => {
+    process.stderr.write(`[lyrra-mcp] Fatal: ${e instanceof Error ? e.stack ?? e.message : e}\n`);
     process.exit(1);
 });
-//# sourceMappingURL=index.js.map