Get Assignments

Instructions

Implementation Reference

• src/index.ts:20-30 (registration)

  Import of registerGetAssignments from the tools barrel module

  import {
    registerGetMyCourses,
    registerGetUpcomingDueDates,
    registerGetMyGrades,
    registerGetAnnouncements,
    registerGetAssignments,
    registerGetCourseContent,
    registerDownloadFile,
    registerGetClasslistEmails,
    registerGetRoster,
    registerGetSyllabus,

• src/index.ts:183-183 (registration)

  Registration call that wires up the get_assignments tool to the MCP server at startup

  registerGetAssignments(server, apiClient, config);

• src/tools/index.ts:12-15 (registration)

  Barrel export re-exporting registerGetAssignments from get-assignments.ts

  export { registerGetAssignments } from "./get-assignments.js";
  export { registerGetCourseContent } from "./get-course-content.js";
  export { registerDownloadFile } from "./download-file.js";
  export { registerGetClasslistEmails } from "./get-classlist-emails.js";

• src/tools/schemas.ts:33-36 (schema)

  Input schema for get_assignments: optional positive integer courseId; if omitted returns all courses

  export const GetAssignmentsSchema = z.object({
    courseId: z.coerce.number().int().positive().optional()
      .describe("Course ID to get assignments for. If omitted, returns assignments for all enrolled courses."),
  });

• src/tools/get-assignments.ts:301-396 (handler)

  Full handler: registerGetAssignments function that calls server.registerTool('get_assignments', ...) with the main logic. If courseId provided, fetches assignments for that single course via fetchCourseAssignments helper; otherwise iterates all enrolled courses, applies course filter, and aggregates results. Returns structured assignment/quiz data with submissions, feedback, rubrics, and attempt info.

  export function registerGetAssignments(
    server: McpServer,
    apiClient: D2LApiClient,
    config: AppConfig
  ): void {
    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: any) => {
        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);
  
            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<EnrollmentResponse>(
            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,
              ...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);
  
              return {
                courseId: item.OrgUnit.Id,
                courseName: item.OrgUnit.Name,
                assignments,
              };
            } catch (error: any) {
              // 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 is PromiseFulfilledResult<any> =>
                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);
        }
      }
    );
  }