@charlie.act7/canvas-mcp-server 1.1.8 → 1.2.1

package/dist/tools/module-tools.js

@@ -63,7 +63,7 @@ export const moduleTools = [
         name: "canvas_update_module",
         tool: {
             name: "canvas_update_module",
-            description: "Update an existing module",
+            description: "Update an existing module (name, published, position, prerequisites, completion requirements)",
             inputSchema: {
                 type: "object",
                 properties: {
@@ -74,7 +74,32 @@ export const moduleTools = [
                     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" }
+                    position: { type: "number", description: "The new position of the module" },
+                    prerequisite_module_ids: {
+                        type: "array",
+                        items: { type: "number" },
+                        description: "IDs of modules that must be completed before this one unlocks"
+                    },
+                    require_sequential_progress: {
+                        type: "boolean",
+                        description: "Whether items in the module must be completed in order"
+                    },
+                    completion_requirements: {
+                        type: "array",
+                        description: "Completion requirements for module items. Replaces ALL existing requirements — include every item that needs one.",
+                        items: {
+                            type: "object",
+                            properties: {
+                                id: { type: "number", description: "The module item ID" },
+                                type: {
+                                    type: "string",
+                                    description: "must_view, must_submit, must_contribute, min_score, must_mark_done"
+                                },
+                                min_score: { type: "number", description: "Required when type is min_score" }
+                            },
+                            required: ["id", "type"]
+                        }
+                    }
                 },
                 required: ["course_id", "module_id"],
             },
@@ -85,13 +110,23 @@ export const moduleTools = [
                 module_id: z.number(),
                 name: z.string().optional(),
                 published: z.boolean().optional(),
-                position: z.number().optional()
+                position: z.number().optional(),
+                prerequisite_module_ids: z.array(z.number()).optional(),
+                require_sequential_progress: z.boolean().optional(),
+                completion_requirements: z.array(z.object({
+                    id: z.number(),
+                    type: z.string(),
+                    min_score: z.number().optional()
+                })).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
+                position: input.position,
+                prerequisite_module_ids: input.prerequisite_module_ids,
+                require_sequential_progress: input.require_sequential_progress,
+                completion_requirements: input.completion_requirements
             });
             return {
                 content: [{ type: "text", text: JSON.stringify(module, null, 2) }],
@@ -206,7 +241,11 @@ export const moduleTools = [
                     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" }
+                    new_module_id: { type: "number", description: "Move the item to a new module" },
+                    completion_requirement_type: {
+                        type: "string",
+                        description: "Completion requirement type: must_view, must_submit, must_contribute, min_score, must_mark_done"
+                    }
                 },
                 required: ["course_id", "module_id", "item_id"],
             },
@@ -220,7 +259,8 @@ export const moduleTools = [
                 position: z.number().optional(),
                 indent: z.number().optional(),
                 published: z.boolean().optional(),
-                new_module_id: z.number().optional()
+                new_module_id: z.number().optional(),
+                completion_requirement_type: z.string().optional()
             }).parse(args);
             const courseId = await resolveCourseId(client, input.course_id);
             const result = await client.updateModuleItem(courseId, input.module_id, input.item_id, {
@@ -228,7 +268,10 @@ export const moduleTools = [
                 position: input.position,
                 indent: input.indent,
                 published: input.published,
-                module_id: input.new_module_id
+                module_id: input.new_module_id,
+                ...(input.completion_requirement_type && {
+                    completion_requirement: { type: input.completion_requirement_type }
+                })
             });
             return {
                 content: [{ type: "text", text: JSON.stringify(result, null, 2) }],

package/dist/tools/new-quiz-tools.js

@@ -0,0 +1,357 @@
+import { resolveCourseId } from "../common/helpers.js";
+import { z } from "zod";
+export const newQuizTools = [
+    {
+        name: "canvas_create_new_quiz",
+        tool: {
+            name: "canvas_create_new_quiz",
+            description: "Create a New Quiz (LTI) in a course. Use this for Canvas's modern quiz engine (not Classic Quizzes).",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    course_id: {
+                        anyOf: [{ type: "number" }, { type: "string" }],
+                        description: "The ID or name of the course"
+                    },
+                    title: { type: "string", description: "Quiz title" },
+                    instructions: { type: "string", description: "HTML instructions shown to students before starting" },
+                    due_at: { type: "string", description: "Due date (ISO 8601)" },
+                    lock_at: { type: "string", description: "Lock date (ISO 8601)" },
+                    unlock_at: { type: "string", description: "Available from date (ISO 8601)" },
+                    points_possible: { type: "number", description: "Total points possible" },
+                    time_limit: { type: "number", description: "Time limit in minutes (null for no limit)" },
+                    allowed_attempts: { type: "number", description: "Number of attempts allowed (-1 for unlimited)" },
+                    shuffle_answers: { type: "boolean", description: "Randomize answer order" },
+                    shuffle_questions: { type: "boolean", description: "Randomize question order" },
+                    one_question_at_a_time: { type: "boolean", description: "Show one question per page" },
+                    cant_go_back: { type: "boolean", description: "Prevent going back to previous questions" },
+                    show_correct_answers: { type: "boolean", description: "Show correct answers after submission" }
+                },
+                required: ["course_id", "title"],
+            },
+        },
+        handler: async (client, args) => {
+            const input = z.object({
+                course_id: z.union([z.number(), z.string()]),
+                title: z.string(),
+                instructions: z.string().optional(),
+                due_at: z.string().optional(),
+                lock_at: z.string().optional(),
+                unlock_at: z.string().optional(),
+                points_possible: z.number().optional(),
+                time_limit: z.number().optional(),
+                allowed_attempts: z.number().optional(),
+                shuffle_answers: z.boolean().optional(),
+                shuffle_questions: z.boolean().optional(),
+                one_question_at_a_time: z.boolean().optional(),
+                cant_go_back: z.boolean().optional(),
+                show_correct_answers: z.boolean().optional()
+            }).parse(args);
+            const courseId = await resolveCourseId(client, input.course_id);
+            const { course_id: _, ...quizData } = input;
+            const result = await client.createNewQuiz(courseId, quizData);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
+    },
+    {
+        name: "canvas_update_new_quiz",
+        tool: {
+            name: "canvas_update_new_quiz",
+            description: "Update an existing New Quiz (LTI)",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    course_id: {
+                        anyOf: [{ type: "number" }, { type: "string" }],
+                        description: "The ID or name of the course"
+                    },
+                    quiz_id: { type: "string", description: "The New Quiz ID (assignment ID)" },
+                    title: { type: "string" },
+                    instructions: { type: "string" },
+                    due_at: { type: "string", description: "ISO 8601 date or null to clear" },
+                    lock_at: { type: "string" },
+                    unlock_at: { type: "string" },
+                    points_possible: { type: "number" },
+                    time_limit: { type: "number", description: "Minutes (null to remove limit)" },
+                    allowed_attempts: { type: "number" },
+                    shuffle_answers: { type: "boolean" },
+                    shuffle_questions: { type: "boolean" },
+                    show_correct_answers: { type: "boolean" }
+                },
+                required: ["course_id", "quiz_id"],
+            },
+        },
+        handler: async (client, args) => {
+            const input = z.object({
+                course_id: z.union([z.number(), z.string()]),
+                quiz_id: z.string(),
+                title: z.string().optional(),
+                instructions: z.string().optional(),
+                due_at: z.string().optional(),
+                lock_at: z.string().optional(),
+                unlock_at: z.string().optional(),
+                points_possible: z.number().optional(),
+                time_limit: z.number().nullable().optional(),
+                allowed_attempts: z.number().optional(),
+                shuffle_answers: z.boolean().optional(),
+                shuffle_questions: z.boolean().optional(),
+                show_correct_answers: z.boolean().optional()
+            }).parse(args);
+            const courseId = await resolveCourseId(client, input.course_id);
+            const { course_id: _, quiz_id, ...updateData } = input;
+            const result = await client.updateNewQuiz(courseId, quiz_id, updateData);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
+    },
+    {
+        name: "canvas_delete_new_quiz",
+        tool: {
+            name: "canvas_delete_new_quiz",
+            description: "Delete a New Quiz (LTI) from a course",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    course_id: {
+                        anyOf: [{ type: "number" }, { type: "string" }],
+                        description: "The ID or name of the course"
+                    },
+                    quiz_id: { type: "string", description: "The New Quiz ID to delete" }
+                },
+                required: ["course_id", "quiz_id"],
+            },
+        },
+        handler: async (client, args) => {
+            const input = z.object({
+                course_id: z.union([z.number(), z.string()]),
+                quiz_id: z.string()
+            }).parse(args);
+            const courseId = await resolveCourseId(client, input.course_id);
+            const result = await client.deleteNewQuiz(courseId, input.quiz_id);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
+    },
+    {
+        name: "canvas_list_new_quiz_items",
+        tool: {
+            name: "canvas_list_new_quiz_items",
+            description: "List all questions/items in a New Quiz (LTI)",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    course_id: {
+                        anyOf: [{ type: "number" }, { type: "string" }],
+                        description: "The ID or name of the course"
+                    },
+                    quiz_id: { type: "string", description: "The New Quiz ID" }
+                },
+                required: ["course_id", "quiz_id"],
+            },
+        },
+        handler: async (client, args) => {
+            const input = z.object({
+                course_id: z.union([z.number(), z.string()]),
+                quiz_id: z.string()
+            }).parse(args);
+            const courseId = await resolveCourseId(client, input.course_id);
+            const result = await client.listNewQuizItems(courseId, input.quiz_id);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
+    },
+    {
+        name: "canvas_get_new_quiz_item",
+        tool: {
+            name: "canvas_get_new_quiz_item",
+            description: "Get details of a specific item/question in a New Quiz (LTI)",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    course_id: {
+                        anyOf: [{ type: "number" }, { type: "string" }],
+                        description: "The ID or name of the course"
+                    },
+                    quiz_id: { type: "string", description: "The New Quiz ID" },
+                    item_id: { type: "string", description: "The item ID" }
+                },
+                required: ["course_id", "quiz_id", "item_id"],
+            },
+        },
+        handler: async (client, args) => {
+            const input = z.object({
+                course_id: z.union([z.number(), z.string()]),
+                quiz_id: z.string(),
+                item_id: z.string()
+            }).parse(args);
+            const courseId = await resolveCourseId(client, input.course_id);
+            const result = await client.getNewQuizItem(courseId, input.quiz_id, input.item_id);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
+    },
+    {
+        name: "canvas_create_new_quiz_item",
+        tool: {
+            name: "canvas_create_new_quiz_item",
+            description: "Add a question/item to a New Quiz (LTI). Supports multiple choice, true/false, essay, fill-in-blank, matching, and more.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    course_id: {
+                        anyOf: [{ type: "number" }, { type: "string" }],
+                        description: "The ID or name of the course"
+                    },
+                    quiz_id: { type: "string", description: "The New Quiz ID" },
+                    points_possible: { type: "number", description: "Points for this item (default: 1)" },
+                    position: { type: "number", description: "Position order in the quiz" },
+                    entry_type: {
+                        type: "string",
+                        description: "Always use 'Item' for a standard question"
+                    },
+                    title: { type: "string", description: "Question title/name" },
+                    item_body: { type: "string", description: "HTML question text shown to students" },
+                    interaction_type_slug: {
+                        type: "string",
+                        description: "Question type: choice (multiple choice), true-false, essay, short-answer, matching, ordering, file-upload, categorization, hot-spot"
+                    },
+                    interaction_data: {
+                        type: "object",
+                        description: "Question-type-specific data (choices, correct answers, etc.)"
+                    },
+                    scoring_data: {
+                        type: "object",
+                        description: "Scoring configuration for the question"
+                    }
+                },
+                required: ["course_id", "quiz_id", "entry_type", "item_body", "interaction_type_slug"],
+            },
+        },
+        handler: async (client, args) => {
+            const input = z.object({
+                course_id: z.union([z.number(), z.string()]),
+                quiz_id: z.string(),
+                points_possible: z.number().optional(),
+                position: z.number().optional(),
+                entry_type: z.string(),
+                title: z.string().optional(),
+                item_body: z.string(),
+                interaction_type_slug: z.string(),
+                interaction_data: z.record(z.any()).optional(),
+                scoring_data: z.record(z.any()).optional()
+            }).parse(args);
+            const courseId = await resolveCourseId(client, input.course_id);
+            const result = await client.createNewQuizItem(courseId, input.quiz_id, {
+                position: input.position,
+                points_possible: input.points_possible,
+                entry_type: input.entry_type,
+                entry: {
+                    title: input.title,
+                    item_body: input.item_body,
+                    interaction_type_slug: input.interaction_type_slug,
+                    interaction_data: input.interaction_data,
+                    scoring_data: input.scoring_data
+                }
+            });
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
+    },
+    {
+        name: "canvas_update_new_quiz_item",
+        tool: {
+            name: "canvas_update_new_quiz_item",
+            description: "Update an existing question/item in a New Quiz (LTI)",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    course_id: {
+                        anyOf: [{ type: "number" }, { type: "string" }],
+                        description: "The ID or name of the course"
+                    },
+                    quiz_id: { type: "string", description: "The New Quiz ID" },
+                    item_id: { type: "string", description: "The item ID to update" },
+                    points_possible: { type: "number" },
+                    position: { type: "number" },
+                    title: { type: "string" },
+                    item_body: { type: "string", description: "HTML question text" },
+                    interaction_data: { type: "object" },
+                    scoring_data: { type: "object" }
+                },
+                required: ["course_id", "quiz_id", "item_id"],
+            },
+        },
+        handler: async (client, args) => {
+            const input = z.object({
+                course_id: z.union([z.number(), z.string()]),
+                quiz_id: z.string(),
+                item_id: z.string(),
+                points_possible: z.number().optional(),
+                position: z.number().optional(),
+                title: z.string().optional(),
+                item_body: z.string().optional(),
+                interaction_data: z.record(z.any()).optional(),
+                scoring_data: z.record(z.any()).optional()
+            }).parse(args);
+            const courseId = await resolveCourseId(client, input.course_id);
+            const updatePayload = {};
+            if (input.points_possible !== undefined)
+                updatePayload.points_possible = input.points_possible;
+            if (input.position !== undefined)
+                updatePayload.position = input.position;
+            if (input.title || input.item_body || input.interaction_data || input.scoring_data) {
+                updatePayload.entry = {};
+                if (input.title)
+                    updatePayload.entry.title = input.title;
+                if (input.item_body)
+                    updatePayload.entry.item_body = input.item_body;
+                if (input.interaction_data)
+                    updatePayload.entry.interaction_data = input.interaction_data;
+                if (input.scoring_data)
+                    updatePayload.entry.scoring_data = input.scoring_data;
+            }
+            const result = await client.updateNewQuizItem(courseId, input.quiz_id, input.item_id, updatePayload);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
+    },
+    {
+        name: "canvas_delete_new_quiz_item",
+        tool: {
+            name: "canvas_delete_new_quiz_item",
+            description: "Delete a question/item from a New Quiz (LTI)",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    course_id: {
+                        anyOf: [{ type: "number" }, { type: "string" }],
+                        description: "The ID or name of the course"
+                    },
+                    quiz_id: { type: "string", description: "The New Quiz ID" },
+                    item_id: { type: "string", description: "The item ID to delete" }
+                },
+                required: ["course_id", "quiz_id", "item_id"],
+            },
+        },
+        handler: async (client, args) => {
+            const input = z.object({
+                course_id: z.union([z.number(), z.string()]),
+                quiz_id: z.string(),
+                item_id: z.string()
+            }).parse(args);
+            const courseId = await resolveCourseId(client, input.course_id);
+            const result = await client.deleteNewQuizItem(courseId, input.quiz_id, input.item_id);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
+    }
+];

package/dist/tools/peer-review-tools.js

@@ -0,0 +1,130 @@
+import { resolveCourseId } from "../common/helpers.js";
+import { z } from "zod";
+export const peerReviewTools = [
+    {
+        name: "canvas_list_peer_reviews",
+        tool: {
+            name: "canvas_list_peer_reviews",
+            description: "List all peer reviews assigned for an assignment",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    course_id: {
+                        anyOf: [{ type: "number" }, { type: "string" }],
+                        description: "The ID or name of the course"
+                    },
+                    assignment_id: { type: "number", description: "The ID of the assignment" }
+                },
+                required: ["course_id", "assignment_id"],
+            },
+        },
+        handler: async (client, args) => {
+            const input = z.object({
+                course_id: z.union([z.number(), z.string()]),
+                assignment_id: z.coerce.number()
+            }).parse(args);
+            const courseId = await resolveCourseId(client, input.course_id);
+            const result = await client.listPeerReviews(courseId, input.assignment_id);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
+    },
+    {
+        name: "canvas_get_submission_peer_reviews",
+        tool: {
+            name: "canvas_get_submission_peer_reviews",
+            description: "List peer reviews assigned to a specific student submission",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    course_id: {
+                        anyOf: [{ type: "number" }, { type: "string" }],
+                        description: "The ID or name of the course"
+                    },
+                    assignment_id: { type: "number", description: "The ID of the assignment" },
+                    student_id: { type: "number", description: "The Canvas user ID of the student whose submission is being reviewed" }
+                },
+                required: ["course_id", "assignment_id", "student_id"],
+            },
+        },
+        handler: async (client, args) => {
+            const input = z.object({
+                course_id: z.union([z.number(), z.string()]),
+                assignment_id: z.coerce.number(),
+                student_id: z.coerce.number()
+            }).parse(args);
+            const courseId = await resolveCourseId(client, input.course_id);
+            const result = await client.getSubmissionPeerReviews(courseId, input.assignment_id, input.student_id);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
+    },
+    {
+        name: "canvas_create_peer_review",
+        tool: {
+            name: "canvas_create_peer_review",
+            description: "Manually assign a peer review: one student reviews another student's submission",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    course_id: {
+                        anyOf: [{ type: "number" }, { type: "string" }],
+                        description: "The ID or name of the course"
+                    },
+                    assignment_id: { type: "number", description: "The ID of the assignment" },
+                    submission_student_id: { type: "number", description: "User ID of the student whose submission will be reviewed" },
+                    reviewer_id: { type: "number", description: "User ID of the student who will perform the review" }
+                },
+                required: ["course_id", "assignment_id", "submission_student_id", "reviewer_id"],
+            },
+        },
+        handler: async (client, args) => {
+            const input = z.object({
+                course_id: z.union([z.number(), z.string()]),
+                assignment_id: z.coerce.number(),
+                submission_student_id: z.coerce.number(),
+                reviewer_id: z.coerce.number()
+            }).parse(args);
+            const courseId = await resolveCourseId(client, input.course_id);
+            const result = await client.createPeerReview(courseId, input.assignment_id, input.submission_student_id, input.reviewer_id);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
+    },
+    {
+        name: "canvas_delete_peer_review",
+        tool: {
+            name: "canvas_delete_peer_review",
+            description: "Remove a peer review assignment",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    course_id: {
+                        anyOf: [{ type: "number" }, { type: "string" }],
+                        description: "The ID or name of the course"
+                    },
+                    assignment_id: { type: "number", description: "The ID of the assignment" },
+                    submission_student_id: { type: "number", description: "User ID of the student whose submission was being reviewed" },
+                    reviewer_id: { type: "number", description: "User ID of the reviewer to remove" }
+                },
+                required: ["course_id", "assignment_id", "submission_student_id", "reviewer_id"],
+            },
+        },
+        handler: async (client, args) => {
+            const input = z.object({
+                course_id: z.union([z.number(), z.string()]),
+                assignment_id: z.coerce.number(),
+                submission_student_id: z.coerce.number(),
+                reviewer_id: z.coerce.number()
+            }).parse(args);
+            const courseId = await resolveCourseId(client, input.course_id);
+            const result = await client.deletePeerReview(courseId, input.assignment_id, input.submission_student_id, input.reviewer_id);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
+    }
+];