brightspace-mcp-server 4.0.5 → 4.0.7

package/build/tools/get-dropbox-submissions.js

@@ -86,21 +86,23 @@ export function registerGetDropboxSubmissions(server, apiClient) {
             const truncated = total > limit;
             const kept = truncated ? rawSubmissions.slice(0, limit) : rawSubmissions;
             // Optionally fetch feedback for each kept submitter, a bounded
-            // number at a time. Best-effort: a submitter with no feedback yet
-            // simply has none in the map.
+            // number at a time. A 404 means no feedback yet, so that submitter
+            // simply has none in the map. Any other failure leaves their grading
+            // status unknown rather than "not graded", and the note names them.
             const feedbackMap = new Map();
+            const feedbackUnread = new Set();
             if (!ignoreFeedback) {
                 await mapWithConcurrency(kept, FEEDBACK_FETCH_CONCURRENCY, async (sub) => {
+                    const userId = sub.SubmittedBy.Identifier;
                     try {
-                        const userId = sub.SubmittedBy.Identifier;
                         const feedbackPath = apiClient.le(courseId, `/dropbox/folders/${folderId}/feedback/user/${userId}`);
                         const fb = await apiClient.get(feedbackPath);
                         feedbackMap.set(userId, fb);
                     }
-                    catch {
-                        // No feedback yet, or this submitter's feedback route
-                        // otherwise failed — silently skip, matching the "not
-                        // graded yet" default below.
+                    catch (error) {
+                        if (!(error instanceof ApiError && error.status === 404)) {
+                            feedbackUnread.add(userId);
+                        }
                     }
                 });
             }
@@ -125,21 +127,41 @@ export function registerGetDropboxSubmissions(server, apiClient) {
                     comment: sub.Comment?.Text ?? null,
                 };
                 if (!ignoreFeedback) {
-                    entry.feedbackStatus = feedback
-                        ? {
-                            isGraded: feedback.IsGraded,
-                            score: feedback.Score,
-                            maxScore,
-                            hasFeedbackText: !!feedback.Feedback?.Text,
-                        }
-                        : { isGraded: false, score: null, maxScore, hasFeedbackText: false };
+                    entry.feedbackStatus = feedbackUnread.has(userId)
+                        ? null
+                        : feedback
+                            ? {
+                                isGraded: feedback.IsGraded,
+                                score: feedback.Score,
+                                maxScore,
+                                hasFeedbackText: !!feedback.Feedback?.Text,
+                            }
+                            : { isGraded: false, score: null, maxScore, hasFeedbackText: false };
                 }
                 return entry;
             });
-            // activeOnly: skip submissions that are already fully graded.
+            // activeOnly: skip submissions that are already fully graded. One
+            // whose feedback couldn't be read stays, since it may still need grading.
             const filtered = activeOnly && !ignoreFeedback
                 ? submissions.filter((s) => !s.feedbackStatus?.isGraded)
                 : submissions;
+            const unreadNames = kept
+                .filter((sub) => feedbackUnread.has(sub.SubmittedBy.Identifier))
+                .map((sub) => `"${sub.SubmittedBy.DisplayName || sub.SubmittedBy.Identifier}"`);
+            if (unreadNames.length > 0) {
+                log("INFO", "get_dropbox_submissions: Some submitters' feedback could not be read", {
+                    courseId,
+                    folderId,
+                    userIds: [...feedbackUnread],
+                });
+            }
+            const notes = [
+                ...(truncated ? [`Showing ${kept.length} of ${total} submissions. Raise the limit argument to see more.`] : []),
+                ...(unreadNames.length > 0
+                    ? [`Couldn't read the feedback for ${unreadNames.join(", ")}, so whether they are graded is unknown ` +
+                            "(feedbackStatus is null)."]
+                    : []),
+            ];
             log("INFO", `get_dropbox_submissions: ${filtered.length} submissions (of ${total} total) for folder ${folderId}`, { truncated });
             return toolResponse({
                 courseId,
@@ -150,9 +172,7 @@ export function registerGetDropboxSubmissions(server, apiClient) {
                 totalSubmissions: total,
                 returnedSubmissions: filtered.length,
                 truncated,
-                ...(truncated
-                    ? { note: `Showing ${kept.length} of ${total} submissions. Raise the limit argument to see more.` }
-                    : {}),
+                ...(notes.length > 0 ? { note: notes.join(" ") } : {}),
                 activeOnly,
                 submissions: filtered,
             });

package/build/tools/get-dropbox-user-submissions.js

@@ -55,14 +55,20 @@ export function registerGetDropboxUserSubmissions(server, apiClient) {
                     note: "No submissions found for this user in the specified folder.",
                 });
             }
+            // A 404 means no feedback yet, matching the "not graded yet" default
+            // below. Any other failure leaves the grading status unknown.
             let feedback = null;
+            let feedbackUnread = false;
             if (!ignoreFeedback) {
                 try {
                     const feedbackPath = apiClient.le(courseId, `/dropbox/folders/${folderId}/feedback/user/${userId}`);
                     feedback = await apiClient.get(feedbackPath);
                 }
-                catch {
-                    // No feedback yet — silently skip, matching the "not graded yet" default below.
+                catch (error) {
+                    if (!(error instanceof ApiError && error.status === 404)) {
+                        feedbackUnread = true;
+                        log("INFO", "get_dropbox_user_submissions: Feedback could not be read", { courseId, folderId, userId });
+                    }
                 }
             }
             const submissions = rawSubmissions.map((sub) => ({
@@ -79,14 +85,16 @@ export function registerGetDropboxUserSubmissions(server, apiClient) {
             }));
             const feedbackStatus = ignoreFeedback
                 ? undefined
-                : feedback
-                    ? {
-                        isGraded: feedback.IsGraded,
-                        score: feedback.Score,
-                        hasFeedbackText: !!feedback.Feedback?.Text,
-                        feedbackText: feedback.Feedback?.Text ?? null,
-                    }
-                    : { isGraded: false, score: null, hasFeedbackText: false, feedbackText: null };
+                : feedbackUnread
+                    ? null
+                    : feedback
+                        ? {
+                            isGraded: feedback.IsGraded,
+                            score: feedback.Score,
+                            hasFeedbackText: !!feedback.Feedback?.Text,
+                            feedbackText: feedback.Feedback?.Text ?? null,
+                        }
+                        : { isGraded: false, score: null, hasFeedbackText: false, feedbackText: null };
             log("INFO", `get_dropbox_user_submissions: ${submissions.length} submissions for user ${userId} in folder ${folderId}`);
             return toolResponse({
                 courseId,
@@ -94,6 +102,9 @@ export function registerGetDropboxUserSubmissions(server, apiClient) {
                 userId,
                 submissions,
                 feedbackStatus,
+                ...(feedbackUnread
+                    ? { note: "Couldn't read this user's feedback, so whether this submission is graded is unknown (feedbackStatus is null)." }
+                    : {}),
             });
         }
         catch (error) {

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

@@ -22,8 +22,9 @@ const QUIZ_FEEDBACK_NOTE = "The gradebook has no comment for this item, but it i
     "browser such as Respondus LockDown Browser. Open feedbackUrl to check; do not report " +
     "this item as having no feedback.";
 /**
- * The course's quizzes, or none when the route refuses or fails. A missing
- * quiz list only costs the feedback links, never the grades themselves.
+ * The course's quizzes, or null when the route refuses or fails. A missing
+ * quiz list only costs the feedback links, never the grades themselves, but
+ * the caller is told so a gradebook link isn't read as "not a quiz" (#278).
  */
 async function fetchQuizzes(apiClient, courseId) {
     try {
@@ -34,7 +35,7 @@ async function fetchQuizzes(apiClient, courseId) {
     }
     catch (error) {
         log("DEBUG", `get_my_grades: quiz list unavailable for course ${courseId}`, error);
-        return [];
+        return null;
     }
 }
 /**
@@ -42,7 +43,7 @@ async function fetchQuizzes(apiClient, courseId) {
  * rows keep the quiz source URL and note; other rows link to the gradebook.
  */
 function toGradeItems(gradeValues, quizzes, baseUrl, courseId) {
-    const quizByGradeItem = new Map(quizzes
+    const quizByGradeItem = new Map((quizzes ?? [])
         .filter((q) => q.GradeItemId != null)
         .map((q) => [String(q.GradeItemId), q.QuizId]));
     return gradeValues.map((gv) => {
@@ -65,6 +66,11 @@ function toGradeItems(gradeValues, quizzes, baseUrl, courseId) {
         };
     });
 }
+function quizzesUnavailableNotice(courseIds) {
+    return (`The quiz list for ${courseIds.length} course(s) (${courseIds.join(", ")}) could not be read, so ` +
+        "quiz-scored grade items there link to the gradebook and lack the quiz feedback note. Quiz " +
+        "feedback may still exist on the quiz's own page; do not report those items as having no feedback.");
+}
 /**
  * Register get_my_grades tool
  */
@@ -122,8 +128,17 @@ export function registerGetMyGrades(server, apiClient, config) {
                     throw error;
                 }
                 // Map to clean objects
-                const grades = toGradeItems(gradeValues, await quizzesPromise, config.baseUrl, courseId);
+                const quizzes = await quizzesPromise;
+                const grades = toGradeItems(gradeValues, quizzes, config.baseUrl, courseId);
                 log("INFO", `get_my_grades: Retrieved ${grades.length} grade items for course ${courseId}`);
+                if (quizzes === null) {
+                    return toolResponse({
+                        courseId,
+                        grades,
+                        quizzesUnavailable: true,
+                        notice: quizzesUnavailableNotice([courseId]),
+                    });
+                }
                 return toolResponse({ courseId, grades });
             }
             // All courses case
@@ -160,6 +175,7 @@ export function registerGetMyGrades(server, apiClient, config) {
                         courseId: item.OrgUnit.Id,
                         courseName: item.OrgUnit.Name,
                         grades,
+                        ...(quizzes === null ? { quizzesUnavailable: true } : {}),
                     };
                 }
                 catch (error) {
@@ -216,7 +232,12 @@ export function registerGetMyGrades(server, apiClient, config) {
                 .map(({ failed: _failed, ...rest }) => rest);
             const courses = settled
                 .filter((c) => !c.authPending && !c.restricted && !c.failed)
-                .map(({ courseId, courseName, grades }) => ({ courseId, courseName, grades }));
+                .map(({ courseId, courseName, grades, quizzesUnavailable }) => ({
+                courseId,
+                courseName,
+                grades,
+                ...(quizzesUnavailable ? { quizzesUnavailable } : {}),
+            }));
             log("INFO", `get_my_grades: Retrieved grades for ${courses.length} courses, ` +
                 `${restrictedCourses.length} restricted (out of ${enrollmentItems.length} enrolled` +
                 `${pending.length > 0 ? `, ${pending.length} pending sign-in` : ""}` +
@@ -255,6 +276,9 @@ export function registerGetMyGrades(server, apiClient, config) {
                     "so they are listed in failedCourses instead of courses. Do not report these courses as " +
                     "having no grades: open each gradeUrl, or call get_my_grades again for that courseId.");
             }
+            const quizGaps = courses.filter((c) => c.quizzesUnavailable).map((c) => c.courseId);
+            if (quizGaps.length > 0)
+                notices.push(quizzesUnavailableNotice(quizGaps));
             if (notices.length > 0)
                 response.notice = notices.join(" ");
             return toolResponse(response);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brightspace-mcp-server",
-  "version": "4.0.5",
+  "version": "4.0.7",
   "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",