canvas-agent 1.0.0

package/dist/tools/quizzes.js

@@ -0,0 +1,83 @@
+import { z } from "zod";
+import { canvas, canvasAll } from "../canvas-client.js";
+export function registerQuizTools(server) {
+    server.tool("list_quizzes", "List quizzes in a course. Note: New Quizzes also appear as assignments (with submission_types=['external_tool'] and is_quiz_lti_assignment=true). This endpoint covers Classic Quizzes; use list_assignments to see New Quizzes.", {
+        course_id: z.string().describe("Canvas course ID"),
+        search_term: z.string().optional().describe("Filter by title"),
+    }, async ({ course_id, search_term }) => {
+        const params = {};
+        if (search_term)
+            params.search_term = search_term;
+        const quizzes = await canvasAll(`/courses/${course_id}/quizzes`, params);
+        const summary = quizzes.map((q) => ({
+            id: q.id,
+            title: q.title,
+            quiz_type: q.quiz_type,
+            due_at: q.due_at,
+            unlock_at: q.unlock_at,
+            lock_at: q.lock_at,
+            points_possible: q.points_possible,
+            question_count: q.question_count,
+            time_limit: q.time_limit,
+            published: q.published,
+            assignment_id: q.assignment_id,
+            html_url: q.html_url,
+        }));
+        return {
+            content: [{ type: "text", text: JSON.stringify(summary, null, 2) }],
+        };
+    });
+    server.tool("get_quiz", "Get full details of a Classic Quiz. For New Quizzes (Quizzes.Next), use get_new_quiz instead.", {
+        course_id: z.string().describe("Canvas course ID"),
+        quiz_id: z.string().describe("Quiz ID"),
+    }, async ({ course_id, quiz_id }) => {
+        const quiz = await canvas(`/courses/${course_id}/quizzes/${quiz_id}`);
+        return {
+            content: [{ type: "text", text: JSON.stringify(quiz, null, 2) }],
+        };
+    });
+    server.tool("update_quiz", "Update a Classic Quiz. Only include fields you want to change. For New Quizzes, use update_new_quiz instead.", {
+        course_id: z.string().describe("Canvas course ID"),
+        quiz_id: z.string().describe("Quiz ID"),
+        title: z.string().optional(),
+        description: z.string().optional().describe("HTML instructions"),
+        due_at: z.string().optional().describe("ISO 8601"),
+        unlock_at: z.string().optional().describe("Available from (ISO 8601)"),
+        lock_at: z.string().optional().describe("Available until (ISO 8601)"),
+        points_possible: z.number().optional(),
+        time_limit: z.number().optional().describe("Time limit in minutes (Classic Quizzes use minutes; New Quizzes use seconds)"),
+        published: z.boolean().optional(),
+    }, async ({ course_id, quiz_id, ...params }) => {
+        const result = await canvas(`/courses/${course_id}/quizzes/${quiz_id}`, { method: "PUT", body: JSON.stringify({ quiz: params }) });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Updated quiz "${result.title}" (ID: ${result.id})`,
+                },
+            ],
+        };
+    });
+    server.tool("list_new_quizzes", "List all New Quizzes (Quizzes.Next) in a course by filtering assignments. Returns a summary of each. For full details/settings of a single New Quiz, use get_new_quiz. For question management, use list_quiz_items, create_quiz_item, etc.", {
+        course_id: z.string().describe("Canvas course ID"),
+    }, async ({ course_id }) => {
+        const assignments = await canvasAll(`/courses/${course_id}/assignments`);
+        const newQuizzes = assignments
+            .filter((a) => a.is_quiz_lti_assignment)
+            .map((a) => ({
+            id: a.id,
+            name: a.name,
+            due_at: a.due_at,
+            unlock_at: a.unlock_at,
+            lock_at: a.lock_at,
+            points_possible: a.points_possible,
+            published: a.published,
+            html_url: a.html_url,
+        }));
+        return {
+            content: [
+                { type: "text", text: JSON.stringify(newQuizzes, null, 2) },
+            ],
+        };
+    });
+}

package/dist/tools/rubrics.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerRubricTools(server: McpServer): void;

package/dist/tools/rubrics.js

@@ -0,0 +1,298 @@
+import { z } from "zod";
+import { canvas, canvasAll } from "../canvas-client.js";
+export function registerRubricTools(server) {
+    server.tool("list_rubrics", "List all rubrics in a course. Returns rubric ID, title, point total, and number of criteria.", {
+        course_id: z.string().describe("Canvas course ID"),
+    }, async ({ course_id }) => {
+        const rubrics = await canvasAll(`/courses/${course_id}/rubrics`);
+        const summary = rubrics.map((r) => ({
+            id: r.id,
+            title: r.title,
+            points_possible: r.points_possible,
+            criteria_count: r.data?.length ?? 0,
+            associations_count: r.association_count,
+        }));
+        return {
+            content: [{ type: "text", text: JSON.stringify(summary, null, 2) }],
+        };
+    });
+    server.tool("get_rubric", "Get full details of a rubric, including all criteria and their rating scales. The returned criterion IDs (e.g. '_7998') are needed by grade_with_rubric.", {
+        course_id: z.string().describe("Canvas course ID"),
+        rubric_id: z.string().describe("Rubric ID"),
+    }, async ({ course_id, rubric_id }) => {
+        const rubric = await canvas(`/courses/${course_id}/rubrics/${rubric_id}?include[]=assignment_associations`);
+        return {
+            content: [{ type: "text", text: JSON.stringify(rubric, null, 2) }],
+        };
+    });
+    server.tool("create_rubric", "Create a new rubric in a course. Provide criteria as an array of objects, each with a description and an array of ratings (description + points). Optionally associate with an assignment immediately.", {
+        course_id: z.string().describe("Canvas course ID"),
+        title: z.string().describe("Rubric title"),
+        criteria: z
+            .array(z.object({
+            description: z.string().describe("Criterion name/description"),
+            long_description: z
+                .string()
+                .optional()
+                .describe("Detailed criterion description"),
+            points: z.number().describe("Maximum points for this criterion"),
+            ratings: z.array(z.object({
+                description: z.string().describe("Rating level description"),
+                points: z.number().describe("Point value for this rating"),
+            })),
+        }))
+            .describe("Array of rubric criteria with their rating scales"),
+        assignment_id: z
+            .string()
+            .optional()
+            .describe("If provided, associate this rubric with the assignment and use it for grading"),
+    }, async ({ course_id, title, criteria, assignment_id }) => {
+        const criteriaObj = {};
+        criteria.forEach((c, i) => {
+            const ratingsObj = {};
+            c.ratings.forEach((r, j) => {
+                ratingsObj[String(j)] = {
+                    description: r.description,
+                    points: r.points,
+                };
+            });
+            criteriaObj[String(i)] = {
+                description: c.description,
+                long_description: c.long_description ?? "",
+                points: c.points,
+                ratings: ratingsObj,
+            };
+        });
+        const body = {
+            rubric: { title, criteria: criteriaObj },
+        };
+        if (assignment_id) {
+            body.rubric_association = {
+                association_id: Number(assignment_id),
+                association_type: "Assignment",
+                use_for_grading: true,
+                purpose: "grading",
+            };
+        }
+        else {
+            body.rubric_association = {
+                association_id: Number(course_id),
+                association_type: "Course",
+                use_for_grading: true,
+                purpose: "grading",
+            };
+        }
+        const result = await canvas(`/courses/${course_id}/rubrics`, {
+            method: "POST",
+            body: JSON.stringify(body),
+        });
+        const rubric = result.rubric ?? result;
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Created rubric "${rubric.title}" (ID: ${rubric.id}), ${criteria.length} criteria, ${rubric.points_possible} points total${assignment_id ? `, associated with assignment ${assignment_id}` : ""}`,
+                },
+            ],
+        };
+    });
+    server.tool("update_rubric", "Update an existing rubric's title or criteria. Changes apply to all assignments using this rubric.", {
+        course_id: z.string().describe("Canvas course ID"),
+        rubric_id: z.string().describe("Rubric ID to update"),
+        title: z.string().optional().describe("New rubric title"),
+        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(),
+            })),
+        }))
+            .optional()
+            .describe("Replacement criteria (replaces all existing criteria)"),
+    }, async ({ course_id, rubric_id, title, criteria }) => {
+        const body = { rubric: {} };
+        if (title)
+            body.rubric.title = title;
+        if (criteria) {
+            const criteriaObj = {};
+            criteria.forEach((c, i) => {
+                const ratingsObj = {};
+                c.ratings.forEach((r, j) => {
+                    ratingsObj[String(j)] = {
+                        description: r.description,
+                        points: r.points,
+                    };
+                });
+                criteriaObj[String(i)] = {
+                    description: c.description,
+                    long_description: c.long_description ?? "",
+                    points: c.points,
+                    ratings: ratingsObj,
+                };
+            });
+            body.rubric.criteria = criteriaObj;
+        }
+        const result = await canvas(`/courses/${course_id}/rubrics/${rubric_id}`, { method: "PUT", body: JSON.stringify(body) });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Updated rubric "${result.title}" (ID: ${result.id})`,
+                },
+            ],
+        };
+    });
+    server.tool("delete_rubric", "Delete a rubric from a course. This removes it from all associated assignments.", {
+        course_id: z.string().describe("Canvas course ID"),
+        rubric_id: z.string().describe("Rubric ID to delete"),
+    }, async ({ course_id, rubric_id }) => {
+        await canvas(`/courses/${course_id}/rubrics/${rubric_id}`, {
+            method: "DELETE",
+        });
+        return {
+            content: [
+                { type: "text", text: `Deleted rubric ${rubric_id}` },
+            ],
+        };
+    });
+    server.tool("associate_rubric", "Associate an existing rubric with one or more assignments. This is how you reuse a rubric across multiple assignments. Use list_rubrics to find the rubric_id.", {
+        course_id: z.string().describe("Canvas course ID"),
+        rubric_id: z.string().describe("Rubric ID to associate"),
+        assignment_ids: z
+            .array(z.string())
+            .describe("List of assignment IDs to associate the rubric with"),
+        use_for_grading: z
+            .boolean()
+            .default(true)
+            .describe("Whether to use this rubric for grading (default: true)"),
+    }, async ({ course_id, rubric_id, assignment_ids, use_for_grading }) => {
+        const results = [];
+        for (const aid of assignment_ids) {
+            try {
+                await canvas(`/courses/${course_id}/rubric_associations`, {
+                    method: "POST",
+                    body: JSON.stringify({
+                        rubric_association: {
+                            rubric_id: Number(rubric_id),
+                            association_type: "Assignment",
+                            association_id: Number(aid),
+                            use_for_grading,
+                            purpose: "grading",
+                        },
+                    }),
+                });
+                results.push(`  OK: assignment ${aid}`);
+            }
+            catch (e) {
+                results.push(`  FAILED: assignment ${aid} — ${e.message}`);
+            }
+        }
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Rubric ${rubric_id} association results (${assignment_ids.length} assignments):\n${results.join("\n")}`,
+                },
+            ],
+        };
+    });
+    server.tool("remove_rubric_from_assignment", "Remove a rubric association from a specific assignment without deleting the rubric itself.", {
+        course_id: z.string().describe("Canvas course ID"),
+        assignment_id: z.string().describe("Assignment ID to remove rubric from"),
+    }, async ({ course_id, assignment_id }) => {
+        // Get the assignment to find its rubric association
+        const assignment = await canvas(`/courses/${course_id}/assignments/${assignment_id}`);
+        const rubricSettings = assignment.rubric_settings;
+        if (!rubricSettings) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Assignment ${assignment_id} has no rubric associated.`,
+                    },
+                ],
+            };
+        }
+        // Remove by updating the assignment to clear rubric
+        await canvas(`/courses/${course_id}/assignments/${assignment_id}`, {
+            method: "PUT",
+            body: JSON.stringify({
+                assignment: { rubric_settings: { id: null } },
+            }),
+        });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Removed rubric from assignment ${assignment_id} ("${assignment.name}")`,
+                },
+            ],
+        };
+    });
+    server.tool("grade_with_rubric", "Grade a student's submission using a rubric. Provide scores for each criterion. For simple score-based grading without a rubric, use grade_submission instead.", {
+        course_id: z.string().describe("Canvas course ID"),
+        assignment_id: z.string().describe("Assignment ID"),
+        student_id: z.string().describe("Student's user ID"),
+        criterion_scores: z
+            .array(z.object({
+            criterion_id: z
+                .string()
+                .describe("Criterion ID from the rubric (e.g., '_7998'). Use get_rubric to find these."),
+            points: z.number().describe("Points to award for this criterion"),
+            comments: z
+                .string()
+                .optional()
+                .describe("Feedback comment for this criterion"),
+        }))
+            .describe("Scores for each rubric criterion"),
+    }, async ({ course_id, assignment_id, student_id, criterion_scores }) => {
+        const rubricAssessment = {};
+        for (const cs of criterion_scores) {
+            rubricAssessment[cs.criterion_id] = {
+                points: cs.points,
+                ...(cs.comments ? { comments: cs.comments } : {}),
+            };
+        }
+        const result = await canvas(`/courses/${course_id}/assignments/${assignment_id}/submissions/${student_id}`, {
+            method: "PUT",
+            body: JSON.stringify({
+                rubric_assessment: rubricAssessment,
+            }),
+        });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Graded submission for student ${student_id} on assignment ${assignment_id}: score ${result.score}/${result.assignment?.points_possible ?? "?"}`,
+                },
+            ],
+        };
+    });
+    server.tool("get_rubric_assessments", "Get all rubric assessments (grades) for an assignment. Shows how each student was scored on each criterion.", {
+        course_id: z.string().describe("Canvas course ID"),
+        assignment_id: z.string().describe("Assignment ID"),
+    }, async ({ course_id, assignment_id }) => {
+        const submissions = await canvasAll(`/courses/${course_id}/assignments/${assignment_id}/submissions`, { include: "rubric_assessment,user" });
+        const assessed = submissions
+            .filter((s) => s.rubric_assessment)
+            .map((s) => ({
+            student_id: s.user_id,
+            student_name: s.user?.name ?? s.user?.sortable_name ?? "unknown",
+            score: s.score,
+            rubric_assessment: s.rubric_assessment,
+        }));
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: assessed.length > 0
+                        ? JSON.stringify(assessed, null, 2)
+                        : "No rubric assessments found for this assignment.",
+                },
+            ],
+        };
+    });
+}

package/dist/tools/scheduling.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerSchedulingTools(server: McpServer): void;

package/dist/tools/scheduling.js

@@ -0,0 +1,133 @@
+import { z } from "zod";
+import { canvas, canvasAll } from "../canvas-client.js";
+export function registerSchedulingTools(server) {
+    server.tool("update_assignment_dates", "Update due_at, unlock_at, and/or lock_at for a single assignment. Also works for graded discussions and New Quizzes (which are assignments under the hood). Prefer this over update_assignment when you only need to change dates.", {
+        course_id: z.string().describe("Canvas course ID"),
+        assignment_id: z.string().describe("Assignment ID"),
+        due_at: z
+            .string()
+            .optional()
+            .describe("Due date (ISO 8601). Empty string to clear."),
+        unlock_at: z
+            .string()
+            .optional()
+            .describe("Available from (ISO 8601). Empty string to clear."),
+        lock_at: z
+            .string()
+            .optional()
+            .describe("Available until (ISO 8601). Empty string to clear."),
+    }, async ({ course_id, assignment_id, ...dates }) => {
+        const result = await canvas(`/courses/${course_id}/assignments/${assignment_id}`, {
+            method: "PUT",
+            body: JSON.stringify({ assignment: dates }),
+        });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Updated dates for "${result.name}":\n  due_at: ${result.due_at}\n  unlock_at: ${result.unlock_at}\n  lock_at: ${result.lock_at}`,
+                },
+            ],
+        };
+    });
+    server.tool("batch_update_dates", "Update dates for multiple assignments at once. Works for regular assignments, graded discussions, and New Quizzes. Use get_course_schedule_overview first to see current dates. Provide an array of {assignment_id, due_at, unlock_at, lock_at} objects.", {
+        course_id: z.string().describe("Canvas course ID"),
+        date_updates: z
+            .array(z.object({
+            assignment_id: z.string(),
+            due_at: z.string().optional(),
+            unlock_at: z.string().optional(),
+            lock_at: z.string().optional(),
+        }))
+            .describe("Array of assignment ID + date updates"),
+    }, async ({ course_id, date_updates }) => {
+        const results = [];
+        for (const { assignment_id, ...dates } of date_updates) {
+            try {
+                const result = await canvas(`/courses/${course_id}/assignments/${assignment_id}`, {
+                    method: "PUT",
+                    body: JSON.stringify({ assignment: dates }),
+                });
+                results.push(`  OK: "${result.name}" → due ${result.due_at ?? "none"}`);
+            }
+            catch (e) {
+                results.push(`  FAILED: ${assignment_id} — ${e.message}`);
+            }
+        }
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Batch date update (${date_updates.length} assignments):\n${results.join("\n")}`,
+                },
+            ],
+        };
+    });
+    server.tool("update_quiz_dates", "Update dates for a classic quiz (not New Quizzes — those are assignments).", {
+        course_id: z.string().describe("Canvas course ID"),
+        quiz_id: z.string().describe("Classic Quiz ID (not assignment ID)"),
+        due_at: z.string().optional().describe("Due date (ISO 8601)"),
+        unlock_at: z.string().optional().describe("Available from (ISO 8601)"),
+        lock_at: z.string().optional().describe("Available until (ISO 8601)"),
+    }, async ({ course_id, quiz_id, ...dates }) => {
+        const result = await canvas(`/courses/${course_id}/quizzes/${quiz_id}`, {
+            method: "PUT",
+            body: JSON.stringify({ quiz: dates }),
+        });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Updated dates for quiz "${result.title}":\n  due_at: ${result.due_at}\n  unlock_at: ${result.unlock_at}\n  lock_at: ${result.lock_at}`,
+                },
+            ],
+        };
+    });
+    server.tool("get_course_schedule_overview", "Get a chronological overview of all dated assignments, discussions, and quizzes in a course. Useful for understanding the current schedule before making changes.", {
+        course_id: z.string().describe("Canvas course ID"),
+    }, async ({ course_id }) => {
+        const [assignments, quizzes] = await Promise.all([
+            canvasAll(`/courses/${course_id}/assignments`),
+            canvasAll(`/courses/${course_id}/quizzes`),
+        ]);
+        const items = [
+            ...assignments.map((a) => ({
+                type: a.is_quiz_lti_assignment
+                    ? "new_quiz"
+                    : a.submission_types?.includes("discussion_topic")
+                        ? "discussion"
+                        : "assignment",
+                id: a.id,
+                name: a.name,
+                due_at: a.due_at,
+                unlock_at: a.unlock_at,
+                lock_at: a.lock_at,
+                points: a.points_possible,
+                published: a.published,
+            })),
+            ...quizzes.map((q) => ({
+                type: "classic_quiz",
+                id: q.id,
+                name: q.title,
+                due_at: q.due_at,
+                unlock_at: q.unlock_at,
+                lock_at: q.lock_at,
+                points: q.points_possible,
+                published: q.published,
+            })),
+        ];
+        // Sort by due date (undated items at the end)
+        items.sort((a, b) => {
+            if (!a.due_at && !b.due_at)
+                return 0;
+            if (!a.due_at)
+                return 1;
+            if (!b.due_at)
+                return -1;
+            return new Date(a.due_at).getTime() - new Date(b.due_at).getTime();
+        });
+        return {
+            content: [{ type: "text", text: JSON.stringify(items, null, 2) }],
+        };
+    });
+}

package/dist/tools/submissions.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerSubmissionTools(server: McpServer): void;

package/dist/tools/submissions.js

@@ -0,0 +1,150 @@
+import { z } from "zod";
+import { canvas, canvasAll } from "../canvas-client.js";
+import { writeFile, mkdir } from "node:fs/promises";
+import { join } from "node:path";
+export function registerSubmissionTools(server) {
+    server.tool("list_submissions", "List all submissions for an assignment (including graded discussions and New Quizzes). Shows student name, score, submission status, and submitted_at timestamp.", {
+        course_id: z.string().describe("Canvas course ID"),
+        assignment_id: z
+            .string()
+            .describe("Assignment ID (also works for the linked assignment of graded discussions and New Quizzes)"),
+        include_comments: z
+            .boolean()
+            .default(false)
+            .describe("Include submission comments"),
+    }, async ({ course_id, assignment_id, include_comments }) => {
+        const params = {
+            include: include_comments ? "user,submission_comments" : "user",
+        };
+        // Use the "grouped" parameter to avoid duplicate entries
+        const submissions = await canvasAll(`/courses/${course_id}/assignments/${assignment_id}/submissions`, params);
+        const summary = submissions.map((s) => ({
+            user_id: s.user_id,
+            user_name: s.user?.name ?? s.user?.sortable_name ?? "unknown",
+            workflow_state: s.workflow_state,
+            submitted_at: s.submitted_at,
+            score: s.score,
+            grade: s.grade,
+            late: s.late,
+            missing: s.missing,
+            attempt: s.attempt,
+            submission_type: s.submission_type,
+            preview_url: s.preview_url,
+            ...(include_comments && s.submission_comments
+                ? {
+                    comments: s.submission_comments.map((c) => ({
+                        author: c.author_name,
+                        comment: c.comment,
+                        created_at: c.created_at,
+                    })),
+                }
+                : {}),
+        }));
+        return {
+            content: [{ type: "text", text: JSON.stringify(summary, null, 2) }],
+        };
+    });
+    server.tool("download_submissions", "Download all submitted files for an assignment to a local directory. Creates a folder per student. Returns the path where files were saved.", {
+        course_id: z.string().describe("Canvas course ID"),
+        assignment_id: z.string().describe("Assignment ID"),
+        output_dir: z
+            .string()
+            .default("./downloads")
+            .describe("Local directory to save files to"),
+    }, async ({ course_id, assignment_id, output_dir }) => {
+        const submissions = await canvasAll(`/courses/${course_id}/assignments/${assignment_id}/submissions`, { include: "user" });
+        // Get assignment name for the folder
+        const assignment = await canvas(`/courses/${course_id}/assignments/${assignment_id}`);
+        const safeName = assignment.name.replace(/[^a-zA-Z0-9_\- ]/g, "");
+        const baseDir = join(output_dir, safeName);
+        let downloaded = 0;
+        let skipped = 0;
+        const errors = [];
+        for (const sub of submissions) {
+            if (!sub.attachments || sub.attachments.length === 0) {
+                skipped++;
+                continue;
+            }
+            const studentName = (sub.user?.sortable_name ??
+                sub.user?.name ??
+                `user_${sub.user_id}`).replace(/[^a-zA-Z0-9_\- ]/g, "");
+            const studentDir = join(baseDir, studentName);
+            await mkdir(studentDir, { recursive: true });
+            for (const attachment of sub.attachments) {
+                try {
+                    let res = null;
+                    for (let attempt = 0; attempt < 3; attempt++) {
+                        res = await fetch(attachment.url, {
+                            headers: {
+                                Authorization: `Bearer ${process.env.CANVAS_API_TOKEN}`,
+                            },
+                        });
+                        if (res.ok || res.status !== 429)
+                            break;
+                        const delay = 1000 * (attempt + 1);
+                        await new Promise((r) => setTimeout(r, delay));
+                    }
+                    if (!res.ok)
+                        throw new Error(`HTTP ${res.status} for ${attachment.filename}`);
+                    const buffer = Buffer.from(await res.arrayBuffer());
+                    await writeFile(join(studentDir, attachment.filename), buffer);
+                    downloaded++;
+                }
+                catch (e) {
+                    errors.push(`  ${studentName}/${attachment.filename}: ${e.message}`);
+                }
+            }
+        }
+        let report = `Downloaded submissions for "${assignment.name}" to ${baseDir}\n`;
+        report += `  Files downloaded: ${downloaded}\n`;
+        report += `  Students with no submission: ${skipped}\n`;
+        if (errors.length > 0) {
+            report += `  Errors:\n${errors.join("\n")}`;
+        }
+        return { content: [{ type: "text", text: report }] };
+    });
+    server.tool("download_discussion_entries", "Download all entries/replies for a discussion topic as a JSON file — the actual student posts and replies. Unlike list_submissions (which shows grading metadata for graded discussions), this downloads the discussion content itself.", {
+        course_id: z.string().describe("Canvas course ID"),
+        discussion_id: z.string().describe("Discussion topic ID"),
+        output_dir: z.string().default("./downloads"),
+    }, async ({ course_id, discussion_id, output_dir }) => {
+        const [discussion, entries] = await Promise.all([
+            canvas(`/courses/${course_id}/discussion_topics/${discussion_id}`),
+            canvasAll(`/courses/${course_id}/discussion_topics/${discussion_id}/entries`),
+        ]);
+        // Also fetch replies for each top-level entry
+        const fullEntries = await Promise.all(entries.map(async (entry) => {
+            let replies = [];
+            try {
+                replies = await canvasAll(`/courses/${course_id}/discussion_topics/${discussion_id}/entries/${entry.id}/replies`);
+            }
+            catch {
+                // Some entries may not have replies endpoint
+            }
+            return {
+                id: entry.id,
+                user_name: entry.user_name,
+                message: entry.message,
+                created_at: entry.created_at,
+                replies: replies.map((r) => ({
+                    id: r.id,
+                    user_name: r.user_name,
+                    message: r.message,
+                    created_at: r.created_at,
+                })),
+            };
+        }));
+        const safeName = discussion.title.replace(/[^a-zA-Z0-9_\- ]/g, "");
+        await mkdir(output_dir, { recursive: true });
+        const filePath = join(output_dir, `${safeName}.json`);
+        await writeFile(filePath, JSON.stringify(fullEntries, null, 2));
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Saved ${fullEntries.length} entries (with replies) to ${filePath}`,
+                },
+            ],
+        };
+    });
+}