@connect-xlab/mcp-server 0.2.1 → 0.3.1

package/dist/tools/listQuizTemplates.js

@@ -0,0 +1,31 @@
+/**
+ * Tool `list_quiz_templates` — modeles de quiz par niche.
+ * Scope : quiz.read.
+ */
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+export const listQuizTemplatesTool = {
+    name: 'list_quiz_templates',
+    description: "Liste les modeles de quiz par niche (key, name, available). Seuls les modeles available=true sont utilisables dans create_quiz.template.",
+    inputSchema: {
+        type: 'object',
+        properties: {
+            lab: { type: 'string', description: 'group_url ou id du Lab' },
+        },
+        required: ['lab'],
+        additionalProperties: false,
+    },
+    zodSchema: z.object({
+        lab: z.string(),
+    }),
+    async handler(args) {
+        const p = this.zodSchema.parse(args);
+        try {
+            const { data } = await http.get(`/mcp/labs/${encodeURIComponent(p.lab)}/quiz/templates`);
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        catch (err) {
+            return { isError: true, content: [{ type: 'text', text: formatApiError(err) }] };
+        }
+    },
+};

package/dist/tools/listQuizzes.js

@@ -0,0 +1,31 @@
+/**
+ * Tool `list_quizzes` — quiz du Lab.
+ * Scope : quiz.read.
+ */
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+export const listQuizzesTool = {
+    name: 'list_quizzes',
+    description: "Liste les quiz du Lab : id, slug, title, status (draft/published), public_key (lien public /quiz/{public_key}), question_count, leads_count.",
+    inputSchema: {
+        type: 'object',
+        properties: {
+            lab: { type: 'string', description: 'group_url ou id du Lab' },
+        },
+        required: ['lab'],
+        additionalProperties: false,
+    },
+    zodSchema: z.object({
+        lab: z.string(),
+    }),
+    async handler(args) {
+        const p = this.zodSchema.parse(args);
+        try {
+            const { data } = await http.get(`/mcp/labs/${encodeURIComponent(p.lab)}/quiz/quizzes`);
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        catch (err) {
+            return { isError: true, content: [{ type: 'text', text: formatApiError(err) }] };
+        }
+    },
+};

package/dist/tools/manageDmEnrollment.js

@@ -0,0 +1,36 @@
+/**
+ * Tool `manage_dm_enrollment` — met en pause / reprend / annule l'inscription d'un membre.
+ * Scope : dm_sequences.write.
+ */
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+export const manageDmEnrollmentTool = {
+    name: 'manage_dm_enrollment',
+    description: "Agit sur l'inscription d'un membre a une sequence : pause, resume ou cancel (arret definitif pour ce membre).",
+    inputSchema: {
+        type: 'object',
+        properties: {
+            lab: { type: 'string', description: 'group_url ou id du Lab' },
+            enrollment_id: { type: 'number', minimum: 1, description: 'id de l\'inscription (list_dm_enrollments)' },
+            action: { type: 'string', enum: ['pause', 'resume', 'cancel'] },
+        },
+        required: ['lab', 'enrollment_id', 'action'],
+        additionalProperties: false,
+    },
+    zodSchema: z.object({
+        lab: z.string(),
+        enrollment_id: z.number().int().positive(),
+        action: z.enum(['pause', 'resume', 'cancel']),
+    }),
+    async handler(args) {
+        const { lab, enrollment_id, ...body } = this.zodSchema.parse(args);
+        const p = { lab, enrollment_id };
+        try {
+            const { data } = await http.post(`/mcp/labs/${encodeURIComponent(p.lab)}/dm-sequences/enrollments/${p.enrollment_id}/status`, body);
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        catch (err) {
+            return { isError: true, content: [{ type: 'text', text: formatApiError(err) }] };
+        }
+    },
+};

package/dist/tools/previewDmSequence.js

@@ -0,0 +1,40 @@
+/**
+ * Tool `preview_dm_sequence` — previsualise les messages d'une sequence.
+ * Scope : dm_sequences.read.
+ */
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+export const previewDmSequenceTool = {
+    name: 'preview_dm_sequence',
+    description: "Rend les messages avec un membre fictif (n'envoie rien) et signale les erreurs de template. steps = [{body_template}].",
+    inputSchema: {
+        type: 'object',
+        properties: {
+            lab: { type: 'string', description: 'group_url ou id du Lab' },
+            sequence_id: { type: 'number', minimum: 1, description: 'id de la sequence (list_dm_sequences)' },
+            steps: { type: 'array', minItems: 1, items: { type: 'object', properties: { body_template: { type: 'string' } }, required: ['body_template'] } },
+            link_url: { type: 'string', maxLength: 500 },
+            first_name: { type: 'string', maxLength: 50 },
+        },
+        required: ['lab', 'sequence_id', 'steps'],
+        additionalProperties: false,
+    },
+    zodSchema: z.object({
+        lab: z.string(),
+        sequence_id: z.number().int().positive(),
+        steps: z.array(z.object({ body_template: z.string() })).min(1),
+        link_url: z.string().max(500).nullable().optional(),
+        first_name: z.string().max(50).nullable().optional(),
+    }),
+    async handler(args) {
+        const { lab, sequence_id, ...body } = this.zodSchema.parse(args);
+        const p = { lab, sequence_id };
+        try {
+            const { data } = await http.post(`/mcp/labs/${encodeURIComponent(p.lab)}/dm-sequences/sequences/${p.sequence_id}/preview`, body);
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        catch (err) {
+            return { isError: true, content: [{ type: 'text', text: formatApiError(err) }] };
+        }
+    },
+};

package/dist/tools/rejectAssistantAction.js

@@ -0,0 +1,33 @@
+/**
+ * Tool `reject_assistant_action` — rejette une proposition de Lou.
+ * Scope : assistant.write.
+ */
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+export const rejectAssistantActionTool = {
+    name: 'reject_assistant_action',
+    description: "Rejette une proposition de Lou (rien n'est envoye).",
+    inputSchema: {
+        type: 'object',
+        properties: {
+            lab: { type: 'string', description: 'group_url ou id du Lab' },
+            uuid: { type: 'string', description: 'uuid de la proposition (list_assistant_actions)' },
+        },
+        required: ['lab', 'uuid'],
+        additionalProperties: false,
+    },
+    zodSchema: z.object({
+        lab: z.string(),
+        uuid: z.string(),
+    }),
+    async handler(args) {
+        const p = this.zodSchema.parse(args);
+        try {
+            const { data } = await http.post(`/mcp/labs/${encodeURIComponent(p.lab)}/assistant/actions/${encodeURIComponent(p.uuid)}/reject`);
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        catch (err) {
+            return { isError: true, content: [{ type: 'text', text: formatApiError(err) }] };
+        }
+    },
+};

package/dist/tools/reorderQuizItems.js

@@ -0,0 +1,36 @@
+/**
+ * Tool `reorder_quiz_items` — reordonne les questions / pages.
+ * Scope : quiz.write.
+ */
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+export const reorderQuizItemsTool = {
+    name: 'reorder_quiz_items',
+    description: "Reordonne les questions et pages du quiz : order = liste complete des item_id dans le nouvel ordre.",
+    inputSchema: {
+        type: 'object',
+        properties: {
+            lab: { type: 'string', description: 'group_url ou id du Lab' },
+            quiz_id: { type: 'number', minimum: 1, description: 'id du quiz (list_quizzes)' },
+            order: { type: 'array', items: { type: 'number' }, minItems: 1 },
+        },
+        required: ['lab', 'quiz_id', 'order'],
+        additionalProperties: false,
+    },
+    zodSchema: z.object({
+        lab: z.string(),
+        quiz_id: z.number().int().positive(),
+        order: z.array(z.number().int().positive()).min(1),
+    }),
+    async handler(args) {
+        const { lab, quiz_id, ...body } = this.zodSchema.parse(args);
+        const p = { lab, quiz_id };
+        try {
+            const { data } = await http.put(`/mcp/labs/${encodeURIComponent(p.lab)}/quiz/quizzes/${p.quiz_id}/items/reorder`, body);
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        catch (err) {
+            return { isError: true, content: [{ type: 'text', text: formatApiError(err) }] };
+        }
+    },
+};

package/dist/tools/requestAssistantPostDraft.js

@@ -0,0 +1,38 @@
+/**
+ * Tool `request_assistant_post_draft` — demande un brouillon de post a Lou.
+ * Scope : assistant.write.
+ */
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+export const requestAssistantPostDraftTool = {
+    name: 'request_assistant_post_draft',
+    description: "Demande a Lou un brouillon de post (kind : announcement, discussion_starter, weekly_recap ; topic optionnel). Le brouillon arrive dans les propositions (list_assistant_actions) : rien n'est publie sans validation.",
+    inputSchema: {
+        type: 'object',
+        properties: {
+            lab: { type: 'string', description: 'group_url ou id du Lab' },
+            kind: { type: 'string', enum: ['announcement', 'discussion_starter', 'weekly_recap'] },
+            topic: { type: 'string', maxLength: 500 },
+            category_id: { type: 'number', minimum: 1 },
+        },
+        required: ['lab', 'kind'],
+        additionalProperties: false,
+    },
+    zodSchema: z.object({
+        lab: z.string(),
+        kind: z.enum(['announcement', 'discussion_starter', 'weekly_recap']),
+        topic: z.string().max(500).nullable().optional(),
+        category_id: z.number().int().min(1).optional(),
+    }),
+    async handler(args) {
+        const { lab, ...body } = this.zodSchema.parse(args);
+        const p = { lab };
+        try {
+            const { data } = await http.post(`/mcp/labs/${encodeURIComponent(p.lab)}/assistant/drafts/post`, body);
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        catch (err) {
+            return { isError: true, content: [{ type: 'text', text: formatApiError(err) }] };
+        }
+    },
+};

package/dist/tools/setDmSequenceStatus.js

@@ -0,0 +1,36 @@
+/**
+ * Tool `set_dm_sequence_status` — publie / met en pause / archive une sequence DM.
+ * Scope : dm_sequences.write.
+ */
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+export const setDmSequenceStatusTool = {
+    name: 'set_dm_sequence_status',
+    description: "Change l'etat d'une sequence : publish (met le brouillon en ligne : les membres concernes commencent a recevoir les DM), pause, archive (definitif). Demander confirmation a l'owner avant publish.",
+    inputSchema: {
+        type: 'object',
+        properties: {
+            lab: { type: 'string', description: 'group_url ou id du Lab' },
+            sequence_id: { type: 'number', minimum: 1, description: 'id de la sequence (list_dm_sequences)' },
+            action: { type: 'string', enum: ['publish', 'pause', 'archive'] },
+        },
+        required: ['lab', 'sequence_id', 'action'],
+        additionalProperties: false,
+    },
+    zodSchema: z.object({
+        lab: z.string(),
+        sequence_id: z.number().int().positive(),
+        action: z.enum(['publish', 'pause', 'archive']),
+    }),
+    async handler(args) {
+        const { lab, sequence_id, ...body } = this.zodSchema.parse(args);
+        const p = { lab, sequence_id };
+        try {
+            const { data } = await http.post(`/mcp/labs/${encodeURIComponent(p.lab)}/dm-sequences/sequences/${p.sequence_id}/status`, body);
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        catch (err) {
+            return { isError: true, content: [{ type: 'text', text: formatApiError(err) }] };
+        }
+    },
+};

package/dist/tools/setQuizPublished.js

@@ -0,0 +1,35 @@
+/**
+ * Tool `set_quiz_published` — publie / depublie un quiz.
+ * Scope : quiz.write.
+ */
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+export const setQuizPublishedTool = {
+    name: 'set_quiz_published',
+    description: "Publie (published=true) ou repasse en brouillon (published=false) un quiz. Publication refusee si : moins de 5 questions, moins de 2 profils, ou un profil qu'aucune reponse notee ne permet d'atteindre. Le plug-in Quiz doit aussi etre active pour que le quiz soit public.",
+    inputSchema: {
+        type: 'object',
+        properties: {
+            lab: { type: 'string', description: 'group_url ou id du Lab' },
+            quiz_id: { type: 'number', minimum: 1, description: 'id du quiz (list_quizzes)' },
+            published: { type: 'boolean' },
+        },
+        required: ['lab', 'quiz_id', 'published'],
+        additionalProperties: false,
+    },
+    zodSchema: z.object({
+        lab: z.string(),
+        quiz_id: z.number().int().positive(),
+        published: z.boolean(),
+    }),
+    async handler(args) {
+        const p = this.zodSchema.parse(args);
+        try {
+            const { data } = await http.post(`/mcp/labs/${encodeURIComponent(p.lab)}/quiz/quizzes/${p.quiz_id}/${p.published ? 'publish' : 'unpublish'}`);
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        catch (err) {
+            return { isError: true, content: [{ type: 'text', text: formatApiError(err) }] };
+        }
+    },
+};

package/dist/tools/updateAssistantProducts.js

@@ -0,0 +1,34 @@
+/**
+ * Tool `update_assistant_products` — configure les produits recommandes par Lou.
+ * Scope : assistant.write.
+ */
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+export const updateAssistantProductsTool = {
+    name: 'update_assistant_products',
+    description: "Configure les produits que Lou peut recommander : products = [{group_shop_id, enabled, pitch_notes?, ideal_for?}] (ids de get_assistant_products).",
+    inputSchema: {
+        type: 'object',
+        properties: {
+            lab: { type: 'string', description: 'group_url ou id du Lab' },
+            products: { type: 'array', maxItems: 100, items: { type: 'object', properties: { group_shop_id: { type: 'number' }, enabled: { type: 'boolean' }, pitch_notes: { type: 'string' }, ideal_for: { type: 'string' } }, required: ['group_shop_id', 'enabled'] } },
+        },
+        required: ['lab', 'products'],
+        additionalProperties: false,
+    },
+    zodSchema: z.object({
+        lab: z.string(),
+        products: z.array(z.object({ group_shop_id: z.number().int().positive(), enabled: z.boolean(), pitch_notes: z.string().max(1000).nullable().optional(), ideal_for: z.string().max(500).nullable().optional() })).max(100),
+    }),
+    async handler(args) {
+        const { lab, ...body } = this.zodSchema.parse(args);
+        const p = { lab };
+        try {
+            const { data } = await http.put(`/mcp/labs/${encodeURIComponent(p.lab)}/assistant/products`, body);
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        catch (err) {
+            return { isError: true, content: [{ type: 'text', text: formatApiError(err) }] };
+        }
+    },
+};

package/dist/tools/updateAssistantSettings.js

@@ -0,0 +1,90 @@
+/**
+ * Tool `update_assistant_settings` — modifie les reglages de Lou.
+ * Scope : assistant.write.
+ */
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+export const updateAssistantSettingsTool = {
+    name: 'update_assistant_settings',
+    description: "Modifie les reglages de Lou (seuls les champs fournis changent). Chaque capacite allow_* a souvent un mode : draft (Lou propose, l'owner valide), assisted (Lou envoie seule les cas surs), autopilot (Lou envoie seule). Activer Lou (enabled=true) exige l'abonnement XLab Agent. Changer un mode remet son compteur de confiance a zero.",
+    inputSchema: {
+        type: 'object',
+        properties: {
+            lab: { type: 'string', description: 'group_url ou id du Lab' },
+            enabled: { type: 'boolean' },
+            language: { type: 'string', maxLength: 8 },
+            tone_preset: { type: 'string', enum: ['friendly', 'professional', 'casual', 'enthusiastic', 'formal'] },
+            tone_instructions: { type: 'string', maxLength: 1000 },
+            allow_comment_replies: { type: 'boolean' },
+            comment_reply_mode: { type: 'string', enum: ['draft', 'assisted', 'autopilot'] },
+            allow_dm_replies: { type: 'boolean' },
+            dm_reply_mode: { type: 'string', enum: ['draft', 'assisted', 'autopilot'] },
+            allow_course_question_replies: { type: 'boolean' },
+            course_question_reply_mode: { type: 'string', enum: ['draft', 'assisted', 'autopilot'] },
+            allow_sales_question_replies: { type: 'boolean' },
+            sales_question_reply_mode: { type: 'string', enum: ['draft', 'assisted', 'autopilot'] },
+            allow_sequence_replies: { type: 'boolean' },
+            sequence_reply_mode: { type: 'string', enum: ['draft', 'assisted', 'autopilot'] },
+            allow_comment_sales_pitch: { type: 'boolean' },
+            comment_sales_pitch_mode: { type: 'string', enum: ['draft', 'assisted', 'autopilot'] },
+            allow_course_sales_pitch: { type: 'boolean' },
+            course_sales_pitch_mode: { type: 'string', enum: ['draft', 'assisted', 'autopilot'] },
+            allow_post_drafts: { type: 'boolean' },
+            allow_sales_dms: { type: 'boolean' },
+            allow_milestone_offers: { type: 'boolean' },
+            allow_product_suggestions: { type: 'boolean' },
+            weekly_recap_enabled: { type: 'boolean' },
+            morning_brief_enabled: { type: 'boolean' },
+            morning_brief_hour: { type: 'number', minimum: 0, maximum: 23 },
+            allow_freeform_commands: { type: 'boolean' },
+            sales_dm_cooldown_days: { type: 'number', minimum: 1, maximum: 365 },
+            sales_dm_daily_cap: { type: 'number', minimum: 1, maximum: 100 },
+            daily_proposal_cap: { type: 'number', minimum: 1, maximum: 200 },
+        },
+        required: ['lab'],
+        additionalProperties: false,
+    },
+    zodSchema: z.object({
+        lab: z.string(),
+        enabled: z.boolean().optional(),
+        language: z.string().max(8).nullable().optional(),
+        tone_preset: z.enum(['friendly', 'professional', 'casual', 'enthusiastic', 'formal']).optional(),
+        tone_instructions: z.string().max(1000).nullable().optional(),
+        allow_comment_replies: z.boolean().optional(),
+        comment_reply_mode: z.enum(['draft', 'assisted', 'autopilot']).optional(),
+        allow_dm_replies: z.boolean().optional(),
+        dm_reply_mode: z.enum(['draft', 'assisted', 'autopilot']).optional(),
+        allow_course_question_replies: z.boolean().optional(),
+        course_question_reply_mode: z.enum(['draft', 'assisted', 'autopilot']).optional(),
+        allow_sales_question_replies: z.boolean().optional(),
+        sales_question_reply_mode: z.enum(['draft', 'assisted', 'autopilot']).optional(),
+        allow_sequence_replies: z.boolean().optional(),
+        sequence_reply_mode: z.enum(['draft', 'assisted', 'autopilot']).optional(),
+        allow_comment_sales_pitch: z.boolean().optional(),
+        comment_sales_pitch_mode: z.enum(['draft', 'assisted', 'autopilot']).optional(),
+        allow_course_sales_pitch: z.boolean().optional(),
+        course_sales_pitch_mode: z.enum(['draft', 'assisted', 'autopilot']).optional(),
+        allow_post_drafts: z.boolean().optional(),
+        allow_sales_dms: z.boolean().optional(),
+        allow_milestone_offers: z.boolean().optional(),
+        allow_product_suggestions: z.boolean().optional(),
+        weekly_recap_enabled: z.boolean().optional(),
+        morning_brief_enabled: z.boolean().optional(),
+        morning_brief_hour: z.number().int().min(0).max(23).optional(),
+        allow_freeform_commands: z.boolean().optional(),
+        sales_dm_cooldown_days: z.number().int().min(1).max(365).optional(),
+        sales_dm_daily_cap: z.number().int().min(1).max(100).optional(),
+        daily_proposal_cap: z.number().int().min(1).max(200).optional(),
+    }),
+    async handler(args) {
+        const { lab, ...body } = this.zodSchema.parse(args);
+        const p = { lab };
+        try {
+            const { data } = await http.put(`/mcp/labs/${encodeURIComponent(p.lab)}/assistant/settings`, body);
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        catch (err) {
+            return { isError: true, content: [{ type: 'text', text: formatApiError(err) }] };
+        }
+    },
+};

package/dist/tools/updateDmSequence.js

@@ -0,0 +1,44 @@
+/**
+ * Tool `update_dm_sequence` — modifie le brouillon d'une sequence DM.
+ * Scope : dm_sequences.write.
+ */
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+export const updateDmSequenceTool = {
+    name: 'update_dm_sequence',
+    description: "Modifie le BROUILLON d'une sequence (la version en ligne ne change qu'a la publication). trigger (keyword : post_ids de list_dm_sequence_target_posts + keywords, max 10) ; goal (objectif qui arrete la sequence : reply, first_comment, lesson_completed + module_id, none ; window_days 1-90) ; config (link_url, group_shop_id) ; steps remplace toute la liste (max 8 messages : delay_seconds depuis le message precedent + body_template). Variables utilisables dans body_template : {{prenom}}, {{lab}}, {{lien}} (config.link_url), {{app}} (lien d'installation de l'app mobile, aux couleurs du Lab). revision facultative.",
+    inputSchema: {
+        type: 'object',
+        properties: {
+            lab: { type: 'string', description: 'group_url ou id du Lab' },
+            sequence_id: { type: 'number', minimum: 1, description: 'id de la sequence (list_dm_sequences)' },
+            trigger: { type: 'object', properties: { post_ids: { type: 'array', items: { type: 'number' } }, keywords: { type: 'array', items: { type: 'string' }, maxItems: 10 } } },
+            goal: { type: 'object', properties: { type: { type: 'string', enum: ['reply', 'first_comment', 'lesson_completed', 'none'] }, window_days: { type: 'number', minimum: 1, maximum: 90 }, module_id: { type: 'number' } } },
+            config: { type: 'object', properties: { link_url: { type: 'string' }, group_shop_id: { type: 'number' } } },
+            steps: { type: 'array', maxItems: 8, items: { type: 'object', properties: { delay_seconds: { type: 'number', minimum: 0 }, body_template: { type: 'string' } }, required: ['delay_seconds', 'body_template'] } },
+            revision: { type: 'number', minimum: 1 },
+        },
+        required: ['lab', 'sequence_id'],
+        additionalProperties: false,
+    },
+    zodSchema: z.object({
+        lab: z.string(),
+        sequence_id: z.number().int().positive(),
+        trigger: z.object({ post_ids: z.array(z.number().int()).optional(), keywords: z.array(z.string().max(60)).max(10).optional() }).optional(),
+        goal: z.object({ type: z.enum(['reply', 'first_comment', 'lesson_completed', 'none']).optional(), window_days: z.number().int().min(1).max(90).optional(), module_id: z.number().int().nullable().optional() }).optional(),
+        config: z.object({ link_url: z.string().max(500).nullable().optional(), group_shop_id: z.number().int().nullable().optional() }).optional(),
+        steps: z.array(z.object({ delay_seconds: z.number().int().min(0), body_template: z.string() })).max(8).optional(),
+        revision: z.number().int().min(1).optional(),
+    }),
+    async handler(args) {
+        const { lab, sequence_id, ...body } = this.zodSchema.parse(args);
+        const p = { lab, sequence_id };
+        try {
+            const { data } = await http.put(`/mcp/labs/${encodeURIComponent(p.lab)}/dm-sequences/sequences/${p.sequence_id}`, body);
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        catch (err) {
+            return { isError: true, content: [{ type: 'text', text: formatApiError(err) }] };
+        }
+    },
+};

package/dist/tools/updateDmSequenceSettings.js

@@ -0,0 +1,44 @@
+/**
+ * Tool `update_dm_sequence_settings` — modifie les reglages Sequences DM.
+ * Scope : dm_sequences.write.
+ */
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+export const updateDmSequenceSettingsTool = {
+    name: 'update_dm_sequence_settings',
+    description: "Modifie les reglages Sequences DM (seuls les champs fournis changent). revision est facultative (la revision courante est utilisee par defaut). Desactiver le plug-in met en pause toutes les inscriptions en cours.",
+    inputSchema: {
+        type: 'object',
+        properties: {
+            lab: { type: 'string', description: 'group_url ou id du Lab' },
+            enabled: { type: 'boolean' },
+            timezone: { type: 'string', maxLength: 64, description: 'ex Europe/Paris' },
+            window_start: { type: 'string', maxLength: 5, description: 'HH:MM' },
+            window_end: { type: 'string', maxLength: 5, description: 'HH:MM, apres window_start' },
+            member_daily_cap: { type: 'number', minimum: 1, maximum: 20 },
+            revision: { type: 'number', minimum: 1 },
+        },
+        required: ['lab'],
+        additionalProperties: false,
+    },
+    zodSchema: z.object({
+        lab: z.string(),
+        enabled: z.boolean().optional(),
+        timezone: z.string().max(64).nullable().optional(),
+        window_start: z.string().max(5).nullable().optional(),
+        window_end: z.string().max(5).nullable().optional(),
+        member_daily_cap: z.number().int().min(1).max(20).optional(),
+        revision: z.number().int().min(1).optional(),
+    }),
+    async handler(args) {
+        const { lab, ...body } = this.zodSchema.parse(args);
+        const p = { lab };
+        try {
+            const { data } = await http.put(`/mcp/labs/${encodeURIComponent(p.lab)}/dm-sequences/settings`, body);
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        catch (err) {
+            return { isError: true, content: [{ type: 'text', text: formatApiError(err) }] };
+        }
+    },
+};

package/dist/tools/updateLinkInBioBlock.js

@@ -1,21 +1,24 @@
 /**
  * Tool `update_link_in_bio_block` — modifie un bloc existant. Tous les champs
- * sont optionnels : seuls ceux fournis sont modifies.
+ * sont optionnels : seuls ceux fournis sont modifies (l'API complete le reste
+ * avec les valeurs actuelles du bloc).
  */
 import { z } from 'zod';
 import { http, formatApiError } from '../http.js';
 export const updateLinkInBioBlockTool = {
     name: 'update_link_in_bio_block',
-    description: "Modifie un bloc existant (identifie par block_id, entier renvoye par get_link_in_bio ou create_link_in_bio_block). Champs modifiables : title, subtitle, action_url, image_url, is_active (afficher/masquer sans supprimer).",
+    description: "Modifie un bloc existant (identifie par block_id, entier renvoye par get_link_in_bio ou create_link_in_bio_block). Seuls les champs fournis changent : title, subtitle, url (bloc externe), image_url, quiz_id (bloc quiz), lab_group_id (bloc Lab), is_active (afficher/masquer sans supprimer). Le type (kind) d'un bloc ne change pas.",
     inputSchema: {
         type: 'object',
         properties: {
             lab: { type: 'string' },
             block_id: { type: 'number', minimum: 1 },
-            title: { type: 'string', maxLength: 60 },
-            subtitle: { type: 'string', maxLength: 120 },
-            action_url: { type: 'string' },
+            title: { type: 'string', maxLength: 200 },
+            subtitle: { type: 'string', maxLength: 300 },
+            url: { type: 'string' },
             image_url: { type: 'string' },
+            quiz_id: { type: 'number', minimum: 1 },
+            lab_group_id: { type: 'number', minimum: 1 },
             is_active: { type: 'boolean' },
         },
         required: ['lab', 'block_id'],
@@ -24,10 +27,12 @@ export const updateLinkInBioBlockTool = {
     zodSchema: z.object({
         lab: z.string(),
         block_id: z.number().int().positive(),
-        title: z.string().max(60).optional(),
-        subtitle: z.string().max(120).optional(),
-        action_url: z.string().optional(),
+        title: z.string().max(200).optional(),
+        subtitle: z.string().max(300).optional(),
+        url: z.string().optional(),
         image_url: z.string().optional(),
+        quiz_id: z.number().int().positive().optional(),
+        lab_group_id: z.number().int().positive().optional(),
         is_active: z.boolean().optional(),
     }),
     async handler(args) {

package/dist/tools/updateQuiz.js

@@ -0,0 +1,56 @@
+/**
+ * Tool `update_quiz` — modifie l'accueil / l'apparence / la capture d'un quiz.
+ * Scope : quiz.write.
+ */
+import { z } from 'zod';
+import { http, formatApiError } from '../http.js';
+export const updateQuizTool = {
+    name: 'update_quiz',
+    description: "Modifie un quiz (seuls les champs fournis changent) : accueil (title, subtitle, cta_label), capture (capture_phone = demander le WhatsApp, capture_promise = promesse affichee au moment de laisser ses coordonnees, footer_note), apparence (color hex, show_progress, background_type text|image, logo_path, background_path).",
+    inputSchema: {
+        type: 'object',
+        properties: {
+            lab: { type: 'string', description: 'group_url ou id du Lab' },
+            quiz_id: { type: 'number', minimum: 1, description: 'id du quiz (list_quizzes)' },
+            title: { type: 'string', maxLength: 255 },
+            subtitle: { type: 'string' },
+            cta_label: { type: 'string', maxLength: 120 },
+            capture_phone: { type: 'boolean' },
+            capture_promise: { type: 'string' },
+            footer_note: { type: 'string', maxLength: 255 },
+            color: { type: 'string', maxLength: 16, description: 'couleur hex, ex #5A6BE3' },
+            show_progress: { type: 'boolean' },
+            background_type: { type: 'string', enum: ['text', 'image'] },
+            logo_path: { type: 'string', maxLength: 255 },
+            background_path: { type: 'string', maxLength: 255 },
+        },
+        required: ['lab', 'quiz_id'],
+        additionalProperties: false,
+    },
+    zodSchema: z.object({
+        lab: z.string(),
+        quiz_id: z.number().int().positive(),
+        title: z.string().max(255).nullable().optional(),
+        subtitle: z.string().nullable().optional(),
+        cta_label: z.string().max(120).nullable().optional(),
+        capture_phone: z.boolean().optional(),
+        capture_promise: z.string().nullable().optional(),
+        footer_note: z.string().max(255).nullable().optional(),
+        color: z.string().max(16).nullable().optional(),
+        show_progress: z.boolean().optional(),
+        background_type: z.enum(['text', 'image']).optional(),
+        logo_path: z.string().max(255).nullable().optional(),
+        background_path: z.string().max(255).nullable().optional(),
+    }),
+    async handler(args) {
+        const { lab, quiz_id, ...body } = this.zodSchema.parse(args);
+        const p = { lab, quiz_id };
+        try {
+            const { data } = await http.put(`/mcp/labs/${encodeURIComponent(p.lab)}/quiz/quizzes/${p.quiz_id}`, body);
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        catch (err) {
+            return { isError: true, content: [{ type: 'text', text: formatApiError(err) }] };
+        }
+    },
+};