@charlie.act7/canvas-mcp-server 1.1.0

package/dist/tools/module-tools.js

@@ -0,0 +1,269 @@
+import { resolveCourseId } from "../common/helpers.js";
+import { z } from "zod";
+export const moduleTools = [
+    {
+        name: "canvas_list_modules",
+        tool: {
+            name: "canvas_list_modules",
+            description: "List modules and their items for a specific course",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    course_id: {
+                        anyOf: [{ type: "number" }, { type: "string" }],
+                        description: "The ID or name of the course"
+                    },
+                },
+                required: ["course_id"],
+            },
+        },
+        handler: async (client, args) => {
+            const input = z.object({ course_id: z.union([z.number(), z.string()]) }).parse(args);
+            const courseId = await resolveCourseId(client, input.course_id);
+            const modules = await client.getModules(courseId);
+            return {
+                content: [{ type: "text", text: JSON.stringify(modules, null, 2) }],
+            };
+        }
+    },
+    {
+        name: "canvas_create_module",
+        tool: {
+            name: "canvas_create_module",
+            description: "Create a new module in a course",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    course_id: {
+                        anyOf: [{ type: "number" }, { type: "string" }],
+                        description: "The ID or name of the course"
+                    },
+                    name: { type: "string", description: "The name of the module" },
+                    published: { type: "boolean", description: "Whether the module is published" },
+                    position: { type: "number", description: "The position of the module" }
+                },
+                required: ["course_id", "name"],
+            },
+        },
+        handler: async (client, args) => {
+            const input = z.object({
+                course_id: z.union([z.number(), z.string()]),
+                name: z.string(),
+                published: z.boolean().optional().default(false),
+                position: z.number().optional()
+            }).parse(args);
+            const courseId = await resolveCourseId(client, input.course_id);
+            const module = await client.createModule(courseId, input.name, input.published, input.position);
+            return {
+                content: [{ type: "text", text: JSON.stringify(module, null, 2) }],
+            };
+        }
+    },
+    {
+        name: "canvas_update_module",
+        tool: {
+            name: "canvas_update_module",
+            description: "Update an existing module",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    course_id: {
+                        anyOf: [{ type: "number" }, { type: "string" }],
+                        description: "The ID or name of the course"
+                    },
+                    module_id: { type: "number", description: "The ID of the module" },
+                    name: { type: "string", description: "The new name of the module" },
+                    published: { type: "boolean", description: "Whether the module is published" },
+                    position: { type: "number", description: "The new position of the module" }
+                },
+                required: ["course_id", "module_id"],
+            },
+        },
+        handler: async (client, args) => {
+            const input = z.object({
+                course_id: z.union([z.number(), z.string()]),
+                module_id: z.number(),
+                name: z.string().optional(),
+                published: z.boolean().optional(),
+                position: z.number().optional()
+            }).parse(args);
+            const courseId = await resolveCourseId(client, input.course_id);
+            const module = await client.updateModule(courseId, input.module_id, {
+                name: input.name,
+                published: input.published,
+                position: input.position
+            });
+            return {
+                content: [{ type: "text", text: JSON.stringify(module, null, 2) }],
+            };
+        }
+    },
+    {
+        name: "canvas_delete_module",
+        tool: {
+            name: "canvas_delete_module",
+            description: "Delete a module from a course",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    course_id: {
+                        anyOf: [{ type: "number" }, { type: "string" }],
+                        description: "The ID or name of the course"
+                    },
+                    module_id: { type: "number", description: "The ID of the module to delete" },
+                },
+                required: ["course_id", "module_id"],
+            },
+        },
+        handler: async (client, args) => {
+            const input = z.object({
+                course_id: z.union([z.number(), z.string()]),
+                module_id: z.number()
+            }).parse(args);
+            const courseId = await resolveCourseId(client, input.course_id);
+            const result = await client.deleteModule(courseId, input.module_id);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
+    },
+    {
+        name: "canvas_create_module_item",
+        tool: {
+            name: "canvas_create_module_item",
+            description: "Create a module item (Assignment, Quiz, File, Page, DiscussionTopic, ExternalUrl, ExternalTool, or SubHeader)",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    course_id: {
+                        anyOf: [{ type: "number" }, { type: "string" }],
+                        description: "The ID or name of the course"
+                    },
+                    module_id: { type: "number", description: "The ID of the module" },
+                    type: {
+                        type: "string",
+                        description: "The type of item (Assignment, Quiz, File, Page, DiscussionTopic, ExternalUrl, ExternalTool, SubHeader)"
+                    },
+                    content_id: {
+                        anyOf: [{ type: "string" }, { type: "number" }],
+                        description: "The ID of the content (not needed for SubHeader, ExternalUrl)"
+                    },
+                    title: { type: "string", description: "The title of the item" },
+                    page_url: { type: "string", description: "The URL of the page (for Page type)" },
+                    external_url: { type: "string", description: "The URL for ExternalUrl or ExternalTool" },
+                    new_tab: { type: "boolean", description: "Whether to open in a new tab" },
+                    indent: { type: "number", description: "The level of indentation (0-3)" },
+                    position: { type: "number", description: "The position in the module" }
+                },
+                required: ["course_id", "module_id", "type"],
+            },
+        },
+        handler: async (client, args) => {
+            const input = z.object({
+                course_id: z.union([z.number(), z.string()]),
+                module_id: z.number(),
+                type: z.enum(['Assignment', 'Quiz', 'File', 'Page', 'DiscussionTopic', 'ExternalUrl', 'ExternalTool', 'SubHeader']),
+                content_id: z.union([z.string(), z.number()]).optional(),
+                title: z.string().optional(),
+                page_url: z.string().optional(),
+                external_url: z.string().optional(),
+                new_tab: z.boolean().optional(),
+                indent: z.number().optional(),
+                position: z.number().optional()
+            }).parse(args);
+            const courseId = await resolveCourseId(client, input.course_id);
+            const item = {
+                type: input.type,
+                title: input.title,
+                content_id: input.content_id,
+                page_url: input.page_url,
+                external_url: input.external_url,
+                new_tab: input.new_tab,
+                indent: input.indent,
+                position: input.position
+            };
+            const result = await client.createModuleItem(courseId, input.module_id, item);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
+    },
+    {
+        name: "canvas_update_module_item",
+        tool: {
+            name: "canvas_update_module_item",
+            description: "Update an existing module item",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    course_id: {
+                        anyOf: [{ type: "number" }, { type: "string" }],
+                        description: "The ID or name of the course"
+                    },
+                    module_id: { type: "number", description: "The ID of the module" },
+                    item_id: { type: "number", description: "The ID of the module item" },
+                    title: { type: "string", description: "The new title of the item" },
+                    position: { type: "number", description: "The new position of the item" },
+                    indent: { type: "number", description: "The new level of indentation (0-3)" },
+                    published: { type: "boolean", description: "Whether the item is published" },
+                    new_module_id: { type: "number", description: "Move the item to a new module" }
+                },
+                required: ["course_id", "module_id", "item_id"],
+            },
+        },
+        handler: async (client, args) => {
+            const input = z.object({
+                course_id: z.union([z.number(), z.string()]),
+                module_id: z.number(),
+                item_id: z.number(),
+                title: z.string().optional(),
+                position: z.number().optional(),
+                indent: z.number().optional(),
+                published: z.boolean().optional(),
+                new_module_id: z.number().optional()
+            }).parse(args);
+            const courseId = await resolveCourseId(client, input.course_id);
+            const result = await client.updateModuleItem(courseId, input.module_id, input.item_id, {
+                title: input.title,
+                position: input.position,
+                indent: input.indent,
+                published: input.published,
+                module_id: input.new_module_id
+            });
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
+    },
+    {
+        name: "canvas_delete_module_item",
+        tool: {
+            name: "canvas_delete_module_item",
+            description: "Delete an item from a module",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    course_id: {
+                        anyOf: [{ type: "number" }, { type: "string" }],
+                        description: "The ID or name of the course"
+                    },
+                    module_id: { type: "number", description: "The ID of the module" },
+                    item_id: { type: "number", description: "The ID of the module item to delete" },
+                },
+                required: ["course_id", "module_id", "item_id"],
+            },
+        },
+        handler: async (client, args) => {
+            const input = z.object({
+                course_id: z.union([z.number(), z.string()]),
+                module_id: z.number(),
+                item_id: z.number()
+            }).parse(args);
+            const courseId = await resolveCourseId(client, input.course_id);
+            const result = await client.deleteModuleItem(courseId, input.module_id, input.item_id);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
+    }
+];

package/dist/tools/question-bank-tools.js

@@ -0,0 +1,238 @@
+import { resolveCourseId } from "../common/helpers.js";
+import { z } from "zod";
+export const questionBankTools = [
+    {
+        name: "canvas_list_question_banks",
+        tool: {
+            name: "canvas_list_question_banks",
+            description: "List question banks for a specific course",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    course_id: {
+                        anyOf: [{ type: "number" }, { type: "string" }],
+                        description: "The ID or name of the course"
+                    }
+                },
+                required: ["course_id"]
+            }
+        },
+        handler: async (client, args) => {
+            const input = z.object({ course_id: z.union([z.number(), z.string()]) }).parse(args);
+            const courseId = await resolveCourseId(client, input.course_id);
+            const banks = await client.listQuestionBanks(courseId);
+            return {
+                content: [{ type: "text", text: JSON.stringify(banks, null, 2) }]
+            };
+        }
+    },
+    {
+        name: "canvas_create_question_bank",
+        tool: {
+            name: "canvas_create_question_bank",
+            description: "Create a new question bank in a course",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    course_id: {
+                        anyOf: [{ type: "number" }, { type: "string" }],
+                        description: "The ID or name of the course"
+                    },
+                    title: {
+                        type: "string",
+                        description: "Title for the question bank"
+                    }
+                },
+                required: ["course_id", "title"]
+            }
+        },
+        handler: async (client, args) => {
+            const input = z.object({
+                course_id: z.union([z.number(), z.string()]),
+                title: z.string().min(1)
+            }).parse(args);
+            const courseId = await resolveCourseId(client, input.course_id);
+            const bank = await client.createQuestionBank(courseId, input.title);
+            return {
+                content: [{ type: "text", text: JSON.stringify(bank, null, 2) }]
+            };
+        }
+    },
+    {
+        name: "canvas_create_assessment_question",
+        tool: {
+            name: "canvas_create_assessment_question",
+            description: "Create a question in a question bank. Supports types: multiple_choice_question, true_false_question, essay_question, short_answer_question, fill_in_multiple_blanks_question, multiple_answers_question, matching_question, numerical_question.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    course_id: {
+                        anyOf: [{ type: "number" }, { type: "string" }],
+                        description: "The ID or name of the course"
+                    },
+                    bank_id: {
+                        type: "number",
+                        description: "The question bank ID"
+                    },
+                    name: {
+                        type: "string",
+                        description: "Short name/title for the question"
+                    },
+                    question_type: {
+                        type: "string",
+                        description: "Question type (e.g. multiple_choice_question, true_false_question, essay_question, short_answer_question)"
+                    },
+                    question_text: {
+                        type: "string",
+                        description: "The question text (HTML supported)"
+                    },
+                    points_possible: {
+                        type: "number",
+                        description: "Point value for the question"
+                    },
+                    answers: {
+                        type: "array",
+                        description: "Array of answer objects. For multiple_choice: weight=100 for correct, weight=0 for incorrect. For true_false: text='True'/'False'.",
+                        items: {
+                            type: "object",
+                            properties: {
+                                text: { type: "string", description: "Answer text" },
+                                weight: { type: "number", description: "100 for correct, 0 for incorrect" },
+                                comments: { type: "string", description: "Optional feedback comment" }
+                            },
+                            required: ["text", "weight"]
+                        }
+                    }
+                },
+                required: ["course_id", "bank_id", "name", "question_type", "question_text", "points_possible"]
+            }
+        },
+        handler: async (client, args) => {
+            const answerSchema = z.object({
+                text: z.string(),
+                weight: z.number(),
+                comments: z.string().optional()
+            });
+            const input = z.object({
+                course_id: z.union([z.number(), z.string()]),
+                bank_id: z.coerce.number(),
+                name: z.string().min(1),
+                question_type: z.string().min(1),
+                question_text: z.string().min(1),
+                points_possible: z.coerce.number(),
+                answers: z.array(answerSchema).optional()
+            }).parse(args);
+            const courseId = await resolveCourseId(client, input.course_id);
+            const question = await client.createAssessmentQuestion(courseId, input.bank_id, {
+                name: input.name,
+                question_type: input.question_type,
+                question_text: input.question_text,
+                points_possible: input.points_possible,
+                answers: input.answers
+            });
+            return {
+                content: [{ type: "text", text: JSON.stringify(question, null, 2) }]
+            };
+        }
+    },
+    {
+        name: "canvas_move_question_bank_questions",
+        tool: {
+            name: "canvas_move_question_bank_questions",
+            description: "Move questions from one question bank to another. If question_ids is omitted, all questions are moved.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    course_id: {
+                        anyOf: [{ type: "number" }, { type: "string" }],
+                        description: "The ID or name of the course"
+                    },
+                    source_bank_id: {
+                        type: "number",
+                        description: "Source question bank ID"
+                    },
+                    dest_bank_id: {
+                        type: "number",
+                        description: "Destination question bank ID"
+                    },
+                    question_ids: {
+                        type: "array",
+                        items: { type: "number" },
+                        description: "Optional list of specific question IDs to move. If omitted, all questions are moved."
+                    }
+                },
+                required: ["course_id", "source_bank_id", "dest_bank_id"]
+            }
+        },
+        handler: async (client, args) => {
+            const input = z.object({
+                course_id: z.union([z.number(), z.string()]),
+                source_bank_id: z.coerce.number(),
+                dest_bank_id: z.coerce.number(),
+                question_ids: z.array(z.coerce.number()).optional()
+            }).parse(args);
+            const courseId = await resolveCourseId(client, input.course_id);
+            const result = await client.moveQuestionBankQuestions(courseId, input.source_bank_id, input.dest_bank_id, input.question_ids);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+            };
+        }
+    },
+    {
+        name: "canvas_create_quiz_group",
+        tool: {
+            name: "canvas_create_quiz_group",
+            description: "Create a quiz group linked to a question bank. The group randomly picks questions from the bank when students take the quiz.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    course_id: {
+                        anyOf: [{ type: "number" }, { type: "string" }],
+                        description: "The ID or name of the course"
+                    },
+                    quiz_id: {
+                        type: "number",
+                        description: "The quiz ID"
+                    },
+                    name: {
+                        type: "string",
+                        description: "Name for the quiz group"
+                    },
+                    pick_count: {
+                        type: "number",
+                        description: "Number of questions to randomly pick from the bank"
+                    },
+                    question_points: {
+                        type: "number",
+                        description: "Points per question in this group"
+                    },
+                    assessment_question_bank_id: {
+                        type: "number",
+                        description: "The question bank ID to link to this group"
+                    }
+                },
+                required: ["course_id", "quiz_id", "name", "pick_count", "question_points"]
+            }
+        },
+        handler: async (client, args) => {
+            const input = z.object({
+                course_id: z.union([z.number(), z.string()]),
+                quiz_id: z.coerce.number(),
+                name: z.string().min(1),
+                pick_count: z.coerce.number().min(1),
+                question_points: z.coerce.number().min(0),
+                assessment_question_bank_id: z.coerce.number().optional()
+            }).parse(args);
+            const courseId = await resolveCourseId(client, input.course_id);
+            const group = await client.createQuizGroup(courseId, input.quiz_id, {
+                name: input.name,
+                pick_count: input.pick_count,
+                question_points: input.question_points,
+                assessment_question_bank_id: input.assessment_question_bank_id
+            });
+            return {
+                content: [{ type: "text", text: JSON.stringify(group, null, 2) }]
+            };
+        }
+    }
+];