canvas-lms-mcp 1.5.0 → 1.6.0

package/dist/canvas/index.cjs

@@ -2,10 +2,14 @@
 
 
 
-var _chunk6HRYCB4Ccjs = require('../chunk-6HRYCB4C.cjs');
 
 
+var _chunkKEDPR66Wcjs = require('../chunk-KEDPR66W.cjs');
 
 
-exports.CanvasApiError = _chunk6HRYCB4Ccjs.CanvasApiError; exports.CanvasClient = _chunk6HRYCB4Ccjs.CanvasClient; exports.CanvasHttpClient = _chunk6HRYCB4Ccjs.CanvasHttpClient;
+
+
+
+
+exports.CanvasApiError = _chunkKEDPR66Wcjs.CanvasApiError; exports.CanvasClient = _chunkKEDPR66Wcjs.CanvasClient; exports.CanvasHttpClient = _chunkKEDPR66Wcjs.CanvasHttpClient; exports.appendCanvasQuery = _chunkKEDPR66Wcjs.appendCanvasQuery; exports.toCanvasQuery = _chunkKEDPR66Wcjs.toCanvasQuery;
 //# sourceMappingURL=index.cjs.map

package/dist/canvas/index.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["/home/runner/work/canvas-lms-mcp/canvas-lms-mcp/dist/canvas/index.cjs"],"names":[],"mappings":"AAAA;AACE;AACA;AACA;AACF,yDAA8B;AAC9B;AACE;AACA;AACA;AACF,gLAAC","file":"/home/runner/work/canvas-lms-mcp/canvas-lms-mcp/dist/canvas/index.cjs"}
+{"version":3,"sources":["/home/runner/work/canvas-lms-mcp/canvas-lms-mcp/dist/canvas/index.cjs"],"names":[],"mappings":"AAAA;AACE;AACA;AACA;AACA;AACA;AACF,yDAA8B;AAC9B;AACE;AACA;AACA;AACA;AACA;AACF,0SAAC","file":"/home/runner/work/canvas-lms-mcp/canvas-lms-mcp/dist/canvas/index.cjs"}

package/dist/canvas/index.js

@@ -1,11 +1,15 @@
 import {
   CanvasApiError,
   CanvasClient,
-  CanvasHttpClient
-} from "../chunk-X7YODHAN.js";
+  CanvasHttpClient,
+  appendCanvasQuery,
+  toCanvasQuery
+} from "../chunk-L3OHOWW5.js";
 export {
   CanvasApiError,
   CanvasClient,
-  CanvasHttpClient
+  CanvasHttpClient,
+  appendCanvasQuery,
+  toCanvasQuery
 };
 //# sourceMappingURL=index.js.map

package/dist/{chunk-FNBRFPKK.js → chunk-2ZN5FAAL.js}

@@ -8,7 +8,7 @@ import {
   OUTCOME_ROLLUP_SORT_BY,
   OUTCOME_SORT_ORDER,
   SEARCH_CONTENT_TYPES
-} from "./chunk-X7YODHAN.js";
+} from "./chunk-L3OHOWW5.js";
 
 // src/server.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
@@ -244,53 +244,148 @@ ${allErrors.join("\n")}`);
 
 // src/tools/assignments.ts
 import { z as z3 } from "zod";
+var ASSIGNMENT_LIST_INCLUDE = [
+  "submission",
+  "assignment_visibility",
+  "all_dates",
+  "overrides",
+  "observed_users",
+  "can_edit",
+  "score_statistics"
+];
+var ASSIGNMENT_GET_INCLUDE = [
+  "submission",
+  "assignment_visibility",
+  "overrides",
+  "observed_users",
+  "can_edit",
+  "score_statistics",
+  "all_dates"
+];
+var ASSIGNMENT_BUCKET = [
+  "past",
+  "overdue",
+  "undated",
+  "ungraded",
+  "unsubmitted",
+  "upcoming",
+  "future"
+];
+var ASSIGNMENT_ORDER_BY = ["position", "name", "due_at"];
+var ASSIGNMENT_GROUP_INCLUDE = [
+  "assignments",
+  "discussion_topic",
+  "all_dates",
+  "assignment_visibility",
+  "overrides",
+  "submission",
+  "observed_users",
+  "can_edit",
+  "score_statistics"
+];
 function assignmentTools(canvas) {
   return [
     {
       name: "list_assignments",
-      description: "List all assignments in a course.",
+      description: "List all assignments in a course. Use `include` to request submission, all_dates, overrides, score_statistics, etc. Use `bucket` to filter by past/upcoming/overdue/etc. Other filters: `search_term`, `assignment_ids`, `order_by`.",
       inputSchema: {
-        course_id: z3.number().describe("The Canvas course ID")
+        course_id: z3.number().describe("The Canvas course ID"),
+        include: z3.array(z3.enum(ASSIGNMENT_LIST_INCLUDE)).optional().describe("Extra fields to include on each assignment (Canvas include[] param)"),
+        search_term: z3.string().optional().describe("Partial name substring to filter assignments by"),
+        bucket: z3.enum(ASSIGNMENT_BUCKET).optional().describe("Only include assignments in the given bucket"),
+        assignment_ids: z3.array(z3.number()).optional().describe("Restrict to the given list of assignment IDs"),
+        order_by: z3.enum(ASSIGNMENT_ORDER_BY).optional().describe("Field to sort the result by"),
+        override_assignment_dates: z3.boolean().optional().describe(
+          "Apply assignment overrides to due/unlock/lock dates (default Canvas behavior: true)"
+        ),
+        needs_grading_count_by_section: z3.boolean().optional().describe("Break needs_grading_count down by section"),
+        post_to_sis: z3.boolean().optional().describe("Filter to assignments that are/are not posted to SIS")
       },
       annotations: {
         readOnlyHint: true,
         openWorldHint: true
       },
       handler: async (params) => {
-        const course_id = params.course_id;
-        return canvas.assignments.list(course_id);
+        const opts = {};
+        if (params.include !== void 0)
+          opts.include = params.include;
+        if (params.search_term !== void 0) opts.search_term = params.search_term;
+        if (params.bucket !== void 0) opts.bucket = params.bucket;
+        if (params.assignment_ids !== void 0)
+          opts.assignment_ids = params.assignment_ids;
+        if (params.order_by !== void 0) opts.order_by = params.order_by;
+        if (params.override_assignment_dates !== void 0)
+          opts.override_assignment_dates = params.override_assignment_dates;
+        if (params.needs_grading_count_by_section !== void 0)
+          opts.needs_grading_count_by_section = params.needs_grading_count_by_section;
+        if (params.post_to_sis !== void 0) opts.post_to_sis = params.post_to_sis;
+        return canvas.assignments.list(params.course_id, opts);
       }
     },
     {
       name: "get_assignment",
-      description: "Get details for a single assignment by ID.",
+      description: "Get details for a single assignment by ID. Use `include` to request submission, overrides, all_dates, score_statistics, and other optional fields.",
       inputSchema: {
         course_id: z3.number().describe("The Canvas course ID"),
-        assignment_id: z3.number().describe("The Canvas assignment ID")
+        assignment_id: z3.number().describe("The Canvas assignment ID"),
+        include: z3.array(z3.enum(ASSIGNMENT_GET_INCLUDE)).optional().describe("Extra fields to include on the assignment (Canvas include[] param)"),
+        override_assignment_dates: z3.boolean().optional().describe("Apply assignment overrides to due/unlock/lock dates"),
+        needs_grading_count_by_section: z3.boolean().optional().describe("Break needs_grading_count down by section"),
+        all_dates: z3.boolean().optional().describe("Return all dates associated with this assignment")
       },
       annotations: {
         readOnlyHint: true,
         openWorldHint: true
       },
       handler: async (params) => {
-        const course_id = params.course_id;
-        const assignment_id = params.assignment_id;
-        return canvas.assignments.get(course_id, assignment_id);
+        const opts = {};
+        if (params.include !== void 0)
+          opts.include = params.include;
+        if (params.override_assignment_dates !== void 0)
+          opts.override_assignment_dates = params.override_assignment_dates;
+        if (params.needs_grading_count_by_section !== void 0)
+          opts.needs_grading_count_by_section = params.needs_grading_count_by_section;
+        if (params.all_dates !== void 0) opts.all_dates = params.all_dates;
+        return canvas.assignments.get(
+          params.course_id,
+          params.assignment_id,
+          opts
+        );
       }
     },
     {
       name: "list_assignment_groups",
-      description: "List assignment groups (categories like Homework, Exams) in a course.",
+      description: "List assignment groups (categories like Homework, Exams) in a course. Use `include=assignments` to nest assignments under each group; other includes add submission, overrides, score_statistics, etc.",
       inputSchema: {
-        course_id: z3.number().describe("The Canvas course ID")
+        course_id: z3.number().describe("The Canvas course ID"),
+        include: z3.array(z3.enum(ASSIGNMENT_GROUP_INCLUDE)).optional().describe("Extra fields to include (Canvas include[] param)"),
+        assignment_ids: z3.array(z3.number()).optional().describe(
+          "When combined with include=assignments, restrict nested assignments to these IDs"
+        ),
+        exclude_assignment_submission_types: z3.array(z3.string()).optional().describe("Exclude assignments whose submission_types match any of these values"),
+        override_assignment_dates: z3.boolean().optional().describe("Apply assignment overrides to due/unlock/lock dates"),
+        grading_period_id: z3.number().int().optional().describe("Scope to a specific grading period"),
+        scope_assignments_to_student: z3.boolean().optional().describe("Limit assignments to what the current student can see")
       },
       annotations: {
         readOnlyHint: true,
         openWorldHint: true
       },
       handler: async (params) => {
-        const course_id = params.course_id;
-        return canvas.assignments.listGroups(course_id);
+        const opts = {};
+        if (params.include !== void 0)
+          opts.include = params.include;
+        if (params.assignment_ids !== void 0)
+          opts.assignment_ids = params.assignment_ids;
+        if (params.exclude_assignment_submission_types !== void 0)
+          opts.exclude_assignment_submission_types = params.exclude_assignment_submission_types;
+        if (params.override_assignment_dates !== void 0)
+          opts.override_assignment_dates = params.override_assignment_dates;
+        if (params.grading_period_id !== void 0)
+          opts.grading_period_id = params.grading_period_id;
+        if (params.scope_assignments_to_student !== void 0)
+          opts.scope_assignments_to_student = params.scope_assignments_to_student;
+        return canvas.assignments.listGroups(params.course_id, opts);
       }
     },
     {
@@ -500,36 +595,82 @@ function conversationTools(canvas) {
 
 // src/tools/courses.ts
 import { z as z6 } from "zod";
+var COURSE_LIST_INCLUDE = [
+  "needs_grading_count",
+  "syllabus_body",
+  "public_description",
+  "total_scores",
+  "current_grading_period_scores",
+  "grading_periods",
+  "term",
+  "account",
+  "course_progress",
+  "sections",
+  "storage_quota_used_mb",
+  "total_students",
+  "passback_status",
+  "favorites",
+  "teachers",
+  "observed_users",
+  "tabs",
+  "course_image",
+  "banner_image",
+  "concluded",
+  "lti_context_id",
+  "post_manually"
+];
+var COURSE_GET_INCLUDE = [...COURSE_LIST_INCLUDE, "all_courses", "permissions"];
+var COURSE_WORKFLOW_STATE = ["unpublished", "available", "completed", "deleted"];
+var COURSE_ENROLLMENT_STATE = ["active", "invited_or_pending", "completed"];
 function courseTools(canvas) {
   return [
     {
       name: "list_courses",
-      description: "List courses for the authenticated user. Optionally filter by enrollment state.",
+      description: "List courses for the authenticated user. `include` adds optional fields (teachers, total_students, term, syllabus_body, etc.). `state[]` narrows by course workflow state; `enrollment_state` narrows by the caller\u2019s enrollment state.",
       inputSchema: {
-        enrollment_state: z6.enum(["active", "completed", "all"]).optional().describe("Filter courses by enrollment state")
+        enrollment_state: z6.enum(COURSE_ENROLLMENT_STATE).optional().describe("Filter courses by the caller\u2019s enrollment state"),
+        state: z6.array(z6.enum(COURSE_WORKFLOW_STATE)).optional().describe("Filter by course workflow state"),
+        enrollment_role_id: z6.number().int().optional().describe("Filter by specific enrollment role ID"),
+        include: z6.array(z6.enum(COURSE_LIST_INCLUDE)).optional().describe("Extra fields to include on each course (Canvas include[] param)"),
+        exclude_blueprint_courses: z6.boolean().optional().describe("Exclude blueprint courses from the results")
       },
       annotations: {
         readOnlyHint: true,
         openWorldHint: true
       },
       handler: async (params) => {
-        const enrollment_state = params.enrollment_state;
-        return canvas.courses.list({ enrollment_state });
+        const opts = {};
+        if (params.enrollment_state !== void 0)
+          opts.enrollment_state = params.enrollment_state;
+        if (params.state !== void 0)
+          opts.state = params.state;
+        if (params.enrollment_role_id !== void 0)
+          opts.enrollment_role_id = params.enrollment_role_id;
+        if (params.include !== void 0)
+          opts.include = params.include;
+        if (params.exclude_blueprint_courses !== void 0)
+          opts.exclude_blueprint_courses = params.exclude_blueprint_courses;
+        return canvas.courses.list(opts);
       }
     },
     {
       name: "get_course",
-      description: "Get details for a single course by ID, including term and total student count.",
+      description: "Get details for a single course. Defaults to requesting `term` and `total_students`. Pass `include` to replace the default set with custom Canvas include[] fields (teachers, permissions, syllabus_body, sections, etc.).",
       inputSchema: {
-        course_id: z6.number().describe("The Canvas course ID")
+        course_id: z6.number().describe("The Canvas course ID"),
+        include: z6.array(z6.enum(COURSE_GET_INCLUDE)).optional().describe("Extra fields to include on the course (Canvas include[] param)"),
+        teacher_limit: z6.number().int().optional().describe("Limit on the number of teachers returned when include=teachers")
       },
       annotations: {
         readOnlyHint: true,
         openWorldHint: true
       },
       handler: async (params) => {
-        const course_id = params.course_id;
-        return canvas.courses.get(course_id);
+        const opts = {};
+        if (params.include !== void 0)
+          opts.include = params.include;
+        if (params.teacher_limit !== void 0) opts.teacher_limit = params.teacher_limit;
+        return canvas.courses.get(params.course_id, opts);
       }
     },
     {
@@ -795,18 +936,96 @@ function discussionTools(canvas) {
 
 // src/tools/enrollments.ts
 import { z as z8 } from "zod";
+var ENROLLMENT_TYPE = [
+  "StudentEnrollment",
+  "TeacherEnrollment",
+  "TaEnrollment",
+  "DesignerEnrollment",
+  "ObserverEnrollment"
+];
+var ENROLLMENT_STATE = [
+  "active",
+  "invited",
+  "creation_pending",
+  "deleted",
+  "rejected",
+  "completed",
+  "inactive",
+  "current_and_invited",
+  "current_and_future",
+  "current_and_concluded"
+];
+var ENROLLMENT_INCLUDE = [
+  "avatar_url",
+  "group_ids",
+  "locked",
+  "observed_users",
+  "can_be_removed",
+  "uuid",
+  "current_points",
+  "grades"
+];
 function enrollmentTools(canvas) {
   return [
     {
       name: "list_enrollments",
-      description: "List all enrollments for the authenticated user across courses.",
-      inputSchema: {},
+      description: "List all enrollments for the authenticated user across courses. Optional filters and includes mirror Canvas `GET /users/self/enrollments`.",
+      inputSchema: {
+        type: z8.array(z8.enum(ENROLLMENT_TYPE)).optional().describe("Filter by one or more enrollment types"),
+        state: z8.array(z8.enum(ENROLLMENT_STATE)).optional().describe("Filter by one or more enrollment states"),
+        role: z8.array(z8.string()).optional().describe("Filter by enrollment role names (as defined in the Canvas account)"),
+        include: z8.array(z8.enum(ENROLLMENT_INCLUDE)).optional().describe("Extra fields to include on each enrollment (Canvas include[] param)"),
+        grading_period_id: z8.number().int().optional().describe("Return enrollments scoped to this grading period"),
+        enrollment_term_id: z8.number().int().optional().describe("Limit to enrollments in the given term")
+      },
       annotations: {
         readOnlyHint: true,
         openWorldHint: true
       },
-      handler: async () => {
-        return canvas.enrollments.list();
+      handler: async (params) => {
+        const opts = {};
+        if (params.type !== void 0) opts.type = params.type;
+        if (params.state !== void 0) opts.state = params.state;
+        if (params.role !== void 0) opts.role = params.role;
+        if (params.include !== void 0)
+          opts.include = params.include;
+        if (params.grading_period_id !== void 0)
+          opts.grading_period_id = params.grading_period_id;
+        if (params.enrollment_term_id !== void 0)
+          opts.enrollment_term_id = params.enrollment_term_id;
+        return canvas.enrollments.list(opts);
+      }
+    },
+    {
+      name: "list_course_enrollments",
+      description: "List enrollments within a specific course with Canvas filters. Use `include=grades` / `include=current_points` for richer grade data, `type[]` to limit to a role, and `user_id` to focus on a single user.",
+      inputSchema: {
+        course_id: z8.number().describe("The Canvas course ID"),
+        type: z8.array(z8.enum(ENROLLMENT_TYPE)).optional().describe("Filter by one or more enrollment types"),
+        state: z8.array(z8.enum(ENROLLMENT_STATE)).optional().describe("Filter by enrollment states"),
+        role: z8.array(z8.string()).optional().describe("Filter by custom role names"),
+        include: z8.array(z8.enum(ENROLLMENT_INCLUDE)).optional().describe("Extra fields to include (Canvas include[] param)"),
+        user_id: z8.union([z8.number(), z8.string()]).optional().describe('Filter to a specific user (may be numeric ID or "self")'),
+        grading_period_id: z8.number().int().optional().describe("Scope grade-related includes to this grading period"),
+        enrollment_term_id: z8.number().int().optional().describe("Limit to enrollments in the given term")
+      },
+      annotations: {
+        readOnlyHint: true,
+        openWorldHint: true
+      },
+      handler: async (params) => {
+        const opts = {};
+        if (params.type !== void 0) opts.type = params.type;
+        if (params.state !== void 0) opts.state = params.state;
+        if (params.role !== void 0) opts.role = params.role;
+        if (params.include !== void 0)
+          opts.include = params.include;
+        if (params.user_id !== void 0) opts.user_id = params.user_id;
+        if (params.grading_period_id !== void 0)
+          opts.grading_period_id = params.grading_period_id;
+        if (params.enrollment_term_id !== void 0)
+          opts.enrollment_term_id = params.enrollment_term_id;
+        return canvas.enrollments.listForCourse(params.course_id, opts);
       }
     },
     {
@@ -1918,42 +2137,96 @@ function studentTools(canvas) {
 
 // src/tools/submissions.ts
 import { z as z19 } from "zod";
+var SUBMISSION_LIST_INCLUDE = [
+  "submission_history",
+  "submission_comments",
+  "rubric_assessment",
+  "assignment",
+  "visibility",
+  "course",
+  "user",
+  "group",
+  "read_status",
+  "sub_assignment_submissions"
+];
+var SUBMISSION_GET_INCLUDE = [
+  "submission_history",
+  "submission_comments",
+  "rubric_assessment",
+  "visibility",
+  "course",
+  "user",
+  "read_status"
+];
+var SUBMISSION_WORKFLOW_STATE = ["submitted", "unsubmitted", "graded", "pending_review"];
 function submissionTools(canvas) {
   return [
     {
       name: "list_submissions",
-      description: "List all submissions for an assignment in a course.",
+      description: "List all submissions for an assignment. Use `include` to attach user, assignment, rubric_assessment, submission_history, or visibility. Filter with `student_ids`, `workflow_state`, or `grading_period_id`. Defaults to including submission_comments.",
       inputSchema: {
         course_id: z19.number().describe("The Canvas course ID"),
-        assignment_id: z19.number().describe("The Canvas assignment ID")
+        assignment_id: z19.number().describe("The Canvas assignment ID"),
+        include: z19.array(z19.enum(SUBMISSION_LIST_INCLUDE)).optional().describe(
+          'Extra fields to include (Canvas include[] param). Defaults to ["submission_comments"] when omitted.'
+        ),
+        student_ids: z19.array(z19.union([z19.number(), z19.string()])).optional().describe(
+          'Restrict to submissions for these user IDs. Use "all" or "self" for shortcuts.'
+        ),
+        section_ids: z19.array(z19.number()).optional().describe("Restrict to submissions in these sections"),
+        grouped: z19.boolean().optional().describe("Return one submission per group rather than per student"),
+        workflow_state: z19.enum(SUBMISSION_WORKFLOW_STATE).optional().describe("Only include submissions in this workflow state"),
+        grading_period_id: z19.number().int().optional().describe("Restrict to a grading period")
       },
       annotations: {
         readOnlyHint: true,
         openWorldHint: true
       },
       handler: async (params) => {
-        const course_id = params.course_id;
-        const assignment_id = params.assignment_id;
-        return canvas.submissions.list(course_id, assignment_id);
+        const opts = {};
+        if (params.include !== void 0)
+          opts.include = params.include;
+        if (params.student_ids !== void 0)
+          opts.student_ids = params.student_ids;
+        if (params.section_ids !== void 0)
+          opts.section_ids = params.section_ids;
+        if (params.grouped !== void 0) opts.grouped = params.grouped;
+        if (params.workflow_state !== void 0)
+          opts.workflow_state = params.workflow_state;
+        if (params.grading_period_id !== void 0)
+          opts.grading_period_id = params.grading_period_id;
+        return canvas.submissions.list(
+          params.course_id,
+          params.assignment_id,
+          opts
+        );
       }
     },
     {
       name: "get_submission",
-      description: "Get a single submission for a specific user on an assignment, including comments.",
+      description: "Get a single submission for a specific user on an assignment. Defaults to including submission_comments. Pass `include` to add rubric_assessment, submission_history, visibility, course, user, or read_status.",
       inputSchema: {
         course_id: z19.number().describe("The Canvas course ID"),
         assignment_id: z19.number().describe("The Canvas assignment ID"),
-        user_id: z19.number().describe("The Canvas user ID")
+        user_id: z19.number().describe("The Canvas user ID"),
+        include: z19.array(z19.enum(SUBMISSION_GET_INCLUDE)).optional().describe(
+          'Extra fields to include (Canvas include[] param). Defaults to ["submission_comments"] when omitted.'
+        )
       },
       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.submissions.get(course_id, assignment_id, user_id);
+        const opts = {};
+        if (params.include !== void 0)
+          opts.include = params.include;
+        return canvas.submissions.get(
+          params.course_id,
+          params.assignment_id,
+          params.user_id,
+          opts
+        );
       }
     },
     {
@@ -2004,6 +2277,27 @@ function submissionTools(canvas) {
 
 // src/tools/users.ts
 import { z as z20 } from "zod";
+var COURSE_USER_ENROLLMENT_TYPE = ["student", "teacher", "ta", "observer", "designer"];
+var COURSE_USER_ENROLLMENT_STATE = [
+  "active",
+  "invited",
+  "rejected",
+  "completed",
+  "inactive"
+];
+var COURSE_USER_INCLUDE = [
+  "email",
+  "enrollments",
+  "locked",
+  "avatar_url",
+  "test_student",
+  "bio",
+  "custom_links",
+  "current_grading_period_scores",
+  "uuid"
+];
+var USER_SORT = ["username", "email", "sis_id", "integration_id", "last_login"];
+var SEARCH_USER_INCLUDE = ["email", "last_login", "avatar_url", "time_zone", "uuid"];
 function userTools(canvas) {
   return [
     {
@@ -2050,42 +2344,65 @@ function userTools(canvas) {
     },
     {
       name: "search_users",
-      description: "Search for users in a Canvas account by name, login, or email.",
+      description: "Search for users in a Canvas account by name, login, or email. Use `include` to request email, last_login, avatar_url, time_zone, or uuid in the response.",
       inputSchema: {
         account_id: z20.number().describe("The Canvas account ID"),
         search_term: z20.string().describe("The search term (name, login, or email)"),
-        sort: z20.enum(["username", "email", "sis_id", "last_login"]).optional().describe("Sort field"),
-        order: z20.enum(["asc", "desc"]).optional().describe("Sort order")
+        sort: z20.enum(USER_SORT).optional().describe("Sort field"),
+        order: z20.enum(["asc", "desc"]).optional().describe("Sort order"),
+        include: z20.array(z20.enum(SEARCH_USER_INCLUDE)).optional().describe("Extra fields to include on each user (Canvas include[] param)")
       },
       annotations: {
         readOnlyHint: true,
         openWorldHint: true
       },
       handler: async (params) => {
+        const opts = {};
+        if (params.sort !== void 0) opts.sort = params.sort;
+        if (params.order !== void 0) opts.order = params.order;
+        if (params.include !== void 0)
+          opts.include = params.include;
         return canvas.users.searchUsers(
           params.account_id,
           params.search_term,
-          params.sort,
-          params.order
+          opts
         );
       }
     },
     {
       name: "list_course_users",
-      description: "List all users in a course, optionally filtered by enrollment type.",
+      description: "List users in a course with optional Canvas filters. Use `include` to request email, enrollments, avatar_url, bio, and other fields otherwise omitted from the default response. Use `enrollment_type` / `enrollment_state` to narrow by role or status, `search_term` to filter by name/login, `user_ids` to fetch a specific subset, and `sort`/`order` to control ordering.",
       inputSchema: {
         course_id: z20.number().describe("The Canvas course ID"),
-        enrollment_type: z20.enum(["student", "teacher", "ta", "observer", "designer"]).optional().describe("Filter by enrollment type")
+        enrollment_type: z20.array(z20.enum(COURSE_USER_ENROLLMENT_TYPE)).optional().describe("Filter by one or more enrollment types"),
+        enrollment_state: z20.array(z20.enum(COURSE_USER_ENROLLMENT_STATE)).optional().describe("Filter by enrollment state (e.g. active, invited)"),
+        enrollment_role_id: z20.number().int().optional().describe("Filter by a specific enrollment role ID (overrides enrollment_type)"),
+        include: z20.array(z20.enum(COURSE_USER_INCLUDE)).optional().describe("Extra fields to include on each user (Canvas include[] param)"),
+        user_ids: z20.array(z20.union([z20.number(), z20.string()])).optional().describe("Restrict the result to the given user IDs"),
+        search_term: z20.string().optional().describe("Partial name or full login/SIS ID to filter users by"),
+        sort: z20.enum(USER_SORT).optional().describe("Sort field"),
+        order: z20.enum(["asc", "desc"]).optional().describe("Sort order")
       },
       annotations: {
         readOnlyHint: true,
         openWorldHint: true
       },
       handler: async (params) => {
-        return canvas.users.listCourseUsers(
-          params.course_id,
-          params.enrollment_type
-        );
+        const opts = {};
+        if (params.enrollment_type !== void 0)
+          opts.enrollment_type = params.enrollment_type;
+        if (params.enrollment_state !== void 0)
+          opts.enrollment_state = params.enrollment_state;
+        if (params.enrollment_role_id !== void 0)
+          opts.enrollment_role_id = params.enrollment_role_id;
+        if (params.include !== void 0)
+          opts.include = params.include;
+        if (params.user_ids !== void 0)
+          opts.user_ids = params.user_ids;
+        if (params.search_term !== void 0) opts.search_term = params.search_term;
+        if (params.sort !== void 0) opts.sort = params.sort;
+        if (params.order !== void 0) opts.order = params.order;
+        return canvas.users.listCourseUsers(params.course_id, opts);
       }
     }
   ];
@@ -2352,4 +2669,4 @@ function createCanvasMCPServer(config) {
 export {
   createCanvasMCPServer
 };
-//# sourceMappingURL=chunk-FNBRFPKK.js.map
+//# sourceMappingURL=chunk-2ZN5FAAL.js.map