brightspace-mcp-server 5.2.4 → 5.2.6

package/build/tools/get-assignments.js

@@ -414,6 +414,19 @@ function feedbackPageListsSubmission(html) {
     }
     return false;
 }
+function assignmentListCoverage(reason) {
+    const status = typeof reason?.status === "number" ? reason.status : null;
+    if (status === 404)
+        return {};
+    return {
+        assignmentListUnavailable: { status },
+        assignmentListNote: (status === 403
+            ? "Brightspace refused this course's assignment (dropbox) list (403), "
+            : `Brightspace did not return this course's assignment (dropbox) list${status !== null ? ` (it answered ${status})` : ""}, `) +
+            "so its assignments are missing from this answer. Do not tell the user this course has no " +
+            "assignments due; call get_assignments again for it, or tell them to check Assignments in Brightspace.",
+    };
+}
 /** A course's assignments and quizzes, with whether its quiz list is complete. */
 async function fetchCourseInventory(apiClient, courseId, baseUrl) {
     const assignments = [];
@@ -633,8 +646,9 @@ async function fetchCourseInventory(apiClient, courseId, baseUrl) {
         }
     }
     else {
-        // Log dropbox fetch failure but don't throw
-        log("DEBUG", `Failed to fetch dropbox folders for course ${courseId}`, dropboxResult.reason);
+        // Don't throw: the quizzes and gradebook may still have answered. The
+        // failure is reported through assignmentListCoverage below.
+        log("INFO", `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.
@@ -809,6 +823,7 @@ async function fetchCourseInventory(apiClient, courseId, baseUrl) {
             gradebook: gradebookResult.status === "fulfilled",
             contentRecovery,
         }),
+        ...(dropboxResult.status === "rejected" ? assignmentListCoverage(dropboxResult.reason) : {}),
     };
 }
 /**
@@ -877,7 +892,9 @@ export function registerGetAssignments(server, apiClient, config) {
             "availability (notYetOpen, open, closed) is worked out from the quiz's own start and end dates and is left out when it has none. exempt: true means Brightspace marks the user exempt from that quiz's topic; the quiz is still listed. " +
             "Each course also carries quizCoverage. \"complete\" means every quiz source answered, not that every quiz is guaranteed to be listed; \"incomplete\" means a quiz source could not be read, so the course may have quizzes not listed. " +
             "Never conclude that a quiz was missed or not taken because it is absent, and never present the listed quizzes as all of them. " +
-            "A gradeOnly row named like a quiz is a quiz whose details could not be read.",
+            "A gradeOnly row named like a quiz is a quiz whose details could not be read. " +
+            "A course with assignmentListUnavailable had its assignment list unread: its assignments are missing, not absent, so never say it has none due. " +
+            "Without courseId, courses listed in unreadCourses could not be read at all and are not in courses; never report them as having nothing due.",
         inputSchema: GetAssignmentsSchema,
     }, async (args) => {
         try {
@@ -944,11 +961,6 @@ export function registerGetAssignments(server, apiClient, config) {
                     };
                 }
                 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;
-                    }
                     // A pending sign-in only means this course's routes never
                     // answered — it says nothing about the other courses, whose
                     // requests may already have gone out independently. Mark this one
@@ -963,13 +975,26 @@ export function registerGetAssignments(server, apiClient, config) {
                             authError: error,
                         };
                     }
-                    throw error; // Re-throw other errors
+                    throw error;
                 }
             });
             const results = await Promise.allSettled(assignmentPromises);
             const settled = results
-                .filter((r) => r.status === "fulfilled" && r.value !== null)
+                .filter((r) => r.status === "fulfilled")
                 .map((r) => r.value);
+            // A course whose inventory failed (a 403 on a past course, a 5xx, a
+            // malformed payload) is not a course with nothing due. It stays out
+            // of `courses`, as before, and is named here instead.
+            // **Why:** these courses used to vanish with no trace, so "what's
+            // due?" silently skipped a class (#447).
+            const unreadCourses = results.flatMap((result, index) => {
+                if (result.status !== "rejected")
+                    return [];
+                const item = filteredEnrollments[index];
+                const status = typeof result.reason?.status === "number" ? result.reason.status : null;
+                log("INFO", `get_assignments: could not read course ${item.OrgUnit.Id} (${item.OrgUnit.Name})`, result.reason);
+                return [{ courseId: item.OrgUnit.Id, courseName: item.OrgUnit.Name, status }];
+            });
             const pending = settled.filter((c) => c.authPending);
             const courses = settled
                 .filter((c) => !c.authPending)
@@ -990,16 +1015,25 @@ export function registerGetAssignments(server, apiClient, config) {
                     })),
                 ],
             };
+            const notices = [];
             if (pending.length > 0) {
                 throwIfCredentialRejected(pending[0].authError);
                 response.authPending = true;
                 response.unavailableCourseIds = pending.map((c) => c.courseId);
-                response.notice =
-                    "Sign-in to Brightspace is still in progress, so assignments for " +
-                        `${pending.length} course(s) (${pending.map((c) => c.courseId).join(", ")}) could not be ` +
-                        `fetched yet. ${authPendingNotice(pending[0].authError)} Call get_assignments again once ` +
-                        "sign-in finishes.";
+                notices.push("Sign-in to Brightspace is still in progress, so assignments for " +
+                    `${pending.length} course(s) (${pending.map((c) => c.courseId).join(", ")}) could not be ` +
+                    `fetched yet. ${authPendingNotice(pending[0].authError)} Call get_assignments again once ` +
+                    "sign-in finishes.");
+            }
+            if (unreadCourses.length > 0) {
+                response.unreadCourses = unreadCourses;
+                notices.push(`Assignments for ${unreadCourses.length} course(s) could not be read from Brightspace ` +
+                    `(${unreadCourses.map((c) => `"${c.courseName}" ${c.courseId}`).join(", ")}), so they are ` +
+                    "missing from this list. Do not tell the user those courses have nothing due: call " +
+                    "get_assignments again with that courseId, or tell them to check Brightspace.");
             }
+            if (notices.length > 0)
+                response.notice = notices.join(" ");
             return toolResponse(response);
         }
         catch (error) {

package/build/tools/get-available-groups.js

@@ -14,6 +14,8 @@ import { log } from "../utils/logger.js";
 const SELF_ENROLLMENT_STYLES = new Set([3, 4, 5]);
 /** Without a courseId, courses that started longer ago than this are skipped unless includeOlder is set. */
 const RECENT_COURSE_MS = 365 * 24 * 60 * 60 * 1000;
+/** Why a category's groups couldn't be read, in words an agent can relay. */
+const unreadReason = (status) => status === 403 ? "Brightspace refused access (403)" : "Brightspace found no group list (404)";
 const inaccessible = (error) => error instanceof ApiError && (error.status === 403 || error.status === 404);
 const text = (value) => value?.Text?.trim() || undefined;
 /**
@@ -27,7 +29,7 @@ function signUpOpen(category, now) {
     const end = category.SelfEnrollmentExpiryDate ? Date.parse(category.SelfEnrollmentExpiryDate) : Infinity;
     return start <= now && now <= end;
 }
-async function fetchCourseGroups(apiClient, course, myId, now) {
+async function fetchCourseGroups(apiClient, course, myId, now, unreadOut) {
     const result = { courseId: course.id, courseName: course.name, categories: [], alreadyInGroup: [] };
     let categories;
     try {
@@ -47,6 +49,7 @@ async function fetchCourseGroups(apiClient, course, myId, now) {
         catch (error) {
             if (inaccessible(error)) {
                 unread.push(category.Name);
+                unreadOut.push({ courseId: course.id, name: category.Name, status: error.status });
                 continue;
             }
             throw error;
@@ -115,7 +118,8 @@ export function registerGetAvailableGroups(server, apiClient, config) {
                 return Number.isFinite(start) && start >= now - RECENT_COURSE_MS;
             });
             const olderSkipped = enrolled.length - courses.length;
-            const results = await Promise.allSettled(courses.map((course) => fetchCourseGroups(apiClient, course, myId, now)));
+            const unreadCategories = [];
+            const results = await Promise.allSettled(courses.map((course) => fetchCourseGroups(apiClient, course, myId, now, unreadCategories)));
             const pendingCourseIds = [];
             const failedCourseIds = [];
             let firstAuthError = null;
@@ -149,6 +153,16 @@ export function registerGetAvailableGroups(server, apiClient, config) {
             if (failedCourseIds.length > 0) {
                 notes.push(`Couldn't read groups for course(s) ${failedCourseIds.join(", ")}, so open sign-ups there aren't listed.`);
             }
+            // Without a reason attached, a bare unreadCategories list reads like a
+            // category with nothing open, so name each one and say why it's there (#433).
+            const shownCourseIds = new Set(withChoices.map((c) => c.courseId));
+            const unread = unreadCategories.filter((u) => shownCourseIds.has(u.courseId));
+            if (unread.length > 0) {
+                const where = unread.map((u) => `"${u.name}" in course ${u.courseId}: ${unreadReason(u.status)}`).join("; ");
+                notes.push(`Couldn't read the groups in these open sign-ups, so any open groups there aren't listed ` +
+                    `(see unreadCategories): ${where}. Don't report them as full or closed; ` +
+                    "check Groups > Available Groups in Brightspace.");
+            }
             const data = {
                 coursesChecked: courses.length,
                 courses: withChoices,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brightspace-mcp-server",
-  "version": "5.2.4",
+  "version": "5.2.6",
   "mcpName": "io.github.RohanMuppa/brightspace",
   "description": "MCP server for Brightspace (D2L). Check grades, due dates, assignments, announcements, syllabus, rosters and more via Claude, ChatGPT, Cursor, Windsurf, or any MCP client.",
   "type": "module",