@charlie.act7/canvas-mcp-server 1.1.0

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

@@ -0,0 +1,303 @@
+import { resolveCourseId } from "../common/helpers.js";
+import { z } from "zod";
+export const quizQuestionTools = [
+    {
+        name: "canvas_list_quiz_questions",
+        tool: {
+            name: "canvas_list_quiz_questions",
+            description: "List all questions in a 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"
+                    }
+                },
+                required: ["course_id", "quiz_id"]
+            }
+        },
+        handler: async (client, args) => {
+            const input = z.object({
+                course_id: z.union([z.number(), z.string()]),
+                quiz_id: z.coerce.number()
+            }).parse(args);
+            const courseId = await resolveCourseId(client, input.course_id);
+            const questions = await client.listQuizQuestions(courseId, input.quiz_id);
+            return {
+                content: [{ type: "text", text: JSON.stringify(questions, null, 2) }]
+            };
+        }
+    },
+    {
+        name: "canvas_create_quiz_question",
+        tool: {
+            name: "canvas_create_quiz_question",
+            description: "Create a question in a quiz. 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. Use quiz_group_id to assign the question to a group for random selection.",
+            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"
+                    },
+                    question_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)"
+                    },
+                    question_text: {
+                        type: "string",
+                        description: "The question text (HTML supported)"
+                    },
+                    points_possible: {
+                        type: "number",
+                        description: "Point value for the question"
+                    },
+                    quiz_group_id: {
+                        type: "number",
+                        description: "Optional quiz group ID to assign this question to (for random picking)"
+                    },
+                    answers: {
+                        type: "array",
+                        description: "Array of answer objects. For multiple_choice: weight=100 for correct, weight=0 for incorrect.",
+                        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", "quiz_id", "question_name", "question_type", "question_text", "points_possible"]
+            }
+        },
+        handler: async (client, args) => {
+            const answerSchema = z.object({
+                text: z.string(),
+                blank_id: z.string().optional(),
+                weight: z.number(),
+                comments: z.string().optional()
+            });
+            const input = z.object({
+                course_id: z.union([z.number(), z.string()]),
+                quiz_id: z.coerce.number(),
+                question_name: z.string().min(1),
+                question_type: z.string().min(1),
+                question_text: z.string().min(1),
+                points_possible: z.coerce.number(),
+                quiz_group_id: z.coerce.number().optional(),
+                answers: z.array(answerSchema).optional()
+            }).parse(args);
+            const courseId = await resolveCourseId(client, input.course_id);
+            const question = await client.createQuizQuestion(courseId, input.quiz_id, {
+                question_name: input.question_name,
+                question_type: input.question_type,
+                question_text: input.question_text,
+                points_possible: input.points_possible,
+                quiz_group_id: input.quiz_group_id,
+                answers: input.answers
+            });
+            return {
+                content: [{ type: "text", text: JSON.stringify(question, null, 2) }]
+            };
+        }
+    },
+    {
+        name: "canvas_update_quiz_question",
+        tool: {
+            name: "canvas_update_quiz_question",
+            description: "Update an existing question in a 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"
+                    },
+                    question_id: {
+                        type: "number",
+                        description: "The question ID to update"
+                    },
+                    question_name: {
+                        type: "string",
+                        description: "New name/title for the question"
+                    },
+                    question_type: {
+                        type: "string",
+                        description: "New question type"
+                    },
+                    question_text: {
+                        type: "string",
+                        description: "New question text (HTML supported)"
+                    },
+                    points_possible: {
+                        type: "number",
+                        description: "New point value"
+                    },
+                    quiz_group_id: {
+                        anyOf: [{ type: "number" }, { type: "null" }],
+                        description: "Quiz group ID to assign to, or null to remove from group"
+                    },
+                    answers: {
+                        type: "array",
+                        description: "New answers array (replaces existing answers)",
+                        items: {
+                            type: "object",
+                            properties: {
+                                text: { type: "string" },
+                                weight: { type: "number" },
+                                comments: { type: "string" }
+                            },
+                            required: ["text", "weight"]
+                        }
+                    }
+                },
+                required: ["course_id", "quiz_id", "question_id"]
+            }
+        },
+        handler: async (client, args) => {
+            const answerSchema = z.object({
+                text: z.string(),
+                blank_id: z.string().optional(),
+                weight: z.number(),
+                comments: z.string().optional()
+            });
+            const input = z.object({
+                course_id: z.union([z.number(), z.string()]),
+                quiz_id: z.coerce.number(),
+                question_id: z.coerce.number(),
+                question_name: z.string().min(1).optional(),
+                question_type: z.string().min(1).optional(),
+                question_text: z.string().min(1).optional(),
+                points_possible: z.coerce.number().optional(),
+                quiz_group_id: z.coerce.number().nullable().optional(),
+                answers: z.array(answerSchema).optional()
+            }).parse(args);
+            const courseId = await resolveCourseId(client, input.course_id);
+            const data = {};
+            if (input.question_name !== undefined)
+                data.question_name = input.question_name;
+            if (input.question_type !== undefined)
+                data.question_type = input.question_type;
+            if (input.question_text !== undefined)
+                data.question_text = input.question_text;
+            if (input.points_possible !== undefined)
+                data.points_possible = input.points_possible;
+            if (input.quiz_group_id !== undefined)
+                data.quiz_group_id = input.quiz_group_id;
+            if (input.answers !== undefined)
+                data.answers = input.answers;
+            const question = await client.updateQuizQuestion(courseId, input.quiz_id, input.question_id, data);
+            return {
+                content: [{ type: "text", text: JSON.stringify(question, null, 2) }]
+            };
+        }
+    },
+    {
+        name: "canvas_delete_quiz_question",
+        tool: {
+            name: "canvas_delete_quiz_question",
+            description: "Delete a question from a 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"
+                    },
+                    question_id: {
+                        type: "number",
+                        description: "The question ID to delete"
+                    }
+                },
+                required: ["course_id", "quiz_id", "question_id"]
+            }
+        },
+        handler: async (client, args) => {
+            const input = z.object({
+                course_id: z.union([z.number(), z.string()]),
+                quiz_id: z.coerce.number(),
+                question_id: z.coerce.number()
+            }).parse(args);
+            const courseId = await resolveCourseId(client, input.course_id);
+            const result = await client.deleteQuizQuestion(courseId, input.quiz_id, input.question_id);
+            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 in a quiz. Questions assigned to the group via quiz_group_id will be randomly picked (pick_count) 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 this group"
+                    },
+                    question_points: {
+                        type: "number",
+                        description: "Points per question in 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)
+            }).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
+            });
+            return {
+                content: [{ type: "text", text: JSON.stringify(group, null, 2) }]
+            };
+        }
+    }
+];

package/dist/tools/quiz-tools.js

@@ -0,0 +1,184 @@
+import { resolveCourseId } from "../common/helpers.js";
+import { z } from "zod";
+export const quizTools = [
+    {
+        name: "canvas_list_quizzes",
+        tool: {
+            name: "canvas_list_quizzes",
+            description: "List quizzes 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 quizzes = await client.getQuizzes(courseId);
+            return {
+                content: [{ type: "text", text: JSON.stringify(quizzes, null, 2) }]
+            };
+        }
+    },
+    {
+        name: "canvas_get_quiz",
+        tool: {
+            name: "canvas_get_quiz",
+            description: "Get details for a specific 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" }
+                },
+                required: ["course_id", "quiz_id"]
+            }
+        },
+        handler: async (client, args) => {
+            const input = z.object({
+                course_id: z.union([z.number(), z.string()]),
+                quiz_id: z.number()
+            }).parse(args);
+            const courseId = await resolveCourseId(client, input.course_id);
+            const quiz = await client.getQuiz(courseId, input.quiz_id);
+            return {
+                content: [{ type: "text", text: JSON.stringify(quiz, null, 2) }]
+            };
+        }
+    },
+    {
+        name: "canvas_update_quiz_dates",
+        tool: {
+            name: "canvas_update_quiz_dates",
+            description: "Update due/unlock/lock dates for a specific 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" },
+                    due_at: { type: "string", description: "ISO-8601 due date. Use null to clear.", nullable: true },
+                    unlock_at: { type: "string", description: "ISO-8601 unlock date. Use null to clear.", nullable: true },
+                    lock_at: { type: "string", description: "ISO-8601 lock date. Use null to clear.", nullable: true }
+                },
+                required: ["course_id", "quiz_id"]
+            }
+        },
+        handler: async (client, args) => {
+            const input = z.object({
+                course_id: z.union([z.number(), z.string()]),
+                quiz_id: z.number(),
+                due_at: z.string().nullable().optional(),
+                unlock_at: z.string().nullable().optional(),
+                lock_at: z.string().nullable().optional()
+            }).parse(args);
+            const courseId = await resolveCourseId(client, input.course_id);
+            const quiz = await client.updateQuiz(courseId, input.quiz_id, {
+                due_at: input.due_at,
+                unlock_at: input.unlock_at,
+                lock_at: input.lock_at
+            });
+            return {
+                content: [{ type: "text", text: JSON.stringify(quiz, null, 2) }]
+            };
+        }
+    },
+    {
+        name: "canvas_create_quiz",
+        tool: {
+            name: "canvas_create_quiz",
+            description: "Create a new quiz for a course",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    course_id: { anyOf: [{ type: "number" }, { type: "string" }] },
+                    title: { type: "string" },
+                    description: { type: "string" },
+                    quiz_type: { type: "string", enum: ["practice_quiz", "assignment", "graded_survey", "survey"] },
+                    time_limit: { type: "number" },
+                    shuffle_answers: { type: "boolean" },
+                    published: { type: "boolean" },
+                    assignment_group_id: { type: "number" },
+                    allowed_attempts: { type: "number" },
+                    require_lockdown_browser: { type: "boolean" },
+                    show_correct_answers: { type: "boolean" },
+                    show_correct_answers_at: { type: "string", description: "ISO-8601 date to show correct answers" }
+                },
+                required: ["course_id", "title"]
+            }
+        },
+        handler: async (client, args) => {
+            const input = z.object({
+                course_id: z.union([z.number(), z.string()]),
+                title: z.string(),
+                description: z.string().optional(),
+                quiz_type: z.enum(["practice_quiz", "assignment", "graded_survey", "survey"]).optional(),
+                time_limit: z.number().optional(),
+                shuffle_answers: z.boolean().optional(),
+                published: z.boolean().optional(),
+                assignment_group_id: z.number().optional(),
+                allowed_attempts: z.number().optional(),
+                require_lockdown_browser: z.boolean().optional(),
+                show_correct_answers: z.boolean().optional(),
+                show_correct_answers_at: z.string().optional()
+            }).parse(args);
+            const courseId = await resolveCourseId(client, input.course_id);
+            const quizData = { ...input };
+            delete quizData.course_id;
+            const quiz = await client.createQuiz(courseId, quizData);
+            return { content: [{ type: "text", text: JSON.stringify(quiz, null, 2) }] };
+        }
+    },
+    {
+        name: "canvas_update_quiz",
+        tool: {
+            name: "canvas_update_quiz",
+            description: "Update an existing quiz",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    course_id: { anyOf: [{ type: "number" }, { type: "string" }] },
+                    quiz_id: { type: "number" },
+                    title: { type: "string" },
+                    description: { type: "string" },
+                    published: { type: "boolean" },
+                    require_lockdown_browser: { type: "boolean" },
+                    show_correct_answers: { type: "boolean" },
+                    show_correct_answers_at: { type: "string", description: "ISO-8601 date to show correct answers" }
+                },
+                required: ["course_id", "quiz_id"]
+            }
+        },
+        handler: async (client, args) => {
+            const input = z.object({
+                course_id: z.union([z.number(), z.string()]),
+                quiz_id: z.number(),
+                title: z.string().optional(),
+                description: z.string().optional(),
+                published: z.boolean().optional(),
+                require_lockdown_browser: z.boolean().optional(),
+                show_correct_answers: z.boolean().optional(),
+                show_correct_answers_at: z.string().optional()
+            }).parse(args);
+            const courseId = await resolveCourseId(client, input.course_id);
+            const quizData = { ...input };
+            delete quizData.course_id;
+            delete quizData.quiz_id;
+            const quiz = await client.updateQuiz(courseId, input.quiz_id, quizData);
+            return { content: [{ type: "text", text: JSON.stringify(quiz, null, 2) }] };
+        }
+    }
+];

package/dist/tools/rubric-tools.js

@@ -0,0 +1,145 @@
+import { resolveCourseId } from "../common/helpers.js";
+import { z } from "zod";
+export const rubricTools = [
+    {
+        name: "canvas_create_rubric",
+        tool: {
+            name: "canvas_create_rubric",
+            description: "Create a new rubric in a course and optionally associate it with an assignment",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    course_id: {
+                        anyOf: [{ type: "number" }, { type: "string" }],
+                        description: "The ID or name of the course"
+                    },
+                    title: { type: "string", description: "The title of the rubric" },
+                    criteria: {
+                        type: "array",
+                        description: "List of criteria objects for the rubric",
+                        items: {
+                            type: "object",
+                            properties: {
+                                description: { type: "string" },
+                                long_description: { type: "string" },
+                                points: { type: "number" },
+                                ratings: {
+                                    type: "array",
+                                    items: {
+                                        type: "object",
+                                        properties: {
+                                            description: { type: "string" },
+                                            points: { type: "number" },
+                                            long_description: { type: "string" }
+                                        },
+                                        required: ["description", "points"]
+                                    }
+                                }
+                            },
+                            required: ["description", "points", "ratings"]
+                        }
+                    },
+                    association_id: { type: "number", description: "Optional Assignment ID to associate the rubric with" },
+                    association_type: { type: "string", description: "Optional Type of association, defaults to 'Assignment'" },
+                    use_for_grading: { type: "boolean", description: "Optional Whether to use the rubric for grading" },
+                    purpose: { type: "string", description: "Optional Purpose of association, e.g. 'grading'" }
+                },
+                required: ["course_id", "title", "criteria"],
+            },
+        },
+        handler: async (client, args) => {
+            const input = z.object({
+                course_id: z.union([z.number(), z.string()]),
+                title: z.string(),
+                criteria: z.array(z.object({
+                    description: z.string(),
+                    long_description: z.string().optional(),
+                    points: z.number(),
+                    ratings: z.array(z.object({
+                        description: z.string(),
+                        points: z.number(),
+                        long_description: z.string().optional()
+                    }))
+                })),
+                association_id: z.number().optional(),
+                association_type: z.string().optional().default("Assignment"),
+                use_for_grading: z.boolean().optional(),
+                purpose: z.string().optional().default("grading")
+            }).parse(args);
+            const courseId = await resolveCourseId(client, input.course_id);
+            // Format criteria as a dictionary keyed by index as Canvas API requires indexed hash/array
+            const criteriaRecord = {};
+            input.criteria.forEach((c, index) => {
+                const ratingsRecord = {};
+                c.ratings.forEach((r, rIndex) => {
+                    ratingsRecord[rIndex.toString()] = r;
+                });
+                criteriaRecord[index.toString()] = {
+                    ...c,
+                    ratings: ratingsRecord
+                };
+            });
+            const rubricData = {
+                title: input.title,
+                criteria: criteriaRecord
+            };
+            let associationData = undefined;
+            if (input.association_id) {
+                associationData = {
+                    association_id: input.association_id,
+                    association_type: input.association_type,
+                    use_for_grading: input.use_for_grading,
+                    purpose: input.purpose
+                };
+            }
+            const rubric = await client.createRubric(courseId, rubricData, associationData);
+            return {
+                content: [{ type: "text", text: JSON.stringify(rubric, null, 2) }],
+            };
+        }
+    },
+    {
+        name: "canvas_create_rubric_association",
+        tool: {
+            name: "canvas_create_rubric_association",
+            description: "Associate an existing rubric with an object like an Assignment",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    course_id: {
+                        anyOf: [{ type: "number" }, { type: "string" }],
+                        description: "The ID or name of the course"
+                    },
+                    rubric_id: { type: "number", description: "The ID of the rubric to associate" },
+                    association_id: { type: "number", description: "The ID of the object (e.g., Assignment ID)" },
+                    association_type: { type: "string", description: "Type of object, defaults to 'Assignment'" },
+                    use_for_grading: { type: "boolean", description: "Whether to use the rubric for grading" },
+                    purpose: { type: "string", description: "Purpose of association, e.g. 'grading'" }
+                },
+                required: ["course_id", "rubric_id", "association_id"],
+            },
+        },
+        handler: async (client, args) => {
+            const input = z.object({
+                course_id: z.union([z.number(), z.string()]),
+                rubric_id: z.number(),
+                association_id: z.number(),
+                association_type: z.string().optional().default("Assignment"),
+                use_for_grading: z.boolean().optional(),
+                purpose: z.string().optional().default("grading")
+            }).parse(args);
+            const courseId = await resolveCourseId(client, input.course_id);
+            const associationData = {
+                rubric_id: input.rubric_id,
+                association_id: input.association_id,
+                association_type: input.association_type,
+                use_for_grading: input.use_for_grading,
+                purpose: input.purpose
+            };
+            const association = await client.createRubricAssociation(courseId, associationData);
+            return {
+                content: [{ type: "text", text: JSON.stringify(association, null, 2) }],
+            };
+        }
+    }
+];