brightspace-d2l-mcp 1.0.0

package/build/tools/get-course-content.js

@@ -0,0 +1,175 @@
+import { DEFAULT_CACHE_TTLS } from "../api/index.js";
+import { GetCourseContentSchema } from "./schemas.js";
+import { toolResponse, sanitizeError } from "./tool-helpers.js";
+import { convertHtmlToMarkdown } from "../utils/html-converter.js";
+import { log } from "../utils/logger.js";
+// Topic type mapping
+const TOPIC_TYPE_MAP = {
+    1: 'file',
+    2: 'link',
+    3: 'link', // External link
+};
+function matchesTypeFilter(item, filter) {
+    switch (filter) {
+        case 'file':
+            return item.TopicType === 1;
+        case 'link':
+            return item.TopicType === 2 || item.TopicType === 3;
+        case 'html':
+            return !!(item.Description?.Html) && item.TopicType !== 1;
+        case 'video':
+            return (item.TopicType === 2 || item.TopicType === 3) &&
+                /youtube|vimeo|kaltura|video/i.test(item.Url ?? '');
+        default:
+            return true;
+    }
+}
+const MAX_CONTENT_DEPTH = 12;
+async function buildContentTree(apiClient, courseId, modules, progressMap, typeFilter, maxDepth, currentDepth = 0) {
+    const tree = [];
+    const depthLimit = Math.min(maxDepth ?? MAX_CONTENT_DEPTH, MAX_CONTENT_DEPTH);
+    for (const item of modules) {
+        if (item.Type === 0) {
+            // Module: fetch children recursively (unless the depth limit is reached)
+            let processedChildren = [];
+            if (currentDepth < depthLimit) {
+                let children = [];
+                try {
+                    children = await apiClient.get(apiClient.le(courseId, `/content/modules/${item.Id}/structure/`), { ttl: DEFAULT_CACHE_TTLS.courseContent });
+                }
+                catch (e) {
+                    log('DEBUG', `Failed to fetch children for module ${item.Id}: skipping`);
+                }
+                processedChildren = await buildContentTree(apiClient, courseId, children, progressMap, typeFilter, maxDepth, currentDepth + 1);
+            }
+            else if (currentDepth >= MAX_CONTENT_DEPTH) {
+                log('DEBUG', `Content depth ceiling of ${MAX_CONTENT_DEPTH} reached at module ${item.Id}: not descending further`);
+            }
+            // Only include module if it has matching children (or filter is 'all')
+            if (typeFilter === 'all' || processedChildren.length > 0) {
+                tree.push({
+                    type: 'module',
+                    id: item.Id,
+                    title: item.Title,
+                    description: item.Description?.Text ?? null,
+                    dueDate: item.ModuleDueDate ?? null,
+                    isHidden: item.IsHidden,
+                    isLocked: item.IsLocked,
+                    children: processedChildren,
+                });
+            }
+        }
+        else if (item.Type === 1) {
+            // Topic: process based on TopicType
+            const topicType = TOPIC_TYPE_MAP[item.TopicType ?? 0] ?? 'other';
+            // Apply type filter
+            if (typeFilter !== 'all' && !matchesTypeFilter(item, typeFilter)) {
+                continue;
+            }
+            const topicProgress = progressMap.get(item.Id);
+            const topic = {
+                type: 'topic',
+                topicType,
+                id: item.Id,
+                title: item.Title,
+                isHidden: item.IsHidden,
+                isLocked: item.IsLocked,
+                dueDate: item.DueDate ?? null,
+                isCompleted: topicProgress?.IsRead ?? false,
+                completedDate: topicProgress?.DateCompleted ?? null,
+            };
+            // Add type-specific content
+            if (item.TopicType === 1) {
+                // File topic: include description
+                topic.description = item.Description?.Text ?? null;
+                topic.topicId = item.Id; // Useful for download_file tool
+            }
+            else if (item.TopicType === 2 || item.TopicType === 3) {
+                // Link topic: include URL
+                topic.url = item.Url ?? null;
+            }
+            // HTML content: include body converted to markdown
+            if (item.Description?.Html) {
+                topic.content = convertHtmlToMarkdown(item.Description.Html);
+            }
+            tree.push(topic);
+        }
+    }
+    return tree;
+}
+function countTopics(tree) {
+    let count = 0;
+    for (const item of tree) {
+        if (item.type === 'topic') {
+            count++;
+        }
+        else if (item.type === 'module' && item.children) {
+            count += countTopics(item.children);
+        }
+    }
+    return count;
+}
+function countModules(tree) {
+    let count = 0;
+    for (const item of tree) {
+        if (item.type === 'module') {
+            count++;
+            if (item.children) {
+                count += countModules(item.children);
+            }
+        }
+    }
+    return count;
+}
+export function registerGetCourseContent(server, apiClient) {
+    server.registerTool("get_course_content", {
+        title: "Get Course Content",
+        description: "Fetch the content tree for a course showing modules, topics, files, and links. Use this when the user asks about course materials, lecture slides, uploaded files, content structure, or what's in a course module. Use moduleTitle to filter to a specific module (e.g. 'Labs', 'Staff', 'Homeworks') instead of fetching the entire tree. Use maxDepth to limit recursion depth for a table-of-contents view.",
+        inputSchema: GetCourseContentSchema,
+    }, async (args) => {
+        try {
+            log("DEBUG", "get_course_content tool called", { args });
+            // Parse and validate input
+            const { courseId, typeFilter = 'all', moduleTitle, maxDepth } = GetCourseContentSchema.parse(args);
+            // Fetch root modules
+            let rootModules = await apiClient.get(apiClient.le(courseId, '/content/root/'), { ttl: DEFAULT_CACHE_TTLS.courseContent });
+            // Filter root modules by title if specified
+            if (moduleTitle) {
+                const searchTerm = moduleTitle.toLowerCase();
+                rootModules = rootModules.filter(m => m.Title.toLowerCase().includes(searchTerm));
+            }
+            // Fetch user progress for the course (graceful degradation)
+            let progressArray = [];
+            try {
+                progressArray = await apiClient.get(apiClient.le(courseId, '/content/userprogress/'), { ttl: DEFAULT_CACHE_TTLS.courseContent });
+            }
+            catch (error) {
+                // 404/403 means no progress data available - not an error
+                if (error?.status !== 404 && error?.status !== 403) {
+                    log('DEBUG', `Failed to fetch progress for course ${courseId}`, error);
+                }
+            }
+            // Build progress map for O(1) lookups
+            const progressMap = new Map();
+            for (const p of progressArray) {
+                progressMap.set(p.ContentObjectId, p);
+            }
+            // Recursively build content tree
+            const contentTree = await buildContentTree(apiClient, courseId, rootModules, progressMap, typeFilter, maxDepth);
+            const topicCount = countTopics(contentTree);
+            const moduleCount = countModules(contentTree);
+            log("INFO", `get_course_content: Retrieved ${moduleCount} modules and ${topicCount} topics for course ${courseId} (filter: ${typeFilter})`);
+            return toolResponse({
+                courseId,
+                typeFilter,
+                contentTree,
+                topicCount,
+                moduleCount,
+            });
+        }
+        catch (error) {
+            return sanitizeError(error);
+        }
+    });
+}
+//# sourceMappingURL=get-course-content.js.map

package/build/tools/get-discussions.js

@@ -0,0 +1,192 @@
+import { DEFAULT_CACHE_TTLS } from "../api/index.js";
+import { GetDiscussionsSchema } from "./schemas.js";
+import { toolResponse, sanitizeError, errorResponse } from "./tool-helpers.js";
+import { convertHtmlToMarkdown } from "../utils/html-converter.js";
+import { log } from "../utils/logger.js";
+export function registerGetDiscussions(server, apiClient) {
+    server.registerTool("get_discussions", {
+        title: "Get Discussions",
+        description: "Fetch discussion board content for a course including forums, topics, and posts. Use this when the user asks about discussion boards, forum posts, class discussions, or wants to see what's been posted. Provide just courseId to list all forums and their topics. Add forumId to get topics and posts for a specific forum. Add both forumId and topicId to get all posts in a specific discussion topic.",
+        inputSchema: GetDiscussionsSchema,
+    }, async (args) => {
+        try {
+            log("DEBUG", "get_discussions tool called", { args });
+            const { courseId, forumId, topicId } = GetDiscussionsSchema.parse(args);
+            // topicId requires forumId
+            if (topicId !== undefined && forumId === undefined) {
+                return errorResponse("topicId requires forumId. Provide both forumId and topicId to get posts for a specific topic.");
+            }
+            // Specific topic: get posts
+            if (forumId !== undefined && topicId !== undefined) {
+                return await getTopicPosts(apiClient, courseId, forumId, topicId);
+            }
+            // Specific forum: get its topics + posts
+            if (forumId !== undefined) {
+                return await getForumDetail(apiClient, courseId, forumId);
+            }
+            // All forums overview
+            return await getForumsOverview(apiClient, courseId);
+        }
+        catch (error) {
+            return sanitizeError(error);
+        }
+    });
+}
+async function getForumsOverview(apiClient, courseId) {
+    const forumsPath = apiClient.le(courseId, "/discussions/forums/");
+    const forums = await apiClient.get(forumsPath, {
+        ttl: DEFAULT_CACHE_TTLS.courseContent,
+    });
+    const result = [];
+    for (const forum of forums) {
+        // Fetch topics for each forum
+        let topics = [];
+        try {
+            const topicsPath = apiClient.le(courseId, `/discussions/forums/${forum.ForumId}/topics/`);
+            topics = await apiClient.get(topicsPath, {
+                ttl: DEFAULT_CACHE_TTLS.courseContent,
+            });
+        }
+        catch (error) {
+            if (error?.status === 403) {
+                log("DEBUG", `No access to topics for forum ${forum.ForumId}, skipping`);
+            }
+            else {
+                log("DEBUG", `Failed to fetch topics for forum ${forum.ForumId}`, error);
+            }
+        }
+        result.push({
+            forumId: forum.ForumId,
+            name: forum.Name,
+            description: forum.Description?.Text ?? null,
+            isLocked: forum.IsLocked,
+            isHidden: forum.IsHidden,
+            topics: topics.map((t) => ({
+                topicId: t.TopicId,
+                forumId: t.ForumId,
+                name: t.Name,
+                description: t.Description?.Text ?? null,
+                dueDate: t.DueDate,
+                isLocked: t.IsLocked,
+                isHidden: t.IsHidden,
+                mustPostToParticipate: t.MustPostToParticipate,
+                scoreOutOf: t.ScoreOutOf,
+            })),
+        });
+    }
+    log("INFO", `get_discussions: Retrieved ${forums.length} forums for course ${courseId}`);
+    return toolResponse({
+        courseId,
+        forumCount: result.length,
+        forums: result,
+    });
+}
+async function getForumDetail(apiClient, courseId, forumId) {
+    // Fetch forum info
+    const forumPath = apiClient.le(courseId, `/discussions/forums/${forumId}`);
+    const forum = await apiClient.get(forumPath, {
+        ttl: DEFAULT_CACHE_TTLS.courseContent,
+    });
+    // Fetch topics
+    const topicsPath = apiClient.le(courseId, `/discussions/forums/${forumId}/topics/`);
+    const topics = await apiClient.get(topicsPath, {
+        ttl: DEFAULT_CACHE_TTLS.courseContent,
+    });
+    // Fetch posts for each topic
+    const topicsWithPosts = [];
+    for (const topic of topics) {
+        let posts = [];
+        try {
+            const postsPath = apiClient.le(courseId, `/discussions/forums/${forumId}/topics/${topic.TopicId}/posts/`);
+            posts = await apiClient.get(postsPath, {
+                ttl: DEFAULT_CACHE_TTLS.announcements,
+            });
+        }
+        catch (error) {
+            if (error?.status === 403) {
+                log("DEBUG", `No access to posts for topic ${topic.TopicId}, skipping`);
+            }
+            else {
+                log("DEBUG", `Failed to fetch posts for topic ${topic.TopicId}`, error);
+            }
+        }
+        topicsWithPosts.push({
+            topicId: topic.TopicId,
+            name: topic.Name,
+            description: topic.Description?.Html
+                ? convertHtmlToMarkdown(topic.Description.Html).markdown
+                : topic.Description?.Text ?? null,
+            dueDate: topic.DueDate,
+            isLocked: topic.IsLocked,
+            mustPostToParticipate: topic.MustPostToParticipate,
+            scoreOutOf: topic.ScoreOutOf,
+            postCount: posts.length,
+            posts: formatPosts(posts),
+        });
+    }
+    log("INFO", `get_discussions: Retrieved forum ${forumId} with ${topics.length} topics for course ${courseId}`);
+    return toolResponse({
+        courseId,
+        forum: {
+            forumId: forum.ForumId,
+            name: forum.Name,
+            description: forum.Description?.Text ?? null,
+            isLocked: forum.IsLocked,
+            isHidden: forum.IsHidden,
+        },
+        topicCount: topicsWithPosts.length,
+        topics: topicsWithPosts,
+    });
+}
+async function getTopicPosts(apiClient, courseId, forumId, topicId) {
+    // Fetch topic info
+    const topicPath = apiClient.le(courseId, `/discussions/forums/${forumId}/topics/${topicId}`);
+    const topic = await apiClient.get(topicPath, {
+        ttl: DEFAULT_CACHE_TTLS.courseContent,
+    });
+    // Fetch posts
+    const postsPath = apiClient.le(courseId, `/discussions/forums/${forumId}/topics/${topicId}/posts/`);
+    const posts = await apiClient.get(postsPath, {
+        ttl: DEFAULT_CACHE_TTLS.announcements,
+    });
+    log("INFO", `get_discussions: Retrieved ${posts.length} posts for topic ${topicId} in forum ${forumId}`);
+    return toolResponse({
+        courseId,
+        forumId,
+        topic: {
+            topicId: topic.TopicId,
+            name: topic.Name,
+            description: topic.Description?.Html
+                ? convertHtmlToMarkdown(topic.Description.Html).markdown
+                : topic.Description?.Text ?? null,
+            dueDate: topic.DueDate,
+            isLocked: topic.IsLocked,
+            mustPostToParticipate: topic.MustPostToParticipate,
+            scoreOutOf: topic.ScoreOutOf,
+        },
+        postCount: posts.length,
+        posts: formatPosts(posts),
+    });
+}
+function formatPosts(posts) {
+    return posts
+        .filter((p) => !p.IsDeleted)
+        .map((p) => ({
+        postId: p.PostId,
+        threadId: p.ThreadId,
+        parentPostId: p.ParentPostId,
+        subject: p.Subject,
+        message: p.Message?.Html
+            ? convertHtmlToMarkdown(p.Message.Html).markdown
+            : p.Message?.Text ?? "",
+        author: p.IsAnonymous ? "Anonymous" : p.PostingUserDisplayName,
+        datePosted: p.DatePosted,
+        lastEditedDate: p.LastEditedDate,
+        replyCount: p.ReplyPostIds?.length ?? 0,
+        wordCount: p.WordCount,
+        attachmentCount: p.AttachmentCount,
+        isRead: p.IsRead,
+    }))
+        .sort((a, b) => new Date(a.datePosted).getTime() - new Date(b.datePosted).getTime());
+}
+//# sourceMappingURL=get-discussions.js.map

package/build/tools/get-my-courses.js

@@ -0,0 +1,42 @@
+import { DEFAULT_CACHE_TTLS } from "../api/index.js";
+import { fetchAllItems } from "../api/paginate.js";
+import { GetMyCoursesSchema, } from "./schemas.js";
+import { toolResponse, sanitizeError } from "./tool-helpers.js";
+import { log } from "../utils/logger.js";
+import { applyCourseFilter } from "../utils/course-filter.js";
+export function registerGetMyCourses(server, apiClient, config) {
+    server.registerTool("get_my_courses", {
+        title: "Get My Courses",
+        description: "Fetch your enrolled Brightspace courses with names, codes, and IDs. Use this when the user asks about their courses, enrolled classes, what they're taking this semester, or needs a course ID for other queries.",
+        inputSchema: GetMyCoursesSchema,
+    }, async (args) => {
+        try {
+            log("DEBUG", "get_my_courses tool called", { args });
+            // Parse and validate input
+            const { activeOnly: activeOnlyArg } = GetMyCoursesSchema.parse(args);
+            const activeOnly = activeOnlyArg ?? config.courseFilter.activeOnly;
+            // Build path - orgUnitTypeId=3 means "Course Offering" type
+            const path = apiClient.lp(`/enrollments/myenrollments/?orgUnitTypeId=3${activeOnly ? "&isActive=true" : ""}`);
+            // Fetch enrollments, following the bookmark chain to the last page
+            const items = await fetchAllItems(apiClient, path, {
+                ttl: DEFAULT_CACHE_TTLS.enrollments,
+            });
+            // Map to clean objects and apply course filter
+            const courses = applyCourseFilter(items.map((item) => ({
+                id: item.OrgUnit.Id,
+                name: item.OrgUnit.Name,
+                code: item.OrgUnit.Code,
+                role: item.Access.ClasslistRoleName,
+                isActive: item.Access.IsActive,
+                canAccess: item.Access.CanAccess,
+                lastAccessed: item.Access.LastAccessed,
+            })), { ...config.courseFilter, activeOnly });
+            log("INFO", `get_my_courses: Retrieved ${courses.length} courses`);
+            return toolResponse(courses);
+        }
+        catch (error) {
+            return sanitizeError(error);
+        }
+    });
+}
+//# sourceMappingURL=get-my-courses.js.map

package/build/tools/get-my-grades.js

@@ -0,0 +1,93 @@
+import { DEFAULT_CACHE_TTLS } from "../api/index.js";
+import { GetMyGradesSchema, } from "./schemas.js";
+import { toolResponse, sanitizeError } from "./tool-helpers.js";
+import { log } from "../utils/logger.js";
+import { applyCourseFilter } from "../utils/course-filter.js";
+export function registerGetMyGrades(server, apiClient, config) {
+    server.registerTool("get_my_grades", {
+        title: "Get My Grades",
+        description: "Fetch your grade breakdown for a specific course or all enrolled courses. Shows grade items with points, percentages, and comments. Use this when the user asks about grades, scores, marks, GPA, academic performance, or how they're doing in a class.",
+        inputSchema: GetMyGradesSchema,
+    }, async (args) => {
+        try {
+            log("DEBUG", "get_my_grades tool called", { args });
+            // Parse and validate input
+            const { courseId } = GetMyGradesSchema.parse(args);
+            // Single course case
+            if (courseId) {
+                const path = apiClient.le(courseId, "/grades/values/myGradeValues/");
+                const gradeValues = await apiClient.get(path, {
+                    ttl: DEFAULT_CACHE_TTLS.grades,
+                });
+                // Map to clean objects
+                const grades = gradeValues.map((gv) => ({
+                    name: gv.GradeObjectName,
+                    displayGrade: gv.DisplayedGrade,
+                    pointsNumerator: gv.PointsNumerator,
+                    pointsDenominator: gv.PointsDenominator,
+                    weightedNumerator: gv.WeightedNumerator,
+                    weightedDenominator: gv.WeightedDenominator,
+                    comments: gv.Comments?.Text || null,
+                    lastModified: gv.LastModified,
+                }));
+                log("INFO", `get_my_grades: Retrieved ${grades.length} grade items for course ${courseId}`);
+                return toolResponse({ courseId, grades });
+            }
+            // All courses case
+            // First, fetch enrolled courses
+            const enrollmentPath = apiClient.lp("/enrollments/myenrollments/?orgUnitTypeId=3&isActive=true");
+            const enrollmentResponse = await apiClient.get(enrollmentPath, { ttl: DEFAULT_CACHE_TTLS.enrollments });
+            // Apply course filter
+            const filteredEnrollments = applyCourseFilter(enrollmentResponse.Items.map(item => ({
+                id: item.OrgUnit.Id,
+                name: item.OrgUnit.Name,
+                code: item.OrgUnit.Code,
+                isActive: item.Access.IsActive,
+                canAccess: item.Access.CanAccess,
+                ...item,
+            })), config.courseFilter);
+            // Fetch grades for each course (handle 403s gracefully)
+            const gradePromises = filteredEnrollments.map(async (item) => {
+                try {
+                    const path = apiClient.le(item.OrgUnit.Id, "/grades/values/myGradeValues/");
+                    const gradeValues = await apiClient.get(path, {
+                        ttl: DEFAULT_CACHE_TTLS.grades,
+                    });
+                    const grades = gradeValues.map((gv) => ({
+                        name: gv.GradeObjectName,
+                        displayGrade: gv.DisplayedGrade,
+                        pointsNumerator: gv.PointsNumerator,
+                        pointsDenominator: gv.PointsDenominator,
+                        weightedNumerator: gv.WeightedNumerator,
+                        weightedDenominator: gv.WeightedDenominator,
+                        comments: gv.Comments?.Text || null,
+                        lastModified: gv.LastModified,
+                    }));
+                    return {
+                        courseId: item.OrgUnit.Id,
+                        courseName: item.OrgUnit.Name,
+                        grades,
+                    };
+                }
+                catch (error) {
+                    // 403 means no access (past course, etc) - log and skip
+                    if (error?.status === 403) {
+                        log("DEBUG", `get_my_grades: 403 Forbidden for course ${item.OrgUnit.Id} (${item.OrgUnit.Name}) - skipping`);
+                        return null;
+                    }
+                    throw error; // Re-throw other errors
+                }
+            });
+            const results = await Promise.allSettled(gradePromises);
+            const courses = results
+                .filter((r) => r.status === "fulfilled" && r.value !== null)
+                .map((r) => r.value);
+            log("INFO", `get_my_grades: Retrieved grades for ${courses.length} courses (out of ${enrollmentResponse.Items.length} enrolled)`);
+            return toolResponse({ courses });
+        }
+        catch (error) {
+            return sanitizeError(error);
+        }
+    });
+}
+//# sourceMappingURL=get-my-grades.js.map

package/build/tools/get-roster.js

@@ -0,0 +1,99 @@
+import { DEFAULT_CACHE_TTLS } from "../api/index.js";
+import { fetchAllObjects } from "../api/paginate.js";
+import { GetRosterSchema, } from "./schemas.js";
+import { toolResponse, sanitizeError } from "./tool-helpers.js";
+import { log } from "../utils/logger.js";
+const INSTRUCTOR_ROLE_ID = 109;
+const TA_ROLE_ID = 135;
+async function fetchClasslistUsers(apiClient, courseId, options) {
+    const params = new URLSearchParams();
+    if (options?.roleId !== undefined) {
+        params.append("roleId", options.roleId.toString());
+    }
+    if (options?.searchTerm) {
+        params.append("searchTerm", options.searchTerm);
+    }
+    const queryString = params.toString();
+    const path = apiClient.le(courseId, `/classlist/paged/${queryString ? "?" + queryString : ""}`);
+    return fetchAllObjects(apiClient, path, {
+        ttl: DEFAULT_CACHE_TTLS.roster,
+    });
+}
+export function registerGetRoster(server, apiClient) {
+    server.registerTool("get_roster", {
+        title: "Get Course Roster",
+        description: "Fetch the roster for a course including instructors, TAs, and optionally students with their names, emails, and roles. Use this when the user asks about classmates, instructor contact info, TA emails, professor names, or who's in a class. By default returns only instructors and TAs for privacy. Use includeStudents to get full class list.",
+        inputSchema: GetRosterSchema,
+    }, async (args) => {
+        try {
+            log("DEBUG", "get_roster tool called", { args });
+            // Parse and validate input
+            const { courseId, includeStudents, searchTerm, limit } = GetRosterSchema.parse(args);
+            const allUsers = [];
+            if (!includeStudents) {
+                // Fetch instructors and TAs in parallel
+                const [instructorResult, taResult] = await Promise.allSettled([
+                    fetchClasslistUsers(apiClient, courseId, {
+                        roleId: INSTRUCTOR_ROLE_ID,
+                        searchTerm,
+                    }),
+                    fetchClasslistUsers(apiClient, courseId, {
+                        roleId: TA_ROLE_ID,
+                        searchTerm,
+                    }),
+                ]);
+                // Merge results
+                if (instructorResult.status === "fulfilled") {
+                    allUsers.push(...instructorResult.value);
+                }
+                else {
+                    log("WARN", "get_roster: Failed to fetch instructors", {
+                        error: instructorResult.reason,
+                    });
+                }
+                if (taResult.status === "fulfilled") {
+                    allUsers.push(...taResult.value);
+                }
+                else {
+                    log("WARN", "get_roster: Failed to fetch TAs", {
+                        error: taResult.reason,
+                    });
+                }
+            }
+            else {
+                // Fetch all users
+                allUsers.push(...(await fetchClasslistUsers(apiClient, courseId, { searchTerm })));
+            }
+            const total = allUsers.length;
+            const truncated = total > limit;
+            const kept = truncated ? allUsers.slice(0, limit) : allUsers;
+            if (truncated) {
+                log("WARN", "get_roster: Result set exceeds the limit, truncating", {
+                    total,
+                    returned: kept.length,
+                });
+            }
+            // Map to clean output
+            const users = kept.map((user) => ({
+                name: user.DisplayName,
+                email: user.Email || null,
+                role: user.ClasslistRoleDisplayName,
+            }));
+            log("INFO", `get_roster: Retrieved ${users.length} users for course ${courseId}`);
+            return toolResponse({
+                courseId,
+                total,
+                returned: users.length,
+                truncated,
+                ...(truncated
+                    ? { note: `Showing ${users.length} of ${total}. Raise the limit argument to see more.` }
+                    : {}),
+                users,
+            });
+        }
+        catch (error) {
+            return sanitizeError(error);
+        }
+    });
+}
+//# sourceMappingURL=get-roster.js.map