@classroomio/mcp 0.0.3 → 0.0.5

package/dist/index.js

@@ -40,12 +40,61 @@ var ClassroomIoApiClient = class {
       method: "GET"
     });
   }
+  async listOrganizationCourses(query = {}) {
+    const searchParams = new URLSearchParams();
+    if (query.tags) searchParams.set("tags", query.tags);
+    const querySuffix = searchParams.toString() ? `?${searchParams.toString()}` : "";
+    return this.request(`/organization/courses${querySuffix}`, {
+      method: "GET"
+    });
+  }
+  async listCourseExercises(courseId, query = {}) {
+    const searchParams = new URLSearchParams();
+    if (query.lessonId) searchParams.set("lessonId", query.lessonId);
+    if (query.sectionId) searchParams.set("sectionId", query.sectionId);
+    const querySuffix = searchParams.toString() ? `?${searchParams.toString()}` : "";
+    return this.request(`/course/${courseId}/exercise${querySuffix}`, {
+      method: "GET"
+    });
+  }
+  async getCourseExercise(courseId, exerciseId) {
+    return this.request(`/course/${courseId}/exercise/${exerciseId}`, {
+      method: "GET"
+    });
+  }
+  async createCourseExercise(courseId, payload) {
+    return this.request(`/course/${courseId}/exercise`, {
+      method: "POST",
+      body: {
+        ...payload,
+        courseId
+      }
+    });
+  }
+  async createCourseExerciseFromTemplate(courseId, payload) {
+    return this.request(`/course/${courseId}/exercise/from-template`, {
+      method: "POST",
+      body: payload
+    });
+  }
+  async updateCourseExercise(courseId, exerciseId, payload) {
+    return this.request(`/course/${courseId}/exercise/${exerciseId}`, {
+      method: "PUT",
+      body: payload
+    });
+  }
   async updateCourseDraft(draftId, payload) {
     return this.request(`/organization/course-import/drafts/${draftId}`, {
       method: "PUT",
       body: payload
     });
   }
+  async tagCourseDraft(draftId, payload) {
+    return this.request(`/organization/course-import/drafts/${draftId}/tags`, {
+      method: "PUT",
+      body: payload
+    });
+  }
   async publishCourseDraft(draftId, payload) {
     return this.request(`/organization/course-import/drafts/${draftId}/publish`, {
       method: "POST",
@@ -58,6 +107,15 @@ var ClassroomIoApiClient = class {
       body: payload
     });
   }
+  async tagCourses(payload) {
+    return this.request(
+      "/organization/tags/courses/assign",
+      {
+        method: "PUT",
+        body: payload
+      }
+    );
+  }
   async request(path, options) {
     const response = await fetch(new URL(path, this.config.CLASSROOMIO_API_URL), {
       method: options.method,
@@ -96,11 +154,318 @@ function getConfig(env = process.env) {
   return ZConfig.parse(env);
 }
 
-// ../utils/dist/validation/course-import/course-import.js
+// ../utils/dist/validation/tag/tag.js
+import * as z2 from "zod";
+var TAG_COLOR_OPTIONS = [
+  "#EF4444",
+  "#F97316",
+  "#F59E0B",
+  "#84CC16",
+  "#22C55E",
+  "#14B8A6",
+  "#06B6D4",
+  "#3B82F6",
+  "#8B5CF6",
+  "#EC4899"
+];
+var ZTagColor = z2.enum(TAG_COLOR_OPTIONS);
+var ZTagGroupParam = z2.object({
+  groupId: z2.uuid()
+});
+var ZTagGroupCreate = z2.object({
+  name: z2.string().min(1).max(80),
+  description: z2.string().max(240).optional(),
+  order: z2.number().int().min(0).optional()
+});
+var ZTagGroupUpdate = ZTagGroupCreate.partial().refine((value) => Object.keys(value).length > 0, {
+  message: "At least one field is required"
+});
+var ZTagParam = z2.object({
+  tagId: z2.uuid()
+});
+var ZTagCreate = z2.object({
+  name: z2.string().min(1).max(80),
+  description: z2.string().max(240).optional(),
+  groupId: z2.uuid(),
+  color: ZTagColor
+});
+var ZTagUpdate = z2.object({
+  name: z2.string().min(1).max(80).optional(),
+  description: z2.string().max(240).optional(),
+  groupId: z2.uuid().optional(),
+  color: ZTagColor.optional()
+}).refine((value) => Object.keys(value).length > 0, {
+  message: "At least one field is required"
+});
+var ZCourseTagParam = z2.object({
+  courseId: z2.uuid()
+});
+var ZCourseTagAssignment = z2.object({
+  tagIds: z2.array(z2.uuid()).max(100).default([])
+});
+var ZAutomationTagMode = z2.enum(["merge", "replace"]).default("merge");
+var ZAutomationTagName = z2.string().trim().min(1).max(80);
+var ZAutomationDraftTagParam = z2.object({
+  draftId: z2.string().uuid()
+});
+var ZAutomationDraftTagAssignment = z2.object({
+  tagNames: z2.array(ZAutomationTagName).min(1).max(100),
+  mode: ZAutomationTagMode,
+  groupName: z2.string().trim().min(1).max(80).optional()
+});
+var ZAutomationCourseTagAssignment = ZAutomationDraftTagAssignment.extend({
+  courseIds: z2.array(z2.string().uuid()).min(1).max(100)
+});
+
+// ../utils/dist/validation/organization/organization.js
 import * as z3 from "zod";
 
-// ../utils/dist/validation/course/course.js
-import * as z2 from "zod";
+// ../utils/dist/constants/org.js
+var blockedSubdomain = [
+  "academy",
+  "app",
+  "apps",
+  "blog",
+  "build",
+  "campaign",
+  "church",
+  "cloud",
+  "community",
+  "conference",
+  "course",
+  "courses",
+  "demo",
+  "dev",
+  "forum",
+  "group",
+  "groups",
+  "help",
+  "launch",
+  "launchweek",
+  "mobile",
+  "play",
+  "prod",
+  "production",
+  "schools",
+  "stage",
+  "staging",
+  "support",
+  "teacher",
+  "teachers",
+  "tech",
+  "training"
+];
+
+// ../utils/dist/constants/content.js
+var ContentType;
+(function(ContentType2) {
+  ContentType2["Section"] = "SECTION";
+  ContentType2["Lesson"] = "LESSON";
+  ContentType2["Exercise"] = "EXERCISE";
+})(ContentType || (ContentType = {}));
+
+// ../utils/dist/validation/organization/organization.js
+var ZGetOrganizations = z3.object({
+  siteName: z3.string().min(1).optional(),
+  customDomain: z3.string().min(1).optional(),
+  isCustomDomainVerified: z3.boolean().optional()
+});
+var ZGetCoursesBySiteName = z3.object({
+  siteName: z3.string().min(1),
+  tags: z3.string().optional()
+});
+var ZGetOrganizationCoursesQuery = z3.object({
+  tags: z3.string().optional()
+});
+var ZGetOrgSetup = z3.object({
+  siteName: z3.string().min(1)
+});
+var ZCreateOrgPlan = z3.object({
+  orgId: z3.uuid(),
+  planName: z3.enum(["EARLY_ADOPTER", "ENTERPRISE", "BASIC"]),
+  subscriptionId: z3.string().min(1),
+  triggeredBy: z3.number().int().positive(),
+  payload: z3.record(z3.string(), z3.unknown())
+});
+var ZUpdateOrgPlan = z3.object({
+  subscriptionId: z3.string().min(1),
+  payload: z3.record(z3.string(), z3.unknown())
+});
+var ZCancelOrgPlan = z3.object({
+  subscriptionId: z3.string().min(1),
+  payload: z3.record(z3.string(), z3.unknown())
+});
+var ZCreateOrganization = z3.object({
+  name: z3.string().min(5).refine((val) => !/^[-]|[-]$/.test(val), {
+    message: "Organization name cannot start or end with a hyphen"
+  }),
+  siteName: z3.string().min(5).refine((val) => !/^[-]|[-]$/.test(val), {
+    message: "Site name cannot start or end with a hyphen"
+  }).refine((val) => !blockedSubdomain.includes(val), {
+    message: "Sitename already exists."
+  })
+});
+var ZUpdateOrganization = z3.object({
+  name: z3.string().min(5).refine((val) => !/^[-]|[-]$/.test(val), {
+    message: "Organization name cannot start or end with a hyphen"
+  }).optional(),
+  avatarUrl: z3.url().optional(),
+  theme: z3.string().optional(),
+  landingpage: z3.record(z3.string(), z3.unknown()).optional(),
+  siteName: z3.string().min(1).optional(),
+  customDomain: z3.string().nullable().optional(),
+  isCustomDomainVerified: z3.boolean().optional(),
+  customization: z3.record(z3.string(), z3.unknown()).optional(),
+  disableSignup: z3.boolean().optional(),
+  disableSignupMessage: z3.string().optional(),
+  disableEmailPassword: z3.boolean().optional(),
+  disableGoogleAuth: z3.boolean().optional(),
+  /** Nested settings (stored in organization.settings JSONB). signup.inviteOnly = true means invite-only signup. */
+  settings: z3.object({
+    signup: z3.object({
+      inviteOnly: z3.boolean().optional()
+    }).optional()
+  }).optional()
+});
+var ZInviteTeamMembers = z3.object({
+  emails: z3.array(z3.string().email()).min(1).max(50),
+  roleId: z3.number().int().positive()
+});
+var ZRemoveTeamMember = z3.object({
+  memberId: z3.coerce.number().int().positive()
+});
+var ZGetUserAnalytics = z3.object({
+  userId: z3.uuid()
+});
+
+// ../utils/dist/validation/organization/quiz.js
+import * as z4 from "zod";
+var ZQuizGetParam = z4.object({
+  orgId: z4.uuid(),
+  quizId: z4.uuid()
+});
+var ZQuizListParam = z4.object({
+  orgId: z4.uuid()
+});
+var ZQuizCreate = z4.object({
+  title: z4.string().min(1),
+  questions: z4.array(z4.any()).optional(),
+  timelimit: z4.string().optional(),
+  theme: z4.string().optional()
+});
+var ZQuizUpdate = z4.object({
+  title: z4.string().min(1).optional(),
+  questions: z4.array(z4.any()).optional(),
+  timelimit: z4.string().optional(),
+  theme: z4.string().optional()
+});
+
+// ../utils/dist/validation/organization/exercise.js
+import * as z5 from "zod";
+var ZLMSExercisesParam = z5.object({
+  orgId: z5.uuid()
+});
+
+// ../utils/dist/validation/organization/invite.js
+import * as z6 from "zod";
+var ZOrganizationInviteTokenParam = z6.object({
+  token: z6.string().min(10).max(512)
+});
+
+// ../utils/dist/validation/organization/sso.js
+import * as z7 from "zod";
+var SSO_PROVIDERS = ["OKTA", "GOOGLE_WORKSPACE", "AUTH0"];
+var ZCreateSsoConnection = z7.object({
+  provider: z7.enum(SSO_PROVIDERS),
+  displayName: z7.string().min(1, "Display name is required"),
+  issuer: z7.url("Must be a valid URL"),
+  domain: z7.string().min(1, "Domain is required").regex(/^[a-zA-Z0-9][a-zA-Z0-9-]{1,61}[a-zA-Z0-9]\.[a-zA-Z]{2,}$/, "Invalid domain format"),
+  clientId: z7.string().min(1, "Client ID is required"),
+  clientSecret: z7.string().min(1, "Client secret is required"),
+  scopes: z7.string().default("openid profile email")
+});
+var ZUpdateSsoConnection = z7.object({
+  displayName: z7.string().min(1).optional(),
+  issuer: z7.url().optional(),
+  domain: z7.string().optional(),
+  clientId: z7.string().optional(),
+  clientSecret: z7.string().optional(),
+  scopes: z7.string().optional(),
+  isActive: z7.boolean().optional()
+});
+var ZUpdateSsoPolicy = z7.object({
+  forceSso: z7.boolean().optional(),
+  autoJoinSsoDomains: z7.boolean().optional(),
+  breakGlassEnabled: z7.boolean().optional(),
+  defaultRoleId: z7.number().int().positive().optional(),
+  roleMapping: z7.record(z7.string(), z7.number()).optional()
+});
+var ZSsoDiscoveryQuery = z7.object({
+  email: z7.email("Valid email is required")
+});
+var ZGetSsoConfig = z7.object({
+  orgId: z7.uuid()
+});
+
+// ../utils/dist/validation/organization/login-link.js
+import { z as z8 } from "zod";
+var ZLoginLinkQuery = z8.object({
+  token: z8.string().min(1),
+  redirect: z8.string().optional()
+});
+var ZLoginLinkPayload = z8.object({
+  sub: z8.uuid(),
+  email: z8.email(),
+  type: z8.literal("login-link")
+});
+
+// ../utils/dist/validation/organization/token-auth.js
+import { z as z9 } from "zod";
+var ZTokenExchangeQuery = z9.object({
+  token: z9.string().min(1),
+  redirect: z9.string().optional()
+});
+var ZTokenExchangePayload = z9.object({
+  sub: z9.string(),
+  email: z9.email(),
+  name: z9.string().optional(),
+  avatar: z9.url().optional(),
+  iat: z9.number(),
+  exp: z9.number()
+});
+
+// ../utils/dist/validation/organization/automation-key.js
+import { z as z10 } from "zod";
+var ZOrganizationApiKeyType = z10.enum(["mcp", "api", "zapier"]);
+var ZOrganizationApiKeyScope = z10.enum([
+  "course_import:draft:create",
+  "course_import:draft:read",
+  "course_import:draft:update",
+  "course_import:draft:publish",
+  "course:read",
+  "course:tag:write",
+  "course:exercise:read",
+  "course:exercise:write",
+  "public_api:*"
+]);
+var ZListOrganizationApiKeysQuery = z10.object({
+  type: ZOrganizationApiKeyType.optional()
+});
+var ZOrganizationAutomationUsageQuery = z10.object({
+  type: ZOrganizationApiKeyType.default("mcp")
+});
+var ZCreateOrganizationApiKey = z10.object({
+  type: ZOrganizationApiKeyType,
+  label: z10.string().min(1).max(120).optional(),
+  expiresAt: z10.string().datetime().optional(),
+  scopes: z10.array(ZOrganizationApiKeyScope).min(1).optional()
+});
+var ZOrganizationApiKeyParam = z10.object({
+  keyId: z10.string().uuid()
+});
+
+// ../utils/dist/validation/exercise/exercise.js
+import * as z11 from "zod";
 
 // ../question-types/dist/question-type-keys.js
 var QUESTION_TYPE_KEY = {
@@ -444,226 +809,384 @@ var ALLOWED_DOCUMENT_TYPES = [
   "application/msword"
   // .doc
 ];
+var QUESTION_TYPE = QUESTION_TYPE_IDS;
+
+// ../utils/dist/validation/exercise/exercise.js
+var QUESTION_VALIDATION_RULES = {
+  [QUESTION_TYPE.RADIO]: [
+    (question) => {
+      const options = question.options || [];
+      if (options.length > 0 && options.length < 2) {
+        return "Options must have at least 2 items for RADIO/CHECKBOX questions";
+      }
+      return null;
+    },
+    (question) => {
+      const options = question.options || [];
+      if (options.length > 0 && !options.some((opt) => opt.isCorrect === true)) {
+        return "Please mark an option as the correct answer";
+      }
+      return null;
+    }
+  ],
+  [QUESTION_TYPE.CHECKBOX]: [
+    (question) => {
+      const options = question.options || [];
+      if (options.length > 0 && options.length < 2) {
+        return "Options must have at least 2 items for RADIO/CHECKBOX questions";
+      }
+      return null;
+    },
+    (question) => {
+      const options = question.options || [];
+      if (options.length > 0 && !options.some((opt) => opt.isCorrect === true)) {
+        return "Please mark an option as the correct answer";
+      }
+      return null;
+    }
+  ],
+  [QUESTION_TYPE.TRUE_FALSE]: [
+    (question) => {
+      const options = question.options || [];
+      if (options.length > 0 && options.length < 2) {
+        return "True/False questions need both True and False options";
+      }
+      return null;
+    },
+    (question) => {
+      const options = question.options || [];
+      if (options.length > 0 && !options.some((opt) => opt.isCorrect === true)) {
+        return "Please mark an option as the correct answer";
+      }
+      return null;
+    }
+  ],
+  [QUESTION_TYPE.TEXTAREA]: []
+};
+var ZExerciseUpdateQuestionBase = z11.object({
+  id: z11.number().int().optional(),
+  question: z11.string().min(1),
+  questionTypeId: z11.number().int().min(1).optional(),
+  // Added to support question type updates
+  points: z11.number().int().min(0).optional(),
+  order: z11.number().int().min(0).optional(),
+  settings: z11.record(z11.string(), z11.unknown()).optional(),
+  deletedAt: z11.string().optional(),
+  // Marks question as deleted
+  options: z11.array(z11.object({
+    id: z11.number().int().optional(),
+    label: z11.string().min(1),
+    isCorrect: z11.boolean(),
+    settings: z11.record(z11.string(), z11.unknown()).optional(),
+    deletedAt: z11.string().optional()
+    // Marks option as deleted
+  })).optional()
+});
+function validateQuestionOptions(question, ctx) {
+  if (question.deletedAt)
+    return;
+  const rules = QUESTION_VALIDATION_RULES[question.questionTypeId ?? -1] ?? [];
+  for (const rule of rules) {
+    const message = rule(question);
+    if (!message)
+      continue;
+    ctx.addIssue({
+      code: "custom",
+      message,
+      path: ["options"]
+    });
+  }
+}
+var ZExerciseUpdateQuestion = ZExerciseUpdateQuestionBase.superRefine(validateQuestionOptions);
+var ZExerciseCreate = z11.object({
+  title: z11.string().min(1),
+  description: z11.string().optional(),
+  lessonId: z11.string().optional(),
+  sectionId: z11.string().optional(),
+  order: z11.number().int().optional(),
+  courseId: z11.string().min(1),
+  dueBy: z11.string().optional(),
+  questions: z11.array(z11.object({
+    question: z11.string().min(1),
+    questionTypeId: z11.number().int().min(1).optional(),
+    points: z11.number().int().min(0).optional(),
+    settings: z11.record(z11.string(), z11.unknown()).optional(),
+    options: z11.array(z11.object({
+      label: z11.string().min(1),
+      isCorrect: z11.boolean(),
+      settings: z11.record(z11.string(), z11.unknown()).optional()
+    })).min(2)
+  })).optional()
+});
+var ZExerciseUpdate = z11.object({
+  title: z11.string().min(1).optional(),
+  description: z11.string().optional(),
+  lessonId: z11.string().optional(),
+  sectionId: z11.string().optional(),
+  order: z11.number().int().optional(),
+  isUnlocked: z11.boolean().optional(),
+  dueBy: z11.string().optional(),
+  // Changed from iso.datetime() to string to match frontend format
+  questions: z11.array(ZExerciseUpdateQuestion).optional()
+});
+var ZExerciseGetParam = z11.object({
+  exerciseId: z11.string().min(1)
+});
+var ZExerciseListQuery = z11.object({
+  lessonId: z11.string().optional(),
+  sectionId: z11.string().optional()
+});
+var ZExerciseSubmissionCreate = z11.object({
+  exerciseId: z11.string().min(1),
+  answers: z11.array(z11.object({
+    questionId: z11.number().int(),
+    optionId: z11.number().int().optional(),
+    answer: z11.string().optional()
+  })).min(1)
+});
+var ZExerciseFromTemplate = z11.object({
+  lessonId: z11.string().optional(),
+  sectionId: z11.string().optional(),
+  order: z11.number().int().optional(),
+  templateId: z11.number().int().min(1)
+});
+
+// ../utils/dist/validation/course-import/course-import.js
+import * as z13 from "zod";
 
 // ../utils/dist/validation/course/course.js
-var ZCourseClone = z2.object({
-  title: z2.string().min(1),
-  description: z2.string().optional(),
-  slug: z2.string().min(1),
-  organizationId: z2.string().min(1)
-});
-var ZCourseCloneParam = z2.object({
-  courseId: z2.string().min(1)
-});
-var ZCourseGetParam = z2.object({
-  courseId: z2.string().min(1)
-});
-var ZCourseGetQuery = z2.object({
-  slug: z2.string().optional()
-});
-var ZCourseGetBySlugParam = z2.object({
-  slug: z2.string().min(1)
-});
-var ZCourseEnrollParam = z2.object({
-  courseId: z2.string().min(1)
-});
-var ZCourseEnrollBody = z2.object({
-  inviteToken: z2.string().min(1).optional()
-});
-var ZCourseDownloadParam = z2.object({
-  courseId: z2.string().min(1)
-});
-var ZCertificateDownload = z2.object({
-  theme: z2.string().min(1),
-  studentName: z2.string().min(1),
-  courseName: z2.string().min(1),
-  courseDescription: z2.string().min(1),
-  orgName: z2.string().min(1),
-  orgLogoUrl: z2.string().url().optional(),
-  facilitator: z2.string().optional()
-});
-var ZCourseDownloadContent = z2.object({
-  courseTitle: z2.string().min(1),
-  orgName: z2.string().min(1),
-  orgTheme: z2.string().min(1),
-  lessons: z2.array(z2.object({
-    lessonTitle: z2.string().min(1),
-    lessonNumber: z2.string().min(1),
-    lessonNote: z2.string(),
-    slideUrl: z2.string().url().optional(),
-    video: z2.array(z2.string().url()).optional()
+import * as z12 from "zod";
+var ZCourseClone = z12.object({
+  title: z12.string().min(1),
+  description: z12.string().optional(),
+  slug: z12.string().min(1),
+  organizationId: z12.string().min(1)
+});
+var ZCourseCloneParam = z12.object({
+  courseId: z12.string().min(1)
+});
+var ZCourseGetParam = z12.object({
+  courseId: z12.string().min(1)
+});
+var ZCourseGetQuery = z12.object({
+  slug: z12.string().optional()
+});
+var ZCourseGetBySlugParam = z12.object({
+  slug: z12.string().min(1)
+});
+var ZCourseEnrollParam = z12.object({
+  courseId: z12.string().min(1)
+});
+var ZCourseEnrollBody = z12.object({
+  inviteToken: z12.string().min(1).optional()
+});
+var ZCourseDownloadParam = z12.object({
+  courseId: z12.string().min(1)
+});
+var ZCertificateDownload = z12.object({
+  theme: z12.string().min(1),
+  studentName: z12.string().min(1),
+  courseName: z12.string().min(1),
+  courseDescription: z12.string().min(1),
+  orgName: z12.string().min(1),
+  orgLogoUrl: z12.string().url().optional(),
+  facilitator: z12.string().optional()
+});
+var ZCourseDownloadContent = z12.object({
+  courseTitle: z12.string().min(1),
+  orgName: z12.string().min(1),
+  orgTheme: z12.string().min(1),
+  lessons: z12.array(z12.object({
+    lessonTitle: z12.string().min(1),
+    lessonNumber: z12.string().min(1),
+    lessonNote: z12.string(),
+    slideUrl: z12.string().url().optional(),
+    video: z12.array(z12.string().url()).optional()
   }))
 });
-var ZLessonDownloadContent = z2.object({
-  title: z2.string().min(1),
-  number: z2.string().min(1),
-  orgName: z2.string().min(1),
-  note: z2.string(),
-  slideUrl: z2.string().url().optional(),
-  video: z2.array(z2.string().url()).optional(),
-  courseTitle: z2.string().min(1)
-});
-var ZCoursePresignUrlUpload = z2.object({
-  fileName: z2.string().min(1),
-  fileType: z2.enum(ALLOWED_CONTENT_TYPES)
-});
-var ZCourseDocumentPresignUrlUpload = z2.object({
-  fileName: z2.string().min(1),
-  fileType: z2.enum(ALLOWED_DOCUMENT_TYPES)
-});
-var ZCourseDownloadPresignedUrl = z2.object({
-  keys: z2.array(z2.string().min(1)).min(1)
-});
-var ZCourseContentUpdateItem = z2.object({
-  id: z2.string().min(1),
-  type: z2.enum(["LESSON", "EXERCISE"]),
-  isUnlocked: z2.boolean().optional(),
-  order: z2.number().int().min(0).optional(),
-  sectionId: z2.string().nullable().optional()
-});
-var ZCourseContentUpdate = z2.object({
-  items: z2.array(ZCourseContentUpdateItem).min(1)
-});
-var ZCourseContentDeleteItem = z2.object({
-  id: z2.string().min(1),
-  type: z2.enum(["LESSON", "EXERCISE"])
-});
-var ZCourseContentDelete = z2.object({
-  sectionId: z2.string().min(1).optional(),
-  items: z2.array(ZCourseContentDeleteItem).min(1).optional()
+var ZLessonDownloadContent = z12.object({
+  title: z12.string().min(1),
+  number: z12.string().min(1),
+  orgName: z12.string().min(1),
+  note: z12.string(),
+  slideUrl: z12.string().url().optional(),
+  video: z12.array(z12.string().url()).optional(),
+  courseTitle: z12.string().min(1)
+});
+var ZCoursePresignUrlUpload = z12.object({
+  fileName: z12.string().min(1),
+  fileType: z12.enum(ALLOWED_CONTENT_TYPES)
+});
+var ZCourseDocumentPresignUrlUpload = z12.object({
+  fileName: z12.string().min(1),
+  fileType: z12.enum(ALLOWED_DOCUMENT_TYPES)
+});
+var ZCourseDownloadPresignedUrl = z12.object({
+  keys: z12.array(z12.string().min(1)).min(1)
+});
+var ZCourseContentUpdateItem = z12.object({
+  id: z12.string().min(1),
+  type: z12.enum(["LESSON", "EXERCISE"]),
+  isUnlocked: z12.boolean().optional(),
+  order: z12.number().int().min(0).optional(),
+  sectionId: z12.string().nullable().optional()
+});
+var ZCourseContentUpdate = z12.object({
+  items: z12.array(ZCourseContentUpdateItem).min(1)
+});
+var ZCourseContentDeleteItem = z12.object({
+  id: z12.string().min(1),
+  type: z12.enum(["LESSON", "EXERCISE"])
+});
+var ZCourseContentDelete = z12.object({
+  sectionId: z12.string().min(1).optional(),
+  items: z12.array(ZCourseContentDeleteItem).min(1).optional()
 }).refine((data) => Boolean(data.sectionId) !== Boolean(data.items), {
   message: "Provide either sectionId or items",
   path: ["sectionId"]
 });
-var ZCourseCreate = z2.object({
-  title: z2.string().min(1),
-  description: z2.string().min(1),
-  type: z2.enum(["LIVE_CLASS", "SELF_PACED"]),
-  organizationId: z2.string().min(1)
-});
-var ZCourseMetadata = z2.object({
-  requirements: z2.string().optional(),
-  description: z2.string().optional(),
-  goals: z2.string().optional(),
-  videoUrl: z2.string().optional(),
-  showDiscount: z2.boolean().optional(),
-  discount: z2.number().optional(),
-  paymentLink: z2.string().optional(),
-  reward: z2.object({
-    show: z2.boolean(),
-    description: z2.string()
+var ZCourseCreate = z12.object({
+  title: z12.string().min(1),
+  description: z12.string().min(1),
+  type: z12.enum(["LIVE_CLASS", "SELF_PACED"]),
+  organizationId: z12.string().min(1)
+});
+var ZCourseMetadata = z12.object({
+  requirements: z12.string().optional(),
+  description: z12.string().optional(),
+  goals: z12.string().optional(),
+  videoUrl: z12.string().optional(),
+  showDiscount: z12.boolean().optional(),
+  discount: z12.number().optional(),
+  paymentLink: z12.string().optional(),
+  reward: z12.object({
+    show: z12.boolean(),
+    description: z12.string()
   }).optional(),
-  instructor: z2.object({
-    name: z2.string(),
-    role: z2.string(),
-    coursesNo: z2.number(),
-    description: z2.string(),
-    imgUrl: z2.string()
+  instructor: z12.object({
+    name: z12.string(),
+    role: z12.string(),
+    coursesNo: z12.number(),
+    description: z12.string(),
+    imgUrl: z12.string()
   }).optional(),
-  certificate: z2.object({
-    templateUrl: z2.string()
+  certificate: z12.object({
+    templateUrl: z12.string()
   }).optional(),
-  reviews: z2.array(z2.object({
-    id: z2.number(),
-    hide: z2.boolean(),
-    name: z2.string(),
-    avatar_url: z2.string(),
-    rating: z2.number(),
-    created_at: z2.number(),
-    description: z2.string()
+  reviews: z12.array(z12.object({
+    id: z12.number(),
+    hide: z12.boolean(),
+    name: z12.string(),
+    avatar_url: z12.string(),
+    rating: z12.number(),
+    created_at: z12.number(),
+    description: z12.string()
   })).optional(),
-  lessonTabsOrder: z2.array(z2.object({
-    id: z2.union([z2.literal(1), z2.literal(2), z2.literal(3), z2.literal(4)]),
-    name: z2.string()
+  lessonTabsOrder: z12.array(z12.object({
+    id: z12.union([z12.literal(1), z12.literal(2), z12.literal(3), z12.literal(4)]),
+    name: z12.string()
   })).optional(),
-  grading: z2.boolean().optional(),
-  lessonDownload: z2.boolean().optional(),
-  allowNewStudent: z2.boolean(),
-  sectionDisplay: z2.record(z2.string(), z2.boolean()).optional(),
-  isContentGroupingEnabled: z2.boolean().optional()
-});
-var ZCourseUpdate = z2.object({
-  title: z2.string().min(1).optional(),
-  description: z2.string().min(1).optional(),
-  type: z2.enum(["LIVE_CLASS", "SELF_PACED"]).optional(),
-  logo: z2.string().optional(),
-  slug: z2.string().optional(),
-  isPublished: z2.boolean().optional(),
-  overview: z2.string().optional(),
+  grading: z12.boolean().optional(),
+  lessonDownload: z12.boolean().optional(),
+  allowNewStudent: z12.boolean(),
+  sectionDisplay: z12.record(z12.string(), z12.boolean()).optional(),
+  isContentGroupingEnabled: z12.boolean().optional()
+});
+var ZCourseUpdate = z12.object({
+  title: z12.string().min(1).optional(),
+  description: z12.string().min(1).optional(),
+  type: z12.enum(["LIVE_CLASS", "SELF_PACED"]).optional(),
+  logo: z12.string().optional(),
+  slug: z12.string().optional(),
+  isPublished: z12.boolean().optional(),
+  overview: z12.string().optional(),
   metadata: ZCourseMetadata.optional(),
-  isCertificateDownloadable: z2.boolean().optional(),
-  certificateTheme: z2.string().optional(),
-  tagIds: z2.array(z2.uuid()).max(100).optional()
+  isCertificateDownloadable: z12.boolean().optional(),
+  certificateTheme: z12.string().optional(),
+  tagIds: z12.array(z12.uuid()).max(100).optional()
 });
-var ZCourseUpdateParam = z2.object({
-  courseId: z2.string().min(1)
+var ZCourseUpdateParam = z12.object({
+  courseId: z12.string().min(1)
 });
-var ZCourseDeleteParam = z2.object({
-  courseId: z2.string().min(1)
+var ZCourseDeleteParam = z12.object({
+  courseId: z12.string().min(1)
 });
-var ZCourseProgressParam = z2.object({
-  courseId: z2.string().min(1)
+var ZCourseProgressParam = z12.object({
+  courseId: z12.string().min(1)
 });
-var ZCourseProgressQuery = z2.object({
-  profileId: z2.string().uuid()
+var ZCourseProgressQuery = z12.object({
+  profileId: z12.string().uuid()
 });
-var ZCourseUserAnalyticsParam = z2.object({
-  courseId: z2.string().min(1),
-  userId: z2.string().uuid()
+var ZCourseUserAnalyticsParam = z12.object({
+  courseId: z12.string().min(1),
+  userId: z12.string().uuid()
 });
 
 // ../utils/dist/validation/course-import/course-import.js
-var ZSupportedLocale = z3.enum(["en", "hi", "fr", "pt", "de", "vi", "ru", "es", "pl", "da"]);
-var ZCourseImportWarning = z3.object({
-  code: z3.string().min(1),
-  message: z3.string().min(1),
-  severity: z3.enum(["info", "warning", "error"])
-});
-var ZCourseImportSourceReference = z3.object({
-  type: z3.enum(["prompt", "pdf", "course"]),
-  label: z3.string().min(1),
-  pageStart: z3.number().int().min(1).optional(),
-  pageEnd: z3.number().int().min(1).optional()
-});
-var ZCourseImportDraftCourse = z3.object({
-  title: z3.string().min(1),
-  description: z3.string().min(1),
-  type: z3.enum(["LIVE_CLASS", "SELF_PACED"]),
+var ZSupportedLocale = z13.enum(["en", "hi", "fr", "pt", "de", "vi", "ru", "es", "pl", "da"]);
+var ZCourseImportWarning = z13.object({
+  code: z13.string().min(1),
+  message: z13.string().min(1),
+  severity: z13.enum(["info", "warning", "error"])
+});
+var ZCourseImportSourceReference = z13.object({
+  type: z13.enum(["prompt", "pdf", "course"]),
+  label: z13.string().min(1),
+  pageStart: z13.number().int().min(1).optional(),
+  pageEnd: z13.number().int().min(1).optional()
+});
+var ZCourseImportDraftCourse = z13.object({
+  title: z13.string().min(1),
+  description: z13.string().min(1),
+  type: z13.enum(["LIVE_CLASS", "SELF_PACED"]),
   locale: ZSupportedLocale.default("en"),
   metadata: ZCourseMetadata.optional()
 });
-var ZCourseImportDraftSection = z3.object({
-  externalId: z3.string().min(1),
-  title: z3.string().min(1),
-  order: z3.number().int().min(0)
-});
-var ZCourseImportDraftLesson = z3.object({
-  externalId: z3.string().min(1),
-  sectionExternalId: z3.string().min(1),
-  title: z3.string().min(1),
-  order: z3.number().int().min(0),
-  isUnlocked: z3.boolean().optional(),
-  public: z3.boolean().optional()
-});
-var ZCourseImportDraftLessonLanguage = z3.object({
-  lessonExternalId: z3.string().min(1),
+var ZCourseImportDraftSection = z13.object({
+  externalId: z13.string().min(1),
+  title: z13.string().min(1),
+  order: z13.number().int().min(0)
+});
+var ZCourseImportDraftLesson = z13.object({
+  externalId: z13.string().min(1),
+  sectionExternalId: z13.string().min(1),
+  title: z13.string().min(1),
+  order: z13.number().int().min(0),
+  isUnlocked: z13.boolean().optional(),
+  public: z13.boolean().optional()
+});
+var ZCourseImportDraftLessonLanguage = z13.object({
+  lessonExternalId: z13.string().min(1),
   locale: ZSupportedLocale,
-  content: z3.string().min(1)
+  content: z13.string().min(1)
 });
-var ZCourseImportDraftPayload = z3.object({
+var ZCourseImportDraftPayload = z13.object({
   course: ZCourseImportDraftCourse,
-  sections: z3.array(ZCourseImportDraftSection).min(1),
-  lessons: z3.array(ZCourseImportDraftLesson).min(1),
-  lessonLanguages: z3.array(ZCourseImportDraftLessonLanguage).min(1),
-  exercises: z3.array(z3.record(z3.string(), z3.unknown())).optional(),
-  sourceReferences: z3.array(ZCourseImportSourceReference).optional(),
-  warnings: z3.array(ZCourseImportWarning).default([])
+  tags: z13.array(z13.string().trim().min(1).max(80)).max(100).default([]),
+  sections: z13.array(ZCourseImportDraftSection).min(1),
+  lessons: z13.array(ZCourseImportDraftLesson).min(1),
+  lessonLanguages: z13.array(ZCourseImportDraftLessonLanguage).min(1),
+  exercises: z13.array(z13.record(z13.string(), z13.unknown())).optional(),
+  sourceReferences: z13.array(ZCourseImportSourceReference).optional(),
+  warnings: z13.array(ZCourseImportWarning).default([])
 }).superRefine((value, ctx) => {
+  const normalizedTags = /* @__PURE__ */ new Set();
+  value.tags.forEach((tag, index) => {
+    const tagKey = tag.trim().toLowerCase();
+    if (normalizedTags.has(tagKey)) {
+      ctx.addIssue({
+        code: z13.ZodIssueCode.custom,
+        path: ["tags", index],
+        message: "Draft tags must be unique"
+      });
+    }
+    normalizedTags.add(tagKey);
+  });
   const sectionIds = /* @__PURE__ */ new Set();
   value.sections.forEach((section, index) => {
     if (sectionIds.has(section.externalId)) {
       ctx.addIssue({
-        code: z3.ZodIssueCode.custom,
+        code: z13.ZodIssueCode.custom,
         path: ["sections", index, "externalId"],
         message: "Section externalId must be unique"
       });
@@ -674,7 +1197,7 @@ var ZCourseImportDraftPayload = z3.object({
   value.lessons.forEach((lesson, index) => {
     if (lessonIds.has(lesson.externalId)) {
       ctx.addIssue({
-        code: z3.ZodIssueCode.custom,
+        code: z13.ZodIssueCode.custom,
         path: ["lessons", index, "externalId"],
         message: "Lesson externalId must be unique"
       });
@@ -682,7 +1205,7 @@ var ZCourseImportDraftPayload = z3.object({
     lessonIds.add(lesson.externalId);
     if (!sectionIds.has(lesson.sectionExternalId)) {
       ctx.addIssue({
-        code: z3.ZodIssueCode.custom,
+        code: z13.ZodIssueCode.custom,
         path: ["lessons", index, "sectionExternalId"],
         message: "Lesson sectionExternalId must reference an existing section"
       });
@@ -691,52 +1214,76 @@ var ZCourseImportDraftPayload = z3.object({
   value.lessonLanguages.forEach((lessonLanguage, index) => {
     if (!lessonIds.has(lessonLanguage.lessonExternalId)) {
       ctx.addIssue({
-        code: z3.ZodIssueCode.custom,
+        code: z13.ZodIssueCode.custom,
         path: ["lessonLanguages", index, "lessonExternalId"],
         message: "Lesson language must reference an existing lesson"
       });
     }
   });
 });
-var ZCourseImportDraftCreate = z3.object({
-  sourceType: z3.enum(["prompt", "pdf", "course"]),
-  idempotencyKey: z3.string().min(1).optional(),
-  summary: z3.record(z3.string(), z3.unknown()).optional(),
-  sourceArtifacts: z3.array(z3.record(z3.string(), z3.unknown())).optional(),
+var ZCourseImportDraftCreate = z13.object({
+  sourceType: z13.enum(["prompt", "pdf", "course"]),
+  idempotencyKey: z13.string().min(1).optional(),
+  summary: z13.record(z13.string(), z13.unknown()).optional(),
+  sourceArtifacts: z13.array(z13.record(z13.string(), z13.unknown())).optional(),
   draft: ZCourseImportDraftPayload
 });
-var ZCourseImportCourseParam = z3.object({
-  courseId: z3.string().min(1)
+var ZCourseImportCourseParam = z13.object({
+  courseId: z13.string().min(1)
 });
-var ZCourseImportDraftCreateFromCourse = z3.object({
-  courseId: z3.string().min(1),
-  idempotencyKey: z3.string().min(1).optional(),
-  summary: z3.record(z3.string(), z3.unknown()).optional(),
-  sourceArtifacts: z3.array(z3.record(z3.string(), z3.unknown())).optional()
+var ZCourseImportDraftCreateFromCourse = z13.object({
+  courseId: z13.string().min(1),
+  idempotencyKey: z13.string().min(1).optional(),
+  summary: z13.record(z13.string(), z13.unknown()).optional(),
+  sourceArtifacts: z13.array(z13.record(z13.string(), z13.unknown())).optional()
 });
-var ZCourseImportDraftGetParam = z3.object({
-  draftId: z3.string().uuid()
+var ZCourseImportDraftGetParam = z13.object({
+  draftId: z13.string().uuid()
 });
-var ZCourseImportDraftUpdate = z3.object({
-  summary: z3.record(z3.string(), z3.unknown()).optional(),
-  sourceArtifacts: z3.array(z3.record(z3.string(), z3.unknown())).optional(),
-  warnings: z3.array(ZCourseImportWarning).optional(),
+var ZCourseImportDraftUpdate = z13.object({
+  summary: z13.record(z13.string(), z13.unknown()).optional(),
+  sourceArtifacts: z13.array(z13.record(z13.string(), z13.unknown())).optional(),
+  warnings: z13.array(ZCourseImportWarning).optional(),
   draft: ZCourseImportDraftPayload.optional()
 });
-var ZCourseImportDraftPublish = z3.object({
-  title: z3.string().min(1).optional(),
-  description: z3.string().min(1).optional(),
-  type: z3.enum(["LIVE_CLASS", "SELF_PACED"]).optional(),
-  metadata: ZCourseMetadata.optional()
+var ZCourseImportDraftPublish = z13.object({
+  title: z13.string().min(1).optional(),
+  description: z13.string().min(1).optional(),
+  type: z13.enum(["LIVE_CLASS", "SELF_PACED"]).optional(),
+  metadata: ZCourseMetadata.optional(),
+  bannerImageUrl: z13.string().url().optional(),
+  bannerImageQuery: z13.string().min(1).max(120).optional(),
+  generateBannerImage: z13.boolean().optional()
 });
 var ZCourseImportDraftPublishToCourse = ZCourseImportDraftPublish.extend({
-  courseId: z3.string().min(1)
+  courseId: z13.string().min(1)
 });
 
 // src/tools/course-drafts.ts
 var ZUpdateCourseDraftToolInput = ZCourseImportDraftUpdate.extend({
   draftId: ZCourseImportDraftGetParam.shape.draftId
 });
+var ZTagCourseDraftToolInput = ZAutomationDraftTagAssignment.extend({
+  draftId: ZAutomationDraftTagParam.shape.draftId
+});
+var ZListCourseExercisesToolInput = ZExerciseListQuery.extend({
+  courseId: ZCourseImportCourseParam.shape.courseId
+});
+var ZGetCourseExerciseToolInput = ZExerciseGetParam.extend({
+  courseId: ZCourseImportCourseParam.shape.courseId
+});
+var ZCreateCourseExerciseToolInput = ZExerciseCreate.omit({
+  courseId: true
+}).extend({
+  courseId: ZCourseImportCourseParam.shape.courseId
+});
+var ZCreateCourseExerciseFromTemplateToolInput = ZExerciseFromTemplate.extend({
+  courseId: ZCourseImportCourseParam.shape.courseId
+});
+var ZUpdateCourseExerciseToolInput = ZExerciseUpdate.extend({
+  courseId: ZCourseImportCourseParam.shape.courseId,
+  exerciseId: ZExerciseGetParam.shape.exerciseId
+});
 var ZPublishCourseDraftToolInput = ZCourseImportDraftPublish.extend({
   draftId: ZCourseImportDraftGetParam.shape.draftId
 });
@@ -745,47 +1292,170 @@ var ZPublishCourseDraftToExistingCourseToolInput = ZCourseImportDraftPublishToCo
 });
 var createCourseDraftShape = ZCourseImportDraftCreate.shape;
 var createCourseDraftFromCourseShape = ZCourseImportDraftCreateFromCourse.shape;
+var listOrganizationCoursesShape = ZGetOrganizationCoursesQuery.shape;
 var getCourseStructureShape = ZCourseImportCourseParam.shape;
 var getCourseDraftShape = ZCourseImportDraftGetParam.shape;
 var updateCourseDraftShape = ZUpdateCourseDraftToolInput.shape;
+var tagCourseDraftShape = ZTagCourseDraftToolInput.shape;
+var listCourseExercisesShape = ZListCourseExercisesToolInput.shape;
+var getCourseExerciseShape = ZGetCourseExerciseToolInput.shape;
+var createCourseExerciseShape = ZCreateCourseExerciseToolInput.shape;
+var createCourseExerciseFromTemplateShape = ZCreateCourseExerciseFromTemplateToolInput.shape;
+var updateCourseExerciseShape = ZUpdateCourseExerciseToolInput.shape;
 var publishCourseDraftShape = ZPublishCourseDraftToolInput.shape;
 var publishCourseDraftToExistingCourseShape = ZPublishCourseDraftToExistingCourseToolInput.shape;
+var tagCoursesShape = ZAutomationCourseTagAssignment.shape;
 function registerCourseDraftTools(server, apiClient) {
-  server.tool("get_course_structure", getCourseStructureShape, async (args) => {
-    const { courseId } = ZCourseImportCourseParam.parse(args);
-    const result = await apiClient.getCourseStructure(courseId);
-    return jsonContent(result);
-  });
-  server.tool("create_course_draft", createCourseDraftShape, async (args) => {
-    const payload = ZCourseImportDraftCreate.parse(args);
-    const result = await apiClient.createCourseDraft(payload);
-    return jsonContent(result);
-  });
-  server.tool("create_course_draft_from_course", createCourseDraftFromCourseShape, async (args) => {
-    const payload = ZCourseImportDraftCreateFromCourse.parse(args);
-    const result = await apiClient.createCourseDraftFromCourse(payload);
-    return jsonContent(result);
-  });
-  server.tool("get_course_draft", getCourseDraftShape, async (args) => {
-    const { draftId } = ZCourseImportDraftGetParam.parse(args);
-    const result = await apiClient.getCourseDraft(draftId);
-    return jsonContent(result);
-  });
-  server.tool("update_course_draft", updateCourseDraftShape, async (args) => {
-    const { draftId, ...payload } = ZUpdateCourseDraftToolInput.parse(args);
-    const result = await apiClient.updateCourseDraft(draftId, payload);
-    return jsonContent(result);
-  });
-  server.tool("publish_course_draft", publishCourseDraftShape, async (args) => {
-    const { draftId, ...payload } = ZPublishCourseDraftToolInput.parse(args);
-    const result = await apiClient.publishCourseDraft(draftId, payload);
-    return jsonContent(result);
-  });
-  server.tool("publish_course_draft_to_existing_course", publishCourseDraftToExistingCourseShape, async (args) => {
-    const { draftId, ...payload } = ZPublishCourseDraftToExistingCourseToolInput.parse(args);
-    const result = await apiClient.publishCourseDraftToExistingCourse(draftId, payload);
-    return jsonContent(result);
-  });
+  server.tool(
+    "list_org_courses",
+    "List all courses in the authenticated organization. Use this when the user refers to a course by name and you need to discover the available course IDs first.",
+    listOrganizationCoursesShape,
+    async (args) => {
+      const query = ZGetOrganizationCoursesQuery.parse(args);
+      const result = await apiClient.listOrganizationCourses(query);
+      return jsonContent(result);
+    }
+  );
+  server.tool(
+    "get_course_structure",
+    "Read the current live course structure. Use this before creating a fresh draft for post-publish edits.",
+    getCourseStructureShape,
+    async (args) => {
+      const { courseId } = ZCourseImportCourseParam.parse(args);
+      const result = await apiClient.getCourseStructure(courseId);
+      return jsonContent(result);
+    }
+  );
+  server.tool(
+    "create_course_draft",
+    "Create a new unpublished course draft from structured course JSON. Use this before the first publish.",
+    createCourseDraftShape,
+    async (args) => {
+      const payload = ZCourseImportDraftCreate.parse(args);
+      const result = await apiClient.createCourseDraft(payload);
+      return jsonContent(result);
+    }
+  );
+  server.tool(
+    "create_course_draft_from_course",
+    "Create a fresh draft from an existing live course. Use this after a course has already been published and the user wants more changes.",
+    createCourseDraftFromCourseShape,
+    async (args) => {
+      const payload = ZCourseImportDraftCreateFromCourse.parse(args);
+      const result = await apiClient.createCourseDraftFromCourse(payload);
+      return jsonContent(result);
+    }
+  );
+  server.tool(
+    "get_course_draft",
+    "Fetch an existing draft. Draft responses include status and publishedCourseId so you can decide whether to keep editing the draft or seed a fresh one from the live course.",
+    getCourseDraftShape,
+    async (args) => {
+      const { draftId } = ZCourseImportDraftGetParam.parse(args);
+      const result = await apiClient.getCourseDraft(draftId);
+      return jsonContent(result);
+    }
+  );
+  server.tool(
+    "list_course_exercises",
+    "List exercises for a live course, optionally filtered by lessonId or sectionId.",
+    listCourseExercisesShape,
+    async (args) => {
+      const { courseId, ...query } = ZListCourseExercisesToolInput.parse(args);
+      const result = await apiClient.listCourseExercises(courseId, query);
+      return jsonContent(result);
+    }
+  );
+  server.tool(
+    "get_course_exercise",
+    "Fetch a single exercise from a live course, including its questions and options.",
+    getCourseExerciseShape,
+    async (args) => {
+      const { courseId, exerciseId } = ZGetCourseExerciseToolInput.parse(args);
+      const result = await apiClient.getCourseExercise(courseId, exerciseId);
+      return jsonContent(result);
+    }
+  );
+  server.tool(
+    "create_course_exercise",
+    "Create a new exercise directly on a live course. Use this for adding exercises after a course has already been published.",
+    createCourseExerciseShape,
+    async (args) => {
+      const { courseId, ...payload } = ZCreateCourseExerciseToolInput.parse(args);
+      const result = await apiClient.createCourseExercise(courseId, payload);
+      return jsonContent(result);
+    }
+  );
+  server.tool(
+    "create_course_exercise_from_template",
+    "Create a new exercise on a live course from an existing template.",
+    createCourseExerciseFromTemplateShape,
+    async (args) => {
+      const { courseId, ...payload } = ZCreateCourseExerciseFromTemplateToolInput.parse(args);
+      const result = await apiClient.createCourseExerciseFromTemplate(courseId, payload);
+      return jsonContent(result);
+    }
+  );
+  server.tool(
+    "update_course_exercise",
+    "Update an existing exercise on a live course, including questions and options.",
+    updateCourseExerciseShape,
+    async (args) => {
+      const { courseId, exerciseId, ...payload } = ZUpdateCourseExerciseToolInput.parse(args);
+      const result = await apiClient.updateCourseExercise(courseId, exerciseId, payload);
+      return jsonContent(result);
+    }
+  );
+  server.tool(
+    "update_course_draft",
+    "Update an unpublished draft. If the draft is already published, do not keep editing it blindly; create a fresh draft from the live course first.",
+    updateCourseDraftShape,
+    async (args) => {
+      const { draftId, ...payload } = ZUpdateCourseDraftToolInput.parse(args);
+      const result = await apiClient.updateCourseDraft(draftId, payload);
+      return jsonContent(result);
+    }
+  );
+  server.tool(
+    "tag_course_draft",
+    "Attach human-readable tags to a draft before publish. The tags are stored on the draft and applied during publish.",
+    tagCourseDraftShape,
+    async (args) => {
+      const { draftId, ...payload } = ZTagCourseDraftToolInput.parse(args);
+      const result = await apiClient.tagCourseDraft(draftId, payload);
+      return jsonContent(result);
+    }
+  );
+  server.tool(
+    "publish_course_draft",
+    "Publish an unpublished draft as a new live course. The result includes courseId and courseUrl. After publish, future major edits should usually start from a fresh draft created from the live course.",
+    publishCourseDraftShape,
+    async (args) => {
+      const { draftId, ...payload } = ZPublishCourseDraftToolInput.parse(args);
+      const result = await apiClient.publishCourseDraft(draftId, payload);
+      return jsonContent(result);
+    }
+  );
+  server.tool(
+    "publish_course_draft_to_existing_course",
+    "Apply a fresh draft back onto an existing live course. Use this after reading the live course and creating a new draft from it.",
+    publishCourseDraftToExistingCourseShape,
+    async (args) => {
+      const { draftId, ...payload } = ZPublishCourseDraftToExistingCourseToolInput.parse(args);
+      const result = await apiClient.publishCourseDraftToExistingCourse(draftId, payload);
+      return jsonContent(result);
+    }
+  );
+  server.tool(
+    "tag_courses",
+    "Assign tags directly to one or more live courses by name. Default mode is merge, so existing tags are preserved unless replace is requested.",
+    tagCoursesShape,
+    async (args) => {
+      const payload = ZAutomationCourseTagAssignment.parse(args);
+      const result = await apiClient.tagCourses(payload);
+      return jsonContent(result);
+    }
+  );
 }
 function jsonContent(data) {
   return {