@classroomio/mcp 0.0.2 → 0.0.4

package/README.md

@@ -45,7 +45,14 @@ Current tools:
 - `create_course_draft`
 - `create_course_draft_from_course`
 - `get_course_draft`
+- `list_course_exercises`
+- `get_course_exercise`
+- `create_course_exercise`
+- `create_course_exercise_from_template`
+- `update_course_exercise`
 - `update_course_draft`
+- `tag_course_draft`
+- `tag_courses`
 - `publish_course_draft`
 - `publish_course_draft_to_existing_course`
 
@@ -139,6 +146,7 @@ Draft payload shape:
 ```text
 draft
   course
+  tags[]
   sections[]
   lessons[]
   lessonLanguages[]
@@ -154,6 +162,31 @@ Drafts support:
 - safer updates to existing courses
 - auditability of AI-generated structure
 
+## After Publish
+
+Once a draft has been published, the live course becomes the safer source of truth.
+
+Recommended agent rule:
+
+- if the draft is still `DRAFT`, continue editing that draft
+- if the draft is `PUBLISHED`, do not keep reusing it for major follow-up edits
+- instead, read the live course and create a fresh draft from that course
+
+Recommended post-publish sequence:
+
+1. `get_course_structure`
+2. `create_course_draft_from_course`
+3. `update_course_draft`
+4. `publish_course_draft_to_existing_course`
+
+Why:
+
+- teachers may edit the live course in the UI after publish
+- another agent session may have changed the course
+- reusing an old published draft can overwrite newer live changes
+
+For exercises on an already-published course, prefer the direct exercise tools instead of creating a whole new draft when the user only wants to add or revise exercises.
+
 ## User Flows
 
 ### Flow 1: Create a new course from a prompt
@@ -178,6 +211,8 @@ Result:
 - a new course is created
 - sections and lessons are created
 - localized lesson content is written
+- publish returns the live `courseId` and public `courseUrl`
+- publish can optionally set a random Unsplash-derived course cover
 
 ### Flow 2: Create a draft from a PDF
 
@@ -202,7 +237,27 @@ Important:
 - the PDF does not need to be uploaded to MCP
 - the MCP package only receives structured JSON
 
-### Flow 3: Update an existing course safely
+### Flow 3: Tag a draft before publish
+
+User says:
+
+```text
+Add tags for algebra, beginner, and exponential growth to this draft.
+```
+
+Expected tool sequence:
+
+1. Agent calls `tag_course_draft`.
+2. User reviews the updated draft tags.
+3. Agent later calls `publish_course_draft`.
+
+Result:
+
+- the draft stores tag names
+- publish ensures the tags exist in ClassroomIO
+- publish assigns those tags to the live course
+
+### Flow 4: Update an existing course safely
 
 User says:
 
@@ -221,10 +276,29 @@ Expected tool sequence:
 What this publish does today:
 
 - updates the existing course title, description, type, and metadata
+- can set a generated course cover from Unsplash
+- returns the public `courseUrl`
 - updates existing sections when the draft keeps their IDs
 - updates existing lessons when the draft keeps their IDs
 - creates new sections and lessons for draft items without matching live IDs
 - upserts lesson language content
+- merges draft tags into the existing course
+
+### Flow 5: Add exercises to a live course
+
+User says:
+
+```text
+Add a 5-question multiple-choice exercise to lesson 3.
+```
+
+Expected tool sequence:
+
+1. Agent calls `list_course_exercises` if it needs current context.
+2. Agent calls `create_course_exercise` for a brand new exercise.
+3. Agent calls `update_course_exercise` for later revisions.
+
+Use this direct path when the course is already live and the change is exercise-specific.
 
 What it does not do today:
 
@@ -253,6 +327,28 @@ For large updates, the agent should:
 3. only generate new `externalId` values for new records
 4. avoid deleting records from the draft unless the user explicitly wants omitted content to remain untouched
 
+Publish input also supports:
+
+- `bannerImageUrl`: use this exact course cover
+- `bannerImageQuery`: search Unsplash with this query
+- `generateBannerImage`: fetch a random Unsplash image using the course title or query
+
+Tagging tools use:
+
+- `tagNames`: human-readable tag names, not tag IDs
+- `mode: "merge" | "replace"`
+- `groupName` optional, defaults to `Automation`
+
+The API creates missing tags automatically when needed.
+
+Exercise tools use the live course directly:
+
+- `list_course_exercises`
+- `get_course_exercise`
+- `create_course_exercise`
+- `create_course_exercise_from_template`
+- `update_course_exercise`
+
 ## Operational Notes
 
 - `create_course_draft_from_course` may add warnings if a live course uses legacy lesson notes instead of localized lesson content

package/dist/index.js

@@ -40,12 +40,53 @@ var ClassroomIoApiClient = class {
       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 +99,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 +146,71 @@ function getConfig(env = process.env) {
   return ZConfig.parse(env);
 }
 
-// ../utils/dist/validation/course-import/course-import.js
-import * as z3 from "zod";
-
-// ../utils/dist/validation/course/course.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/exercise/exercise.js
+import * as z3 from "zod";
 
 // ../question-types/dist/question-type-keys.js
 var QUESTION_TYPE_KEY = {
@@ -444,226 +554,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 = z3.object({
+  id: z3.number().int().optional(),
+  question: z3.string().min(1),
+  questionTypeId: z3.number().int().min(1).optional(),
+  // Added to support question type updates
+  points: z3.number().int().min(0).optional(),
+  order: z3.number().int().min(0).optional(),
+  settings: z3.record(z3.string(), z3.unknown()).optional(),
+  deletedAt: z3.string().optional(),
+  // Marks question as deleted
+  options: z3.array(z3.object({
+    id: z3.number().int().optional(),
+    label: z3.string().min(1),
+    isCorrect: z3.boolean(),
+    settings: z3.record(z3.string(), z3.unknown()).optional(),
+    deletedAt: z3.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 = z3.object({
+  title: z3.string().min(1),
+  description: z3.string().optional(),
+  lessonId: z3.string().optional(),
+  sectionId: z3.string().optional(),
+  order: z3.number().int().optional(),
+  courseId: z3.string().min(1),
+  dueBy: z3.string().optional(),
+  questions: z3.array(z3.object({
+    question: z3.string().min(1),
+    questionTypeId: z3.number().int().min(1).optional(),
+    points: z3.number().int().min(0).optional(),
+    settings: z3.record(z3.string(), z3.unknown()).optional(),
+    options: z3.array(z3.object({
+      label: z3.string().min(1),
+      isCorrect: z3.boolean(),
+      settings: z3.record(z3.string(), z3.unknown()).optional()
+    })).min(2)
+  })).optional()
+});
+var ZExerciseUpdate = z3.object({
+  title: z3.string().min(1).optional(),
+  description: z3.string().optional(),
+  lessonId: z3.string().optional(),
+  sectionId: z3.string().optional(),
+  order: z3.number().int().optional(),
+  isUnlocked: z3.boolean().optional(),
+  dueBy: z3.string().optional(),
+  // Changed from iso.datetime() to string to match frontend format
+  questions: z3.array(ZExerciseUpdateQuestion).optional()
+});
+var ZExerciseGetParam = z3.object({
+  exerciseId: z3.string().min(1)
+});
+var ZExerciseListQuery = z3.object({
+  lessonId: z3.string().optional(),
+  sectionId: z3.string().optional()
+});
+var ZExerciseSubmissionCreate = z3.object({
+  exerciseId: z3.string().min(1),
+  answers: z3.array(z3.object({
+    questionId: z3.number().int(),
+    optionId: z3.number().int().optional(),
+    answer: z3.string().optional()
+  })).min(1)
+});
+var ZExerciseFromTemplate = z3.object({
+  lessonId: z3.string().optional(),
+  sectionId: z3.string().optional(),
+  order: z3.number().int().optional(),
+  templateId: z3.number().int().min(1)
+});
+
+// ../utils/dist/validation/course-import/course-import.js
+import * as z5 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 z4 from "zod";
+var ZCourseClone = z4.object({
+  title: z4.string().min(1),
+  description: z4.string().optional(),
+  slug: z4.string().min(1),
+  organizationId: z4.string().min(1)
+});
+var ZCourseCloneParam = z4.object({
+  courseId: z4.string().min(1)
+});
+var ZCourseGetParam = z4.object({
+  courseId: z4.string().min(1)
+});
+var ZCourseGetQuery = z4.object({
+  slug: z4.string().optional()
+});
+var ZCourseGetBySlugParam = z4.object({
+  slug: z4.string().min(1)
+});
+var ZCourseEnrollParam = z4.object({
+  courseId: z4.string().min(1)
+});
+var ZCourseEnrollBody = z4.object({
+  inviteToken: z4.string().min(1).optional()
+});
+var ZCourseDownloadParam = z4.object({
+  courseId: z4.string().min(1)
+});
+var ZCertificateDownload = z4.object({
+  theme: z4.string().min(1),
+  studentName: z4.string().min(1),
+  courseName: z4.string().min(1),
+  courseDescription: z4.string().min(1),
+  orgName: z4.string().min(1),
+  orgLogoUrl: z4.string().url().optional(),
+  facilitator: z4.string().optional()
+});
+var ZCourseDownloadContent = z4.object({
+  courseTitle: z4.string().min(1),
+  orgName: z4.string().min(1),
+  orgTheme: z4.string().min(1),
+  lessons: z4.array(z4.object({
+    lessonTitle: z4.string().min(1),
+    lessonNumber: z4.string().min(1),
+    lessonNote: z4.string(),
+    slideUrl: z4.string().url().optional(),
+    video: z4.array(z4.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 = z4.object({
+  title: z4.string().min(1),
+  number: z4.string().min(1),
+  orgName: z4.string().min(1),
+  note: z4.string(),
+  slideUrl: z4.string().url().optional(),
+  video: z4.array(z4.string().url()).optional(),
+  courseTitle: z4.string().min(1)
+});
+var ZCoursePresignUrlUpload = z4.object({
+  fileName: z4.string().min(1),
+  fileType: z4.enum(ALLOWED_CONTENT_TYPES)
+});
+var ZCourseDocumentPresignUrlUpload = z4.object({
+  fileName: z4.string().min(1),
+  fileType: z4.enum(ALLOWED_DOCUMENT_TYPES)
+});
+var ZCourseDownloadPresignedUrl = z4.object({
+  keys: z4.array(z4.string().min(1)).min(1)
+});
+var ZCourseContentUpdateItem = z4.object({
+  id: z4.string().min(1),
+  type: z4.enum(["LESSON", "EXERCISE"]),
+  isUnlocked: z4.boolean().optional(),
+  order: z4.number().int().min(0).optional(),
+  sectionId: z4.string().nullable().optional()
+});
+var ZCourseContentUpdate = z4.object({
+  items: z4.array(ZCourseContentUpdateItem).min(1)
+});
+var ZCourseContentDeleteItem = z4.object({
+  id: z4.string().min(1),
+  type: z4.enum(["LESSON", "EXERCISE"])
+});
+var ZCourseContentDelete = z4.object({
+  sectionId: z4.string().min(1).optional(),
+  items: z4.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 = z4.object({
+  title: z4.string().min(1),
+  description: z4.string().min(1),
+  type: z4.enum(["LIVE_CLASS", "SELF_PACED"]),
+  organizationId: z4.string().min(1)
+});
+var ZCourseMetadata = z4.object({
+  requirements: z4.string().optional(),
+  description: z4.string().optional(),
+  goals: z4.string().optional(),
+  videoUrl: z4.string().optional(),
+  showDiscount: z4.boolean().optional(),
+  discount: z4.number().optional(),
+  paymentLink: z4.string().optional(),
+  reward: z4.object({
+    show: z4.boolean(),
+    description: z4.string()
   }).optional(),
-  instructor: z2.object({
-    name: z2.string(),
-    role: z2.string(),
-    coursesNo: z2.number(),
-    description: z2.string(),
-    imgUrl: z2.string()
+  instructor: z4.object({
+    name: z4.string(),
+    role: z4.string(),
+    coursesNo: z4.number(),
+    description: z4.string(),
+    imgUrl: z4.string()
   }).optional(),
-  certificate: z2.object({
-    templateUrl: z2.string()
+  certificate: z4.object({
+    templateUrl: z4.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: z4.array(z4.object({
+    id: z4.number(),
+    hide: z4.boolean(),
+    name: z4.string(),
+    avatar_url: z4.string(),
+    rating: z4.number(),
+    created_at: z4.number(),
+    description: z4.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: z4.array(z4.object({
+    id: z4.union([z4.literal(1), z4.literal(2), z4.literal(3), z4.literal(4)]),
+    name: z4.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: z4.boolean().optional(),
+  lessonDownload: z4.boolean().optional(),
+  allowNewStudent: z4.boolean(),
+  sectionDisplay: z4.record(z4.string(), z4.boolean()).optional(),
+  isContentGroupingEnabled: z4.boolean().optional()
+});
+var ZCourseUpdate = z4.object({
+  title: z4.string().min(1).optional(),
+  description: z4.string().min(1).optional(),
+  type: z4.enum(["LIVE_CLASS", "SELF_PACED"]).optional(),
+  logo: z4.string().optional(),
+  slug: z4.string().optional(),
+  isPublished: z4.boolean().optional(),
+  overview: z4.string().optional(),
   metadata: ZCourseMetadata.optional(),
-  isCertificateDownloadable: z2.boolean().optional(),
-  certificateTheme: z2.string().optional(),
-  tagIds: z2.array(z2.uuid()).max(100).optional()
+  isCertificateDownloadable: z4.boolean().optional(),
+  certificateTheme: z4.string().optional(),
+  tagIds: z4.array(z4.uuid()).max(100).optional()
 });
-var ZCourseUpdateParam = z2.object({
-  courseId: z2.string().min(1)
+var ZCourseUpdateParam = z4.object({
+  courseId: z4.string().min(1)
 });
-var ZCourseDeleteParam = z2.object({
-  courseId: z2.string().min(1)
+var ZCourseDeleteParam = z4.object({
+  courseId: z4.string().min(1)
 });
-var ZCourseProgressParam = z2.object({
-  courseId: z2.string().min(1)
+var ZCourseProgressParam = z4.object({
+  courseId: z4.string().min(1)
 });
-var ZCourseProgressQuery = z2.object({
-  profileId: z2.string().uuid()
+var ZCourseProgressQuery = z4.object({
+  profileId: z4.string().uuid()
 });
-var ZCourseUserAnalyticsParam = z2.object({
-  courseId: z2.string().min(1),
-  userId: z2.string().uuid()
+var ZCourseUserAnalyticsParam = z4.object({
+  courseId: z4.string().min(1),
+  userId: z4.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 = z5.enum(["en", "hi", "fr", "pt", "de", "vi", "ru", "es", "pl", "da"]);
+var ZCourseImportWarning = z5.object({
+  code: z5.string().min(1),
+  message: z5.string().min(1),
+  severity: z5.enum(["info", "warning", "error"])
+});
+var ZCourseImportSourceReference = z5.object({
+  type: z5.enum(["prompt", "pdf", "course"]),
+  label: z5.string().min(1),
+  pageStart: z5.number().int().min(1).optional(),
+  pageEnd: z5.number().int().min(1).optional()
+});
+var ZCourseImportDraftCourse = z5.object({
+  title: z5.string().min(1),
+  description: z5.string().min(1),
+  type: z5.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 ZCourseImportDraftSection = z5.object({
+  externalId: z5.string().min(1),
+  title: z5.string().min(1),
+  order: z5.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 ZCourseImportDraftLesson = z5.object({
+  externalId: z5.string().min(1),
+  sectionExternalId: z5.string().min(1),
+  title: z5.string().min(1),
+  order: z5.number().int().min(0),
+  isUnlocked: z5.boolean().optional(),
+  public: z5.boolean().optional()
 });
-var ZCourseImportDraftLessonLanguage = z3.object({
-  lessonExternalId: z3.string().min(1),
+var ZCourseImportDraftLessonLanguage = z5.object({
+  lessonExternalId: z5.string().min(1),
   locale: ZSupportedLocale,
-  content: z3.string().min(1)
+  content: z5.string().min(1)
 });
-var ZCourseImportDraftPayload = z3.object({
+var ZCourseImportDraftPayload = z5.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: z5.array(z5.string().trim().min(1).max(80)).max(100).default([]),
+  sections: z5.array(ZCourseImportDraftSection).min(1),
+  lessons: z5.array(ZCourseImportDraftLesson).min(1),
+  lessonLanguages: z5.array(ZCourseImportDraftLessonLanguage).min(1),
+  exercises: z5.array(z5.record(z5.string(), z5.unknown())).optional(),
+  sourceReferences: z5.array(ZCourseImportSourceReference).optional(),
+  warnings: z5.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: z5.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: z5.ZodIssueCode.custom,
         path: ["sections", index, "externalId"],
         message: "Section externalId must be unique"
       });
@@ -674,7 +942,7 @@ var ZCourseImportDraftPayload = z3.object({
   value.lessons.forEach((lesson, index) => {
     if (lessonIds.has(lesson.externalId)) {
       ctx.addIssue({
-        code: z3.ZodIssueCode.custom,
+        code: z5.ZodIssueCode.custom,
         path: ["lessons", index, "externalId"],
         message: "Lesson externalId must be unique"
       });
@@ -682,7 +950,7 @@ var ZCourseImportDraftPayload = z3.object({
     lessonIds.add(lesson.externalId);
     if (!sectionIds.has(lesson.sectionExternalId)) {
       ctx.addIssue({
-        code: z3.ZodIssueCode.custom,
+        code: z5.ZodIssueCode.custom,
         path: ["lessons", index, "sectionExternalId"],
         message: "Lesson sectionExternalId must reference an existing section"
       });
@@ -691,52 +959,76 @@ var ZCourseImportDraftPayload = z3.object({
   value.lessonLanguages.forEach((lessonLanguage, index) => {
     if (!lessonIds.has(lessonLanguage.lessonExternalId)) {
       ctx.addIssue({
-        code: z3.ZodIssueCode.custom,
+        code: z5.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 = z5.object({
+  sourceType: z5.enum(["prompt", "pdf", "course"]),
+  idempotencyKey: z5.string().min(1).optional(),
+  summary: z5.record(z5.string(), z5.unknown()).optional(),
+  sourceArtifacts: z5.array(z5.record(z5.string(), z5.unknown())).optional(),
   draft: ZCourseImportDraftPayload
 });
-var ZCourseImportCourseParam = z3.object({
-  courseId: z3.string().min(1)
+var ZCourseImportCourseParam = z5.object({
+  courseId: z5.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 = z5.object({
+  courseId: z5.string().min(1),
+  idempotencyKey: z5.string().min(1).optional(),
+  summary: z5.record(z5.string(), z5.unknown()).optional(),
+  sourceArtifacts: z5.array(z5.record(z5.string(), z5.unknown())).optional()
 });
-var ZCourseImportDraftGetParam = z3.object({
-  draftId: z3.string().uuid()
+var ZCourseImportDraftGetParam = z5.object({
+  draftId: z5.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 = z5.object({
+  summary: z5.record(z5.string(), z5.unknown()).optional(),
+  sourceArtifacts: z5.array(z5.record(z5.string(), z5.unknown())).optional(),
+  warnings: z5.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 = z5.object({
+  title: z5.string().min(1).optional(),
+  description: z5.string().min(1).optional(),
+  type: z5.enum(["LIVE_CLASS", "SELF_PACED"]).optional(),
+  metadata: ZCourseMetadata.optional(),
+  bannerImageUrl: z5.string().url().optional(),
+  bannerImageQuery: z5.string().min(1).max(120).optional(),
+  generateBannerImage: z5.boolean().optional()
 });
 var ZCourseImportDraftPublishToCourse = ZCourseImportDraftPublish.extend({
-  courseId: z3.string().min(1)
+  courseId: z5.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
 });
@@ -748,44 +1040,156 @@ var createCourseDraftFromCourseShape = ZCourseImportDraftCreateFromCourse.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(
+    "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 {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@classroomio/mcp",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "private": false,
   "type": "module",
   "main": "./dist/index.js",