brightspace-d2l-mcp 1.0.0

package/build/tools/get-announcements.js

@@ -0,0 +1,116 @@
+import { DEFAULT_CACHE_TTLS } from "../api/index.js";
+import { GetAnnouncementsSchema, } from "./schemas.js";
+import { toolResponse, sanitizeError } from "./tool-helpers.js";
+import { log } from "../utils/logger.js";
+import { applyCourseFilter } from "../utils/course-filter.js";
+function readableDate(raw) {
+    if (typeof raw !== "string")
+        return null;
+    return Number.isNaN(new Date(raw).getTime()) ? null : raw;
+}
+export function effectiveDate(item) {
+    return readableDate(item.StartDate) ?? readableDate(item.CreatedDate);
+}
+export function isPublishedNewsItem(item) {
+    return item.IsPublished !== false;
+}
+export function newestFirst(a, b) {
+    if (a.date === b.date)
+        return 0;
+    if (a.date === null)
+        return 1;
+    if (b.date === null)
+        return -1;
+    return new Date(b.date).getTime() - new Date(a.date).getTime();
+}
+export function mapNewsItem(item) {
+    return {
+        id: item.Id,
+        title: item.Title,
+        body: item.Body?.Text ?? "",
+        createdBy: item.CreatedBy?.DisplayName ?? "Unknown",
+        createdDate: item.CreatedDate,
+        startDate: item.StartDate,
+        date: effectiveDate(item),
+        isPinned: item.IsPinned,
+    };
+}
+export function registerGetAnnouncements(server, apiClient, config) {
+    server.registerTool("get_announcements", {
+        title: "Get Announcements",
+        description: "Fetch recent announcements from your courses. Can filter to a specific course or get announcements across all courses. Use this when the user asks about announcements, news, updates from instructors, recent posts, or what professors said.",
+        inputSchema: GetAnnouncementsSchema,
+    }, async (args) => {
+        try {
+            log("DEBUG", "get_announcements tool called", { args });
+            // Parse and validate input
+            const { courseId, count } = GetAnnouncementsSchema.parse(args);
+            // Single course case
+            if (courseId) {
+                const path = apiClient.le(courseId, "/news/");
+                const newsItems = await apiClient.get(path, {
+                    ttl: DEFAULT_CACHE_TTLS.announcements,
+                });
+                // Drop drafts, then map to clean objects
+                const announcements = newsItems
+                    .filter(isPublishedNewsItem)
+                    .map(mapNewsItem)
+                    .sort(newestFirst)
+                    .slice(0, count);
+                log("INFO", `get_announcements: Retrieved ${announcements.length} announcements for course ${courseId}`);
+                return toolResponse(announcements);
+            }
+            // 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 announcements for each course (handle 403s gracefully)
+            const announcementPromises = filteredEnrollments.map(async (item) => {
+                try {
+                    const path = apiClient.le(item.OrgUnit.Id, "/news/");
+                    const newsItems = await apiClient.get(path, {
+                        ttl: DEFAULT_CACHE_TTLS.announcements,
+                    });
+                    return newsItems
+                        .filter(isPublishedNewsItem)
+                        .map((newsItem) => ({
+                        ...mapNewsItem(newsItem),
+                        courseId: item.OrgUnit.Id,
+                        courseName: item.OrgUnit.Name,
+                    }));
+                }
+                catch (error) {
+                    // 403 means no access (past course, etc) - log and skip
+                    if (error?.status === 403) {
+                        log("DEBUG", `get_announcements: 403 Forbidden for course ${item.OrgUnit.Id} (${item.OrgUnit.Name}) - skipping`);
+                        return [];
+                    }
+                    throw error; // Re-throw other errors
+                }
+            });
+            const results = await Promise.allSettled(announcementPromises);
+            const allAnnouncements = results
+                .filter((r) => r.status === "fulfilled")
+                .flatMap((r) => r.value);
+            // Sort by the scheduled date and slice to count
+            const announcements = allAnnouncements
+                .sort(newestFirst)
+                .slice(0, count);
+            log("INFO", `get_announcements: Retrieved ${announcements.length} announcements (out of ${allAnnouncements.length} total across ${enrollmentResponse.Items.length} courses)`);
+            return toolResponse(announcements);
+        }
+        catch (error) {
+            return sanitizeError(error);
+        }
+    });
+}
+//# sourceMappingURL=get-announcements.js.map

package/build/tools/get-assignment-files.js

@@ -0,0 +1,159 @@
+import { DEFAULT_CACHE_TTLS } from "../api/index.js";
+import { GetAssignmentFilesSchema } from "./schemas.js";
+import { toolResponse, sanitizeError } from "./tool-helpers.js";
+import { extractPdfText } from "../utils/pdf-extractor.js";
+import { officeDocumentText } from "../utils/zip-extract.js";
+import { assignmentUrl } from "../utils/deep-links.js";
+import { log } from "../utils/logger.js";
+function unwrapList(raw) {
+    return Array.isArray(raw) ? raw : (raw?.Objects ?? []);
+}
+const KIND_BY_EXTENSION = {
+    pdf: "pdf",
+    docx: "docx",
+    doc: "other",
+    xlsx: "xlsx",
+    xls: "other",
+    pptx: "pptx",
+    ppt: "other",
+    png: "image",
+    jpg: "image",
+    jpeg: "image",
+    gif: "image",
+    webp: "image",
+    txt: "text",
+    md: "text",
+    csv: "text",
+    json: "text",
+};
+export function fileKind(fileName) {
+    const extension = fileName.split(".").pop()?.toLowerCase() ?? "";
+    return KIND_BY_EXTENSION[extension] ?? "other";
+}
+function describeAttachment(attachment) {
+    return {
+        fileId: attachment.FileId,
+        fileName: attachment.FileName,
+        size: attachment.Size,
+        kind: fileKind(attachment.FileName),
+    };
+}
+async function listFolders(apiClient, courseId, folderId) {
+    const raw = await apiClient.get(apiClient.le(courseId, "/dropbox/folders/"), {
+        ttl: DEFAULT_CACHE_TTLS.assignments,
+    });
+    return unwrapList(raw)
+        .filter((folder) => folder.IsHidden !== true)
+        .filter((folder) => (folderId === undefined ? true : folder.Id === folderId));
+}
+async function readAttachment(apiClient, courseId, folderId, attachment, extract, maxChars) {
+    const base = describeAttachment(attachment);
+    if (!extract)
+        return { ...base, text: null, note: "Text extraction was not requested." };
+    const response = await apiClient.getRaw(apiClient.le(courseId, `/dropbox/folders/${folderId}/attachments/${attachment.FileId}`));
+    const buffer = Buffer.from(await response.arrayBuffer());
+    let text = null;
+    let note;
+    switch (base.kind) {
+        case "pdf": {
+            const extracted = await extractPdfText(buffer);
+            text = extracted?.text?.trim() || null;
+            if (!text)
+                note = "No text layer in this PDF. It may be a scan.";
+            break;
+        }
+        case "docx":
+        case "xlsx":
+        case "pptx": {
+            text = officeDocumentText(buffer);
+            if (!text)
+                note = "No readable text found in this Office document.";
+            break;
+        }
+        case "text": {
+            text = buffer.toString("utf-8").trim() || null;
+            break;
+        }
+        default: {
+            note = `Cannot extract text from a ${base.kind} file. Use download_file to save it.`;
+        }
+    }
+    const truncated = text !== null && text.length > maxChars;
+    return {
+        ...base,
+        bytes: buffer.length,
+        text: truncated ? text.slice(0, maxChars) : text,
+        truncated,
+        ...(note ? { note } : {}),
+    };
+}
+export function registerGetAssignmentFiles(server, apiClient, baseUrl) {
+    server.registerTool("get_assignment_files", {
+        title: "Get Assignment Files",
+        description: "Read the files an instructor attached to an assignment: the spec or instructions PDF, a starter workbook, a rubric document. Call it with just courseId to see which assignments have attachments, then with folderId and fileId to read one. Use this when the user asks what an assignment requires, what the instructions say, or to summarize a handout. Returns the text itself. Use download_file instead when the user wants the file saved to disk.",
+        inputSchema: GetAssignmentFilesSchema,
+    }, async (args) => {
+        try {
+            log("DEBUG", "get_assignment_files tool called", { args });
+            const { courseId, folderId, fileId, extractText, maxChars } = GetAssignmentFilesSchema.parse(args);
+            const folders = await listFolders(apiClient, courseId, folderId);
+            if (folderId !== undefined && folders.length === 0) {
+                return toolResponse({
+                    courseId,
+                    folderId,
+                    error: `No visible assignment with id ${folderId} in course ${courseId}.`,
+                });
+            }
+            // Read one file.
+            if (fileId !== undefined) {
+                if (folderId === undefined) {
+                    return toolResponse({
+                        courseId,
+                        error: "folderId is required when fileId is given.",
+                    });
+                }
+                const folder = folders[0];
+                const attachment = (folder.Attachments ?? []).find((a) => a.FileId === fileId);
+                if (!attachment) {
+                    return toolResponse({
+                        courseId,
+                        folderId,
+                        fileId,
+                        error: `No attachment with id ${fileId} on assignment "${folder.Name}".`,
+                        available: (folder.Attachments ?? []).map(describeAttachment),
+                    });
+                }
+                const file = await readAttachment(apiClient, courseId, folderId, attachment, extractText, maxChars);
+                return toolResponse({
+                    courseId,
+                    folderId,
+                    folderName: folder.Name,
+                    url: baseUrl ? assignmentUrl(baseUrl, courseId, folderId) : null,
+                    file,
+                });
+            }
+            // Discovery: which assignments have files, without downloading any.
+            const withFiles = folders
+                .filter((folder) => (folder.Attachments ?? []).length > 0)
+                .map((folder) => ({
+                folderId: folder.Id,
+                folderName: folder.Name,
+                dueDate: folder.DueDate,
+                url: baseUrl ? assignmentUrl(baseUrl, courseId, folder.Id) : null,
+                attachments: (folder.Attachments ?? []).map(describeAttachment),
+            }));
+            log("INFO", `get_assignment_files: ${withFiles.length} assignments with attachments in course ${courseId}`);
+            return toolResponse({
+                courseId,
+                assignments: withFiles,
+                ...(withFiles.length === 0
+                    ? { note: "No assignment in this course has an attached file." }
+                    : {}),
+            });
+        }
+        catch (error) {
+            return sanitizeError(error);
+        }
+    });
+}
+//# sourceMappingURL=get-assignment-files.js.map

package/build/tools/get-assignments.js

@@ -0,0 +1,343 @@
+import { fetchSubmissionStatus } from "./submission-status.js";
+import { DEFAULT_CACHE_TTLS } from "../api/index.js";
+import { GetAssignmentsSchema } from "./schemas.js";
+import { toolResponse, sanitizeError } from "./tool-helpers.js";
+import { convertHtmlToMarkdown } from "../utils/html-converter.js";
+import { log } from "../utils/logger.js";
+import { applyCourseFilter } from "../utils/course-filter.js";
+import { assignmentUrl, gradebookUrl, quizUrl } from "../utils/deep-links.js";
+function richTextHtml(field) {
+    if (!field)
+        return null;
+    const nested = typeof field.Text === "object" && field.Text !== null ? field.Text.Html : null;
+    return nested ?? field.Html ?? null;
+}
+const STUDENT_SCORED = new Set([1, 2, 3, 4]);
+function missingContentQuizTopics(raw, listedIds) {
+    if (!raw || typeof raw !== "object")
+        return [];
+    const found = new Map();
+    const visit = (modules) => {
+        if (!Array.isArray(modules))
+            return;
+        for (const module of modules) {
+            for (const topic of module.Topics ?? []) {
+                const isQuiz = topic.ActivityType === 4
+                    || topic.TypeIdentifier?.toLowerCase() === "quiz"
+                    || /(?:[?&]|&)type=quiz(?:[&#]|$)/i.test(topic.Url ?? "");
+                if (!isQuiz || topic.IsHidden || topic.IsBroken || topic.IsExempt)
+                    continue;
+                const activityId = topic.ToolItemId ?? Number(topic.ActivityId);
+                if (!Number.isSafeInteger(activityId) || activityId <= 0 || listedIds.has(activityId))
+                    continue;
+                if (!found.has(activityId))
+                    found.set(activityId, topic);
+            }
+            visit(module.Modules);
+        }
+    };
+    visit(raw.Modules);
+    return [...found.values()];
+}
+async function recoverContentQuizzes(apiClient, courseId, toc, listedIds) {
+    return Promise.all(missingContentQuizTopics(toc, listedIds).map(async (topic) => {
+        const quizId = topic.ToolItemId ?? Number(topic.ActivityId);
+        try {
+            return await apiClient.get(apiClient.le(courseId, `/quizzes/${quizId}`), {
+                ttl: DEFAULT_CACHE_TTLS.assignments,
+            });
+        }
+        catch (error) {
+            log("DEBUG", `Failed to fetch content-linked quiz ${quizId}: using content metadata`, error);
+        }
+        let detail = topic;
+        try {
+            detail = await apiClient.get(apiClient.le(courseId, `/content/topics/${topic.TopicId}`), { ttl: DEFAULT_CACHE_TTLS.courseContent });
+        }
+        catch (error) {
+            log("DEBUG", `Failed to fetch content topic ${topic.TopicId}: using table-of-contents metadata`, error);
+        }
+        return {
+            QuizId: quizId,
+            Name: detail.Title || topic.Title,
+            Description: detail.Description ?? null,
+            StartDate: detail.StartDate ?? detail.StartDateTime ?? topic.StartDateTime ?? null,
+            EndDate: detail.EndDate ?? detail.EndDateTime ?? topic.EndDateTime ?? null,
+            DueDate: detail.DueDate ?? null,
+            IsActive: true,
+            AttemptsAllowed: null,
+            ContentMetadataOnly: true,
+        };
+    }));
+}
+export async function fetchCourseAssignments(apiClient, courseId, baseUrl) {
+    const assignments = [];
+    const [dropboxResult, quizResult, gradebookResult, contentResult] = await Promise.allSettled([
+        apiClient.get(apiClient.le(courseId, "/dropbox/folders/"), { ttl: DEFAULT_CACHE_TTLS.assignments }),
+        apiClient.get(apiClient.le(courseId, "/quizzes/"), { ttl: DEFAULT_CACHE_TTLS.assignments }),
+        apiClient.get(apiClient.le(courseId, "/grades/"), {
+            ttl: DEFAULT_CACHE_TTLS.assignments,
+        }),
+        apiClient.get(apiClient.le(courseId, "/content/toc"), {
+            ttl: DEFAULT_CACHE_TTLS.courseContent,
+        }),
+    ]);
+    // Process Dropbox folders
+    if (dropboxResult.status === "fulfilled") {
+        // D2L dropbox endpoint may return paged { Objects: [...] } or flat array
+        const dropboxRaw = dropboxResult.value;
+        const folders = Array.isArray(dropboxRaw) ? dropboxRaw : dropboxRaw.Objects ?? [];
+        for (const folder of folders) {
+            // Skip hidden folders
+            if (folder.IsHidden)
+                continue;
+            const submissionStatus = await fetchSubmissionStatus(apiClient, courseId, folder);
+            // Fetch feedback independently of submissions
+            let feedback = null;
+            try {
+                feedback = await apiClient.get(apiClient.le(courseId, `/dropbox/folders/${folder.Id}/feedback/myFeedback/`), { ttl: DEFAULT_CACHE_TTLS.assignments });
+            }
+            catch (error) {
+                // 404/403 means no feedback available (or no access) - that's fine
+                if (error?.status !== 404 && error?.status !== 403) {
+                    log("DEBUG", `Failed to fetch feedback for folder ${folder.Id}`, error);
+                }
+            }
+            // Build assignment object
+            const assignment = {
+                type: "assignment",
+                id: folder.Id,
+                name: folder.Name,
+                url: baseUrl ? assignmentUrl(baseUrl, courseId, folder.Id) : null,
+                instructions: folder.CustomInstructions?.Html
+                    ? convertHtmlToMarkdown(folder.CustomInstructions.Html)
+                    : { markdown: "", html: "" },
+                dueDate: folder.DueDate,
+                points: folder.Assessment?.ScoreDenominator ?? null,
+                isGroup: folder.GroupTypeId !== null,
+                rubric: folder.Assessment?.Rubrics?.map((r) => ({
+                    name: r.Name,
+                    criteria: r.Criteria?.map((c) => ({
+                        name: c.Name,
+                        levels: c.Levels?.map((l) => ({
+                            name: l.Name,
+                            points: l.Points,
+                            description: l.Description?.Text ?? null,
+                        })) ?? [],
+                    })) ?? [],
+                })) ?? null,
+                startDate: folder.Availability?.StartDate ?? null,
+                endDate: folder.Availability?.EndDate ?? null,
+                ...submissionStatus,
+                feedback: feedback
+                    ? {
+                        score: feedback.Score,
+                        feedback: feedback.Feedback?.Html
+                            ? convertHtmlToMarkdown(feedback.Feedback.Html)
+                            : null,
+                    }
+                    : null,
+            };
+            assignments.push(assignment);
+        }
+    }
+    else {
+        // Log dropbox fetch failure but don't throw
+        log("DEBUG", `Failed to fetch dropbox folders for course ${courseId}`, dropboxResult.reason);
+    }
+    // Process quizzes. Content discovery remains useful when the list route is
+    // forbidden or unavailable, so a failed list starts from an empty set.
+    let quizzes = [];
+    if (quizResult.status === "fulfilled") {
+        const quizResponse = quizResult.value;
+        // D2L quizzes API returns paged result { Objects: [...] } or a plain array
+        quizzes = Array.isArray(quizResponse)
+            ? quizResponse
+            : quizResponse?.Objects ?? [];
+    }
+    else {
+        log("DEBUG", `Failed to fetch quizzes for course ${courseId}`, quizResult.reason);
+    }
+    if (contentResult.status === "fulfilled") {
+        const listedIds = new Set(quizzes.map((quiz) => quiz.QuizId));
+        quizzes.push(...await recoverContentQuizzes(apiClient, courseId, contentResult.value, listedIds));
+    }
+    else {
+        log("DEBUG", `Failed to fetch course content for quiz discovery in course ${courseId}`, contentResult.reason);
+    }
+    let attemptsForbidden = false;
+    for (const quiz of quizzes) {
+        // Skip inactive quizzes
+        if (!quiz.IsActive)
+            continue;
+        // Fetch quiz attempts. null means "not measured", which is different
+        // from an empty list, and the output says which one it was.
+        let attempts = null;
+        if (!attemptsForbidden && !quiz.ContentMetadataOnly) {
+            try {
+                const attemptsRaw = await apiClient.get(apiClient.le(courseId, `/quizzes/${quiz.QuizId}/attempts/`), { ttl: DEFAULT_CACHE_TTLS.assignments });
+                // D2L attempts endpoint may return paged { Objects: [...] } or flat array
+                attempts = Array.isArray(attemptsRaw) ? attemptsRaw : attemptsRaw.Objects ?? [];
+            }
+            catch (error) {
+                if (error?.status === 404) {
+                    // 404 means no attempts yet, which is a measurement of zero
+                    attempts = [];
+                }
+                else if (error?.status === 403) {
+                    attemptsForbidden = true;
+                    log("DEBUG", `Attempts are forbidden for course ${courseId}: not asking again`);
+                }
+                else {
+                    log("DEBUG", `Failed to fetch attempts for quiz ${quiz.QuizId}`, error);
+                }
+            }
+        }
+        // Calculate remaining attempts
+        const completedAttempts = attempts?.filter((a) => a.IsCompleted) ?? null;
+        let attemptsRemaining = null;
+        let attemptWarning = null;
+        if (completedAttempts) {
+            attemptsRemaining = "Unlimited";
+            if (quiz.AttemptsAllowed && !quiz.AttemptsAllowed.IsUnlimited) {
+                const allowed = quiz.AttemptsAllowed.NumberOfAttemptsAllowed ?? 0;
+                attemptsRemaining = allowed - completedAttempts.length;
+                // Generate warning for low attempts
+                if (attemptsRemaining <= 0) {
+                    attemptWarning = "WARNING: No attempts remaining";
+                }
+                else if (attemptsRemaining === 1) {
+                    attemptWarning = "WARNING: Only 1 attempt remaining";
+                }
+            }
+        }
+        const timeLimit = quiz.SubmissionTimeLimit ?? quiz.TimeLimit;
+        const descriptionHtml = richTextHtml(quiz.Description);
+        // Build quiz object
+        const quizAssignment = {
+            type: "quiz",
+            id: quiz.QuizId,
+            name: quiz.Name,
+            url: baseUrl ? quizUrl(baseUrl, courseId, quiz.QuizId) : null,
+            instructions: descriptionHtml
+                ? convertHtmlToMarkdown(descriptionHtml)
+                : { markdown: "", html: "" },
+            dueDate: quiz.DueDate,
+            startDate: quiz.StartDate,
+            endDate: quiz.EndDate,
+            timeLimit: timeLimit?.IsEnforced ? timeLimit.TimeLimitValue : null,
+            attemptsAllowed: quiz.AttemptsAllowed?.IsUnlimited
+                ? "Unlimited"
+                : quiz.AttemptsAllowed?.NumberOfAttemptsAllowed ?? null,
+            // False when the tenant refused the attempts endpoint, in which case
+            // every count below is null rather than a guess of zero.
+            attemptsAvailable: completedAttempts !== null,
+            attemptsUsed: completedAttempts?.length ?? null,
+            attemptsRemaining,
+            attemptWarning,
+            bestScore: completedAttempts && completedAttempts.length > 0
+                ? Math.max(...completedAttempts.map((a) => a.Score ?? 0))
+                : null,
+            gracePeriodMinutes: quiz.SubmissionGracePeriod ?? null,
+            hasPassword: Boolean(quiz.Password),
+        };
+        assignments.push(quizAssignment);
+    }
+    // Process the gradebook last, once the fetched items are known.
+    if (gradebookResult.status === "fulfilled") {
+        assignments.push(...gradebookHeadsUp(gradebookResult.value, assignments, courseId, baseUrl));
+    }
+    else {
+        log("DEBUG", `Failed to fetch the gradebook for course ${courseId}`, gradebookResult.reason);
+    }
+    return assignments;
+}
+function gradebookHeadsUp(raw, fetched, courseId, baseUrl) {
+    if (!Array.isArray(raw))
+        return [];
+    const covered = new Set(fetched.map((item) => item.id).filter((id) => typeof id === "number"));
+    const rows = [];
+    for (const column of raw) {
+        if (!STUDENT_SCORED.has(column?.GradeObjectTypeId))
+            continue;
+        if (covered.has(column.AssociatedTool?.ToolItemId))
+            continue;
+        if (typeof column.Id !== "number" || typeof column.Name !== "string")
+            continue;
+        rows.push({
+            type: "gradeOnly",
+            id: column.Id,
+            name: column.Name,
+            // Always null: a grade column carries no due date of its own, and
+            // inventing one from the column name would be a guess.
+            dueDate: null,
+            url: baseUrl ? gradebookUrl(baseUrl, courseId) : null,
+        });
+    }
+    return rows;
+}
+export function registerGetAssignments(server, apiClient, config) {
+    server.registerTool("get_assignments", {
+        title: "Get Assignments",
+        description: "Fetch assignments and quizzes for a specific course or all enrolled courses. Shows dropbox submissions and quizzes with due dates, status, and rubric info. Use this when the user asks about assignments, homework, what to submit, quizzes, or assignment details and rubrics.",
+        inputSchema: GetAssignmentsSchema,
+    }, async (args) => {
+        try {
+            log("DEBUG", "get_assignments tool called", { args });
+            // Parse and validate input
+            const { courseId } = GetAssignmentsSchema.parse(args);
+            // Single course case
+            if (courseId) {
+                const assignments = await fetchCourseAssignments(apiClient, courseId, config.baseUrl);
+                log("INFO", `get_assignments: Retrieved ${assignments.length} assignments for course ${courseId}`);
+                return toolResponse({ courseId, assignments });
+            }
+            // 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 assignments for each course (handle 403s gracefully)
+            const assignmentPromises = filteredEnrollments.map(async (item) => {
+                try {
+                    const assignments = await fetchCourseAssignments(apiClient, item.OrgUnit.Id, config.baseUrl);
+                    return {
+                        courseId: item.OrgUnit.Id,
+                        courseName: item.OrgUnit.Name,
+                        assignments,
+                    };
+                }
+                catch (error) {
+                    // 403 means no access (past course, etc) - log and skip
+                    if (error?.status === 403) {
+                        log("DEBUG", `get_assignments: 403 Forbidden for course ${item.OrgUnit.Id} (${item.OrgUnit.Name}) - skipping`);
+                        return null;
+                    }
+                    throw error; // Re-throw other errors
+                }
+            });
+            const results = await Promise.allSettled(assignmentPromises);
+            const courses = results
+                .filter((r) => r.status === "fulfilled" && r.value !== null)
+                .map((r) => r.value);
+            log("INFO", `get_assignments: Retrieved assignments for ${courses.length} courses (out of ${enrollmentResponse.Items.length} enrolled)`);
+            return toolResponse({ courses });
+        }
+        catch (error) {
+            // Temporary: log full error details to stderr for debugging
+            if (error instanceof Error) {
+                log("ERROR", `get_assignments failed: ${error.message}\n${error.stack}`);
+            }
+            return sanitizeError(error);
+        }
+    });
+}
+//# sourceMappingURL=get-assignments.js.map

package/build/tools/get-classlist-emails.js

@@ -0,0 +1,38 @@
+import { DEFAULT_CACHE_TTLS } from "../api/index.js";
+import { fetchAllObjects } from "../api/paginate.js";
+import { GetClasslistEmailsSchema } from "./schemas.js";
+import { toolResponse, sanitizeError } from "./tool-helpers.js";
+import { log } from "../utils/logger.js";
+export function registerGetClasslistEmails(server, apiClient) {
+    server.registerTool("get_classlist_emails", {
+        title: "Get Classlist Emails",
+        description: "Fetch all email addresses for everyone in a course: instructors, TAs, and students. " +
+            "Use this when the user wants a list of emails for a class, needs to email the whole class, " +
+            "or wants contact info for everyone enrolled.",
+        inputSchema: GetClasslistEmailsSchema,
+    }, async (args) => {
+        try {
+            log("DEBUG", "get_classlist_emails tool called", { args });
+            const { courseId } = GetClasslistEmailsSchema.parse(args);
+            // Fetch full classlist (all roles) using paged endpoint
+            const path = apiClient.le(courseId, "/classlist/paged/");
+            const users = await fetchAllObjects(apiClient, path, {
+                ttl: DEFAULT_CACHE_TTLS.roster,
+            });
+            // Extract emails, filtering out nulls (privacy-hidden)
+            const emails = users
+                .filter((user) => user.Email)
+                .map((user) => ({
+                name: user.DisplayName,
+                email: user.Email,
+                role: user.ClasslistRoleDisplayName,
+            }));
+            log("INFO", `get_classlist_emails: ${emails.length} emails from ${users.length} users in course ${courseId}`);
+            return toolResponse(emails);
+        }
+        catch (error) {
+            return sanitizeError(error);
+        }
+    });
+}
+//# sourceMappingURL=get-classlist-emails.js.map