canvas-lms-mcp 1.3.0 → 1.4.1

package/dist/{chunk-VDHNHHYO.cjs → chunk-2BS2WOAF.cjs}

@@ -13,6 +13,104 @@ var _chunkXAOI3FO6cjs = require('./chunk-XAOI3FO6.cjs');
 // src/server.ts
 var _mcpjs = require('@modelcontextprotocol/sdk/server/mcp.js');
 
+// src/tools/accounts.ts
+var _zod = require('zod');
+function accountTools(canvas) {
+  return [
+    {
+      name: "get_account",
+      description: "Get details for a Canvas account by ID.",
+      inputSchema: {
+        account_id: _zod.z.number().describe("The Canvas account ID")
+      },
+      annotations: {
+        readOnlyHint: true,
+        openWorldHint: true
+      },
+      handler: async (params) => {
+        return canvas.accounts.get(params.account_id);
+      }
+    },
+    {
+      name: "list_accounts",
+      description: "List all accounts accessible to the authenticated user.",
+      inputSchema: {},
+      annotations: {
+        readOnlyHint: true,
+        openWorldHint: true
+      },
+      handler: async () => {
+        return canvas.accounts.list();
+      }
+    },
+    {
+      name: "list_sub_accounts",
+      description: "List sub-accounts under a given Canvas account.",
+      inputSchema: {
+        account_id: _zod.z.number().describe("The parent Canvas account ID")
+      },
+      annotations: {
+        readOnlyHint: true,
+        openWorldHint: true
+      },
+      handler: async (params) => {
+        return canvas.accounts.listSubAccounts(params.account_id);
+      }
+    },
+    {
+      name: "list_account_courses",
+      description: "List courses under a given Canvas account.",
+      inputSchema: {
+        account_id: _zod.z.number().describe("The Canvas account ID"),
+        search_term: _zod.z.string().optional().describe("Search courses by name or course code")
+      },
+      annotations: {
+        readOnlyHint: true,
+        openWorldHint: true
+      },
+      handler: async (params) => {
+        return canvas.accounts.listCourses(params.account_id, {
+          search_term: params.search_term
+        });
+      }
+    },
+    {
+      name: "list_account_users",
+      description: "List users in a Canvas account.",
+      inputSchema: {
+        account_id: _zod.z.number().describe("The Canvas account ID"),
+        search_term: _zod.z.string().optional().describe("Search users by name, email, or login")
+      },
+      annotations: {
+        readOnlyHint: true,
+        openWorldHint: true
+      },
+      handler: async (params) => {
+        return canvas.accounts.listUsers(params.account_id, {
+          search_term: params.search_term
+        });
+      }
+    },
+    {
+      name: "get_account_reports",
+      description: "List available report types for a Canvas account.",
+      inputSchema: {
+        account_id: _zod.z.number().describe("The Canvas account ID")
+      },
+      annotations: {
+        readOnlyHint: true,
+        openWorldHint: true
+      },
+      handler: async (params) => {
+        return canvas.accounts.getReports(params.account_id);
+      }
+    }
+  ];
+}
+
+// src/tools/analytics.ts
+
+
 // src/tools/errors.ts
 function formatError(error) {
   if (error instanceof _chunkXAOI3FO6cjs.CanvasApiError) {
@@ -50,47 +148,53 @@ function isNetworkError(error) {
   return msg.includes("fetch") || msg.includes("enotfound") || msg.includes("econnrefused") || msg.includes("econnreset") || msg.includes("etimedout") || msg.includes("network") || msg.includes("dns") || msg.includes("socket") || error.name === "TypeError";
 }
 
-// src/tools/health.ts
-function healthTools(canvas) {
-  return [
-    {
-      name: "health_check",
-      description: "Check if the Canvas API is reachable and the token is valid. Returns ok/error status.",
-      inputSchema: {},
-      annotations: {
-        readOnlyHint: true,
-        openWorldHint: true
-      },
-      handler: async () => {
-        await canvas.users.getProfile();
-        return { status: "ok", message: "Canvas API is reachable" };
-      }
-    }
-  ];
-}
-
-// src/tools/courses.ts
-var _zod = require('zod');
-function courseTools(canvas) {
+// src/tools/analytics.ts
+function analyticsTools(canvas) {
   return [
     {
-      name: "list_courses",
-      description: "List courses for the authenticated user. Optionally filter by enrollment state.",
+      name: "search_course_content",
+      description: "Search for content within a course. Searches pages, assignments, discussions, and announcements by keyword.",
       inputSchema: {
-        enrollment_state: _zod.z.enum(["active", "completed", "all"]).optional().describe("Filter courses by enrollment state")
+        course_id: _zod.z.number().describe("The Canvas course ID"),
+        search_term: _zod.z.string().describe("The keyword or phrase to search for"),
+        content_types: _zod.z.array(_zod.z.enum(_chunkXAOI3FO6cjs.SEARCH_CONTENT_TYPES)).optional().describe(
+          "Content types to search. Defaults to all types: pages, discussions, assignments, announcements."
+        )
       },
       annotations: {
         readOnlyHint: true,
         openWorldHint: true
       },
       handler: async (params) => {
-        const enrollment_state = params.enrollment_state;
-        return canvas.courses.list({ enrollment_state });
+        const courseId = params.course_id;
+        const searchTerm = params.search_term;
+        const types = _nullishCoalesce(params.content_types, () => ( [
+          ..._chunkXAOI3FO6cjs.SEARCH_CONTENT_TYPES
+        ]));
+        if (types.length === 0) return { results: [] };
+        const settled = await Promise.allSettled(
+          types.map((type) => canvas.analytics.searchContentType(courseId, searchTerm, type))
+        );
+        const fulfilled = settled.filter(
+          (r) => r.status === "fulfilled"
+        );
+        if (fulfilled.length === 0) {
+          const allErrors = settled.map(
+            (result, index) => result.status === "rejected" ? `${types[index]}: ${formatError(result.reason)}` : null
+          ).filter((errorLine) => errorLine !== null);
+          throw new Error(`All content type searches failed:
+${allErrors.join("\n")}`);
+        }
+        const results = fulfilled.flatMap((r) => r.value);
+        const warnings = settled.map(
+          (r, i) => r.status === "rejected" ? `${types[i]} search failed: ${formatError(r.reason)}` : null
+        ).filter((w) => w !== null);
+        return warnings.length > 0 ? { results, warnings } : { results };
       }
     },
     {
-      name: "get_course",
-      description: "Get details for a single course by ID, including term and total student count.",
+      name: "get_course_analytics",
+      description: "Get course-level activity analytics. Returns daily page view and participation counts.",
       inputSchema: {
         course_id: _zod.z.number().describe("The Canvas course ID")
       },
@@ -100,14 +204,15 @@ function courseTools(canvas) {
       },
       handler: async (params) => {
         const course_id = params.course_id;
-        return canvas.courses.get(course_id);
+        return canvas.analytics.getCourseActivity(course_id);
       }
     },
     {
-      name: "get_syllabus",
-      description: "Get the syllabus HTML body for a course.",
+      name: "get_student_analytics",
+      description: "Get per-student activity analytics for a course. Returns page views, participations, and submission timeline for a specific student.",
       inputSchema: {
-        course_id: _zod.z.number().describe("The Canvas course ID")
+        course_id: _zod.z.number().describe("The Canvas course ID"),
+        student_id: _zod.z.number().describe("The Canvas user ID of the student")
       },
       annotations: {
         readOnlyHint: true,
@@ -115,49 +220,23 @@ function courseTools(canvas) {
       },
       handler: async (params) => {
         const course_id = params.course_id;
-        const syllabus_body = await canvas.courses.getSyllabus(course_id);
-        return { course_id, syllabus_body };
-      }
-    },
-    {
-      name: "create_course",
-      description: "Create a new course in a Canvas account. Returns the created course object.",
-      inputSchema: {
-        account_id: _zod.z.number().int().positive().describe("The Canvas account ID to create the course in"),
-        name: _zod.z.string().describe("The name of the course"),
-        course_code: _zod.z.string().optional().describe("The course code (e.g. CS101)"),
-        start_at: _zod.z.string().datetime().optional().describe("Course start date in ISO 8601 format (e.g. 2026-01-15T00:00:00Z)"),
-        end_at: _zod.z.string().datetime().optional().describe("Course end date in ISO 8601 format (e.g. 2026-05-15T00:00:00Z)")
-      },
-      annotations: {
-        destructiveHint: true,
-        openWorldHint: true
-      },
-      handler: async (params) => {
-        const { account_id, ...courseFields } = params;
-        return canvas.courses.create({ account_id, ...courseFields });
+        const student_id = params.student_id;
+        return canvas.analytics.getStudentActivity(course_id, student_id);
       }
     },
     {
-      name: "update_course",
-      description: "Update an existing course. Only provided fields are changed; omitted fields are left as-is.",
+      name: "get_course_activity_stream",
+      description: "Get a summary of recent activity in a course. Returns counts of recent events grouped by type (submissions, discussions, announcements, etc.).",
       inputSchema: {
-        course_id: _zod.z.number().int().positive().describe("The Canvas course ID to update"),
-        name: _zod.z.string().optional().describe("New course name"),
-        course_code: _zod.z.string().optional().describe("New course code"),
-        start_at: _zod.z.string().datetime().optional().describe("New start date in ISO 8601 format (e.g. 2026-01-15T00:00:00Z)"),
-        end_at: _zod.z.string().datetime().optional().describe("New end date in ISO 8601 format (e.g. 2026-05-15T00:00:00Z)"),
-        default_view: _zod.z.enum(["feed", "wiki", "modules", "assignments", "syllabus"]).optional().describe("Default course home page view"),
-        syllabus_body: _zod.z.string().optional().describe("HTML body for the course syllabus")
+        course_id: _zod.z.number().describe("The Canvas course ID")
       },
       annotations: {
-        destructiveHint: true,
-        idempotentHint: true,
+        readOnlyHint: true,
         openWorldHint: true
       },
       handler: async (params) => {
-        const { course_id, ...fields } = params;
-        return canvas.courses.update(course_id, fields);
+        const course_id = params.course_id;
+        return canvas.analytics.getCourseActivityStream(course_id);
       }
     }
   ];
@@ -281,16 +360,15 @@ function assignmentTools(canvas) {
   ];
 }
 
-// src/tools/submissions.ts
+// src/tools/calendar.ts
 
-function submissionTools(canvas) {
+function calendarTools(canvas) {
   return [
     {
-      name: "list_submissions",
-      description: "List all submissions for an assignment in a course.",
+      name: "list_calendar_events",
+      description: "List calendar events for a course.",
       inputSchema: {
-        course_id: _zod.z.number().describe("The Canvas course ID"),
-        assignment_id: _zod.z.number().describe("The Canvas assignment ID")
+        course_id: _zod.z.number().describe("The Canvas course ID")
       },
       annotations: {
         readOnlyHint: true,
@@ -298,201 +376,152 @@ function submissionTools(canvas) {
       },
       handler: async (params) => {
         const course_id = params.course_id;
-        const assignment_id = params.assignment_id;
-        return canvas.submissions.list(course_id, assignment_id);
+        return canvas.calendar.list(course_id);
       }
     },
     {
-      name: "get_submission",
-      description: "Get a single submission for a specific user on an assignment, including comments.",
+      name: "create_calendar_event",
+      description: "Create a new calendar event in Canvas.",
       inputSchema: {
-        course_id: _zod.z.number().describe("The Canvas course ID"),
-        assignment_id: _zod.z.number().describe("The Canvas assignment ID"),
-        user_id: _zod.z.number().describe("The Canvas user ID")
+        context_code: _zod.z.string().describe('Canvas context code, e.g. "course_123" for a course event'),
+        title: _zod.z.string().describe("Event title"),
+        start_at: _zod.z.string().describe('Start time in ISO 8601 format, e.g. "2026-05-01T10:00:00Z"'),
+        end_at: _zod.z.string().optional().describe("End time in ISO 8601 format. Omit for all-day events."),
+        description: _zod.z.string().optional().describe("Event description (HTML allowed)"),
+        location_name: _zod.z.string().optional().describe("Location name")
       },
       annotations: {
-        readOnlyHint: true,
+        destructiveHint: true,
         openWorldHint: true
       },
       handler: async (params) => {
-        const course_id = params.course_id;
-        const assignment_id = params.assignment_id;
-        const user_id = params.user_id;
-        return canvas.submissions.get(course_id, assignment_id, user_id);
+        return canvas.calendar.createEvent({
+          context_code: params.context_code,
+          title: params.title,
+          start_at: params.start_at,
+          end_at: params.end_at,
+          description: params.description,
+          location_name: params.location_name
+        });
       }
     },
     {
-      name: "grade_submission",
-      description: "Post or update a grade for a submission. Requires grading permissions.",
-      inputSchema: {
-        course_id: _zod.z.number().describe("The Canvas course ID"),
-        assignment_id: _zod.z.number().describe("The Canvas assignment ID"),
-        user_id: _zod.z.number().describe("The Canvas user ID"),
-        grade: _zod.z.string().describe('The grade to assign (e.g. "95", "A", "pass")')
-      },
-      annotations: {
-        destructiveHint: true,
-        idempotentHint: true,
-        openWorldHint: true
-      },
-      handler: async (params) => {
-        const course_id = params.course_id;
-        const assignment_id = params.assignment_id;
-        const user_id = params.user_id;
-        const grade = params.grade;
-        return canvas.submissions.grade(course_id, assignment_id, user_id, grade);
-      }
-    },
-    {
-      name: "comment_on_submission",
-      description: "Add a text comment to a submission.",
+      name: "update_calendar_event",
+      description: "Update an existing calendar event. Only provided fields are changed.",
       inputSchema: {
-        course_id: _zod.z.number().describe("The Canvas course ID"),
-        assignment_id: _zod.z.number().describe("The Canvas assignment ID"),
-        user_id: _zod.z.number().describe("The Canvas user ID"),
-        comment: _zod.z.string().describe("The comment text to add")
+        event_id: _zod.z.number().describe("The Canvas calendar event ID"),
+        title: _zod.z.string().optional().describe("New event title"),
+        start_at: _zod.z.string().optional().describe("New start time in ISO 8601 format"),
+        end_at: _zod.z.string().optional().describe("New end time in ISO 8601 format"),
+        description: _zod.z.string().optional().describe("New description (HTML allowed)"),
+        location_name: _zod.z.string().optional().describe("New location name")
       },
       annotations: {
         destructiveHint: true,
         openWorldHint: true
       },
       handler: async (params) => {
-        const course_id = params.course_id;
-        const assignment_id = params.assignment_id;
-        const user_id = params.user_id;
-        const comment = params.comment;
-        return canvas.submissions.comment(course_id, assignment_id, user_id, comment);
+        const event_id = params.event_id;
+        return canvas.calendar.updateEvent(event_id, {
+          title: params.title,
+          start_at: params.start_at,
+          end_at: params.end_at,
+          description: params.description,
+          location_name: params.location_name
+        });
       }
     }
   ];
 }
 
-// src/tools/rubrics.ts
+// src/tools/conversations.ts
 
-function rubricTools(canvas) {
+function conversationTools(canvas) {
   return [
     {
-      name: "list_rubrics",
-      description: "List all rubrics in a course.",
-      inputSchema: {
-        course_id: _zod.z.number().describe("The Canvas course ID")
-      },
+      name: "list_conversations",
+      description: "List conversations (inbox messages) for the authenticated user.",
+      inputSchema: {},
       annotations: {
         readOnlyHint: true,
         openWorldHint: true
       },
-      handler: async (params) => {
-        const course_id = params.course_id;
-        return canvas.rubrics.list(course_id);
+      handler: async () => {
+        return canvas.conversations.list();
       }
     },
     {
-      name: "get_rubric",
-      description: "Get details for a single rubric by ID, including criteria.",
+      name: "get_conversation",
+      description: "Get a single conversation with its full message thread.",
       inputSchema: {
-        course_id: _zod.z.number().describe("The Canvas course ID"),
-        rubric_id: _zod.z.number().describe("The Canvas rubric ID")
+        conversation_id: _zod.z.number().describe("The conversation ID")
       },
       annotations: {
         readOnlyHint: true,
         openWorldHint: true
       },
       handler: async (params) => {
-        const course_id = params.course_id;
-        const rubric_id = params.rubric_id;
-        return canvas.rubrics.get(course_id, rubric_id);
+        return canvas.conversations.get(params.conversation_id);
       }
     },
     {
-      name: "get_rubric_assessment",
-      description: "Get the rubric assessment for a specific student submission on an assignment.",
-      inputSchema: {
-        course_id: _zod.z.number().describe("The Canvas course ID"),
-        assignment_id: _zod.z.number().describe("The Canvas assignment ID"),
-        user_id: _zod.z.number().describe("The Canvas user ID")
-      },
+      name: "get_conversation_unread_count",
+      description: "Get the number of unread conversations for the authenticated user.",
+      inputSchema: {},
       annotations: {
         readOnlyHint: true,
         openWorldHint: true
       },
-      handler: async (params) => {
-        const course_id = params.course_id;
-        const assignment_id = params.assignment_id;
-        const user_id = params.user_id;
-        return canvas.rubrics.getAssessment(course_id, assignment_id, user_id);
+      handler: async () => {
+        return canvas.conversations.getUnreadCount();
       }
     },
     {
-      name: "submit_rubric_assessment",
-      description: "Submit a rubric assessment with scores and comments for each criterion.",
+      name: "send_conversation",
+      description: "Send a new conversation message to one or more recipients.",
       inputSchema: {
-        course_id: _zod.z.number().describe("The Canvas course ID"),
-        association_id: _zod.z.number().describe("The rubric association ID"),
-        data: _zod.z.array(
-          _zod.z.object({
-            criterion_id: _zod.z.string().describe("The rubric criterion ID"),
-            points: _zod.z.number().describe("Points awarded for this criterion"),
-            comments: _zod.z.string().describe("Feedback comment for this criterion")
-          })
-        ).describe("Array of criterion assessments")
+        recipients: _zod.z.array(_zod.z.string()).describe("Array of recipient user IDs (as strings)"),
+        subject: _zod.z.string().describe("The conversation subject line"),
+        body: _zod.z.string().describe("The message body")
       },
       annotations: {
         destructiveHint: true,
-        idempotentHint: true,
         openWorldHint: true
       },
       handler: async (params) => {
-        const course_id = params.course_id;
-        const association_id = params.association_id;
-        const data = params.data;
-        return canvas.rubrics.submitAssessment(course_id, association_id, data);
+        const recipients = params.recipients;
+        const subject = params.subject;
+        const body = params.body;
+        return canvas.conversations.send(recipients, subject, body);
       }
     }
   ];
 }
 
-// src/tools/quizzes.ts
+// src/tools/courses.ts
 
-function quizTools(canvas) {
+function courseTools(canvas) {
   return [
     {
-      name: "list_quizzes",
-      description: "List all quizzes in a course.",
-      inputSchema: {
-        course_id: _zod.z.number().describe("The Canvas course ID")
-      },
-      annotations: {
-        readOnlyHint: true,
-        openWorldHint: true
-      },
-      handler: async (params) => {
-        const course_id = params.course_id;
-        return canvas.quizzes.list(course_id);
-      }
-    },
-    {
-      name: "get_quiz",
-      description: "Get details for a single quiz by ID.",
+      name: "list_courses",
+      description: "List courses for the authenticated user. Optionally filter by enrollment state.",
       inputSchema: {
-        course_id: _zod.z.number().describe("The Canvas course ID"),
-        quiz_id: _zod.z.number().describe("The Canvas quiz ID")
+        enrollment_state: _zod.z.enum(["active", "completed", "all"]).optional().describe("Filter courses by enrollment state")
       },
       annotations: {
         readOnlyHint: true,
         openWorldHint: true
       },
       handler: async (params) => {
-        const course_id = params.course_id;
-        const quiz_id = params.quiz_id;
-        return canvas.quizzes.get(course_id, quiz_id);
+        const enrollment_state = params.enrollment_state;
+        return canvas.courses.list({ enrollment_state });
       }
     },
     {
-      name: "list_quiz_submissions",
-      description: "List all submissions for a quiz.",
+      name: "get_course",
+      description: "Get details for a single course by ID, including term and total student count.",
       inputSchema: {
-        course_id: _zod.z.number().describe("The Canvas course ID"),
-        quiz_id: _zod.z.number().describe("The Canvas quiz ID")
+        course_id: _zod.z.number().describe("The Canvas course ID")
       },
       annotations: {
         readOnlyHint: true,
@@ -500,16 +529,14 @@ function quizTools(canvas) {
       },
       handler: async (params) => {
         const course_id = params.course_id;
-        const quiz_id = params.quiz_id;
-        return canvas.quizzes.listSubmissions(course_id, quiz_id);
+        return canvas.courses.get(course_id);
       }
     },
     {
-      name: "list_quiz_questions",
-      description: "List all questions in a quiz.",
+      name: "get_syllabus",
+      description: "Get the syllabus HTML body for a course.",
       inputSchema: {
-        course_id: _zod.z.number().describe("The Canvas course ID"),
-        quiz_id: _zod.z.number().describe("The Canvas quiz ID")
+        course_id: _zod.z.number().describe("The Canvas course ID")
       },
       annotations: {
         readOnlyHint: true,
@@ -517,36 +544,40 @@ function quizTools(canvas) {
       },
       handler: async (params) => {
         const course_id = params.course_id;
-        const quiz_id = params.quiz_id;
-        return canvas.quizzes.listQuestions(course_id, quiz_id);
+        const syllabus_body = await canvas.courses.getSyllabus(course_id);
+        return { course_id, syllabus_body };
       }
     },
     {
-      name: "get_quiz_submission_answers",
-      description: "Get a student's answers for a quiz submission.",
+      name: "create_course",
+      description: "Create a new course in a Canvas account. Returns the created course object.",
       inputSchema: {
-        quiz_submission_id: _zod.z.number().describe("The Canvas quiz submission ID")
+        account_id: _zod.z.number().int().positive().describe("The Canvas account ID to create the course in"),
+        name: _zod.z.string().describe("The name of the course"),
+        course_code: _zod.z.string().optional().describe("The course code (e.g. CS101)"),
+        start_at: _zod.z.string().datetime().optional().describe("Course start date in ISO 8601 format (e.g. 2026-01-15T00:00:00Z)"),
+        end_at: _zod.z.string().datetime().optional().describe("Course end date in ISO 8601 format (e.g. 2026-05-15T00:00:00Z)")
       },
       annotations: {
-        readOnlyHint: true,
+        destructiveHint: true,
         openWorldHint: true
       },
       handler: async (params) => {
-        const quiz_submission_id = params.quiz_submission_id;
-        return canvas.quizzes.getSubmissionAnswers(quiz_submission_id);
+        const { account_id, ...courseFields } = params;
+        return canvas.courses.create({ account_id, ...courseFields });
       }
     },
     {
-      name: "score_quiz_question",
-      description: "Score a specific question in a quiz submission. Specify attempt to score a particular attempt (omit for latest). Requires grading permissions.",
+      name: "update_course",
+      description: "Update an existing course. Only provided fields are changed; omitted fields are left as-is.",
       inputSchema: {
-        course_id: _zod.z.number().describe("The Canvas course ID"),
-        quiz_id: _zod.z.number().describe("The Canvas quiz ID"),
-        submission_id: _zod.z.number().describe("The Canvas quiz submission ID"),
-        question_id: _zod.z.number().describe("The Canvas quiz question ID"),
-        score: _zod.z.number().describe("The score to assign"),
-        comment: _zod.z.string().optional().describe("Optional feedback comment"),
-        attempt: _zod.z.number().optional().describe("Quiz attempt number to score (omit for latest)")
+        course_id: _zod.z.number().int().positive().describe("The Canvas course ID to update"),
+        name: _zod.z.string().optional().describe("New course name"),
+        course_code: _zod.z.string().optional().describe("New course code"),
+        start_at: _zod.z.string().datetime().optional().describe("New start date in ISO 8601 format (e.g. 2026-01-15T00:00:00Z)"),
+        end_at: _zod.z.string().datetime().optional().describe("New end date in ISO 8601 format (e.g. 2026-05-15T00:00:00Z)"),
+        default_view: _zod.z.enum(["feed", "wiki", "modules", "assignments", "syllabus"]).optional().describe("Default course home page view"),
+        syllabus_body: _zod.z.string().optional().describe("HTML body for the course syllabus")
       },
       annotations: {
         destructiveHint: true,
@@ -554,127 +585,74 @@ function quizTools(canvas) {
         openWorldHint: true
       },
       handler: async (params) => {
-        const course_id = params.course_id;
-        const quiz_id = params.quiz_id;
-        const submission_id = params.submission_id;
-        const question_id = params.question_id;
-        const score = params.score;
-        const comment = params.comment;
-        const attempt = params.attempt;
-        await canvas.quizzes.scoreQuestion(
-          course_id,
-          quiz_id,
-          submission_id,
-          question_id,
-          score,
-          comment,
-          attempt
-        );
-        return { success: true };
+        const { course_id, ...fields } = params;
+        return canvas.courses.update(course_id, fields);
       }
     }
   ];
 }
 
-// src/tools/files.ts
-
-function fileTools(canvas) {
+// src/tools/dashboard.ts
+function dashboardTools(canvas) {
   return [
     {
-      name: "list_files",
-      description: "List all files in a course.",
-      inputSchema: {
-        course_id: _zod.z.number().describe("The Canvas course ID")
-      },
+      name: "get_dashboard_cards",
+      description: "Get the current user's dashboard course cards with position, color, and image.",
+      inputSchema: {},
       annotations: {
         readOnlyHint: true,
         openWorldHint: true
       },
-      handler: async (params) => {
-        const course_id = params.course_id;
-        return canvas.files.list(course_id);
+      handler: async () => {
+        return canvas.dashboard.getDashboardCards();
       }
     },
     {
-      name: "list_folders",
-      description: "List all folders in a course.",
-      inputSchema: {
-        course_id: _zod.z.number().describe("The Canvas course ID")
-      },
+      name: "get_todo_items",
+      description: "Get the current user's to-do items, including upcoming assignments and grading tasks.",
+      inputSchema: {},
       annotations: {
         readOnlyHint: true,
         openWorldHint: true
       },
-      handler: async (params) => {
-        const course_id = params.course_id;
-        return canvas.files.listFolders(course_id);
+      handler: async () => {
+        return canvas.dashboard.getTodoItems();
       }
     },
     {
-      name: "get_file",
-      description: "Get metadata for a single file by ID, including download URL.",
-      inputSchema: {
-        course_id: _zod.z.number().describe("The Canvas course ID"),
-        file_id: _zod.z.number().describe("The Canvas file ID")
-      },
+      name: "get_upcoming_events",
+      description: "Get the current user's upcoming calendar events and assignments.",
+      inputSchema: {},
       annotations: {
         readOnlyHint: true,
         openWorldHint: true
       },
-      handler: async (params) => {
-        const course_id = params.course_id;
-        const file_id = params.file_id;
-        return canvas.files.get(course_id, file_id);
-      }
-    },
-    {
-      name: "upload_file",
-      description: "Upload a file to a course. Content must be base64-encoded. Canvas performs a multi-step upload internally.",
-      inputSchema: {
-        course_id: _zod.z.number().describe("The Canvas course ID"),
-        name: _zod.z.string().describe("File name including extension"),
-        content: _zod.z.string().describe("Base64-encoded file content"),
-        content_type: _zod.z.string().describe('MIME type, e.g. "application/pdf" or "image/png"'),
-        parent_folder_path: _zod.z.string().optional().describe('Destination folder path within the course, e.g. "subfolder/nested"')
-      },
-      annotations: {
-        destructiveHint: true,
-        openWorldHint: true
-      },
-      handler: async (params) => {
-        const course_id = params.course_id;
-        const name = params.name;
-        const content = params.content;
-        const content_type = params.content_type;
-        const parent_folder_path = params.parent_folder_path;
-        return canvas.files.upload(course_id, name, content, content_type, parent_folder_path);
+      handler: async () => {
+        return canvas.dashboard.getUpcomingEvents();
       }
     },
     {
-      name: "delete_file",
-      description: "Delete a file by ID. This action is permanent.",
-      inputSchema: {
-        file_id: _zod.z.number().describe("The Canvas file ID")
-      },
+      name: "get_missing_submissions",
+      description: "Get assignments with missing submissions for the current user.",
+      inputSchema: {},
       annotations: {
-        destructiveHint: true,
+        readOnlyHint: true,
         openWorldHint: true
       },
-      handler: async (params) => {
-        const file_id = params.file_id;
-        return canvas.files.delete(file_id);
+      handler: async () => {
+        return canvas.dashboard.getMissingSubmissions();
       }
     }
   ];
 }
 
-// src/tools/users.ts
+// src/tools/discussions.ts
 
-function userTools(canvas) {
+function discussionTools(canvas) {
   return [
     {
-      name: "list_students",
-      description: "List all students enrolled in a course.",
+      name: "list_discussions",
+      description: "List all discussion topics in a course.",
       inputSchema: {
         course_id: _zod.z.number().describe("The Canvas course ID")
       },
@@ -684,111 +662,132 @@ function userTools(canvas) {
       },
       handler: async (params) => {
         const course_id = params.course_id;
-        return canvas.users.listStudents(course_id);
+        return canvas.discussions.list(course_id);
       }
     },
     {
-      name: "get_user",
-      description: "Get details for a single user by ID.",
+      name: "get_discussion",
+      description: "Get details for a single discussion topic by ID.",
       inputSchema: {
-        user_id: _zod.z.number().describe("The Canvas user ID")
+        course_id: _zod.z.number().describe("The Canvas course ID"),
+        topic_id: _zod.z.number().describe("The Canvas discussion topic ID")
       },
       annotations: {
         readOnlyHint: true,
         openWorldHint: true
       },
       handler: async (params) => {
-        const user_id = params.user_id;
-        return canvas.users.get(user_id);
+        const course_id = params.course_id;
+        const topic_id = params.topic_id;
+        return canvas.discussions.get(course_id, topic_id);
       }
     },
     {
-      name: "get_profile",
-      description: "Get the profile of the currently authenticated user.",
-      inputSchema: {},
+      name: "list_announcements",
+      description: "List all announcements in a course.",
+      inputSchema: {
+        course_id: _zod.z.number().describe("The Canvas course ID")
+      },
       annotations: {
         readOnlyHint: true,
         openWorldHint: true
       },
-      handler: async () => {
-        return canvas.users.getProfile();
+      handler: async (params) => {
+        const course_id = params.course_id;
+        return canvas.discussions.listAnnouncements(course_id);
       }
     },
     {
-      name: "search_users",
-      description: "Search for users in a Canvas account by name, login, or email.",
+      name: "post_discussion_entry",
+      description: "Post a new entry (reply) to a discussion topic.",
       inputSchema: {
-        account_id: _zod.z.number().describe("The Canvas account ID"),
-        search_term: _zod.z.string().describe("The search term (name, login, or email)"),
-        sort: _zod.z.enum(["username", "email", "sis_id", "last_login"]).optional().describe("Sort field"),
-        order: _zod.z.enum(["asc", "desc"]).optional().describe("Sort order")
+        course_id: _zod.z.number().describe("The Canvas course ID"),
+        topic_id: _zod.z.number().describe("The Canvas discussion topic ID"),
+        message: _zod.z.string().describe("The message body (supports HTML)")
       },
       annotations: {
-        readOnlyHint: true,
+        destructiveHint: true,
         openWorldHint: true
       },
       handler: async (params) => {
-        return canvas.users.searchUsers(
-          params.account_id,
-          params.search_term,
-          params.sort,
-          params.order
-        );
+        const course_id = params.course_id;
+        const topic_id = params.topic_id;
+        const message = params.message;
+        return canvas.discussions.postEntry(course_id, topic_id, message);
       }
     },
     {
-      name: "list_course_users",
-      description: "List all users in a course, optionally filtered by enrollment type.",
+      name: "create_discussion",
+      description: "Create a new discussion topic in a course.",
       inputSchema: {
         course_id: _zod.z.number().describe("The Canvas course ID"),
-        enrollment_type: _zod.z.enum(["student", "teacher", "ta", "observer", "designer"]).optional().describe("Filter by enrollment type")
+        title: _zod.z.string().min(1).describe("Title of the discussion topic"),
+        message: _zod.z.string().optional().describe("Body text of the discussion (supports HTML)"),
+        discussion_type: _zod.z.enum(["side_comment", "threaded"]).optional().describe("Discussion type: side_comment (flat) or threaded"),
+        published: _zod.z.boolean().optional().describe("Whether the topic is published"),
+        require_initial_post: _zod.z.boolean().optional().describe("Require students to post before seeing replies")
       },
       annotations: {
-        readOnlyHint: true,
+        destructiveHint: true,
         openWorldHint: true
       },
       handler: async (params) => {
-        return canvas.users.listCourseUsers(
-          params.course_id,
-          params.enrollment_type
-        );
+        const course_id = params.course_id;
+        return canvas.discussions.create(course_id, {
+          title: params.title,
+          message: params.message,
+          discussion_type: params.discussion_type,
+          published: params.published,
+          require_initial_post: params.require_initial_post
+        });
       }
-    }
-  ];
-}
-
-// src/tools/groups.ts
-
-function groupTools(canvas) {
-  return [
+    },
     {
-      name: "list_groups",
-      description: "List all groups in a course.",
+      name: "update_discussion",
+      description: "Update an existing discussion topic.",
       inputSchema: {
-        course_id: _zod.z.number().describe("The Canvas course ID")
+        course_id: _zod.z.number().describe("The Canvas course ID"),
+        topic_id: _zod.z.number().describe("The Canvas discussion topic ID"),
+        title: _zod.z.string().optional().describe("New title for the discussion topic"),
+        message: _zod.z.string().optional().describe("New body text (supports HTML)"),
+        published: _zod.z.boolean().optional().describe("Publish or unpublish the topic"),
+        require_initial_post: _zod.z.boolean().optional().describe("Require students to post before seeing replies")
       },
       annotations: {
-        readOnlyHint: true,
+        destructiveHint: true,
         openWorldHint: true
       },
       handler: async (params) => {
         const course_id = params.course_id;
-        return canvas.groups.list(course_id);
+        const topic_id = params.topic_id;
+        const updateParams = {
+          title: params.title,
+          message: params.message,
+          published: params.published,
+          require_initial_post: params.require_initial_post
+        };
+        if (Object.values(updateParams).every((v) => v === void 0)) {
+          throw new Error("At least one field must be provided to update a discussion topic");
+        }
+        return canvas.discussions.update(course_id, topic_id, updateParams);
       }
     },
     {
-      name: "list_group_members",
-      description: "List all members of a group.",
+      name: "delete_discussion",
+      description: "Delete a discussion topic from a course.",
       inputSchema: {
-        group_id: _zod.z.number().describe("The Canvas group ID")
+        course_id: _zod.z.number().describe("The Canvas course ID"),
+        topic_id: _zod.z.number().describe("The Canvas discussion topic ID to delete")
       },
       annotations: {
-        readOnlyHint: true,
+        destructiveHint: true,
         openWorldHint: true
       },
       handler: async (params) => {
-        const group_id = params.group_id;
-        return canvas.groups.listMembers(group_id);
+        const course_id = params.course_id;
+        const topic_id = params.topic_id;
+        await canvas.discussions.delete(course_id, topic_id);
+        return { deleted: true, topic_id };
       }
     }
   ];
@@ -861,13 +860,13 @@ function enrollmentTools(canvas) {
   ];
 }
 
-// src/tools/discussions.ts
+// src/tools/files.ts
 
-function discussionTools(canvas) {
+function fileTools(canvas) {
   return [
     {
-      name: "list_discussions",
-      description: "List all discussion topics in a course.",
+      name: "list_files",
+      description: "List all files in a course.",
       inputSchema: {
         course_id: _zod.z.number().describe("The Canvas course ID")
       },
@@ -877,15 +876,14 @@ function discussionTools(canvas) {
       },
       handler: async (params) => {
         const course_id = params.course_id;
-        return canvas.discussions.list(course_id);
+        return canvas.files.list(course_id);
       }
     },
     {
-      name: "get_discussion",
-      description: "Get details for a single discussion topic by ID.",
+      name: "list_folders",
+      description: "List all folders in a course.",
       inputSchema: {
-        course_id: _zod.z.number().describe("The Canvas course ID"),
-        topic_id: _zod.z.number().describe("The Canvas discussion topic ID")
+        course_id: _zod.z.number().describe("The Canvas course ID")
       },
       annotations: {
         readOnlyHint: true,
@@ -893,15 +891,15 @@ function discussionTools(canvas) {
       },
       handler: async (params) => {
         const course_id = params.course_id;
-        const topic_id = params.topic_id;
-        return canvas.discussions.get(course_id, topic_id);
+        return canvas.files.listFolders(course_id);
       }
     },
     {
-      name: "list_announcements",
-      description: "List all announcements in a course.",
+      name: "get_file",
+      description: "Get metadata for a single file by ID, including download URL.",
       inputSchema: {
-        course_id: _zod.z.number().describe("The Canvas course ID")
+        course_id: _zod.z.number().describe("The Canvas course ID"),
+        file_id: _zod.z.number().describe("The Canvas file ID")
       },
       annotations: {
         readOnlyHint: true,
@@ -909,16 +907,19 @@ function discussionTools(canvas) {
       },
       handler: async (params) => {
         const course_id = params.course_id;
-        return canvas.discussions.listAnnouncements(course_id);
+        const file_id = params.file_id;
+        return canvas.files.get(course_id, file_id);
       }
     },
     {
-      name: "post_discussion_entry",
-      description: "Post a new entry (reply) to a discussion topic.",
+      name: "upload_file",
+      description: "Upload a file to a course. Content must be base64-encoded. Canvas performs a multi-step upload internally.",
       inputSchema: {
         course_id: _zod.z.number().describe("The Canvas course ID"),
-        topic_id: _zod.z.number().describe("The Canvas discussion topic ID"),
-        message: _zod.z.string().describe("The message body (supports HTML)")
+        name: _zod.z.string().describe("File name including extension"),
+        content: _zod.z.string().describe("Base64-encoded file content"),
+        content_type: _zod.z.string().describe('MIME type, e.g. "application/pdf" or "image/png"'),
+        parent_folder_path: _zod.z.string().optional().describe('Destination folder path within the course, e.g. "subfolder/nested"')
       },
       annotations: {
         destructiveHint: true,
@@ -926,83 +927,82 @@ function discussionTools(canvas) {
       },
       handler: async (params) => {
         const course_id = params.course_id;
-        const topic_id = params.topic_id;
-        const message = params.message;
-        return canvas.discussions.postEntry(course_id, topic_id, message);
+        const name = params.name;
+        const content = params.content;
+        const content_type = params.content_type;
+        const parent_folder_path = params.parent_folder_path;
+        return canvas.files.upload(course_id, name, content, content_type, parent_folder_path);
       }
     },
     {
-      name: "create_discussion",
-      description: "Create a new discussion topic in a course.",
+      name: "delete_file",
+      description: "Delete a file by ID. This action is permanent.",
       inputSchema: {
-        course_id: _zod.z.number().describe("The Canvas course ID"),
-        title: _zod.z.string().min(1).describe("Title of the discussion topic"),
-        message: _zod.z.string().optional().describe("Body text of the discussion (supports HTML)"),
-        discussion_type: _zod.z.enum(["side_comment", "threaded"]).optional().describe("Discussion type: side_comment (flat) or threaded"),
-        published: _zod.z.boolean().optional().describe("Whether the topic is published"),
-        require_initial_post: _zod.z.boolean().optional().describe("Require students to post before seeing replies")
+        file_id: _zod.z.number().describe("The Canvas file ID")
       },
       annotations: {
         destructiveHint: true,
         openWorldHint: true
       },
       handler: async (params) => {
-        const course_id = params.course_id;
-        return canvas.discussions.create(course_id, {
-          title: params.title,
-          message: params.message,
-          discussion_type: params.discussion_type,
-          published: params.published,
-          require_initial_post: params.require_initial_post
-        });
+        const file_id = params.file_id;
+        return canvas.files.delete(file_id);
       }
-    },
-    {
-      name: "update_discussion",
-      description: "Update an existing discussion topic.",
-      inputSchema: {
-        course_id: _zod.z.number().describe("The Canvas course ID"),
-        topic_id: _zod.z.number().describe("The Canvas discussion topic ID"),
-        title: _zod.z.string().optional().describe("New title for the discussion topic"),
-        message: _zod.z.string().optional().describe("New body text (supports HTML)"),
-        published: _zod.z.boolean().optional().describe("Publish or unpublish the topic"),
-        require_initial_post: _zod.z.boolean().optional().describe("Require students to post before seeing replies")
+    }
+  ];
+}
+
+// src/tools/groups.ts
+
+function groupTools(canvas) {
+  return [
+    {
+      name: "list_groups",
+      description: "List all groups in a course.",
+      inputSchema: {
+        course_id: _zod.z.number().describe("The Canvas course ID")
       },
       annotations: {
-        destructiveHint: true,
+        readOnlyHint: true,
         openWorldHint: true
       },
       handler: async (params) => {
         const course_id = params.course_id;
-        const topic_id = params.topic_id;
-        const updateParams = {
-          title: params.title,
-          message: params.message,
-          published: params.published,
-          require_initial_post: params.require_initial_post
-        };
-        if (Object.values(updateParams).every((v) => v === void 0)) {
-          throw new Error("At least one field must be provided to update a discussion topic");
-        }
-        return canvas.discussions.update(course_id, topic_id, updateParams);
+        return canvas.groups.list(course_id);
       }
     },
     {
-      name: "delete_discussion",
-      description: "Delete a discussion topic from a course.",
+      name: "list_group_members",
+      description: "List all members of a group.",
       inputSchema: {
-        course_id: _zod.z.number().describe("The Canvas course ID"),
-        topic_id: _zod.z.number().describe("The Canvas discussion topic ID to delete")
+        group_id: _zod.z.number().describe("The Canvas group ID")
       },
       annotations: {
-        destructiveHint: true,
+        readOnlyHint: true,
         openWorldHint: true
       },
       handler: async (params) => {
-        const course_id = params.course_id;
-        const topic_id = params.topic_id;
-        await canvas.discussions.delete(course_id, topic_id);
-        return { deleted: true, topic_id };
+        const group_id = params.group_id;
+        return canvas.groups.listMembers(group_id);
+      }
+    }
+  ];
+}
+
+// src/tools/health.ts
+function healthTools(canvas) {
+  return [
+    {
+      name: "health_check",
+      description: "Check if the Canvas API is reachable and the token is valid. Returns ok/error status.",
+      inputSchema: {},
+      annotations: {
+        readOnlyHint: true,
+        openWorldHint: true
+      },
+      handler: async () => {
+        await canvas.users.getProfile();
+        return { status: "ok", message: "Canvas API is reachable" };
       }
     }
   ];
@@ -1151,246 +1151,330 @@ function moduleTools(canvas) {
   ];
 }
 
-// src/tools/pages.ts
+// src/tools/outcomes.ts
 
-function pageTools(canvas) {
+function outcomeTools(canvas) {
   return [
     {
-      name: "list_pages",
-      description: "List all wiki pages in a course.",
+      name: "get_root_outcome_group",
+      description: "Get the root outcome group for an account or course context.",
       inputSchema: {
-        course_id: _zod.z.number().describe("The Canvas course ID")
-      },
-      annotations: {
-        readOnlyHint: true,
-        openWorldHint: true
+        context_type: _zod.z.enum(_chunkXAOI3FO6cjs.OUTCOME_CONTEXT_TYPES).describe("Whether to read outcomes from an account or course context."),
+        context_id: _zod.z.number().describe("The Canvas account ID or course ID for the context.")
       },
-      handler: async (params) => {
-        const course_id = params.course_id;
-        return canvas.pages.list(course_id);
-      }
+      annotations: { readOnlyHint: true, openWorldHint: true },
+      handler: async (params) => canvas.outcomes.getRootOutcomeGroup(
+        params.context_type,
+        params.context_id
+      )
     },
     {
-      name: "get_page",
-      description: "Get a single wiki page by its URL slug.",
+      name: "list_outcome_groups",
+      description: "List all outcome groups for an account or course context.",
       inputSchema: {
-        course_id: _zod.z.number().describe("The Canvas course ID"),
-        page_url: _zod.z.string().describe('The page URL slug (e.g. "welcome-page")')
-      },
-      annotations: {
-        readOnlyHint: true,
-        openWorldHint: true
+        context_type: _zod.z.enum(_chunkXAOI3FO6cjs.OUTCOME_CONTEXT_TYPES).describe("Whether to read outcome groups from an account or course context."),
+        context_id: _zod.z.number().describe("The Canvas account ID or course ID for the context.")
       },
-      handler: async (params) => {
-        const course_id = params.course_id;
-        const page_url = params.page_url;
-        return canvas.pages.get(course_id, page_url);
-      }
+      annotations: { readOnlyHint: true, openWorldHint: true },
+      handler: async (params) => canvas.outcomes.listOutcomeGroups(
+        params.context_type,
+        params.context_id
+      )
     },
     {
-      name: "create_page",
-      description: "Create a new wiki page in a course.",
+      name: "list_outcome_group_links",
+      description: "List all outcome links in an account or course context.",
       inputSchema: {
-        course_id: _zod.z.number().describe("The Canvas course ID"),
-        title: _zod.z.string().describe("Title of the page"),
-        body: _zod.z.string().optional().describe("HTML body content of the page"),
-        published: _zod.z.boolean().optional().describe("Whether the page is published"),
-        editing_roles: _zod.z.string().optional().describe('Who can edit: "teachers", "students", "members", or "public"')
-      },
-      annotations: {
-        destructiveHint: true,
-        openWorldHint: true
+        context_type: _zod.z.enum(_chunkXAOI3FO6cjs.OUTCOME_CONTEXT_TYPES).describe("Whether to read outcome links from an account or course context."),
+        context_id: _zod.z.number().describe("The Canvas account ID or course ID for the context."),
+        outcome_style: _zod.z.enum(_chunkXAOI3FO6cjs.OUTCOME_DETAIL_LEVELS).optional().describe('Outcome detail level. Use "full" to include expanded outcome fields.'),
+        outcome_group_style: _zod.z.enum(_chunkXAOI3FO6cjs.OUTCOME_DETAIL_LEVELS).optional().describe(
+          'Outcome group detail level. Use "full" to include expanded outcome group fields.'
+        )
       },
-      handler: async (params) => {
-        const course_id = params.course_id;
-        return canvas.pages.create(course_id, {
-          title: params.title,
-          body: params.body,
-          published: params.published,
-          editing_roles: params.editing_roles
-        });
-      }
+      annotations: { readOnlyHint: true, openWorldHint: true },
+      handler: async (params) => canvas.outcomes.listOutcomeGroupLinks(
+        params.context_type,
+        params.context_id,
+        {
+          outcome_style: params.outcome_style,
+          outcome_group_style: params.outcome_group_style
+        }
+      )
     },
     {
-      name: "update_page",
-      description: "Update an existing wiki page.",
+      name: "get_outcome_group",
+      description: "Get details for a specific outcome group in an account or course context.",
       inputSchema: {
-        course_id: _zod.z.number().describe("The Canvas course ID"),
-        page_url: _zod.z.string().describe("The page URL slug"),
-        title: _zod.z.string().optional().describe("New title for the page"),
-        body: _zod.z.string().optional().describe("New HTML body content"),
-        published: _zod.z.boolean().optional().describe("Whether the page is published"),
-        editing_roles: _zod.z.string().optional().describe('Who can edit: "teachers", "students", "members", or "public"')
-      },
-      annotations: {
-        destructiveHint: true,
-        openWorldHint: true
+        context_type: _zod.z.enum(_chunkXAOI3FO6cjs.OUTCOME_CONTEXT_TYPES).describe("The outcome group context type."),
+        context_id: _zod.z.number().describe("The Canvas account ID or course ID for the context."),
+        outcome_group_id: _zod.z.number().describe("The Canvas outcome group ID.")
       },
-      handler: async (params) => {
-        const course_id = params.course_id;
-        const page_url = params.page_url;
-        return canvas.pages.update(course_id, page_url, {
-          title: params.title,
-          body: params.body,
-          published: params.published,
-          editing_roles: params.editing_roles
-        });
-      }
+      annotations: { readOnlyHint: true, openWorldHint: true },
+      handler: async (params) => canvas.outcomes.getOutcomeGroup(
+        params.context_type,
+        params.context_id,
+        params.outcome_group_id
+      )
     },
     {
-      name: "delete_page",
-      description: "Delete a wiki page from a course.",
+      name: "list_outcome_group_outcomes",
+      description: "List the linked outcomes directly under a specific outcome group.",
       inputSchema: {
-        course_id: _zod.z.number().describe("The Canvas course ID"),
-        page_url: _zod.z.string().describe("The page URL slug to delete")
-      },
-      annotations: {
-        destructiveHint: true,
-        openWorldHint: true
+        context_type: _zod.z.enum(_chunkXAOI3FO6cjs.OUTCOME_CONTEXT_TYPES).describe("The outcome group context type."),
+        context_id: _zod.z.number().describe("The Canvas account ID or course ID for the context."),
+        outcome_group_id: _zod.z.number().describe("The Canvas outcome group ID."),
+        outcome_style: _zod.z.enum(_chunkXAOI3FO6cjs.OUTCOME_DETAIL_LEVELS).optional().describe('Outcome detail level. Use "full" to include expanded outcome fields.')
       },
-      handler: async (params) => {
-        const course_id = params.course_id;
-        const page_url = params.page_url;
-        await canvas.pages.delete(course_id, page_url);
-        return { deleted: true, page_url };
-      }
-    }
-  ];
-}
-
-// src/tools/calendar.ts
-
-function calendarTools(canvas) {
-  return [
+      annotations: { readOnlyHint: true, openWorldHint: true },
+      handler: async (params) => canvas.outcomes.listGroupOutcomes(
+        params.context_type,
+        params.context_id,
+        params.outcome_group_id,
+        {
+          outcome_style: params.outcome_style
+        }
+      )
+    },
     {
-      name: "list_calendar_events",
-      description: "List calendar events for a course.",
+      name: "list_outcome_group_subgroups",
+      description: "List the immediate child outcome groups under a specific outcome group.",
       inputSchema: {
-        course_id: _zod.z.number().describe("The Canvas course ID")
-      },
-      annotations: {
-        readOnlyHint: true,
-        openWorldHint: true
+        context_type: _zod.z.enum(_chunkXAOI3FO6cjs.OUTCOME_CONTEXT_TYPES).describe("The outcome group context type."),
+        context_id: _zod.z.number().describe("The Canvas account ID or course ID for the context."),
+        outcome_group_id: _zod.z.number().describe("The Canvas outcome group ID.")
       },
-      handler: async (params) => {
-        const course_id = params.course_id;
-        return canvas.calendar.list(course_id);
-      }
+      annotations: { readOnlyHint: true, openWorldHint: true },
+      handler: async (params) => canvas.outcomes.listGroupSubgroups(
+        params.context_type,
+        params.context_id,
+        params.outcome_group_id
+      )
     },
     {
-      name: "create_calendar_event",
-      description: "Create a new calendar event in Canvas.",
+      name: "get_outcome",
+      description: "Get the full details for a specific learning outcome by ID.",
       inputSchema: {
-        context_code: _zod.z.string().describe('Canvas context code, e.g. "course_123" for a course event'),
-        title: _zod.z.string().describe("Event title"),
-        start_at: _zod.z.string().describe('Start time in ISO 8601 format, e.g. "2026-05-01T10:00:00Z"'),
-        end_at: _zod.z.string().optional().describe("End time in ISO 8601 format. Omit for all-day events."),
-        description: _zod.z.string().optional().describe("Event description (HTML allowed)"),
-        location_name: _zod.z.string().optional().describe("Location name")
+        outcome_id: _zod.z.number().describe("The Canvas outcome ID."),
+        add_defaults: _zod.z.boolean().optional().describe("Include default mastery colors and levels when Canvas supports it.")
       },
-      annotations: {
-        destructiveHint: true,
-        openWorldHint: true
+      annotations: { readOnlyHint: true, openWorldHint: true },
+      handler: async (params) => canvas.outcomes.getOutcome(params.outcome_id, {
+        add_defaults: params.add_defaults
+      })
+    },
+    {
+      name: "get_outcome_alignments",
+      description: "Get outcome alignments for a course, optionally filtered to a specific student or assignment.",
+      inputSchema: {
+        course_id: _zod.z.number().describe("The Canvas course ID."),
+        student_id: _zod.z.number().optional().describe("Optional Canvas user ID of the student to filter alignments by."),
+        assignment_id: _zod.z.number().optional().describe("Optional Canvas assignment ID to filter alignments by.")
       },
-      handler: async (params) => {
-        return canvas.calendar.createEvent({
-          context_code: params.context_code,
-          title: params.title,
-          start_at: params.start_at,
-          end_at: params.end_at,
-          description: params.description,
-          location_name: params.location_name
-        });
-      }
+      annotations: { readOnlyHint: true, openWorldHint: true },
+      handler: async (params) => canvas.outcomes.getOutcomeAlignments(params.course_id, {
+        student_id: params.student_id,
+        assignment_id: params.assignment_id
+      })
     },
     {
-      name: "update_calendar_event",
-      description: "Update an existing calendar event. Only provided fields are changed.",
+      name: "get_outcome_results",
+      description: "Get per-student outcome results for a course, with optional outcome, student, and alignment filters.",
       inputSchema: {
-        event_id: _zod.z.number().describe("The Canvas calendar event ID"),
-        title: _zod.z.string().optional().describe("New event title"),
-        start_at: _zod.z.string().optional().describe("New start time in ISO 8601 format"),
-        end_at: _zod.z.string().optional().describe("New end time in ISO 8601 format"),
-        description: _zod.z.string().optional().describe("New description (HTML allowed)"),
-        location_name: _zod.z.string().optional().describe("New location name")
+        course_id: _zod.z.number().describe("The Canvas course ID."),
+        user_ids: _zod.z.array(_zod.z.union([_zod.z.number(), _zod.z.string()])).optional().describe('Optional Canvas user IDs or SIS user IDs prefixed with "sis_user_id:".'),
+        outcome_ids: _zod.z.array(_zod.z.number()).optional().describe("Optional outcome IDs to restrict the results."),
+        include_alignments: _zod.z.boolean().optional().describe("Include linked alignment details in the response."),
+        include_hidden: _zod.z.boolean().optional().describe("Include hidden outcomes when Canvas supports it.")
       },
-      annotations: {
-        destructiveHint: true,
-        openWorldHint: true
+      annotations: { readOnlyHint: true, openWorldHint: true },
+      handler: async (params) => canvas.outcomes.getOutcomeResults(params.course_id, {
+        user_ids: params.user_ids,
+        outcome_ids: params.outcome_ids,
+        include_alignments: params.include_alignments,
+        include_hidden: params.include_hidden
+      })
+    },
+    {
+      name: "get_outcome_rollups",
+      description: "Get outcome rollups for a course, optionally aggregated or filtered by students, outcomes, and sort options.",
+      inputSchema: {
+        course_id: _zod.z.number().describe("The Canvas course ID."),
+        aggregate: _zod.z.enum(["course"]).optional().describe("Aggregate all student rollups into a single course-level rollup."),
+        aggregate_stat: _zod.z.enum(_chunkXAOI3FO6cjs.OUTCOME_ROLLUP_AGGREGATE_STATS).optional().describe('Statistic to use when aggregate="course".'),
+        user_ids: _zod.z.array(_zod.z.union([_zod.z.number(), _zod.z.string()])).optional().describe('Optional Canvas user IDs or SIS user IDs prefixed with "sis_user_id:".'),
+        outcome_ids: _zod.z.array(_zod.z.number()).optional().describe("Optional outcome IDs to restrict the rollups."),
+        include_courses: _zod.z.boolean().optional().describe("Include linked course details in the response payload."),
+        exclude: _zod.z.array(_zod.z.enum(_chunkXAOI3FO6cjs.OUTCOME_EXCLUDE_OPTIONS)).optional().describe("Optional rollup exclusions for missing users or missing outcome results."),
+        sort_by: _zod.z.enum(_chunkXAOI3FO6cjs.OUTCOME_ROLLUP_SORT_BY).optional().describe("Sort rollups by student name or by a specific outcome score."),
+        sort_outcome_id: _zod.z.number().optional().describe('Outcome ID to sort by when sort_by="outcome".'),
+        sort_order: _zod.z.enum(_chunkXAOI3FO6cjs.OUTCOME_SORT_ORDER).optional().describe("Sort order to apply when sorting rollups."),
+        add_defaults: _zod.z.boolean().optional().describe("Include default mastery colors and levels when Canvas supports it.")
       },
-      handler: async (params) => {
-        const event_id = params.event_id;
-        return canvas.calendar.updateEvent(event_id, {
-          title: params.title,
-          start_at: params.start_at,
-          end_at: params.end_at,
-          description: params.description,
-          location_name: params.location_name
-        });
-      }
+      annotations: { readOnlyHint: true, openWorldHint: true },
+      handler: async (params) => canvas.outcomes.getOutcomeRollups(params.course_id, {
+        aggregate: params.aggregate,
+        aggregate_stat: params.aggregate_stat,
+        user_ids: params.user_ids,
+        outcome_ids: params.outcome_ids,
+        include_courses: params.include_courses,
+        exclude: params.exclude,
+        sort_by: params.sort_by,
+        sort_outcome_id: params.sort_outcome_id,
+        sort_order: params.sort_order,
+        add_defaults: params.add_defaults
+      })
+    },
+    {
+      name: "get_outcome_contributing_scores",
+      description: "Get assignment or quiz scores that contributed to a specific outcome for one or more students in a course.",
+      inputSchema: {
+        course_id: _zod.z.number().describe("The Canvas course ID."),
+        outcome_id: _zod.z.number().describe("The Canvas outcome ID."),
+        user_ids: _zod.z.array(_zod.z.union([_zod.z.number(), _zod.z.string()])).optional().describe('Optional Canvas user IDs or SIS user IDs prefixed with "sis_user_id:".'),
+        only_assignment_alignments: _zod.z.boolean().optional().describe("Limit results to assignment alignments only."),
+        show_unpublished_assignments: _zod.z.boolean().optional().describe("Include unpublished assignments in the contributing score results.")
+      },
+      annotations: { readOnlyHint: true, openWorldHint: true },
+      handler: async (params) => canvas.outcomes.getOutcomeContributingScores(
+        params.course_id,
+        params.outcome_id,
+        {
+          user_ids: params.user_ids,
+          only_assignment_alignments: params.only_assignment_alignments,
+          show_unpublished_assignments: params.show_unpublished_assignments
+        }
+      )
+    },
+    {
+      name: "get_outcome_mastery_distribution",
+      description: "Get mastery distribution analytics for outcomes in a course, optionally filtered by students or outcomes.",
+      inputSchema: {
+        course_id: _zod.z.number().describe("The Canvas course ID."),
+        exclude: _zod.z.array(_zod.z.enum(_chunkXAOI3FO6cjs.OUTCOME_EXCLUDE_OPTIONS)).optional().describe("Optional exclusions for missing users or missing outcome results."),
+        outcome_ids: _zod.z.array(_zod.z.number()).optional().describe("Optional outcome IDs to restrict the distribution results."),
+        student_ids: _zod.z.array(_zod.z.union([_zod.z.number(), _zod.z.string()])).optional().describe('Optional Canvas student IDs or SIS user IDs prefixed with "sis_user_id:".'),
+        include_alignment_distributions: _zod.z.boolean().optional().describe("Include contributing score distributions for alignments."),
+        only_assignment_alignments: _zod.z.boolean().optional().describe("When including alignment distributions, limit them to assignments only."),
+        show_unpublished_assignments: _zod.z.boolean().optional().describe("Include unpublished assignments in alignment distributions."),
+        add_defaults: _zod.z.boolean().optional().describe("Include default mastery colors and levels when Canvas supports it.")
+      },
+      annotations: { readOnlyHint: true, openWorldHint: true },
+      handler: async (params) => canvas.outcomes.getOutcomeMasteryDistribution(params.course_id, {
+        exclude: params.exclude,
+        outcome_ids: params.outcome_ids,
+        student_ids: params.student_ids,
+        include_alignment_distributions: params.include_alignment_distributions,
+        only_assignment_alignments: params.only_assignment_alignments,
+        show_unpublished_assignments: params.show_unpublished_assignments,
+        add_defaults: params.add_defaults
+      })
     }
   ];
 }
 
-// src/tools/conversations.ts
+// src/tools/pages.ts
 
-function conversationTools(canvas) {
+function pageTools(canvas) {
   return [
     {
-      name: "list_conversations",
-      description: "List conversations (inbox messages) for the authenticated user.",
-      inputSchema: {},
+      name: "list_pages",
+      description: "List all wiki pages in a course.",
+      inputSchema: {
+        course_id: _zod.z.number().describe("The Canvas course ID")
+      },
       annotations: {
         readOnlyHint: true,
         openWorldHint: true
       },
-      handler: async () => {
-        return canvas.conversations.list();
+      handler: async (params) => {
+        const course_id = params.course_id;
+        return canvas.pages.list(course_id);
       }
     },
     {
-      name: "get_conversation",
-      description: "Get a single conversation with its full message thread.",
+      name: "get_page",
+      description: "Get a single wiki page by its URL slug.",
       inputSchema: {
-        conversation_id: _zod.z.number().describe("The conversation ID")
+        course_id: _zod.z.number().describe("The Canvas course ID"),
+        page_url: _zod.z.string().describe('The page URL slug (e.g. "welcome-page")')
       },
       annotations: {
         readOnlyHint: true,
         openWorldHint: true
       },
       handler: async (params) => {
-        return canvas.conversations.get(params.conversation_id);
+        const course_id = params.course_id;
+        const page_url = params.page_url;
+        return canvas.pages.get(course_id, page_url);
       }
     },
     {
-      name: "get_conversation_unread_count",
-      description: "Get the number of unread conversations for the authenticated user.",
-      inputSchema: {},
+      name: "create_page",
+      description: "Create a new wiki page in a course.",
+      inputSchema: {
+        course_id: _zod.z.number().describe("The Canvas course ID"),
+        title: _zod.z.string().describe("Title of the page"),
+        body: _zod.z.string().optional().describe("HTML body content of the page"),
+        published: _zod.z.boolean().optional().describe("Whether the page is published"),
+        editing_roles: _zod.z.string().optional().describe('Who can edit: "teachers", "students", "members", or "public"')
+      },
       annotations: {
-        readOnlyHint: true,
+        destructiveHint: true,
         openWorldHint: true
       },
-      handler: async () => {
-        return canvas.conversations.getUnreadCount();
+      handler: async (params) => {
+        const course_id = params.course_id;
+        return canvas.pages.create(course_id, {
+          title: params.title,
+          body: params.body,
+          published: params.published,
+          editing_roles: params.editing_roles
+        });
       }
     },
     {
-      name: "send_conversation",
-      description: "Send a new conversation message to one or more recipients.",
+      name: "update_page",
+      description: "Update an existing wiki page.",
       inputSchema: {
-        recipients: _zod.z.array(_zod.z.string()).describe("Array of recipient user IDs (as strings)"),
-        subject: _zod.z.string().describe("The conversation subject line"),
-        body: _zod.z.string().describe("The message body")
+        course_id: _zod.z.number().describe("The Canvas course ID"),
+        page_url: _zod.z.string().describe("The page URL slug"),
+        title: _zod.z.string().optional().describe("New title for the page"),
+        body: _zod.z.string().optional().describe("New HTML body content"),
+        published: _zod.z.boolean().optional().describe("Whether the page is published"),
+        editing_roles: _zod.z.string().optional().describe('Who can edit: "teachers", "students", "members", or "public"')
       },
       annotations: {
         destructiveHint: true,
         openWorldHint: true
       },
       handler: async (params) => {
-        const recipients = params.recipients;
-        const subject = params.subject;
-        const body = params.body;
-        return canvas.conversations.send(recipients, subject, body);
+        const course_id = params.course_id;
+        const page_url = params.page_url;
+        return canvas.pages.update(course_id, page_url, {
+          title: params.title,
+          body: params.body,
+          published: params.published,
+          editing_roles: params.editing_roles
+        });
+      }
+    },
+    {
+      name: "delete_page",
+      description: "Delete a wiki page from a course.",
+      inputSchema: {
+        course_id: _zod.z.number().describe("The Canvas course ID"),
+        page_url: _zod.z.string().describe("The page URL slug to delete")
+      },
+      annotations: {
+        destructiveHint: true,
+        openWorldHint: true
+      },
+      handler: async (params) => {
+        const course_id = params.course_id;
+        const page_url = params.page_url;
+        await canvas.pages.delete(course_id, page_url);
+        return { deleted: true, page_url };
       }
     }
   ];
@@ -1481,151 +1565,156 @@ function peerReviewTools(canvas) {
   ];
 }
 
-// src/tools/accounts.ts
+// src/tools/quizzes.ts
 
-function accountTools(canvas) {
+function quizTools(canvas) {
   return [
     {
-      name: "get_account",
-      description: "Get details for a Canvas account by ID.",
+      name: "list_quizzes",
+      description: "List all quizzes in a course.",
       inputSchema: {
-        account_id: _zod.z.number().describe("The Canvas account ID")
+        course_id: _zod.z.number().describe("The Canvas course ID")
       },
       annotations: {
         readOnlyHint: true,
         openWorldHint: true
       },
       handler: async (params) => {
-        return canvas.accounts.get(params.account_id);
+        const course_id = params.course_id;
+        return canvas.quizzes.list(course_id);
       }
     },
     {
-      name: "list_accounts",
-      description: "List all accounts accessible to the authenticated user.",
-      inputSchema: {},
+      name: "get_quiz",
+      description: "Get details for a single quiz by ID.",
+      inputSchema: {
+        course_id: _zod.z.number().describe("The Canvas course ID"),
+        quiz_id: _zod.z.number().describe("The Canvas quiz ID")
+      },
       annotations: {
         readOnlyHint: true,
         openWorldHint: true
       },
-      handler: async () => {
-        return canvas.accounts.list();
+      handler: async (params) => {
+        const course_id = params.course_id;
+        const quiz_id = params.quiz_id;
+        return canvas.quizzes.get(course_id, quiz_id);
       }
     },
     {
-      name: "list_sub_accounts",
-      description: "List sub-accounts under a given Canvas account.",
+      name: "list_quiz_submissions",
+      description: "List all submissions for a quiz.",
       inputSchema: {
-        account_id: _zod.z.number().describe("The parent Canvas account ID")
+        course_id: _zod.z.number().describe("The Canvas course ID"),
+        quiz_id: _zod.z.number().describe("The Canvas quiz ID")
       },
       annotations: {
         readOnlyHint: true,
         openWorldHint: true
       },
       handler: async (params) => {
-        return canvas.accounts.listSubAccounts(params.account_id);
+        const course_id = params.course_id;
+        const quiz_id = params.quiz_id;
+        return canvas.quizzes.listSubmissions(course_id, quiz_id);
       }
     },
     {
-      name: "list_account_courses",
-      description: "List courses under a given Canvas account.",
+      name: "list_quiz_questions",
+      description: "List all questions in a quiz.",
       inputSchema: {
-        account_id: _zod.z.number().describe("The Canvas account ID"),
-        search_term: _zod.z.string().optional().describe("Search courses by name or course code")
+        course_id: _zod.z.number().describe("The Canvas course ID"),
+        quiz_id: _zod.z.number().describe("The Canvas quiz ID")
       },
       annotations: {
         readOnlyHint: true,
         openWorldHint: true
       },
       handler: async (params) => {
-        return canvas.accounts.listCourses(params.account_id, {
-          search_term: params.search_term
-        });
+        const course_id = params.course_id;
+        const quiz_id = params.quiz_id;
+        return canvas.quizzes.listQuestions(course_id, quiz_id);
       }
     },
     {
-      name: "list_account_users",
-      description: "List users in a Canvas account.",
+      name: "get_quiz_submission_answers",
+      description: "Get a student's answers for a quiz submission.",
       inputSchema: {
-        account_id: _zod.z.number().describe("The Canvas account ID"),
-        search_term: _zod.z.string().optional().describe("Search users by name, email, or login")
+        quiz_submission_id: _zod.z.number().describe("The Canvas quiz submission ID")
       },
       annotations: {
         readOnlyHint: true,
         openWorldHint: true
       },
       handler: async (params) => {
-        return canvas.accounts.listUsers(params.account_id, {
-          search_term: params.search_term
-        });
+        const quiz_submission_id = params.quiz_submission_id;
+        return canvas.quizzes.getSubmissionAnswers(quiz_submission_id);
       }
     },
     {
-      name: "get_account_reports",
-      description: "List available report types for a Canvas account.",
+      name: "score_quiz_question",
+      description: "Score a specific question in a quiz submission. Specify attempt to score a particular attempt (omit for latest). Requires grading permissions.",
       inputSchema: {
-        account_id: _zod.z.number().describe("The Canvas account ID")
+        course_id: _zod.z.number().describe("The Canvas course ID"),
+        quiz_id: _zod.z.number().describe("The Canvas quiz ID"),
+        submission_id: _zod.z.number().describe("The Canvas quiz submission ID"),
+        question_id: _zod.z.number().describe("The Canvas quiz question ID"),
+        score: _zod.z.number().describe("The score to assign"),
+        comment: _zod.z.string().optional().describe("Optional feedback comment"),
+        attempt: _zod.z.number().optional().describe("Quiz attempt number to score (omit for latest)")
       },
       annotations: {
-        readOnlyHint: true,
+        destructiveHint: true,
+        idempotentHint: true,
         openWorldHint: true
       },
       handler: async (params) => {
-        return canvas.accounts.getReports(params.account_id);
+        const course_id = params.course_id;
+        const quiz_id = params.quiz_id;
+        const submission_id = params.submission_id;
+        const question_id = params.question_id;
+        const score = params.score;
+        const comment = params.comment;
+        const attempt = params.attempt;
+        await canvas.quizzes.scoreQuestion(
+          course_id,
+          quiz_id,
+          submission_id,
+          question_id,
+          score,
+          comment,
+          attempt
+        );
+        return { success: true };
       }
     }
   ];
 }
 
-// src/tools/analytics.ts
+// src/tools/rubrics.ts
 
-function analyticsTools(canvas) {
+function rubricTools(canvas) {
   return [
     {
-      name: "search_course_content",
-      description: "Search for content within a course. Searches pages, assignments, discussions, and announcements by keyword.",
+      name: "list_rubrics",
+      description: "List all rubrics in a course.",
       inputSchema: {
-        course_id: _zod.z.number().describe("The Canvas course ID"),
-        search_term: _zod.z.string().describe("The keyword or phrase to search for"),
-        content_types: _zod.z.array(_zod.z.enum(_chunkXAOI3FO6cjs.SEARCH_CONTENT_TYPES)).optional().describe(
-          "Content types to search. Defaults to all types: pages, discussions, assignments, announcements."
-        )
+        course_id: _zod.z.number().describe("The Canvas course ID")
       },
       annotations: {
         readOnlyHint: true,
         openWorldHint: true
       },
       handler: async (params) => {
-        const courseId = params.course_id;
-        const searchTerm = params.search_term;
-        const types = _nullishCoalesce(params.content_types, () => ( [
-          ..._chunkXAOI3FO6cjs.SEARCH_CONTENT_TYPES
-        ]));
-        if (types.length === 0) return { results: [] };
-        const settled = await Promise.allSettled(
-          types.map((type) => canvas.analytics.searchContentType(courseId, searchTerm, type))
-        );
-        const fulfilled = settled.filter(
-          (r) => r.status === "fulfilled"
-        );
-        if (fulfilled.length === 0) {
-          const allErrors = settled.map(
-            (result, index) => result.status === "rejected" ? `${types[index]}: ${formatError(result.reason)}` : null
-          ).filter((errorLine) => errorLine !== null);
-          throw new Error(`All content type searches failed:
-${allErrors.join("\n")}`);
-        }
-        const results = fulfilled.flatMap((r) => r.value);
-        const warnings = settled.map(
-          (r, i) => r.status === "rejected" ? `${types[i]} search failed: ${formatError(r.reason)}` : null
-        ).filter((w) => w !== null);
-        return warnings.length > 0 ? { results, warnings } : { results };
+        const course_id = params.course_id;
+        return canvas.rubrics.list(course_id);
       }
     },
     {
-      name: "get_course_analytics",
-      description: "Get course-level activity analytics. Returns daily page view and participation counts.",
+      name: "get_rubric",
+      description: "Get details for a single rubric by ID, including criteria.",
       inputSchema: {
-        course_id: _zod.z.number().describe("The Canvas course ID")
+        course_id: _zod.z.number().describe("The Canvas course ID"),
+        rubric_id: _zod.z.number().describe("The Canvas rubric ID")
       },
       annotations: {
         readOnlyHint: true,
@@ -1633,15 +1722,17 @@ ${allErrors.join("\n")}`);
       },
       handler: async (params) => {
         const course_id = params.course_id;
-        return canvas.analytics.getCourseActivity(course_id);
+        const rubric_id = params.rubric_id;
+        return canvas.rubrics.get(course_id, rubric_id);
       }
     },
     {
-      name: "get_student_analytics",
-      description: "Get per-student activity analytics for a course. Returns page views, participations, and submission timeline for a specific student.",
+      name: "get_rubric_assessment",
+      description: "Get the rubric assessment for a specific student submission on an assignment.",
       inputSchema: {
         course_id: _zod.z.number().describe("The Canvas course ID"),
-        student_id: _zod.z.number().describe("The Canvas user ID of the student")
+        assignment_id: _zod.z.number().describe("The Canvas assignment ID"),
+        user_id: _zod.z.number().describe("The Canvas user ID")
       },
       annotations: {
         readOnlyHint: true,
@@ -1649,23 +1740,35 @@ ${allErrors.join("\n")}`);
       },
       handler: async (params) => {
         const course_id = params.course_id;
-        const student_id = params.student_id;
-        return canvas.analytics.getStudentActivity(course_id, student_id);
+        const assignment_id = params.assignment_id;
+        const user_id = params.user_id;
+        return canvas.rubrics.getAssessment(course_id, assignment_id, user_id);
       }
     },
     {
-      name: "get_course_activity_stream",
-      description: "Get a summary of recent activity in a course. Returns counts of recent events grouped by type (submissions, discussions, announcements, etc.).",
+      name: "submit_rubric_assessment",
+      description: "Submit a rubric assessment with scores and comments for each criterion.",
       inputSchema: {
-        course_id: _zod.z.number().describe("The Canvas course ID")
+        course_id: _zod.z.number().describe("The Canvas course ID"),
+        association_id: _zod.z.number().describe("The rubric association ID"),
+        data: _zod.z.array(
+          _zod.z.object({
+            criterion_id: _zod.z.string().describe("The rubric criterion ID"),
+            points: _zod.z.number().describe("Points awarded for this criterion"),
+            comments: _zod.z.string().describe("Feedback comment for this criterion")
+          })
+        ).describe("Array of criterion assessments")
       },
       annotations: {
-        readOnlyHint: true,
+        destructiveHint: true,
+        idempotentHint: true,
         openWorldHint: true
       },
       handler: async (params) => {
         const course_id = params.course_id;
-        return canvas.analytics.getCourseActivityStream(course_id);
+        const association_id = params.association_id;
+        const data = params.data;
+        return canvas.rubrics.submitAssessment(course_id, association_id, data);
       }
     }
   ];
@@ -1732,307 +1835,293 @@ function studentTools(canvas) {
   ];
 }
 
-// src/tools/dashboard.ts
-function dashboardTools(canvas) {
+// src/tools/submissions.ts
+
+function submissionTools(canvas) {
   return [
     {
-      name: "get_dashboard_cards",
-      description: "Get the current user's dashboard course cards with position, color, and image.",
-      inputSchema: {},
+      name: "list_submissions",
+      description: "List all submissions for an assignment in a course.",
+      inputSchema: {
+        course_id: _zod.z.number().describe("The Canvas course ID"),
+        assignment_id: _zod.z.number().describe("The Canvas assignment ID")
+      },
       annotations: {
         readOnlyHint: true,
         openWorldHint: true
       },
-      handler: async () => {
-        return canvas.dashboard.getDashboardCards();
+      handler: async (params) => {
+        const course_id = params.course_id;
+        const assignment_id = params.assignment_id;
+        return canvas.submissions.list(course_id, assignment_id);
       }
     },
     {
-      name: "get_todo_items",
-      description: "Get the current user's to-do items, including upcoming assignments and grading tasks.",
-      inputSchema: {},
+      name: "get_submission",
+      description: "Get a single submission for a specific user on an assignment, including comments.",
+      inputSchema: {
+        course_id: _zod.z.number().describe("The Canvas course ID"),
+        assignment_id: _zod.z.number().describe("The Canvas assignment ID"),
+        user_id: _zod.z.number().describe("The Canvas user ID")
+      },
       annotations: {
         readOnlyHint: true,
         openWorldHint: true
       },
-      handler: async () => {
-        return canvas.dashboard.getTodoItems();
+      handler: async (params) => {
+        const course_id = params.course_id;
+        const assignment_id = params.assignment_id;
+        const user_id = params.user_id;
+        return canvas.submissions.get(course_id, assignment_id, user_id);
       }
     },
     {
-      name: "get_upcoming_events",
-      description: "Get the current user's upcoming calendar events and assignments.",
-      inputSchema: {},
+      name: "grade_submission",
+      description: "Post or update a grade for a submission. Requires grading permissions.",
+      inputSchema: {
+        course_id: _zod.z.number().describe("The Canvas course ID"),
+        assignment_id: _zod.z.number().describe("The Canvas assignment ID"),
+        user_id: _zod.z.number().describe("The Canvas user ID"),
+        grade: _zod.z.string().describe('The grade to assign (e.g. "95", "A", "pass")')
+      },
       annotations: {
-        readOnlyHint: true,
+        destructiveHint: true,
+        idempotentHint: true,
         openWorldHint: true
       },
-      handler: async () => {
-        return canvas.dashboard.getUpcomingEvents();
+      handler: async (params) => {
+        const course_id = params.course_id;
+        const assignment_id = params.assignment_id;
+        const user_id = params.user_id;
+        const grade = params.grade;
+        return canvas.submissions.grade(course_id, assignment_id, user_id, grade);
       }
     },
     {
-      name: "get_missing_submissions",
-      description: "Get assignments with missing submissions for the current user.",
-      inputSchema: {},
+      name: "comment_on_submission",
+      description: "Add a text comment to a submission.",
+      inputSchema: {
+        course_id: _zod.z.number().describe("The Canvas course ID"),
+        assignment_id: _zod.z.number().describe("The Canvas assignment ID"),
+        user_id: _zod.z.number().describe("The Canvas user ID"),
+        comment: _zod.z.string().describe("The comment text to add")
+      },
       annotations: {
-        readOnlyHint: true,
+        destructiveHint: true,
         openWorldHint: true
       },
-      handler: async () => {
-        return canvas.dashboard.getMissingSubmissions();
+      handler: async (params) => {
+        const course_id = params.course_id;
+        const assignment_id = params.assignment_id;
+        const user_id = params.user_id;
+        const comment = params.comment;
+        return canvas.submissions.comment(course_id, assignment_id, user_id, comment);
       }
     }
   ];
 }
 
-// src/tools/outcomes.ts
+// src/tools/users.ts
 
-function outcomeTools(canvas) {
+function userTools(canvas) {
   return [
     {
-      name: "get_root_outcome_group",
-      description: "Get the root outcome group for an account or course context.",
-      inputSchema: {
-        context_type: _zod.z.enum(_chunkXAOI3FO6cjs.OUTCOME_CONTEXT_TYPES).describe("Whether to read outcomes from an account or course context."),
-        context_id: _zod.z.number().describe("The Canvas account ID or course ID for the context.")
-      },
-      annotations: { readOnlyHint: true, openWorldHint: true },
-      handler: async (params) => canvas.outcomes.getRootOutcomeGroup(
-        params.context_type,
-        params.context_id
-      )
-    },
-    {
-      name: "list_outcome_groups",
-      description: "List all outcome groups for an account or course context.",
-      inputSchema: {
-        context_type: _zod.z.enum(_chunkXAOI3FO6cjs.OUTCOME_CONTEXT_TYPES).describe("Whether to read outcome groups from an account or course context."),
-        context_id: _zod.z.number().describe("The Canvas account ID or course ID for the context.")
-      },
-      annotations: { readOnlyHint: true, openWorldHint: true },
-      handler: async (params) => canvas.outcomes.listOutcomeGroups(
-        params.context_type,
-        params.context_id
-      )
-    },
-    {
-      name: "list_outcome_group_links",
-      description: "List all outcome links in an account or course context.",
-      inputSchema: {
-        context_type: _zod.z.enum(_chunkXAOI3FO6cjs.OUTCOME_CONTEXT_TYPES).describe("Whether to read outcome links from an account or course context."),
-        context_id: _zod.z.number().describe("The Canvas account ID or course ID for the context."),
-        outcome_style: _zod.z.enum(_chunkXAOI3FO6cjs.OUTCOME_DETAIL_LEVELS).optional().describe('Outcome detail level. Use "full" to include expanded outcome fields.'),
-        outcome_group_style: _zod.z.enum(_chunkXAOI3FO6cjs.OUTCOME_DETAIL_LEVELS).optional().describe(
-          'Outcome group detail level. Use "full" to include expanded outcome group fields.'
-        )
-      },
-      annotations: { readOnlyHint: true, openWorldHint: true },
-      handler: async (params) => canvas.outcomes.listOutcomeGroupLinks(
-        params.context_type,
-        params.context_id,
-        {
-          outcome_style: params.outcome_style,
-          outcome_group_style: params.outcome_group_style
-        }
-      )
-    },
-    {
-      name: "get_outcome_group",
-      description: "Get details for a specific outcome group in an account or course context.",
+      name: "list_students",
+      description: "List all students enrolled in a course.",
       inputSchema: {
-        context_type: _zod.z.enum(_chunkXAOI3FO6cjs.OUTCOME_CONTEXT_TYPES).describe("The outcome group context type."),
-        context_id: _zod.z.number().describe("The Canvas account ID or course ID for the context."),
-        outcome_group_id: _zod.z.number().describe("The Canvas outcome group ID.")
+        course_id: _zod.z.number().describe("The Canvas course ID")
       },
-      annotations: { readOnlyHint: true, openWorldHint: true },
-      handler: async (params) => canvas.outcomes.getOutcomeGroup(
-        params.context_type,
-        params.context_id,
-        params.outcome_group_id
-      )
-    },
-    {
-      name: "list_outcome_group_outcomes",
-      description: "List the linked outcomes directly under a specific outcome group.",
-      inputSchema: {
-        context_type: _zod.z.enum(_chunkXAOI3FO6cjs.OUTCOME_CONTEXT_TYPES).describe("The outcome group context type."),
-        context_id: _zod.z.number().describe("The Canvas account ID or course ID for the context."),
-        outcome_group_id: _zod.z.number().describe("The Canvas outcome group ID."),
-        outcome_style: _zod.z.enum(_chunkXAOI3FO6cjs.OUTCOME_DETAIL_LEVELS).optional().describe('Outcome detail level. Use "full" to include expanded outcome fields.')
+      annotations: {
+        readOnlyHint: true,
+        openWorldHint: true
       },
-      annotations: { readOnlyHint: true, openWorldHint: true },
-      handler: async (params) => canvas.outcomes.listGroupOutcomes(
-        params.context_type,
-        params.context_id,
-        params.outcome_group_id,
-        {
-          outcome_style: params.outcome_style
-        }
-      )
+      handler: async (params) => {
+        const course_id = params.course_id;
+        return canvas.users.listStudents(course_id);
+      }
     },
     {
-      name: "list_outcome_group_subgroups",
-      description: "List the immediate child outcome groups under a specific outcome group.",
+      name: "get_user",
+      description: "Get details for a single user by ID.",
       inputSchema: {
-        context_type: _zod.z.enum(_chunkXAOI3FO6cjs.OUTCOME_CONTEXT_TYPES).describe("The outcome group context type."),
-        context_id: _zod.z.number().describe("The Canvas account ID or course ID for the context."),
-        outcome_group_id: _zod.z.number().describe("The Canvas outcome group ID.")
+        user_id: _zod.z.number().describe("The Canvas user ID")
       },
-      annotations: { readOnlyHint: true, openWorldHint: true },
-      handler: async (params) => canvas.outcomes.listGroupSubgroups(
-        params.context_type,
-        params.context_id,
-        params.outcome_group_id
-      )
-    },
-    {
-      name: "get_outcome",
-      description: "Get the full details for a specific learning outcome by ID.",
-      inputSchema: {
-        outcome_id: _zod.z.number().describe("The Canvas outcome ID."),
-        add_defaults: _zod.z.boolean().optional().describe("Include default mastery colors and levels when Canvas supports it.")
+      annotations: {
+        readOnlyHint: true,
+        openWorldHint: true
       },
-      annotations: { readOnlyHint: true, openWorldHint: true },
-      handler: async (params) => canvas.outcomes.getOutcome(params.outcome_id, {
-        add_defaults: params.add_defaults
-      })
+      handler: async (params) => {
+        const user_id = params.user_id;
+        return canvas.users.get(user_id);
+      }
     },
     {
-      name: "get_outcome_alignments",
-      description: "Get outcome alignments for a course, optionally filtered to a specific student or assignment.",
-      inputSchema: {
-        course_id: _zod.z.number().describe("The Canvas course ID."),
-        student_id: _zod.z.number().optional().describe("Optional Canvas user ID of the student to filter alignments by."),
-        assignment_id: _zod.z.number().optional().describe("Optional Canvas assignment ID to filter alignments by.")
+      name: "get_profile",
+      description: "Get the profile of the currently authenticated user.",
+      inputSchema: {},
+      annotations: {
+        readOnlyHint: true,
+        openWorldHint: true
       },
-      annotations: { readOnlyHint: true, openWorldHint: true },
-      handler: async (params) => canvas.outcomes.getOutcomeAlignments(params.course_id, {
-        student_id: params.student_id,
-        assignment_id: params.assignment_id
-      })
+      handler: async () => {
+        return canvas.users.getProfile();
+      }
     },
     {
-      name: "get_outcome_results",
-      description: "Get per-student outcome results for a course, with optional outcome, student, and alignment filters.",
+      name: "search_users",
+      description: "Search for users in a Canvas account by name, login, or email.",
       inputSchema: {
-        course_id: _zod.z.number().describe("The Canvas course ID."),
-        user_ids: _zod.z.array(_zod.z.union([_zod.z.number(), _zod.z.string()])).optional().describe('Optional Canvas user IDs or SIS user IDs prefixed with "sis_user_id:".'),
-        outcome_ids: _zod.z.array(_zod.z.number()).optional().describe("Optional outcome IDs to restrict the results."),
-        include_alignments: _zod.z.boolean().optional().describe("Include linked alignment details in the response."),
-        include_hidden: _zod.z.boolean().optional().describe("Include hidden outcomes when Canvas supports it.")
+        account_id: _zod.z.number().describe("The Canvas account ID"),
+        search_term: _zod.z.string().describe("The search term (name, login, or email)"),
+        sort: _zod.z.enum(["username", "email", "sis_id", "last_login"]).optional().describe("Sort field"),
+        order: _zod.z.enum(["asc", "desc"]).optional().describe("Sort order")
       },
-      annotations: { readOnlyHint: true, openWorldHint: true },
-      handler: async (params) => canvas.outcomes.getOutcomeResults(params.course_id, {
-        user_ids: params.user_ids,
-        outcome_ids: params.outcome_ids,
-        include_alignments: params.include_alignments,
-        include_hidden: params.include_hidden
-      })
-    },
-    {
-      name: "get_outcome_rollups",
-      description: "Get outcome rollups for a course, optionally aggregated or filtered by students, outcomes, and sort options.",
-      inputSchema: {
-        course_id: _zod.z.number().describe("The Canvas course ID."),
-        aggregate: _zod.z.enum(["course"]).optional().describe("Aggregate all student rollups into a single course-level rollup."),
-        aggregate_stat: _zod.z.enum(_chunkXAOI3FO6cjs.OUTCOME_ROLLUP_AGGREGATE_STATS).optional().describe('Statistic to use when aggregate="course".'),
-        user_ids: _zod.z.array(_zod.z.union([_zod.z.number(), _zod.z.string()])).optional().describe('Optional Canvas user IDs or SIS user IDs prefixed with "sis_user_id:".'),
-        outcome_ids: _zod.z.array(_zod.z.number()).optional().describe("Optional outcome IDs to restrict the rollups."),
-        include_courses: _zod.z.boolean().optional().describe("Include linked course details in the response payload."),
-        exclude: _zod.z.array(_zod.z.enum(_chunkXAOI3FO6cjs.OUTCOME_EXCLUDE_OPTIONS)).optional().describe("Optional rollup exclusions for missing users or missing outcome results."),
-        sort_by: _zod.z.enum(_chunkXAOI3FO6cjs.OUTCOME_ROLLUP_SORT_BY).optional().describe("Sort rollups by student name or by a specific outcome score."),
-        sort_outcome_id: _zod.z.number().optional().describe('Outcome ID to sort by when sort_by="outcome".'),
-        sort_order: _zod.z.enum(_chunkXAOI3FO6cjs.OUTCOME_SORT_ORDER).optional().describe("Sort order to apply when sorting rollups."),
-        add_defaults: _zod.z.boolean().optional().describe("Include default mastery colors and levels when Canvas supports it.")
+      annotations: {
+        readOnlyHint: true,
+        openWorldHint: true
       },
-      annotations: { readOnlyHint: true, openWorldHint: true },
-      handler: async (params) => canvas.outcomes.getOutcomeRollups(params.course_id, {
-        aggregate: params.aggregate,
-        aggregate_stat: params.aggregate_stat,
-        user_ids: params.user_ids,
-        outcome_ids: params.outcome_ids,
-        include_courses: params.include_courses,
-        exclude: params.exclude,
-        sort_by: params.sort_by,
-        sort_outcome_id: params.sort_outcome_id,
-        sort_order: params.sort_order,
-        add_defaults: params.add_defaults
-      })
+      handler: async (params) => {
+        return canvas.users.searchUsers(
+          params.account_id,
+          params.search_term,
+          params.sort,
+          params.order
+        );
+      }
     },
     {
-      name: "get_outcome_contributing_scores",
-      description: "Get assignment or quiz scores that contributed to a specific outcome for one or more students in a course.",
+      name: "list_course_users",
+      description: "List all users in a course, optionally filtered by enrollment type.",
       inputSchema: {
-        course_id: _zod.z.number().describe("The Canvas course ID."),
-        outcome_id: _zod.z.number().describe("The Canvas outcome ID."),
-        user_ids: _zod.z.array(_zod.z.union([_zod.z.number(), _zod.z.string()])).optional().describe('Optional Canvas user IDs or SIS user IDs prefixed with "sis_user_id:".'),
-        only_assignment_alignments: _zod.z.boolean().optional().describe("Limit results to assignment alignments only."),
-        show_unpublished_assignments: _zod.z.boolean().optional().describe("Include unpublished assignments in the contributing score results.")
+        course_id: _zod.z.number().describe("The Canvas course ID"),
+        enrollment_type: _zod.z.enum(["student", "teacher", "ta", "observer", "designer"]).optional().describe("Filter by enrollment type")
       },
-      annotations: { readOnlyHint: true, openWorldHint: true },
-      handler: async (params) => canvas.outcomes.getOutcomeContributingScores(
-        params.course_id,
-        params.outcome_id,
-        {
-          user_ids: params.user_ids,
-          only_assignment_alignments: params.only_assignment_alignments,
-          show_unpublished_assignments: params.show_unpublished_assignments
-        }
-      )
-    },
-    {
-      name: "get_outcome_mastery_distribution",
-      description: "Get mastery distribution analytics for outcomes in a course, optionally filtered by students or outcomes.",
-      inputSchema: {
-        course_id: _zod.z.number().describe("The Canvas course ID."),
-        exclude: _zod.z.array(_zod.z.enum(_chunkXAOI3FO6cjs.OUTCOME_EXCLUDE_OPTIONS)).optional().describe("Optional exclusions for missing users or missing outcome results."),
-        outcome_ids: _zod.z.array(_zod.z.number()).optional().describe("Optional outcome IDs to restrict the distribution results."),
-        student_ids: _zod.z.array(_zod.z.union([_zod.z.number(), _zod.z.string()])).optional().describe('Optional Canvas student IDs or SIS user IDs prefixed with "sis_user_id:".'),
-        include_alignment_distributions: _zod.z.boolean().optional().describe("Include contributing score distributions for alignments."),
-        only_assignment_alignments: _zod.z.boolean().optional().describe("When including alignment distributions, limit them to assignments only."),
-        show_unpublished_assignments: _zod.z.boolean().optional().describe("Include unpublished assignments in alignment distributions."),
-        add_defaults: _zod.z.boolean().optional().describe("Include default mastery colors and levels when Canvas supports it.")
+      annotations: {
+        readOnlyHint: true,
+        openWorldHint: true
       },
-      annotations: { readOnlyHint: true, openWorldHint: true },
-      handler: async (params) => canvas.outcomes.getOutcomeMasteryDistribution(params.course_id, {
-        exclude: params.exclude,
-        outcome_ids: params.outcome_ids,
-        student_ids: params.student_ids,
-        include_alignment_distributions: params.include_alignment_distributions,
-        only_assignment_alignments: params.only_assignment_alignments,
-        show_unpublished_assignments: params.show_unpublished_assignments,
-        add_defaults: params.add_defaults
-      })
+      handler: async (params) => {
+        return canvas.users.listCourseUsers(
+          params.course_id,
+          params.enrollment_type
+        );
+      }
     }
   ];
 }
 
+// src/tools/catalog.ts
+var toolDomainCatalog = [
+  {
+    domain: "health",
+    defaultPrimaryAudience: "shared",
+    getTools: healthTools
+  },
+  {
+    domain: "courses",
+    defaultPrimaryAudience: "shared",
+    getTools: courseTools
+  },
+  {
+    domain: "assignments",
+    defaultPrimaryAudience: "educator",
+    getTools: assignmentTools
+  },
+  {
+    domain: "submissions",
+    defaultPrimaryAudience: "educator",
+    getTools: submissionTools
+  },
+  {
+    domain: "rubrics",
+    defaultPrimaryAudience: "educator",
+    getTools: rubricTools
+  },
+  {
+    domain: "quizzes",
+    defaultPrimaryAudience: "educator",
+    getTools: quizTools
+  },
+  {
+    domain: "files",
+    defaultPrimaryAudience: "shared",
+    getTools: fileTools
+  },
+  {
+    domain: "users",
+    defaultPrimaryAudience: "educator",
+    getTools: userTools
+  },
+  {
+    domain: "groups",
+    defaultPrimaryAudience: "shared",
+    getTools: groupTools
+  },
+  {
+    domain: "enrollments",
+    defaultPrimaryAudience: "admin",
+    getTools: enrollmentTools
+  },
+  {
+    domain: "discussions",
+    defaultPrimaryAudience: "shared",
+    getTools: discussionTools
+  },
+  {
+    domain: "modules",
+    defaultPrimaryAudience: "educator",
+    getTools: moduleTools
+  },
+  {
+    domain: "pages",
+    defaultPrimaryAudience: "educator",
+    getTools: pageTools
+  },
+  {
+    domain: "calendar",
+    defaultPrimaryAudience: "shared",
+    getTools: calendarTools
+  },
+  {
+    domain: "conversations",
+    defaultPrimaryAudience: "shared",
+    getTools: conversationTools
+  },
+  {
+    domain: "peer_reviews",
+    defaultPrimaryAudience: "shared",
+    getTools: peerReviewTools
+  },
+  {
+    domain: "accounts",
+    defaultPrimaryAudience: "admin",
+    getTools: accountTools
+  },
+  {
+    domain: "analytics",
+    defaultPrimaryAudience: "educator",
+    getTools: analyticsTools
+  },
+  {
+    domain: "outcomes",
+    defaultPrimaryAudience: "educator",
+    getTools: outcomeTools
+  },
+  {
+    domain: "student",
+    defaultPrimaryAudience: "student",
+    getTools: studentTools
+  },
+  {
+    domain: "dashboard",
+    defaultPrimaryAudience: "student",
+    getTools: dashboardTools
+  }
+];
+
 // src/tools/index.ts
 function getAllTools(canvas) {
-  return [
-    ...healthTools(canvas),
-    ...courseTools(canvas),
-    ...assignmentTools(canvas),
-    ...submissionTools(canvas),
-    ...rubricTools(canvas),
-    ...quizTools(canvas),
-    ...fileTools(canvas),
-    ...userTools(canvas),
-    ...groupTools(canvas),
-    ...enrollmentTools(canvas),
-    ...discussionTools(canvas),
-    ...moduleTools(canvas),
-    ...pageTools(canvas),
-    ...calendarTools(canvas),
-    ...conversationTools(canvas),
-    ...peerReviewTools(canvas),
-    ...accountTools(canvas),
-    ...analyticsTools(canvas),
-    ...outcomeTools(canvas),
-    ...studentTools(canvas),
-    ...dashboardTools(canvas)
-  ];
+  return toolDomainCatalog.flatMap((registration) => registration.getTools(canvas));
 }
 function registerAllTools(server, canvas) {
   const tools = getAllTools(canvas);
@@ -2177,4 +2266,4 @@ function createCanvasMCPServer(config) {
 
 
 exports.createCanvasMCPServer = createCanvasMCPServer;
-//# sourceMappingURL=chunk-VDHNHHYO.cjs.map
+//# sourceMappingURL=chunk-2BS2WOAF.cjs.map