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

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

@@ -1,238 +0,0 @@
-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) }]
-            };
-        }
-    }
-];