gogcli-mcp 2.0.4 → 2.0.7

package/src/tools/classroom.ts

@@ -37,88 +37,6 @@ export function registerClassroomTools(server: McpServer): void {
     return runOrDiagnose(['classroom', 'courses', 'get', courseId], { account });
   });
 
-  server.registerTool('gog_classroom_courses_create', {
-    description: 'Create a new Google Classroom course.',
-    inputSchema: {
-      name: z.string().describe('Course name'),
-      owner: z.string().optional().describe('Owner user ID (default: "me")'),
-      section: z.string().optional().describe('Section'),
-      descriptionHeading: z.string().optional().describe('Description heading'),
-      description: z.string().optional().describe('Description'),
-      room: z.string().optional().describe('Room'),
-      state: z.string().optional().describe('Course state: ACTIVE, ARCHIVED, PROVISIONED, DECLINED, SUSPENDED'),
-      account: accountParam,
-    },
-  }, async ({ name, owner, section, descriptionHeading, description, room, state, account }) => {
-    const args = ['classroom', 'courses', 'create', `--name=${name}`];
-    if (owner) args.push(`--owner=${owner}`);
-    if (section) args.push(`--section=${section}`);
-    if (descriptionHeading) args.push(`--description-heading=${descriptionHeading}`);
-    if (description) args.push(`--description=${description}`);
-    if (room) args.push(`--room=${room}`);
-    if (state) args.push(`--state=${state}`);
-    return runOrDiagnose(args, { account });
-  });
-
-  server.registerTool('gog_classroom_courses_update', {
-    description: 'Update an existing Google Classroom course.',
-    annotations: { destructiveHint: true },
-    inputSchema: {
-      courseId: z.string().describe('Course ID'),
-      name: z.string().optional().describe('Course name'),
-      owner: z.string().optional().describe('Owner user ID'),
-      section: z.string().optional().describe('Section'),
-      descriptionHeading: z.string().optional().describe('Description heading'),
-      description: z.string().optional().describe('Description'),
-      room: z.string().optional().describe('Room'),
-      state: z.string().optional().describe('Course state: ACTIVE, ARCHIVED, PROVISIONED, DECLINED, SUSPENDED'),
-      account: accountParam,
-    },
-  }, async ({ courseId, name, owner, section, descriptionHeading, description, room, state, account }) => {
-    const args = ['classroom', 'courses', 'update', courseId];
-    if (name) args.push(`--name=${name}`);
-    if (owner) args.push(`--owner=${owner}`);
-    if (section) args.push(`--section=${section}`);
-    if (descriptionHeading) args.push(`--description-heading=${descriptionHeading}`);
-    if (description) args.push(`--description=${description}`);
-    if (room) args.push(`--room=${room}`);
-    if (state) args.push(`--state=${state}`);
-    return runOrDiagnose(args, { account });
-  });
-
-  server.registerTool('gog_classroom_courses_delete', {
-    description: 'Delete a Google Classroom course.',
-    annotations: { destructiveHint: true },
-    inputSchema: {
-      courseId: z.string().describe('Course ID'),
-      account: accountParam,
-    },
-  }, async ({ courseId, account }) => {
-    return runOrDiagnose(['classroom', 'courses', 'delete', courseId], { account });
-  });
-
-  server.registerTool('gog_classroom_courses_archive', {
-    description: 'Archive a Google Classroom course.',
-    annotations: { destructiveHint: true },
-    inputSchema: {
-      courseId: z.string().describe('Course ID'),
-      account: accountParam,
-    },
-  }, async ({ courseId, account }) => {
-    return runOrDiagnose(['classroom', 'courses', 'archive', courseId], { account });
-  });
-
-  server.registerTool('gog_classroom_courses_unarchive', {
-    description: 'Unarchive a Google Classroom course (restore to ACTIVE).',
-    annotations: { destructiveHint: true },
-    inputSchema: {
-      courseId: z.string().describe('Course ID'),
-      account: accountParam,
-    },
-  }, async ({ courseId, account }) => {
-    return runOrDiagnose(['classroom', 'courses', 'unarchive', courseId], { account });
-  });
-
   server.registerTool('gog_classroom_students_list', {
     description: 'List students enrolled in a Google Classroom course.',
     annotations: { readOnlyHint: true },
@@ -149,32 +67,6 @@ export function registerClassroomTools(server: McpServer): void {
     return runOrDiagnose(['classroom', 'students', 'get', courseId, userId], { account });
   });
 
-  server.registerTool('gog_classroom_students_add', {
-    description: 'Add a student to a Google Classroom course.',
-    inputSchema: {
-      courseId: z.string().describe('Course ID'),
-      userId: z.string().describe('Student user ID (or "me")'),
-      enrollmentCode: z.string().optional().describe('Enrollment code (required if adding self via code)'),
-      account: accountParam,
-    },
-  }, async ({ courseId, userId, enrollmentCode, account }) => {
-    const args = ['classroom', 'students', 'add', courseId, userId];
-    if (enrollmentCode) args.push(`--enrollment-code=${enrollmentCode}`);
-    return runOrDiagnose(args, { account });
-  });
-
-  server.registerTool('gog_classroom_students_remove', {
-    description: 'Remove a student from a Google Classroom course.',
-    annotations: { destructiveHint: true },
-    inputSchema: {
-      courseId: z.string().describe('Course ID'),
-      userId: z.string().describe('Student user ID'),
-      account: accountParam,
-    },
-  }, async ({ courseId, userId, account }) => {
-    return runOrDiagnose(['classroom', 'students', 'remove', courseId, userId], { account });
-  });
-
   server.registerTool('gog_classroom_teachers_list', {
     description: 'List teachers in a Google Classroom course.',
     annotations: { readOnlyHint: true },
@@ -205,29 +97,6 @@ export function registerClassroomTools(server: McpServer): void {
     return runOrDiagnose(['classroom', 'teachers', 'get', courseId, userId], { account });
   });
 
-  server.registerTool('gog_classroom_teachers_add', {
-    description: 'Add a teacher to a Google Classroom course.',
-    inputSchema: {
-      courseId: z.string().describe('Course ID'),
-      userId: z.string().describe('Teacher user ID'),
-      account: accountParam,
-    },
-  }, async ({ courseId, userId, account }) => {
-    return runOrDiagnose(['classroom', 'teachers', 'add', courseId, userId], { account });
-  });
-
-  server.registerTool('gog_classroom_teachers_remove', {
-    description: 'Remove a teacher from a Google Classroom course.',
-    annotations: { destructiveHint: true },
-    inputSchema: {
-      courseId: z.string().describe('Course ID'),
-      userId: z.string().describe('Teacher user ID'),
-      account: accountParam,
-    },
-  }, async ({ courseId, userId, account }) => {
-    return runOrDiagnose(['classroom', 'teachers', 'remove', courseId, userId], { account });
-  });
-
   server.registerTool('gog_classroom_roster', {
     description: 'List the full roster (students and/or teachers) of a Google Classroom course. Omit both flags to return both groups.',
     annotations: { readOnlyHint: true },
@@ -288,81 +157,6 @@ export function registerClassroomTools(server: McpServer): void {
     return runOrDiagnose(['classroom', 'coursework', 'get', courseId, courseworkId], { account });
   });
 
-  server.registerTool('gog_classroom_coursework_create', {
-    description: 'Create a new coursework item (assignment, question, etc.) in a course.',
-    inputSchema: {
-      courseId: z.string().describe('Course ID'),
-      title: z.string().describe('Coursework title'),
-      description: z.string().optional().describe('Description'),
-      type: z.string().optional().describe('Work type (ASSIGNMENT, SHORT_ANSWER_QUESTION, MULTIPLE_CHOICE_QUESTION). Default: ASSIGNMENT'),
-      state: z.string().optional().describe('State: PUBLISHED or DRAFT'),
-      maxPoints: z.number().optional().describe('Max points'),
-      due: z.string().optional().describe('Due datetime (combined date+time)'),
-      dueDate: z.string().optional().describe('Due date (YYYY-MM-DD)'),
-      dueTime: z.string().optional().describe('Due time (HH:MM)'),
-      scheduled: z.string().optional().describe('Scheduled publish time'),
-      topic: z.string().optional().describe('Topic ID'),
-      account: accountParam,
-    },
-  }, async ({ courseId, title, description, type, state, maxPoints, due, dueDate, dueTime, scheduled, topic, account }) => {
-    const args = ['classroom', 'coursework', 'create', courseId, `--title=${title}`];
-    if (description) args.push(`--description=${description}`);
-    if (type) args.push(`--type=${type}`);
-    if (state) args.push(`--state=${state}`);
-    if (maxPoints !== undefined) args.push(`--max-points=${maxPoints}`);
-    if (due) args.push(`--due=${due}`);
-    if (dueDate) args.push(`--due-date=${dueDate}`);
-    if (dueTime) args.push(`--due-time=${dueTime}`);
-    if (scheduled) args.push(`--scheduled=${scheduled}`);
-    if (topic) args.push(`--topic=${topic}`);
-    return runOrDiagnose(args, { account });
-  });
-
-  server.registerTool('gog_classroom_coursework_update', {
-    description: 'Update an existing coursework item.',
-    annotations: { destructiveHint: true },
-    inputSchema: {
-      courseId: z.string().describe('Course ID'),
-      courseworkId: z.string().describe('Coursework ID'),
-      title: z.string().optional().describe('New title'),
-      description: z.string().optional().describe('New description'),
-      type: z.string().optional().describe('Work type'),
-      state: z.string().optional().describe('State: PUBLISHED or DRAFT'),
-      maxPoints: z.number().optional().describe('Max points'),
-      due: z.string().optional().describe('Due datetime'),
-      dueDate: z.string().optional().describe('Due date (YYYY-MM-DD)'),
-      dueTime: z.string().optional().describe('Due time (HH:MM)'),
-      scheduled: z.string().optional().describe('Scheduled publish time'),
-      topic: z.string().optional().describe('Topic ID'),
-      account: accountParam,
-    },
-  }, async ({ courseId, courseworkId, title, description, type, state, maxPoints, due, dueDate, dueTime, scheduled, topic, account }) => {
-    const args = ['classroom', 'coursework', 'update', courseId, courseworkId];
-    if (title) args.push(`--title=${title}`);
-    if (description) args.push(`--description=${description}`);
-    if (type) args.push(`--type=${type}`);
-    if (state) args.push(`--state=${state}`);
-    if (maxPoints !== undefined) args.push(`--max-points=${maxPoints}`);
-    if (due) args.push(`--due=${due}`);
-    if (dueDate) args.push(`--due-date=${dueDate}`);
-    if (dueTime) args.push(`--due-time=${dueTime}`);
-    if (scheduled) args.push(`--scheduled=${scheduled}`);
-    if (topic) args.push(`--topic=${topic}`);
-    return runOrDiagnose(args, { account });
-  });
-
-  server.registerTool('gog_classroom_coursework_delete', {
-    description: 'Delete a coursework item.',
-    annotations: { destructiveHint: true },
-    inputSchema: {
-      courseId: z.string().describe('Course ID'),
-      courseworkId: z.string().describe('Coursework ID'),
-      account: accountParam,
-    },
-  }, async ({ courseId, courseworkId, account }) => {
-    return runOrDiagnose(['classroom', 'coursework', 'delete', courseId, courseworkId], { account });
-  });
-
   server.registerTool('gog_classroom_submissions_list', {
     description: 'List student submissions for a coursework item.',
     annotations: { readOnlyHint: true },
@@ -497,7 +291,7 @@ export function registerClassroomTools(server: McpServer): void {
     inputSchema: {
       courseId: z.string().describe('Course ID'),
       text: z.string().describe('Announcement text'),
-      state: z.string().optional().describe('State: PUBLISHED or DRAFT'),
+      state: z.enum(['PUBLISHED', 'DRAFT']).optional().describe('State'),
       scheduled: z.string().optional().describe('Scheduled publish time'),
       account: accountParam,
     },
@@ -508,37 +302,6 @@ export function registerClassroomTools(server: McpServer): void {
     return runOrDiagnose(args, { account });
   });
 
-  server.registerTool('gog_classroom_announcements_update', {
-    description: 'Update an existing announcement.',
-    annotations: { destructiveHint: true },
-    inputSchema: {
-      courseId: z.string().describe('Course ID'),
-      announcementId: z.string().describe('Announcement ID'),
-      text: z.string().optional().describe('New text'),
-      state: z.string().optional().describe('State: PUBLISHED or DRAFT'),
-      scheduled: z.string().optional().describe('Scheduled publish time'),
-      account: accountParam,
-    },
-  }, async ({ courseId, announcementId, text, state, scheduled, account }) => {
-    const args = ['classroom', 'announcements', 'update', courseId, announcementId];
-    if (text) args.push(`--text=${text}`);
-    if (state) args.push(`--state=${state}`);
-    if (scheduled) args.push(`--scheduled=${scheduled}`);
-    return runOrDiagnose(args, { account });
-  });
-
-  server.registerTool('gog_classroom_announcements_delete', {
-    description: 'Delete an announcement.',
-    annotations: { destructiveHint: true },
-    inputSchema: {
-      courseId: z.string().describe('Course ID'),
-      announcementId: z.string().describe('Announcement ID'),
-      account: accountParam,
-    },
-  }, async ({ courseId, announcementId, account }) => {
-    return runOrDiagnose(['classroom', 'announcements', 'delete', courseId, announcementId], { account });
-  });
-
   server.registerTool('gog_classroom_topics_list', {
     description: 'List topics in a Google Classroom course.',
     annotations: { readOnlyHint: true },
@@ -569,42 +332,6 @@ export function registerClassroomTools(server: McpServer): void {
     return runOrDiagnose(['classroom', 'topics', 'get', courseId, topicId], { account });
   });
 
-  server.registerTool('gog_classroom_topics_create', {
-    description: 'Create a topic in a Google Classroom course.',
-    inputSchema: {
-      courseId: z.string().describe('Course ID'),
-      name: z.string().describe('Topic name'),
-      account: accountParam,
-    },
-  }, async ({ courseId, name, account }) => {
-    return runOrDiagnose(['classroom', 'topics', 'create', courseId, `--name=${name}`], { account });
-  });
-
-  server.registerTool('gog_classroom_topics_update', {
-    description: 'Rename an existing topic.',
-    annotations: { destructiveHint: true },
-    inputSchema: {
-      courseId: z.string().describe('Course ID'),
-      topicId: z.string().describe('Topic ID'),
-      name: z.string().describe('New topic name'),
-      account: accountParam,
-    },
-  }, async ({ courseId, topicId, name, account }) => {
-    return runOrDiagnose(['classroom', 'topics', 'update', courseId, topicId, `--name=${name}`], { account });
-  });
-
-  server.registerTool('gog_classroom_topics_delete', {
-    description: 'Delete a topic.',
-    annotations: { destructiveHint: true },
-    inputSchema: {
-      courseId: z.string().describe('Course ID'),
-      topicId: z.string().describe('Topic ID'),
-      account: accountParam,
-    },
-  }, async ({ courseId, topicId, account }) => {
-    return runOrDiagnose(['classroom', 'topics', 'delete', courseId, topicId], { account });
-  });
-
   server.registerTool('gog_classroom_invitations_list', {
     description: 'List Google Classroom invitations.',
     annotations: { readOnlyHint: true },
@@ -637,18 +364,6 @@ export function registerClassroomTools(server: McpServer): void {
     return runOrDiagnose(['classroom', 'invitations', 'get', invitationId], { account });
   });
 
-  server.registerTool('gog_classroom_invitations_create', {
-    description: 'Create an invitation to a Google Classroom course.',
-    inputSchema: {
-      courseId: z.string().describe('Course ID'),
-      userId: z.string().describe('User ID to invite'),
-      role: z.enum(['STUDENT', 'TEACHER', 'OWNER']).describe('Role for the invited user'),
-      account: accountParam,
-    },
-  }, async ({ courseId, userId, role, account }) => {
-    return runOrDiagnose(['classroom', 'invitations', 'create', courseId, userId, `--role=${role}`], { account });
-  });
-
   server.registerTool('gog_classroom_invitations_accept', {
     description: 'Accept a Google Classroom invitation.',
     inputSchema: {
@@ -659,17 +374,6 @@ export function registerClassroomTools(server: McpServer): void {
     return runOrDiagnose(['classroom', 'invitations', 'accept', invitationId], { account });
   });
 
-  server.registerTool('gog_classroom_invitations_delete', {
-    description: 'Delete (revoke) a Google Classroom invitation.',
-    annotations: { destructiveHint: true },
-    inputSchema: {
-      invitationId: z.string().describe('Invitation ID'),
-      account: accountParam,
-    },
-  }, async ({ invitationId, account }) => {
-    return runOrDiagnose(['classroom', 'invitations', 'delete', invitationId], { account });
-  });
-
   server.registerTool('gog_classroom_profile_get', {
     description: 'Get a Google Classroom user profile. Omit userId to fetch the authenticated user.',
     annotations: { readOnlyHint: true },
@@ -685,6 +389,7 @@ export function registerClassroomTools(server: McpServer): void {
 
   server.registerTool('gog_classroom_run', {
     description: 'Run any gog classroom subcommand not covered by the other tools (guardians, guardian-invitations, materials, coursework assignees, announcement assignees, etc.). Run `gog classroom --help` for the full list, or `gog classroom <subcommand> --help` for flags.',
+    annotations: { destructiveHint: true },
     inputSchema: {
       subcommand: z.string().describe('The gog classroom subcommand to run, e.g. "guardians", "materials", "guardian-invitations"'),
       args: z.array(z.string()).describe('Additional positional args and flags'),

package/src/tools/contacts.ts

@@ -4,7 +4,7 @@ import { accountParam, runOrDiagnose } from './utils.js';
 
 export function registerContactsTools(server: McpServer): void {
   server.registerTool('gog_contacts_search', {
-    description: 'Search Google Contacts by name, email, or phone.',
+    description: 'Search personal Google Contacts by name, email, or phone. For searching the Workspace directory (internal users not in your personal contacts), use gog_people_search from gogcli-mcp-contacts.',
     annotations: { readOnlyHint: true },
     inputSchema: {
       query: z.string().describe('Search query (name, email, or phone)'),
@@ -68,78 +68,4 @@ export function registerContactsTools(server: McpServer): void {
   }, async ({ subcommand, args, account }) => {
     return runOrDiagnose(['contacts', subcommand, ...args], { account });
   });
-
-  // ─── People API tools ──────────────────────────────────────────
-  // Folded into the contacts wrapper because People is the richer API behind
-  // Google Contacts (Workspace directory search, profile fields, relations).
-
-  server.registerTool('gog_people_me', {
-    description: 'Show your own People profile (people/me).',
-    annotations: { readOnlyHint: true },
-    inputSchema: {
-      account: accountParam,
-    },
-  }, async ({ account }) => {
-    return runOrDiagnose(['people', 'me'], { account });
-  });
-
-  server.registerTool('gog_people_get', {
-    description: 'Get a People profile by resource name.',
-    annotations: { readOnlyHint: true },
-    inputSchema: {
-      userId: z.string().describe('Person resource name (people/...) or email'),
-      account: accountParam,
-    },
-  }, async ({ userId, account }) => {
-    return runOrDiagnose(['people', 'get', userId], { account });
-  });
-
-  server.registerTool('gog_people_search', {
-    description: 'Search the Google Workspace directory (covers internal users, unlike contacts search which is limited to your personal contacts).',
-    annotations: { readOnlyHint: true },
-    inputSchema: {
-      query: z.string().describe('Search query (name, email, etc.)'),
-      max: z.number().optional().describe('Max results (default: 50)'),
-      page: z.string().optional().describe('Page token'),
-      all: z.boolean().optional().describe('Fetch all pages'),
-      account: accountParam,
-    },
-  }, async ({ query, max, page, all, account }) => {
-    const args = ['people', 'search', query];
-    if (max !== undefined) args.push(`--max=${max}`);
-    if (page) args.push(`--page=${page}`);
-    if (all) args.push('--all');
-    return runOrDiagnose(args, { account });
-  });
-
-  server.registerTool('gog_people_relations', {
-    description: 'Get relations (manager, reports, etc.) for a user. Defaults to self when userId is omitted.',
-    annotations: { readOnlyHint: true },
-    inputSchema: {
-      userId: z.string().optional().describe('Person resource name (defaults to self when omitted)'),
-      type: z.string().optional().describe('Filter to a specific relation type (e.g. "manager")'),
-      account: accountParam,
-    },
-  }, async ({ userId, type, account }) => {
-    const args = ['people', 'relations'];
-    if (userId) args.push(userId);
-    if (type) args.push(`--type=${type}`);
-    return runOrDiagnose(args, { account });
-  });
-
-  server.registerTool('gog_people_raw', {
-    description: 'Dump the raw People API response as JSON (lossless; for scripting and LLM consumption).',
-    annotations: { readOnlyHint: true },
-    inputSchema: {
-      userId: z.string().describe('Person resource name (people/...) or email'),
-      personFields: z.string().optional().describe('People API personFields mask (default: broad set)'),
-      pretty: z.boolean().optional().describe('Pretty-print JSON (default: compact single-line)'),
-      account: accountParam,
-    },
-  }, async ({ userId, personFields, pretty, account }) => {
-    const args = ['people', 'raw', userId];
-    if (personFields) args.push(`--person-fields=${personFields}`);
-    if (pretty) args.push('--pretty');
-    return runOrDiagnose(args, { account });
-  });
 }

package/src/tools/slides.ts

@@ -45,49 +45,6 @@ export function registerSlidesTools(server: McpServer): void {
     return runOrDiagnose(args, { account });
   });
 
-  server.registerTool('gog_slides_create_from_markdown', {
-    description: 'Create a new Google Slides presentation from markdown content (inline or from a file).',
-    inputSchema: {
-      title: z.string().describe('Presentation title'),
-      content: z.string().optional().describe('Inline markdown content'),
-      contentFile: z.string().optional().describe('Path to a markdown file'),
-      parent: z.string().optional().describe('Destination folder ID'),
-      debug: z.boolean().optional().describe('Enable debug output'),
-      account: accountParam,
-    },
-  }, async ({ title, content, contentFile, parent, debug, account }) => {
-    const args = ['slides', 'create-from-markdown', title];
-    if (content) args.push(`--content=${content}`);
-    if (contentFile) args.push(`--content-file=${contentFile}`);
-    if (parent) args.push(`--parent=${parent}`);
-    if (debug) args.push('--debug');
-    return runOrDiagnose(args, { account });
-  });
-
-  server.registerTool('gog_slides_create_from_template', {
-    description: 'Create a new Google Slides presentation from a template, with optional placeholder replacements.',
-    inputSchema: {
-      templateId: z.string().describe('Template presentation ID'),
-      title: z.string().describe('New presentation title'),
-      replacements: z.record(z.string(), z.string()).optional().describe('Placeholder replacements as a key/value object (emitted as --replace=k=v for each entry)'),
-      replacementsFile: z.string().optional().describe('Path to a JSON file containing replacements'),
-      parent: z.string().optional().describe('Destination folder ID'),
-      exact: z.boolean().optional().describe('Require exact placeholder matches'),
-      account: accountParam,
-    },
-  }, async ({ templateId, title, replacements, replacementsFile, parent, exact, account }) => {
-    const args = ['slides', 'create-from-template', templateId, title];
-    if (replacements) {
-      for (const [k, v] of Object.entries(replacements)) {
-        args.push(`--replace=${k}=${v}`);
-      }
-    }
-    if (replacementsFile) args.push(`--replacements=${replacementsFile}`);
-    if (parent) args.push(`--parent=${parent}`);
-    if (exact) args.push('--exact');
-    return runOrDiagnose(args, { account });
-  });
-
   server.registerTool('gog_slides_copy', {
     description: 'Copy a Google Slides presentation to a new presentation with the given title.',
     inputSchema: {
@@ -102,24 +59,6 @@ export function registerSlidesTools(server: McpServer): void {
     return runOrDiagnose(args, { account });
   });
 
-  server.registerTool('gog_slides_add_slide', {
-    description: 'Add a new slide to a presentation from a local image, with optional speaker notes.',
-    inputSchema: {
-      presentationId: z.string().describe('Presentation ID'),
-      image: z.string().describe('Path to the local image file'),
-      notes: z.string().optional().describe('Speaker notes text'),
-      notesFile: z.string().optional().describe('Path to a file containing speaker notes'),
-      before: z.string().optional().describe('Insert before this slide ID (default: append at end)'),
-      account: accountParam,
-    },
-  }, async ({ presentationId, image, notes, notesFile, before, account }) => {
-    const args = ['slides', 'add-slide', presentationId, image];
-    if (notes) args.push(`--notes=${notes}`);
-    if (notesFile) args.push(`--notes-file=${notesFile}`);
-    if (before) args.push(`--before=${before}`);
-    return runOrDiagnose(args, { account });
-  });
-
   server.registerTool('gog_slides_list_slides', {
     description: 'List slides in a Google Slides presentation.',
     annotations: { readOnlyHint: true },
@@ -131,18 +70,6 @@ export function registerSlidesTools(server: McpServer): void {
     return runOrDiagnose(['slides', 'list-slides', presentationId], { account });
   });
 
-  server.registerTool('gog_slides_delete_slide', {
-    description: 'Delete a slide from a Google Slides presentation.',
-    annotations: { destructiveHint: true },
-    inputSchema: {
-      presentationId: z.string().describe('Presentation ID'),
-      slideId: z.string().describe('Slide ID to delete'),
-      account: accountParam,
-    },
-  }, async ({ presentationId, slideId, account }) => {
-    return runOrDiagnose(['slides', 'delete-slide', presentationId, slideId], { account });
-  });
-
   server.registerTool('gog_slides_read_slide', {
     description: 'Read the content of a slide (text, shapes, speaker notes).',
     annotations: { readOnlyHint: true },
@@ -155,43 +82,9 @@ export function registerSlidesTools(server: McpServer): void {
     return runOrDiagnose(['slides', 'read-slide', presentationId, slideId], { account });
   });
 
-  server.registerTool('gog_slides_update_notes', {
-    description: 'Update the speaker notes on a slide (inline text or from a file).',
-    annotations: { destructiveHint: true },
-    inputSchema: {
-      presentationId: z.string().describe('Presentation ID'),
-      slideId: z.string().describe('Slide ID'),
-      notes: z.string().optional().describe('New speaker notes text'),
-      notesFile: z.string().optional().describe('Path to a file containing new speaker notes'),
-      account: accountParam,
-    },
-  }, async ({ presentationId, slideId, notes, notesFile, account }) => {
-    const args = ['slides', 'update-notes', presentationId, slideId];
-    if (notes) args.push(`--notes=${notes}`);
-    if (notesFile) args.push(`--notes-file=${notesFile}`);
-    return runOrDiagnose(args, { account });
-  });
-
-  server.registerTool('gog_slides_replace_slide', {
-    description: 'Replace the image content of an existing slide, with optional speaker notes.',
-    annotations: { destructiveHint: true },
-    inputSchema: {
-      presentationId: z.string().describe('Presentation ID'),
-      slideId: z.string().describe('Slide ID to replace'),
-      image: z.string().describe('Path to the new local image file'),
-      notes: z.string().optional().describe('Speaker notes text'),
-      notesFile: z.string().optional().describe('Path to a file containing speaker notes'),
-      account: accountParam,
-    },
-  }, async ({ presentationId, slideId, image, notes, notesFile, account }) => {
-    const args = ['slides', 'replace-slide', presentationId, slideId, image];
-    if (notes) args.push(`--notes=${notes}`);
-    if (notesFile) args.push(`--notes-file=${notesFile}`);
-    return runOrDiagnose(args, { account });
-  });
-
   server.registerTool('gog_slides_run', {
     description: 'Run any gog slides subcommand not covered by the other tools. Run `gog slides --help` for the full list of subcommands, or `gog slides <subcommand> --help` for flags on a specific subcommand.',
+    annotations: { destructiveHint: true },
     inputSchema: {
       subcommand: z.string().describe('The gog slides subcommand to run'),
       args: z.array(z.string()).describe('Additional positional args and flags'),

package/tests/helpers/extras-harness.ts

@@ -0,0 +1,31 @@
+// Shared test harness for `*-extra.ts` registrars across sub-packages.
+//
+// Each sub-package's extras test file follows the same shape: mock the
+// `runOrDiagnose` export from `gogcli-mcp/lib`, register the extras tools onto
+// a stub `McpServer`, capture each tool's handler into a Map, and exercise the
+// handlers with sample inputs. The `vi.mock(...)` call must stay in the
+// caller's test file (vitest hoists it at the module scope), but the
+// boilerplate around it can live here.
+import { vi } from 'vitest';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+
+export type ToolHandler = (
+  args: Record<string, unknown>,
+) => Promise<{ content: Array<{ type: string; text: string }> }>;
+
+export function toText(text: string): { content: Array<{ type: string; text: string }> } {
+  return { content: [{ type: 'text', text }] };
+}
+
+export function setupExtrasHandlers(
+  register: (server: McpServer) => void,
+): Map<string, ToolHandler> {
+  const server = new McpServer({ name: 'test', version: '0.0.0' });
+  const handlers = new Map<string, ToolHandler>();
+  vi.spyOn(server, 'registerTool').mockImplementation((name, _config, cb) => {
+    handlers.set(name, cb as ToolHandler);
+    return undefined as never;
+  });
+  register(server);
+  return handlers;
+}