@hed-hog/lms 0.0.349 → 0.0.350

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

@@ -0,0 +1,243 @@
+import { McpContext, McpTool } from '@hed-hog/core';
+import { Injectable } from '@nestjs/common';
+import { InstructorSkillService } from './instructor-skill.service';
+import { InstructorService } from './instructor.service';
+
+@Injectable()
+export class LmsInstructorsMcpTools {
+  constructor(
+    private readonly instructorService: InstructorService,
+    private readonly instructorSkillService: InstructorSkillService,
+  ) {}
+
+  @McpTool({
+    name: 'lms.instructors.list',
+    description: 'Lists instructors with optional pagination and filters.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        page: { type: 'number', description: 'Page number (default: 1)' },
+        pageSize: { type: 'number', description: 'Items per page (default: 20)' },
+        search: { type: 'string', description: 'Search term' },
+        status: { type: 'string', description: 'Filter by status (active|inactive)' },
+        qualificationSlugs: { type: 'string', description: 'Filter by qualification slugs (comma-separated)' },
+      },
+    },
+    readOnly: true,
+  })
+  async listInstructors(args: Record<string, any>, _context: McpContext): Promise<any> {
+    return this.instructorService.list(args);
+  }
+
+  @McpTool({
+    name: 'lms.instructors.stats',
+    description: 'Returns aggregate statistics for instructors.',
+    inputSchema: { type: 'object', properties: {} },
+    readOnly: true,
+  })
+  async getStats(_args: Record<string, any>, _context: McpContext): Promise<any> {
+    return this.instructorService.getStats();
+  }
+
+  @McpTool({
+    name: 'lms.instructors.me',
+    description: 'Returns the instructor profile linked to the authenticated user.',
+    inputSchema: { type: 'object', properties: {} },
+    readOnly: true,
+  })
+  async getMe(_args: Record<string, any>, context: McpContext): Promise<any> {
+    return this.instructorService.getMe(context.userId);
+  }
+
+  @McpTool({
+    name: 'lms.instructors.get',
+    description: 'Returns a single instructor by ID.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'number', description: 'Instructor ID' },
+      },
+      required: ['id'],
+    },
+    readOnly: true,
+  })
+  async getInstructor(args: { id: number }, _context: McpContext): Promise<any> {
+    return this.instructorService.getById(args.id);
+  }
+
+  @McpTool({
+    name: 'lms.instructors.class-groups',
+    description: "Lists class groups where an instructor is assigned.",
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'number', description: 'Instructor 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 getInstructorClassGroups(args: { id: number; [key: string]: any }, _context: McpContext): Promise<any> {
+    const { id, ...params } = args;
+    return this.instructorService.getInstructorClassGroups(id, params);
+  }
+
+  @McpTool({
+    name: 'lms.instructors.create',
+    description: 'Creates a new instructor profile.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        name: { type: 'string', description: 'Instructor name (required, max 255)' },
+        email: { type: 'string', description: 'Email address' },
+        phone: { type: 'string', description: 'Phone number' },
+        qualificationSlugs: { type: 'array', description: 'Qualification slugs (required, at least 1)', items: { type: 'string' } },
+        hourlyRate: { type: 'number', description: 'Hourly rate' },
+        skillSlugs: { type: 'array', description: 'Skill slugs', items: { type: 'string' } },
+        status: { type: 'string', description: 'Status (active|inactive)' },
+        personId: { type: 'number', description: 'Link to existing person ID' },
+        avatarId: { type: 'number', description: 'Avatar file ID' },
+      },
+      required: ['name', 'qualificationSlugs'],
+    },
+  })
+  async createInstructor(args: Record<string, any>, _context: McpContext): Promise<any> {
+    return this.instructorService.create(args as any);
+  }
+
+  @McpTool({
+    name: 'lms.instructors.update',
+    description: 'Updates an existing instructor profile.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'number', description: 'Instructor ID' },
+        name: { type: 'string', description: 'Instructor name' },
+        email: { type: 'string', description: 'Email address' },
+        phone: { type: 'string', description: 'Phone number' },
+        qualificationSlugs: { type: 'array', description: 'Qualification slugs', items: { type: 'string' } },
+        hourlyRate: { type: 'number', description: 'Hourly rate' },
+        skillSlugs: { type: 'array', description: 'Skill slugs', items: { type: 'string' } },
+        status: { type: 'string', description: 'Status (active|inactive)' },
+      },
+      required: ['id'],
+    },
+  })
+  async updateInstructor(args: { id: number; [key: string]: any }, _context: McpContext): Promise<any> {
+    const { id, ...dto } = args;
+    return this.instructorService.update(id, dto as any);
+  }
+
+  @McpTool({
+    name: 'lms.instructors.delete',
+    description: 'Deletes an instructor by ID.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'number', description: 'Instructor ID' },
+      },
+      required: ['id'],
+    },
+  })
+  async deleteInstructor(args: { id: number }, _context: McpContext): Promise<any> {
+    return this.instructorService.delete(args.id);
+  }
+
+  @McpTool({
+    name: 'lms.instructors.training-access',
+    description: 'Enables or disables the training portal access for an instructor.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'number', description: 'Instructor ID' },
+        enabled: { type: 'boolean', description: 'Whether to enable training access' },
+      },
+      required: ['id', 'enabled'],
+    },
+  })
+  async setTrainingAccess(args: { id: number; enabled: boolean }, _context: McpContext): Promise<any> {
+    return this.instructorService.setTrainingAccess(args.id, args.enabled);
+  }
+
+  // ── Skills ───────────────────────────────────────────────────────────────────
+
+  @McpTool({
+    name: 'lms.instructors.skills.list',
+    description: 'Lists instructor skills with optional pagination and search.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        page: { type: 'number', description: 'Page number' },
+        pageSize: { type: 'number', description: 'Items per page' },
+        search: { type: 'string', description: 'Search term' },
+      },
+    },
+    readOnly: true,
+  })
+  async listSkills(args: Record<string, any>, _context: McpContext): Promise<any> {
+    return this.instructorSkillService.list(args);
+  }
+
+  @McpTool({
+    name: 'lms.instructors.skills.all',
+    description: 'Returns all instructor skills (no pagination) for use in dropdowns.',
+    inputSchema: { type: 'object', properties: {} },
+    readOnly: true,
+  })
+  async getAllSkills(_args: Record<string, any>, _context: McpContext): Promise<any> {
+    return this.instructorSkillService.getAll();
+  }
+
+  @McpTool({
+    name: 'lms.instructors.skills.create',
+    description: 'Creates a new instructor skill.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        name: { type: 'string', description: 'Skill name (required)' },
+        slug: { type: 'string', description: 'Skill slug' },
+      },
+      required: ['name'],
+    },
+  })
+  async createSkill(args: Record<string, any>, _context: McpContext): Promise<any> {
+    return this.instructorSkillService.create(args as any);
+  }
+
+  @McpTool({
+    name: 'lms.instructors.skills.update',
+    description: 'Updates an instructor skill.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'number', description: 'Skill ID' },
+        name: { type: 'string', description: 'Skill name' },
+        slug: { type: 'string', description: 'Skill slug' },
+      },
+      required: ['id'],
+    },
+  })
+  async updateSkill(args: { id: number; [key: string]: any }, _context: McpContext): Promise<any> {
+    const { id, ...dto } = args;
+    return this.instructorSkillService.update(id, dto as any);
+  }
+
+  @McpTool({
+    name: 'lms.instructors.skills.delete',
+    description: 'Deletes an instructor skill by ID.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'number', description: 'Skill ID' },
+      },
+      required: ['id'],
+    },
+  })
+  async deleteSkill(args: { id: number }, _context: McpContext): Promise<any> {
+    return this.instructorSkillService.delete(args.id);
+  }
+}

package/src/instructor/instructor.module.ts

@@ -2,13 +2,14 @@ import { PrismaModule } from '@hed-hog/api-prisma';
 import { forwardRef, Module } from '@nestjs/common';
 import { InstructorSkillController } from './instructor-skill.controller';
 import { InstructorSkillService } from './instructor-skill.service';
+import { LmsInstructorsMcpTools } from './instructor.mcp-tools';
 import { InstructorController } from './instructor.controller';
 import { InstructorService } from './instructor.service';
 
 @Module({
   imports: [forwardRef(() => PrismaModule)],
   controllers: [InstructorController, InstructorSkillController],
-  providers: [InstructorService, InstructorSkillService],
+  providers: [InstructorService, InstructorSkillService, LmsInstructorsMcpTools],
   exports: [forwardRef(() => InstructorService)],
 })
 export class InstructorModule {}

package/src/lms.module.ts

@@ -3,8 +3,12 @@ import { PaginationModule } from '@hed-hog/api-pagination';
 import { PrismaModule } from '@hed-hog/api-prisma';
 import { forwardRef, Module } from '@nestjs/common';
 import { ConfigModule } from '@nestjs/config';
+import { AchievementModule } from './achievement/achievement.module';
+import { BitcodeWalletModule } from './bitcode-wallet/bitcode-wallet.module';
 import { LmsCertificateModule } from './certificate/certificate.module';
 import { ClassGroupModule } from './class-group/class-group.module';
+import { CourseLessonDiscussionModule } from './course-lesson-discussion/course-lesson-discussion.module';
+import { CourseLessonNoteModule } from './course-lesson-note/course-lesson-note.module';
 import { CourseModule } from './course/course.module';
 import { LmsDashboardModule } from './dashboard/dashboard.module';
 import { EnterpriseModule } from './enterprise/enterprise.module';
@@ -12,6 +16,7 @@ import { EnterpriseTrainingModule } from './enterprise/training/enterprise-train
 import { EvaluationModule } from './evaluation/evaluation.module';
 import { ExamModule } from './exam/exam.module';
 import { InstructorModule } from './instructor/instructor.module';
+import { LmsRealtimeModule } from './realtime/lms-realtime.module';
 import { LmsReportsModule } from './reports/reports.module';
 import { TrainingModule } from './training/training.module';
 
@@ -21,8 +26,12 @@ import { TrainingModule } from './training/training.module';
     forwardRef(() => PaginationModule),
     forwardRef(() => PrismaModule),
     forwardRef(() => LocaleModule),
+    forwardRef(() => AchievementModule),
+    forwardRef(() => BitcodeWalletModule),
     forwardRef(() => LmsCertificateModule),
     forwardRef(() => ClassGroupModule),
+    forwardRef(() => CourseLessonDiscussionModule),
+    forwardRef(() => CourseLessonNoteModule),
     forwardRef(() => CourseModule),
     forwardRef(() => LmsDashboardModule),
     forwardRef(() => EnterpriseModule),
@@ -30,12 +39,16 @@ import { TrainingModule } from './training/training.module';
     forwardRef(() => EvaluationModule),
     forwardRef(() => ExamModule),
     forwardRef(() => InstructorModule),
+    forwardRef(() => LmsRealtimeModule),
     forwardRef(() => LmsReportsModule),
     forwardRef(() => TrainingModule),
-    
   ],
   exports: [
+    forwardRef(() => AchievementModule),
+    forwardRef(() => BitcodeWalletModule),
     forwardRef(() => ClassGroupModule),
+    forwardRef(() => CourseLessonDiscussionModule),
+    forwardRef(() => CourseLessonNoteModule),
     forwardRef(() => LmsCertificateModule),
     forwardRef(() => CourseModule),
     forwardRef(() => LmsDashboardModule),
@@ -44,6 +57,7 @@ import { TrainingModule } from './training/training.module';
     forwardRef(() => EvaluationModule),
     forwardRef(() => ExamModule),
     forwardRef(() => InstructorModule),
+    forwardRef(() => LmsRealtimeModule),
     forwardRef(() => LmsReportsModule),
     forwardRef(() => TrainingModule),
   ],

package/src/realtime/lms-realtime.controller.ts

@@ -0,0 +1,12 @@
+import { Controller, Get } from '@nestjs/common';
+import { LmsRealtimeCursor, LmsRealtimeService } from './lms-realtime.service';
+
+@Controller('lms/realtime')
+export class LmsRealtimeController {
+  constructor(private readonly lmsRealtime: LmsRealtimeService) {}
+
+  @Get('cursor')
+  getCursor(): LmsRealtimeCursor {
+    return this.lmsRealtime.getCursor();
+  }
+}

package/src/realtime/lms-realtime.module.ts

@@ -0,0 +1,12 @@
+import { forwardRef, Module } from '@nestjs/common';
+import { LmsRealtimeController } from './lms-realtime.controller';
+import { LmsRealtimeService } from './lms-realtime.service';
+import { LmsRealtimeSubscriber } from './lms-realtime.subscriber';
+
+@Module({
+  imports: [],
+  controllers: [LmsRealtimeController],
+  providers: [LmsRealtimeService, LmsRealtimeSubscriber],
+  exports: [forwardRef(() => LmsRealtimeService)],
+})
+export class LmsRealtimeModule {}

package/src/realtime/lms-realtime.service.ts

@@ -0,0 +1,98 @@
+import { Injectable } from '@nestjs/common';
+
+export type LmsRealtimeDomain =
+  | 'course'
+  | 'training'
+  | 'class_group'
+  | 'certificate_template'
+  | 'exam_attempt'
+  | 'enterprise'
+  | 'instructor'
+  | 'achievement';
+
+export type LmsRealtimeEventType =
+  | 'created'
+  | 'updated'
+  | 'deleted'
+  | 'student_enrolled'
+  | 'student_removed'
+  | 'submitted';
+
+export type LmsRealtimeEvent = {
+  version: 'lms-realtime-v1';
+  eventId: string;
+  cursor: number;
+  occurredAt: string;
+  domain: LmsRealtimeDomain;
+  type: LmsRealtimeEventType;
+  entityId?: number | null;
+  actorId?: number | null;
+  payload?: Record<string, unknown>;
+};
+
+export type LmsRealtimeEventPayload = {
+  domain: LmsRealtimeDomain;
+  type: LmsRealtimeEventType;
+  entityId?: number | null;
+  actorId?: number | null;
+  payload?: Record<string, unknown>;
+};
+
+export type LmsRealtimeCursor = {
+  cursor: number;
+  updatedAt: string | null;
+};
+
+type LmsRealtimeListener = {
+  onEvent: (event: LmsRealtimeEvent) => void;
+};
+
+@Injectable()
+export class LmsRealtimeService {
+  private static readonly EVENT_RETENTION_LIMIT = 500;
+
+  private sequence = 0;
+  private updatedAt: string | null = null;
+  private readonly eventLog: LmsRealtimeEvent[] = [];
+  private readonly listeners = new Map<number, LmsRealtimeListener>();
+  private listenerSequence = 0;
+
+  publish(event: LmsRealtimeEventPayload): LmsRealtimeCursor {
+    const nextCursor = ++this.sequence;
+    const occurredAt = new Date().toISOString();
+    this.updatedAt = occurredAt;
+
+    const realtimeEvent: LmsRealtimeEvent = {
+      version: 'lms-realtime-v1',
+      eventId: String(nextCursor),
+      cursor: nextCursor,
+      occurredAt,
+      domain: event.domain,
+      type: event.type,
+      entityId: event.entityId ?? null,
+      actorId: event.actorId ?? null,
+      payload: event.payload,
+    };
+
+    this.eventLog.push(realtimeEvent);
+    if (this.eventLog.length > LmsRealtimeService.EVENT_RETENTION_LIMIT) {
+      this.eventLog.splice(0, this.eventLog.length - LmsRealtimeService.EVENT_RETENTION_LIMIT);
+    }
+
+    for (const listener of this.listeners.values()) {
+      listener.onEvent(realtimeEvent);
+    }
+
+    return { cursor: nextCursor, updatedAt: this.updatedAt };
+  }
+
+  getCursor(): LmsRealtimeCursor {
+    return { cursor: this.sequence, updatedAt: this.updatedAt };
+  }
+
+  subscribe(onEvent: (event: LmsRealtimeEvent) => void): () => void {
+    const id = ++this.listenerSequence;
+    this.listeners.set(id, { onEvent });
+    return () => this.listeners.delete(id);
+  }
+}

package/src/realtime/lms-realtime.subscriber.ts

@@ -0,0 +1,61 @@
+import { IntegrationDeveloperApiService } from '@hed-hog/core';
+import { Inject, Injectable, OnModuleInit, forwardRef } from '@nestjs/common';
+import type { LmsRealtimeDomain, LmsRealtimeEventType } from './lms-realtime.service';
+import { LmsRealtimeService } from './lms-realtime.service';
+
+type LmsEventMapping = {
+  eventName: string;
+  domain: LmsRealtimeDomain;
+  type: LmsRealtimeEventType;
+};
+
+const LMS_EVENT_MAPPINGS: LmsEventMapping[] = [
+  { eventName: 'lms.course.created', domain: 'course', type: 'created' },
+  { eventName: 'lms.course.updated', domain: 'course', type: 'updated' },
+  { eventName: 'lms.course.deleted', domain: 'course', type: 'deleted' },
+  { eventName: 'lms.training.created', domain: 'training', type: 'created' },
+  { eventName: 'lms.training.updated', domain: 'training', type: 'updated' },
+  { eventName: 'lms.training.deleted', domain: 'training', type: 'deleted' },
+  { eventName: 'lms.class_group.created', domain: 'class_group', type: 'created' },
+  { eventName: 'lms.class_group.updated', domain: 'class_group', type: 'updated' },
+  { eventName: 'lms.class_group.deleted', domain: 'class_group', type: 'deleted' },
+  { eventName: 'lms.class_group.student.enrolled', domain: 'class_group', type: 'student_enrolled' },
+  { eventName: 'lms.class_group.student.removed', domain: 'class_group', type: 'student_removed' },
+  { eventName: 'lms.certificate_template.created', domain: 'certificate_template', type: 'created' },
+  { eventName: 'lms.certificate_template.updated', domain: 'certificate_template', type: 'updated' },
+  { eventName: 'lms.certificate_template.deleted', domain: 'certificate_template', type: 'deleted' },
+  { eventName: 'lms.exam.attempt.submitted', domain: 'exam_attempt', type: 'submitted' },
+];
+
+@Injectable()
+export class LmsRealtimeSubscriber implements OnModuleInit {
+  constructor(
+    @Inject(forwardRef(() => IntegrationDeveloperApiService))
+    private readonly integrationApi: IntegrationDeveloperApiService,
+    private readonly lmsRealtime: LmsRealtimeService,
+  ) {}
+
+  onModuleInit() {
+    this.integrationApi.subscribeMany(
+      LMS_EVENT_MAPPINGS.map((mapping) => ({
+        eventName: mapping.eventName,
+        consumerName: `lms.realtime.${mapping.domain}.${mapping.type}`,
+        priority: 0,
+        handler: async (event) => {
+          const entityId = event.payload?.id
+            ? Number(event.payload.id)
+            : event.aggregateId
+              ? Number(event.aggregateId)
+              : null;
+
+          this.lmsRealtime.publish({
+            domain: mapping.domain,
+            type: mapping.type,
+            entityId: Number.isFinite(entityId) && (entityId ?? 0) > 0 ? entityId : null,
+            payload: event.payload,
+          });
+        },
+      })),
+    );
+  }
+}

package/src/reports/reports.mcp-tools.ts

@@ -0,0 +1,27 @@
+import { McpContext, McpTool } from '@hed-hog/core';
+import { Injectable } from '@nestjs/common';
+import { LmsReportsService } from './reports.service';
+
+@Injectable()
+export class LmsReportsMcpTools {
+  constructor(private readonly reportsService: LmsReportsService) {}
+
+  @McpTool({
+    name: 'lms.reports.get',
+    description: 'Returns LMS report data including KPIs, monthly enrollments, course ranking, student status distribution, quality radar, and weekly activity.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        period: {
+          type: 'string',
+          description: 'Report period (7d|30d|6m|12m, default: 12m)',
+          enum: ['7d', '30d', '6m', '12m'],
+        },
+      },
+    },
+    readOnly: true,
+  })
+  async getReports(args: { period?: string }, _context: McpContext): Promise<any> {
+    return this.reportsService.getReports(args.period ?? '12m');
+  }
+}

package/src/reports/reports.module.ts

@@ -1,12 +1,13 @@
 import { PrismaModule } from '@hed-hog/api-prisma';
 import { forwardRef, Module } from '@nestjs/common';
 import { LmsReportsController } from './reports.controller';
+import { LmsReportsMcpTools } from './reports.mcp-tools';
 import { LmsReportsService } from './reports.service';
 
 @Module({
   imports: [forwardRef(() => PrismaModule)],
   controllers: [LmsReportsController],
-  providers: [LmsReportsService],
+  providers: [LmsReportsService, LmsReportsMcpTools],
   exports: [LmsReportsService],
 })
 export class LmsReportsModule {}

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

@@ -0,0 +1,128 @@
+import { McpContext, McpTool } from '@hed-hog/core';
+import { Injectable } from '@nestjs/common';
+import { TrainingService } from './training.service';
+
+@Injectable()
+export class LmsTrainingPathsMcpTools {
+  constructor(private readonly trainingService: TrainingService) {}
+
+  @McpTool({
+    name: 'lms.paths.list',
+    description: 'Lists learning paths (trainings) with optional pagination and filters.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        page: { type: 'number', description: 'Page number (default: 1)' },
+        pageSize: { type: 'number', description: 'Items per page (default: 20)' },
+        search: { type: 'string', description: 'Search term' },
+        status: { type: 'string', description: 'Filter by status (draft|active|archived)' },
+        level: { type: 'string', description: 'Filter by level (beginner|intermediate|advanced)' },
+        area: { type: 'string', description: 'Filter by area' },
+      },
+    },
+    readOnly: true,
+  })
+  async listPaths(args: Record<string, any>, _context: McpContext): Promise<any> {
+    return this.trainingService.list(args);
+  }
+
+  @McpTool({
+    name: 'lms.paths.stats',
+    description: 'Returns aggregate statistics for learning paths.',
+    inputSchema: { type: 'object', properties: {} },
+    readOnly: true,
+  })
+  async getStats(_args: Record<string, any>, _context: McpContext): Promise<any> {
+    return this.trainingService.stats();
+  }
+
+  @McpTool({
+    name: 'lms.paths.get',
+    description: 'Returns a single learning path by ID with its course/exam items.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'number', description: 'Learning path ID' },
+      },
+      required: ['id'],
+    },
+    readOnly: true,
+  })
+  async getPath(args: { id: number }, _context: McpContext): Promise<any> {
+    return this.trainingService.getById(args.id);
+  }
+
+  @McpTool({
+    name: 'lms.paths.create',
+    description: 'Creates a new learning path.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        title: { type: 'string', description: 'Path title (required, max 255)' },
+        slug: { type: 'string', description: 'Unique slug' },
+        description: { type: 'string', description: 'Full description' },
+        shortDescription: { type: 'string', description: 'Short description' },
+        level: { type: 'string', description: 'Level (beginner|intermediate|advanced)' },
+        status: { type: 'string', description: 'Status (draft|active|archived)' },
+        progressMode: { type: 'string', description: 'Progress mode (sequential|free)' },
+        courseIds: { type: 'array', description: 'Course IDs to include', items: { type: 'number' } },
+        items: {
+          type: 'array',
+          description: 'Path items with type and order',
+          items: {
+            type: 'object',
+            properties: {
+              type: { type: 'string', description: 'Item type (course|exam)' },
+              itemId: { type: 'number', description: 'Course or exam ID' },
+              order: { type: 'number' },
+              isRequired: { type: 'boolean' },
+            },
+          },
+        },
+      },
+      required: ['title'],
+    },
+  })
+  async createPath(args: Record<string, any>, _context: McpContext): Promise<any> {
+    return this.trainingService.create(args as any);
+  }
+
+  @McpTool({
+    name: 'lms.paths.update',
+    description: 'Updates an existing learning path.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'number', description: 'Learning path ID' },
+        title: { type: 'string', description: 'Path title' },
+        description: { type: 'string', description: 'Full description' },
+        shortDescription: { type: 'string', description: 'Short description' },
+        level: { type: 'string', description: 'Level' },
+        status: { type: 'string', description: 'Status (draft|active|archived)' },
+        progressMode: { type: 'string', description: 'Progress mode (sequential|free)' },
+        courseIds: { type: 'array', description: 'Course IDs', items: { type: 'number' } },
+        items: { type: 'array', description: 'Path items', items: { type: 'object' } },
+      },
+      required: ['id'],
+    },
+  })
+  async updatePath(args: { id: number; [key: string]: any }, _context: McpContext): Promise<any> {
+    const { id, ...dto } = args;
+    return this.trainingService.update(id, dto as any);
+  }
+
+  @McpTool({
+    name: 'lms.paths.delete',
+    description: 'Removes a learning path by ID.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'number', description: 'Learning path ID' },
+      },
+      required: ['id'],
+    },
+  })
+  async deletePath(args: { id: number }, _context: McpContext): Promise<any> {
+    return this.trainingService.remove(args.id);
+  }
+}