@hed-hog/lms 0.0.349 → 0.0.351

package/src/enterprise/training/training-admin.mcp-tools.ts

@@ -0,0 +1,479 @@
+import { McpContext, McpTool } from '@hed-hog/core';
+import { Injectable } from '@nestjs/common';
+import { TrainingAdminService } from './training-admin.service';
+
+@Injectable()
+export class LmsTrainingAdminMcpTools {
+  constructor(private readonly trainingAdminService: TrainingAdminService) {}
+
+  @McpTool({
+    name: 'lms.training-admin.dashboard',
+    description: 'Returns the training admin dashboard summary for the authenticated user (or enterprise).',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        enterpriseId: { type: 'number', description: 'Enterprise ID (optional; inferred from user if omitted)' },
+      },
+    },
+    readOnly: true,
+  })
+  async getDashboard(args: { enterpriseId?: number }, context: McpContext): Promise<any> {
+    return this.trainingAdminService.getDashboard(context.userId, args.enterpriseId);
+  }
+
+  @McpTool({
+    name: 'lms.training-admin.courses.list',
+    description: 'Lists courses visible to the authenticated training admin.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        enterpriseId: { type: 'number', description: 'Enterprise ID' },
+        page: { type: 'number', description: 'Page number' },
+        pageSize: { type: 'number', description: 'Items per page' },
+        search: { type: 'string', description: 'Search term' },
+        level: { type: 'string', description: 'Filter by level' },
+        category: { type: 'string', description: 'Filter by category' },
+      },
+    },
+    readOnly: true,
+  })
+  async getCourses(args: Record<string, any>, context: McpContext): Promise<any> {
+    return this.trainingAdminService.getCourses(context.userId, args);
+  }
+
+  @McpTool({
+    name: 'lms.training-admin.courses.stats',
+    description: 'Returns course statistics for the authenticated training admin.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        enterpriseId: { type: 'number', description: 'Enterprise ID' },
+      },
+    },
+    readOnly: true,
+  })
+  async getCourseStats(args: { enterpriseId?: number }, context: McpContext): Promise<any> {
+    return this.trainingAdminService.getCourseStats(context.userId, args.enterpriseId);
+  }
+
+  @McpTool({
+    name: 'lms.training-admin.courses.get',
+    description: 'Returns details of a specific course for the training admin.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        courseId: { type: 'number', description: 'Course ID' },
+        enterpriseId: { type: 'number', description: 'Enterprise ID' },
+      },
+      required: ['courseId'],
+    },
+    readOnly: true,
+  })
+  async getCourseDetail(args: { courseId: number; enterpriseId?: number }, context: McpContext): Promise<any> {
+    return this.trainingAdminService.getCourseDetail(context.userId, args.courseId, args.enterpriseId);
+  }
+
+  @McpTool({
+    name: 'lms.training-admin.class-groups.list',
+    description: 'Lists class groups visible to the authenticated training admin.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        enterpriseId: { type: 'number', description: 'Enterprise ID' },
+        page: { type: 'number', description: 'Page number' },
+        pageSize: { type: 'number', description: 'Items per page' },
+        search: { type: 'string', description: 'Search term' },
+        status: { type: 'string', description: 'Filter by status' },
+        deliveryMode: { type: 'string', description: 'Filter by delivery mode' },
+        instructorId: { type: 'number', description: 'Filter by instructor ID' },
+      },
+    },
+    readOnly: true,
+  })
+  async getClassGroups(args: Record<string, any>, context: McpContext): Promise<any> {
+    return this.trainingAdminService.getClassGroups(context.userId, args);
+  }
+
+  @McpTool({
+    name: 'lms.training-admin.class-groups.get',
+    description: 'Returns details of a specific class group for the training admin.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'number', description: 'Class group ID' },
+      },
+      required: ['id'],
+    },
+    readOnly: true,
+  })
+  async getClassGroupDetail(args: { id: number }, context: McpContext): Promise<any> {
+    return this.trainingAdminService.getClassGroupDetail(context.userId, args.id);
+  }
+
+  @McpTool({
+    name: 'lms.training-admin.class-groups.students',
+    description: 'Lists students in a class group for the training admin.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'number', description: 'Class group ID' },
+        page: { type: 'number', description: 'Page number' },
+        pageSize: { type: 'number', description: 'Items per page' },
+        search: { type: 'string', description: 'Search term' },
+        status: { type: 'string', description: 'Filter by status' },
+      },
+      required: ['id'],
+    },
+    readOnly: true,
+  })
+  async getClassGroupStudents(args: { id: number; [key: string]: any }, context: McpContext): Promise<any> {
+    const { id, ...params } = args;
+    return this.trainingAdminService.getClassGroupStudents(context.userId, id, params);
+  }
+
+  @McpTool({
+    name: 'lms.training-admin.class-groups.sessions',
+    description: 'Lists sessions for a class group (training admin view).',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'number', description: 'Class group ID' },
+      },
+      required: ['id'],
+    },
+    readOnly: true,
+  })
+  async getClassGroupSessions(args: { id: number }, context: McpContext): Promise<any> {
+    return this.trainingAdminService.getClassGroupSessions(context.userId, args.id);
+  }
+
+  @McpTool({
+    name: 'lms.training-admin.class-groups.materials',
+    description: 'Lists materials for a class group (training admin view).',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'number', description: 'Class group ID' },
+      },
+      required: ['id'],
+    },
+    readOnly: true,
+  })
+  async getClassGroupMaterials(args: { id: number }, context: McpContext): Promise<any> {
+    return this.trainingAdminService.getClassGroupMaterials(context.userId, args.id);
+  }
+
+  @McpTool({
+    name: 'lms.training-admin.class-groups.enrollable-students',
+    description: 'Lists students that can be enrolled in a class group.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'number', description: 'Class group ID' },
+        search: { type: 'string', description: 'Search term' },
+      },
+      required: ['id'],
+    },
+    readOnly: true,
+  })
+  async getEnrollableStudents(args: { id: number; search?: string }, context: McpContext): Promise<any> {
+    return this.trainingAdminService.getEnrollableStudents(context.userId, args.id, args.search);
+  }
+
+  @McpTool({
+    name: 'lms.training-admin.class-groups.enroll',
+    description: 'Enrolls an existing student in a class group.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'number', description: 'Class group ID' },
+        personId: { type: 'number', description: 'Person ID to enroll' },
+      },
+      required: ['id', 'personId'],
+    },
+  })
+  async enrollExistingStudent(args: { id: number; personId: number }, context: McpContext): Promise<any> {
+    return this.trainingAdminService.enrollExistingStudent(context.userId, args.id, args.personId);
+  }
+
+  @McpTool({
+    name: 'lms.training-admin.class-groups.enroll-new',
+    description: 'Creates a new student and enrolls them in a class group.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'number', description: 'Class group ID' },
+        name: { type: 'string', description: 'Student name (required)' },
+        email: { type: 'string', description: 'Student email' },
+        department: { type: 'string', description: 'Department' },
+      },
+      required: ['id', 'name'],
+    },
+  })
+  async createAndEnrollNewStudent(args: { id: number; [key: string]: any }, context: McpContext): Promise<any> {
+    const { id, ...dto } = args;
+    return this.trainingAdminService.createAndEnrollNewStudent(context.userId, id, dto as any);
+  }
+
+  @McpTool({
+    name: 'lms.training-admin.license-info',
+    description: 'Returns license availability info for the authenticated training admin.',
+    inputSchema: { type: 'object', properties: {} },
+    readOnly: true,
+  })
+  async getLicenseInfo(_args: Record<string, any>, context: McpContext): Promise<any> {
+    return this.trainingAdminService.getLicenseAvailability(context.userId);
+  }
+
+  @McpTool({
+    name: 'lms.training-admin.licenses.list',
+    description: 'Lists licenses managed by the authenticated training admin.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        page: { type: 'number', description: 'Page number' },
+        pageSize: { type: 'number', description: 'Items per page' },
+        search: { type: 'string', description: 'Search term' },
+        status: { type: 'string', description: 'Filter by status' },
+        department: { type: 'string', description: 'Filter by department' },
+      },
+    },
+    readOnly: true,
+  })
+  async listLicenses(args: Record<string, any>, context: McpContext): Promise<any> {
+    return this.trainingAdminService.listLicenses(context.userId, args);
+  }
+
+  @McpTool({
+    name: 'lms.training-admin.licenses.assign',
+    description: 'Assigns a license to a user.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        name: { type: 'string', description: 'User name (required)' },
+        email: { type: 'string', description: 'User email' },
+        department: { type: 'string', description: 'Department' },
+      },
+      required: ['name'],
+    },
+  })
+  async assignLicense(args: Record<string, any>, context: McpContext): Promise<any> {
+    return this.trainingAdminService.assignLicense(context.userId, args as any);
+  }
+
+  @McpTool({
+    name: 'lms.training-admin.licenses.revoke',
+    description: 'Revokes a license from a user.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        personId: { type: 'number', description: 'Person ID whose license to revoke' },
+      },
+      required: ['personId'],
+    },
+  })
+  async revokeLicense(args: { personId: number }, context: McpContext): Promise<any> {
+    return this.trainingAdminService.revokeLicense(context.userId, args.personId);
+  }
+
+  @McpTool({
+    name: 'lms.training-admin.students.list',
+    description: 'Lists students visible to the authenticated training admin.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        enterpriseId: { type: 'number', description: 'Enterprise ID' },
+        page: { type: 'number', description: 'Page number' },
+        pageSize: { type: 'number', description: 'Items per page' },
+        search: { type: 'string', description: 'Search term' },
+        status: { type: 'string', description: 'Filter by status' },
+      },
+    },
+    readOnly: true,
+  })
+  async getStudents(args: Record<string, any>, context: McpContext): Promise<any> {
+    return this.trainingAdminService.getStudents(context.userId, args);
+  }
+
+  @McpTool({
+    name: 'lms.training-admin.students.stats',
+    description: 'Returns student statistics for the authenticated training admin.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        enterpriseId: { type: 'number', description: 'Enterprise ID' },
+      },
+    },
+    readOnly: true,
+  })
+  async getStudentStats(args: { enterpriseId?: number }, context: McpContext): Promise<any> {
+    return this.trainingAdminService.getStudentStats(context.userId, args.enterpriseId);
+  }
+
+  @McpTool({
+    name: 'lms.training-admin.students.get',
+    description: 'Returns the profile and progress of a specific student.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        personId: { type: 'number', description: 'Person ID' },
+        enterpriseId: { type: 'number', description: 'Enterprise ID' },
+      },
+      required: ['personId'],
+    },
+    readOnly: true,
+  })
+  async getStudentDetail(args: { personId: number; enterpriseId?: number }, context: McpContext): Promise<any> {
+    return this.trainingAdminService.getStudentDetail(context.userId, args.personId, args.enterpriseId);
+  }
+
+  @McpTool({
+    name: 'lms.training-admin.admins.list',
+    description: 'Lists admins for the enterprise.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        enterpriseId: { type: 'number', description: 'Enterprise ID' },
+        page: { type: 'number', description: 'Page number' },
+        pageSize: { type: 'number', description: 'Items per page' },
+        search: { type: 'string', description: 'Search term' },
+        role: { type: 'string', description: 'Filter by role' },
+      },
+    },
+    readOnly: true,
+  })
+  async getAdmins(args: Record<string, any>, context: McpContext): Promise<any> {
+    return this.trainingAdminService.getAdmins(context.userId, args);
+  }
+
+  @McpTool({
+    name: 'lms.training-admin.admins.stats',
+    description: 'Returns admin statistics for the enterprise.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        enterpriseId: { type: 'number', description: 'Enterprise ID' },
+      },
+    },
+    readOnly: true,
+  })
+  async getAdminStats(args: { enterpriseId?: number }, context: McpContext): Promise<any> {
+    return this.trainingAdminService.getAdminStats(context.userId, args.enterpriseId);
+  }
+
+  @McpTool({
+    name: 'lms.training-admin.admins.add',
+    description: 'Adds a new admin to the enterprise.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        name: { type: 'string', description: 'Admin name (required)' },
+        email: { type: 'string', description: 'Admin email' },
+        department: { type: 'string', description: 'Department' },
+        role: { type: 'string', description: 'Role' },
+      },
+      required: ['name'],
+    },
+  })
+  async addAdmin(args: Record<string, any>, context: McpContext): Promise<any> {
+    return this.trainingAdminService.addAdmin(context.userId, args as any);
+  }
+
+  @McpTool({
+    name: 'lms.training-admin.admins.update-role',
+    description: 'Updates the role of an admin within the enterprise.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'number', description: 'Enterprise user ID' },
+        role: { type: 'string', description: 'New role (required)' },
+      },
+      required: ['id', 'role'],
+    },
+  })
+  async updateAdminRole(args: { id: number; role: string }, context: McpContext): Promise<any> {
+    return this.trainingAdminService.updateAdminRole(context.userId, args.id, args.role);
+  }
+
+  @McpTool({
+    name: 'lms.training-admin.admins.remove',
+    description: 'Removes an admin from the enterprise.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'number', description: 'Enterprise user ID' },
+      },
+      required: ['id'],
+    },
+  })
+  async removeAdmin(args: { id: number }, context: McpContext): Promise<any> {
+    return this.trainingAdminService.removeAdmin(context.userId, args.id);
+  }
+
+  @McpTool({
+    name: 'lms.training-admin.reports',
+    description: 'Returns admin reports for the enterprise.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        enterpriseId: { type: 'number', description: 'Enterprise ID' },
+        dateFrom: { type: 'string', description: 'Start date (ISO8601)' },
+        dateTo: { type: 'string', description: 'End date (ISO8601)' },
+      },
+    },
+    readOnly: true,
+  })
+  async getAdminReports(args: Record<string, any>, context: McpContext): Promise<any> {
+    return this.trainingAdminService.getAdminReports(context.userId, args);
+  }
+
+  @McpTool({
+    name: 'lms.training-admin.evaluations.stats',
+    description: 'Returns evaluation statistics for the enterprise.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        enterpriseId: { type: 'number', description: 'Enterprise ID' },
+      },
+    },
+    readOnly: true,
+  })
+  async getEvaluationStats(args: { enterpriseId?: number }, context: McpContext): Promise<any> {
+    return this.trainingAdminService.getEvaluationStats(context.userId, args.enterpriseId);
+  }
+
+  @McpTool({
+    name: 'lms.training-admin.evaluations.list',
+    description: 'Lists class groups with evaluation data.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        enterpriseId: { type: 'number', description: 'Enterprise ID' },
+        page: { type: 'number', description: 'Page number' },
+        pageSize: { type: 'number', description: 'Items per page' },
+        search: { type: 'string', description: 'Search term' },
+      },
+    },
+    readOnly: true,
+  })
+  async getEvaluationClassGroups(args: Record<string, any>, context: McpContext): Promise<any> {
+    return this.trainingAdminService.getEvaluationClassGroups(context.userId, args);
+  }
+
+  @McpTool({
+    name: 'lms.training-admin.evaluations.get',
+    description: 'Returns evaluation details for a specific class group.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        classGroupId: { type: 'number', description: 'Class group ID' },
+        enterpriseId: { type: 'number', description: 'Enterprise ID' },
+      },
+      required: ['classGroupId'],
+    },
+    readOnly: true,
+  })
+  async getEvaluationClassGroupDetail(args: { classGroupId: number; enterpriseId?: number }, context: McpContext): Promise<any> {
+    return this.trainingAdminService.getEvaluationClassGroupDetail(context.userId, args.classGroupId, args.enterpriseId);
+  }
+}

package/src/enterprise/training/training-instructor.mcp-tools.ts

@@ -0,0 +1,210 @@
+import { McpContext, McpTool } from '@hed-hog/core';
+import { Injectable } from '@nestjs/common';
+import { TrainingInstructorService } from './training-instructor.service';
+
+@Injectable()
+export class LmsTrainingInstructorMcpTools {
+  constructor(private readonly trainingInstructorService: TrainingInstructorService) {}
+
+  @McpTool({
+    name: 'lms.training-instructor.dashboard',
+    description: 'Returns the training dashboard summary for the authenticated instructor.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        enterpriseId: { type: 'number', description: 'Enterprise ID (optional; inferred from user if omitted)' },
+      },
+    },
+    readOnly: true,
+  })
+  async getDashboard(args: { enterpriseId?: number }, context: McpContext): Promise<any> {
+    return this.trainingInstructorService.getDashboard(context.userId, args.enterpriseId);
+  }
+
+  @McpTool({
+    name: 'lms.training-instructor.class-groups.list',
+    description: 'Lists class groups assigned to the authenticated instructor.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        enterpriseId: { type: 'number', description: 'Enterprise ID' },
+        search: { type: 'string', description: 'Search term' },
+        status: { type: 'string', description: 'Filter by status (open|ongoing|completed|cancelled)' },
+        deliveryMode: { type: 'string', description: 'Filter by delivery mode (presential|online|hybrid)' },
+      },
+    },
+    readOnly: true,
+  })
+  async getClassGroups(args: Record<string, any>, context: McpContext): Promise<any> {
+    return this.trainingInstructorService.getClassGroups(context.userId, args);
+  }
+
+  @McpTool({
+    name: 'lms.training-instructor.class-groups.get',
+    description: 'Returns details of a specific class group for the authenticated instructor.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        classGroupId: { type: 'number', description: 'Class group ID' },
+      },
+      required: ['classGroupId'],
+    },
+    readOnly: true,
+  })
+  async getClassGroupDetail(args: { classGroupId: number }, context: McpContext): Promise<any> {
+    return this.trainingInstructorService.getClassGroupDetail(context.userId, args.classGroupId);
+  }
+
+  @McpTool({
+    name: 'lms.training-instructor.class-groups.students',
+    description: 'Lists students in a class group (instructor view).',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        classGroupId: { type: 'number', description: 'Class group ID' },
+        page: { type: 'number', description: 'Page number' },
+        pageSize: { type: 'number', description: 'Items per page' },
+        search: { type: 'string', description: 'Search term' },
+        status: { type: 'string', description: 'Filter by status' },
+      },
+      required: ['classGroupId'],
+    },
+    readOnly: true,
+  })
+  async getClassGroupStudents(args: { classGroupId: number; [key: string]: any }, context: McpContext): Promise<any> {
+    const { classGroupId, ...params } = args;
+    return this.trainingInstructorService.getClassGroupStudents(context.userId, classGroupId, params);
+  }
+
+  @McpTool({
+    name: 'lms.training-instructor.class-groups.sessions',
+    description: 'Lists sessions for a class group (instructor view).',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        classGroupId: { type: 'number', description: 'Class group ID' },
+      },
+      required: ['classGroupId'],
+    },
+    readOnly: true,
+  })
+  async getClassGroupSessions(args: { classGroupId: number }, context: McpContext): Promise<any> {
+    return this.trainingInstructorService.getClassGroupSessions(context.userId, args.classGroupId);
+  }
+
+  @McpTool({
+    name: 'lms.training-instructor.class-groups.attendance.get',
+    description: 'Returns the full attendance summary for a class group.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        classGroupId: { type: 'number', description: 'Class group ID' },
+      },
+      required: ['classGroupId'],
+    },
+    readOnly: true,
+  })
+  async getClassGroupAttendance(args: { classGroupId: number }, context: McpContext): Promise<any> {
+    return this.trainingInstructorService.getClassGroupAttendance(context.userId, args.classGroupId);
+  }
+
+  @McpTool({
+    name: 'lms.training-instructor.class-groups.attendance.submit',
+    description: 'Submits attendance records for a specific session.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        classGroupId: { type: 'number', description: 'Class group ID' },
+        sessionId: { type: 'number', description: 'Session ID' },
+        records: {
+          type: 'array',
+          description: 'Attendance records',
+          items: {
+            type: 'object',
+            properties: {
+              studentId: { type: 'number', description: 'Student person ID' },
+              present: { type: 'boolean', description: 'Whether the student was present' },
+            },
+          },
+        },
+      },
+      required: ['classGroupId', 'sessionId', 'records'],
+    },
+  })
+  async submitSessionAttendance(
+    args: { classGroupId: number; sessionId: number; records: { studentId: number; present: boolean }[] },
+    context: McpContext,
+  ): Promise<any> {
+    return this.trainingInstructorService.submitSessionAttendance(
+      context.userId,
+      args.classGroupId,
+      args.sessionId,
+      args.records,
+    );
+  }
+
+  @McpTool({
+    name: 'lms.training-instructor.class-groups.materials.list',
+    description: 'Lists materials for a class group (instructor view).',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        classGroupId: { type: 'number', description: 'Class group ID' },
+      },
+      required: ['classGroupId'],
+    },
+    readOnly: true,
+  })
+  async getClassGroupMaterials(args: { classGroupId: number }, context: McpContext): Promise<any> {
+    return this.trainingInstructorService.getClassGroupMaterials(context.userId, args.classGroupId);
+  }
+
+  @McpTool({
+    name: 'lms.training-instructor.class-groups.materials.delete',
+    description: 'Deletes a material from a class group.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        classGroupId: { type: 'number', description: 'Class group ID' },
+        materialId: { type: 'number', description: 'Material ID' },
+      },
+      required: ['classGroupId', 'materialId'],
+    },
+  })
+  async deleteMaterial(args: { classGroupId: number; materialId: number }, context: McpContext): Promise<any> {
+    return this.trainingInstructorService.deleteMaterial(context.userId, args.classGroupId, args.materialId);
+  }
+
+  @McpTool({
+    name: 'lms.training-instructor.class-groups.evaluations',
+    description: 'Returns evaluation data for a class group (instructor view).',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        classGroupId: { type: 'number', description: 'Class group ID' },
+      },
+      required: ['classGroupId'],
+    },
+    readOnly: true,
+  })
+  async getClassEvaluations(args: { classGroupId: number }, context: McpContext): Promise<any> {
+    return this.trainingInstructorService.getClassEvaluations(context.userId, args.classGroupId);
+  }
+
+  @McpTool({
+    name: 'lms.training-instructor.reports',
+    description: 'Returns reports for the authenticated instructor.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        enterpriseId: { type: 'number', description: 'Enterprise ID' },
+        dateFrom: { type: 'string', description: 'Start date (ISO8601)' },
+        dateTo: { type: 'string', description: 'End date (ISO8601)' },
+      },
+    },
+    readOnly: true,
+  })
+  async getReports(args: { enterpriseId?: number; dateFrom?: string; dateTo?: string }, context: McpContext): Promise<any> {
+    return this.trainingInstructorService.getReports(context.userId, args.enterpriseId, args.dateFrom, args.dateTo);
+  }
+}