gogcli-mcp 2.30.0 → 3.0.0

package/src/tools/calendar.ts

@@ -1,4 +1,4 @@
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { McpServer } from '@modelcontextprotocol/server';
 import { z } from 'zod';
 import { viewParam, resolveView } from '@chrischall/mcp-utils';
 import { accountParam, runOrDiagnose, registerRunTool, pageTokenParam, pageAliasParam, resolvePageToken } from './utils.js';
@@ -82,7 +82,7 @@ export function registerCalendarTools(server: McpServer): void {
       + 'gog returns only 10 events by default, so a wide date range is USUALLY INCOMPLETE: raise max, or page with pageToken until the response carries no nextPageToken. '
       + 'A response carrying "truncated": true is an incomplete view — never conclude an event does not exist from one.',
     annotations: { readOnlyHint: true },
-    inputSchema: {
+    inputSchema: z.object({
       calendarId: z.string().optional().describe('Calendar ID (default: primary calendar)'),
       from: z.string().optional().describe('Start time filter (RFC3339, date, or natural language)'),
       to: z.string().optional().describe('End time filter (RFC3339, date, or natural language). Mutually exclusive with today and with days.'),
@@ -105,7 +105,7 @@ export function registerCalendarTools(server: McpServer): void {
           + 'listing\'s bytes — plus etag/iCalUID/kind. Ask for full when you need a body or a guest list.',
       }),
       account: accountParam,
-    },
+    }),
   }, async ({ calendarId, from, to, days, today, query, max, pageToken, page, all, eventTypes, timezone, view, account }) => {
     const args = ['calendar', 'events'];
     if (calendarId) args.push(calendarId);
@@ -134,12 +134,12 @@ export function registerCalendarTools(server: McpServer): void {
   server.registerTool('gog_calendar_get', {
     description: 'Get a specific calendar event by ID.',
     annotations: { readOnlyHint: true },
-    inputSchema: {
+    inputSchema: z.object({
       calendarId: z.string().describe('Calendar ID'),
       eventId: z.string().describe('Event ID'),
       timezone: z.string().optional().describe('Display timezone for event times (IANA name, e.g. America/New_York, or "local" for the system timezone). Default: the event\'s timezone, then its calendar\'s timezone.'),
       account: accountParam,
-    },
+    }),
   }, async ({ calendarId, eventId, timezone, account }) => {
     const args = ['calendar', 'event', calendarId, eventId];
     if (timezone) args.push(`--timezone=${timezone}`);
@@ -149,7 +149,7 @@ export function registerCalendarTools(server: McpServer): void {
   server.registerTool('gog_calendar_create', {
     description: 'Create a calendar event. Set withZoom=true to attach a Zoom meeting (requires Zoom S2S OAuth setup via gog_zoom_auth_setup; the join URL + meeting ID + passcode are appended to the event description — Google rejects native conference card writes from non-Workspace-Marketplace OAuth clients).',
     annotations: { destructiveHint: false },
-    inputSchema: {
+    inputSchema: z.object({
       calendarId: z.string().describe('Calendar ID (use "primary" for the default calendar)'),
       summary: z.string().describe('Event title'),
       from: z.string().describe('Start time (RFC3339 or date for all-day events)'),
@@ -162,7 +162,7 @@ export function registerCalendarTools(server: McpServer): void {
       withZoom: z.boolean().optional().describe('Create a Zoom video conference for this event (requires Zoom S2S OAuth setup)'),
       ...reminderParams,
       account: accountParam,
-    },
+    }),
   }, async ({ calendarId, summary, from, to, description, location, attendees, allDay, timezone, withZoom, reminders, noReminders, account }) => {
     const args = ['calendar', 'create', calendarId, `--summary=${summary}`, `--from=${from}`, `--to=${to}`];
     if (description) args.push(`--description=${description}`);
@@ -178,7 +178,7 @@ export function registerCalendarTools(server: McpServer): void {
   server.registerTool('gog_calendar_update', {
     description: 'Update an existing calendar event. Zoom: withZoom adds a Zoom meeting, regenerateZoom replaces the existing one, removeZoom strips it. removeMeet clears the event\'s Google Meet conference data (e.g. before attaching another provider). Conference flags are independent — use one per call.',
     annotations: { destructiveHint: false },
-    inputSchema: {
+    inputSchema: z.object({
       calendarId: z.string().describe('Calendar ID'),
       eventId: z.string().describe('Event ID'),
       summary: z.string().optional().describe('New event title'),
@@ -195,7 +195,7 @@ export function registerCalendarTools(server: McpServer): void {
       removeMeet: z.boolean().optional().describe('Remove the event\'s Google Meet video conference (clears conference data only)'),
       ...reminderParams,
       account: accountParam,
-    },
+    }),
   }, async ({ calendarId, eventId, summary, from, to, description, location, attendees, addAttendees, attachments, withZoom, regenerateZoom, removeZoom, removeMeet, reminders, noReminders, account }) => {
     const args = ['calendar', 'update', calendarId, eventId];
     if (summary !== undefined) args.push(`--summary=${summary}`);
@@ -217,11 +217,11 @@ export function registerCalendarTools(server: McpServer): void {
   server.registerTool('gog_calendar_delete', {
     description: 'Delete a calendar event.',
     annotations: { destructiveHint: true },
-    inputSchema: {
+    inputSchema: z.object({
       calendarId: z.string().describe('Calendar ID'),
       eventId: z.string().describe('Event ID'),
       account: accountParam,
-    },
+    }),
   }, async ({ calendarId, eventId, account }) => {
     // gog gates this delete behind a confirmation; the runner injects
     // --no-input, so without --force it refuses at runtime.
@@ -231,13 +231,13 @@ export function registerCalendarTools(server: McpServer): void {
   server.registerTool('gog_calendar_respond', {
     description: 'Respond to a calendar event invitation.',
     annotations: { destructiveHint: true },
-    inputSchema: {
+    inputSchema: z.object({
       calendarId: z.string().describe('Calendar ID'),
       eventId: z.string().describe('Event ID'),
       status: z.enum(['accepted', 'declined', 'tentative']).describe('Response status'),
       comment: z.string().optional().describe('Optional comment to include with response'),
       account: accountParam,
-    },
+    }),
   }, async ({ calendarId, eventId, status, comment, account }) => {
     const args = ['calendar', 'respond', calendarId, eventId, `--status=${status}`];
     if (comment) args.push(`--comment=${comment}`);

package/src/tools/chat.ts

@@ -1,4 +1,4 @@
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { McpServer } from '@modelcontextprotocol/server';
 import { z } from 'zod';
 import {
   accountParam,
@@ -49,10 +49,10 @@ export function registerChatTools(server: McpServer): void {
       + 'Start here when you do not yet have a space name; gog_chat_spaces_find is faster when you know the room\'s title.'
       + workspaceOnlyNote,
     annotations: { readOnlyHint: true },
-    inputSchema: {
+    inputSchema: z.object({
       ...paginationParams,
       account: accountParam,
-    },
+    }),
   }, async ({ max, pageToken, page, all, account }) => {
     const args = ['chat', 'spaces', 'list'];
     pushPaginationFlags(args, { max, pageToken, page, all });
@@ -65,12 +65,12 @@ export function registerChatTools(server: McpServer): void {
       + 'user names a room approximately ("the launch room"); pass exact=true to require the whole title. DMs have no '
       + 'display name — use gog_chat_dm_space to reach a person.' + workspaceOnlyNote,
     annotations: { readOnlyHint: true },
-    inputSchema: {
+    inputSchema: z.object({
       displayName: z.string().describe('Space display name, or part of one'),
       exact: z.boolean().optional().describe('Require an exact (still case-insensitive) match on the whole display name'),
       max: z.number().int().optional().describe('Max results per page'),
       account: accountParam,
-    },
+    }),
   }, async ({ displayName, exact, max, account }) => {
     const args = ['chat', 'spaces', 'find', displayName];
     if (exact) args.push('--exact');
@@ -82,11 +82,11 @@ export function registerChatTools(server: McpServer): void {
     description:
       'Create a named Chat space, optionally seeding its membership. Members are added immediately and are notified — this '
       + 'is visible to other people the moment it runs, so confirm the member list before calling it.' + workspaceOnlyNote,
-    inputSchema: {
+    inputSchema: z.object({
       displayName: z.string().describe('Display name for the new space'),
       members: z.array(z.string()).optional().describe('Initial members, as email addresses or "users/..." resource names'),
       account: accountParam,
-    },
+    }),
   }, async ({ displayName, members, account }) => {
     const args = ['chat', 'spaces', 'create', displayName];
     if (members) for (const member of members) args.push(`--member=${member}`);
@@ -98,11 +98,11 @@ export function registerChatTools(server: McpServer): void {
       'List the threads in a space, so a reply can be targeted at an existing conversation rather than starting a new one. '
       + 'Pass a thread name from here as `thread` to gog_chat_messages_send.' + workspaceOnlyNote,
     annotations: { readOnlyHint: true },
-    inputSchema: {
+    inputSchema: z.object({
       space: spaceParam,
       ...paginationParams,
       account: accountParam,
-    },
+    }),
   }, async ({ space, max, pageToken, page, all, account }) => {
     const args = ['chat', 'threads', 'list', space];
     pushPaginationFlags(args, { max, pageToken, page, all });
@@ -117,7 +117,7 @@ export function registerChatTools(server: McpServer): void {
       + 'miss". Newest-first needs an explicit order="createTime desc"; Chat\'s own default is oldest-first.'
       + workspaceOnlyNote,
     annotations: { readOnlyHint: true },
-    inputSchema: {
+    inputSchema: z.object({
       space: spaceParam,
       thread: threadParam,
       unread: z.boolean().optional().describe('Only messages posted after the account last read this space'),
@@ -125,7 +125,7 @@ export function registerChatTools(server: McpServer): void {
         .optional().describe('Sort order (Chat default: "createTime asc", i.e. OLDEST first — ask for "createTime desc" when you want the latest messages)'),
       ...paginationParams,
       account: accountParam,
-    },
+    }),
   }, async ({ space, thread, unread, order, max, pageToken, page, all, account }) => {
     const args = ['chat', 'messages', 'list', space];
     if (thread) args.push(`--thread=${thread}`);
@@ -146,7 +146,7 @@ export function registerChatTools(server: McpServer): void {
       + 'which gog\'s chat scope set does NOT request (re-auth with extraScopes to get it). Missing metadata is OMITTED '
       + 'rather than defaulted, so an absent `read` means unknown while an explicit false means unread.' + workspaceOnlyNote,
     annotations: { readOnlyHint: true },
-    inputSchema: {
+    inputSchema: z.object({
       query: z.string().describe('Google Chat filter-syntax query — keywords, or filters such as "from:alice@example.com budget"'),
       order: z.enum(['create_time desc', 'relevance desc']).optional().describe(
         'Sort order. NOTE the snake_case, which differs from gog_chat_messages_list\'s camelCase. "relevance desc" needs '
@@ -160,7 +160,7 @@ export function registerChatTools(server: McpServer): void {
       ...paginationParams,
       max: z.number().int().min(1).max(100).optional().describe('Max results per page (1-100; Chat search caps a page at 100)'),
       account: accountParam,
-    },
+    }),
   }, async ({ query, order, view, markup, max, pageToken, page, all, account }) => {
     const args = ['chat', 'messages', 'search', query];
     if (order) args.push(`--order=${order}`);
@@ -176,7 +176,7 @@ export function registerChatTools(server: McpServer): void {
       + 'this tool, so treat it like sending mail, not like saving a draft. Pass `thread` to reply inside an existing '
       + 'conversation (from gog_chat_threads_list or a message\'s thread field); omit it to start a new one. Text supports '
       + 'Chat\'s markdown-ish formatting (*bold*, _italic_, `code`).' + workspaceOnlyNote,
-    inputSchema: {
+    inputSchema: z.object({
       space: spaceParam,
       text: z.string().optional().describe('Message text. Optional only when an attachment is supplied.'),
       thread: threadParam,
@@ -186,7 +186,7 @@ export function registerChatTools(server: McpServer): void {
       ),
       attachInline: attachInlineParam,
       account: accountParam,
-    },
+    }),
   }, async ({ space, text, thread, attach, attachInline, account }) => {
     if (text === undefined && !attach?.length && !attachInline?.length) {
       throw new Error('A Chat message needs text, an attachment, or both.');
@@ -207,12 +207,12 @@ export function registerChatTools(server: McpServer): void {
       'Send a direct message to one person by email address, creating the DM space if this is the first message. Delivered '
       + 'immediately and cannot be unsent through this tool. For a room rather than a person, use gog_chat_messages_send.'
       + workspaceOnlyNote,
-    inputSchema: {
+    inputSchema: z.object({
       email: z.string().describe('Recipient email address'),
       text: z.string().describe('Message text'),
       thread: threadParam,
       account: accountParam,
-    },
+    }),
   }, async ({ email, text, thread, account }) => {
     const args = ['chat', 'dm', 'send', email, `--text=${text}`];
     if (thread) args.push(`--thread=${thread}`);
@@ -223,10 +223,10 @@ export function registerChatTools(server: McpServer): void {
     description:
       'Resolve the DM space for an email address — the bridge from a person to the "spaces/..." name the message tools '
       + 'want. Creates the space if none exists yet, which is silent: it does not message the person.' + workspaceOnlyNote,
-    inputSchema: {
+    inputSchema: z.object({
       email: z.string().describe('The other person\'s email address'),
       account: accountParam,
-    },
+    }),
   }, async ({ email, account }) => {
     return runOrDiagnose(['chat', 'dm', 'space', email], { account });
   });
@@ -237,12 +237,12 @@ export function registerChatTools(server: McpServer): void {
       + 'SUMMARY per message; come here when you need the individual reactors, or the reaction resource names that '
       + 'gog_chat_reactions_delete takes.' + workspaceOnlyNote,
     annotations: { readOnlyHint: true },
-    inputSchema: {
+    inputSchema: z.object({
       message: z.string().describe('Message resource name ("spaces/AAAA/messages/BBBB"), or a bare message ID together with `space`'),
       space: z.string().optional().describe('Space resource name — required only when `message` is a bare ID'),
       ...paginationParams,
       account: accountParam,
-    },
+    }),
   }, async ({ message, space, max, pageToken, page, all, account }) => {
     const args = ['chat', 'messages', 'reactions', 'list', message];
     if (space) args.push(`--space=${space}`);
@@ -254,12 +254,12 @@ export function registerChatTools(server: McpServer): void {
     description:
       'React to a message with an emoji. Visible to the space immediately. Pass the emoji itself ("👍"), not a :shortcode:.'
       + workspaceOnlyNote,
-    inputSchema: {
+    inputSchema: z.object({
       message: z.string().describe('Message resource name ("spaces/AAAA/messages/BBBB"), or a bare message ID together with `space`'),
       emoji: z.string().describe('The emoji character to react with, e.g. "👍"'),
       space: z.string().optional().describe('Space resource name — required only when `message` is a bare ID'),
       account: accountParam,
-    },
+    }),
   }, async ({ message, emoji, space, account }) => {
     const args = ['chat', 'messages', 'reactions', 'create', message, emoji];
     if (space) args.push(`--space=${space}`);
@@ -272,10 +272,10 @@ export function registerChatTools(server: McpServer): void {
       + 'the message\'s and not the emoji — get it from gog_chat_reactions_list. An account can only remove its own reaction.'
       + workspaceOnlyNote,
     annotations: { destructiveHint: true },
-    inputSchema: {
+    inputSchema: z.object({
       reaction: z.string().describe('Reaction resource name, e.g. "spaces/AAAA/messages/BBBB/reactions/CCCC"'),
       account: accountParam,
-    },
+    }),
   }, async ({ reaction, account }) => {
     return runOrDiagnose(['chat', 'messages', 'reactions', 'delete', reaction], { account });
   });

package/src/tools/classroom.ts

@@ -1,4 +1,4 @@
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { McpServer } from '@modelcontextprotocol/server';
 import { z } from 'zod';
 import { accountParam, runOrDiagnose, registerRunTool, pageTokenParam, pageAliasParam, resolvePageToken} from './utils.js';
 
@@ -6,7 +6,7 @@ export function registerClassroomTools(server: McpServer): void {
   server.registerTool('gog_classroom_courses_list', {
     description: 'List Google Classroom courses.',
     annotations: { readOnlyHint: true },
-    inputSchema: {
+    inputSchema: z.object({
       state: z.string().optional().describe('Comma-separated course states (ACTIVE, ARCHIVED, PROVISIONED, DECLINED, SUSPENDED)'),
       teacher: z.string().optional().describe('Filter by teacher user ID'),
       student: z.string().optional().describe('Filter by student user ID'),
@@ -15,7 +15,7 @@ export function registerClassroomTools(server: McpServer): void {
       page: pageAliasParam,
       all: z.boolean().optional().describe('Fetch all pages'),
       account: accountParam,
-    },
+    }),
   }, async ({ state, teacher, student, max, pageToken, page, all, account }) => {
     const args = ['classroom', 'courses', 'list'];
     if (state) args.push(`--state=${state}`);
@@ -31,10 +31,10 @@ export function registerClassroomTools(server: McpServer): void {
   server.registerTool('gog_classroom_courses_get', {
     description: 'Get a single Google Classroom course by ID.',
     annotations: { readOnlyHint: true },
-    inputSchema: {
+    inputSchema: z.object({
       courseId: z.string().describe('Course ID'),
       account: accountParam,
-    },
+    }),
   }, async ({ courseId, account }) => {
     return runOrDiagnose(['classroom', 'courses', 'get', courseId], { account });
   });
@@ -42,14 +42,14 @@ export function registerClassroomTools(server: McpServer): void {
   server.registerTool('gog_classroom_students_list', {
     description: 'List students enrolled in a Google Classroom course.',
     annotations: { readOnlyHint: true },
-    inputSchema: {
+    inputSchema: z.object({
       courseId: z.string().describe('Course ID'),
       max: z.number().optional().describe('Max results per page'),
       pageToken: pageTokenParam,
       page: pageAliasParam,
       all: z.boolean().optional().describe('Fetch all pages'),
       account: accountParam,
-    },
+    }),
   }, async ({ courseId, max, pageToken, page, all, account }) => {
     const args = ['classroom', 'students', 'list', courseId];
     if (max !== undefined) args.push(`--max=${max}`);
@@ -62,11 +62,11 @@ export function registerClassroomTools(server: McpServer): void {
   server.registerTool('gog_classroom_students_get', {
     description: 'Get a specific student enrolled in a course.',
     annotations: { readOnlyHint: true },
-    inputSchema: {
+    inputSchema: z.object({
       courseId: z.string().describe('Course ID'),
       userId: z.string().describe('Student user ID'),
       account: accountParam,
-    },
+    }),
   }, async ({ courseId, userId, account }) => {
     return runOrDiagnose(['classroom', 'students', 'get', courseId, userId], { account });
   });
@@ -74,14 +74,14 @@ export function registerClassroomTools(server: McpServer): void {
   server.registerTool('gog_classroom_teachers_list', {
     description: 'List teachers in a Google Classroom course.',
     annotations: { readOnlyHint: true },
-    inputSchema: {
+    inputSchema: z.object({
       courseId: z.string().describe('Course ID'),
       max: z.number().optional().describe('Max results per page'),
       pageToken: pageTokenParam,
       page: pageAliasParam,
       all: z.boolean().optional().describe('Fetch all pages'),
       account: accountParam,
-    },
+    }),
   }, async ({ courseId, max, pageToken, page, all, account }) => {
     const args = ['classroom', 'teachers', 'list', courseId];
     if (max !== undefined) args.push(`--max=${max}`);
@@ -94,11 +94,11 @@ export function registerClassroomTools(server: McpServer): void {
   server.registerTool('gog_classroom_teachers_get', {
     description: 'Get a specific teacher in a course.',
     annotations: { readOnlyHint: true },
-    inputSchema: {
+    inputSchema: z.object({
       courseId: z.string().describe('Course ID'),
       userId: z.string().describe('Teacher user ID'),
       account: accountParam,
-    },
+    }),
   }, async ({ courseId, userId, account }) => {
     return runOrDiagnose(['classroom', 'teachers', 'get', courseId, userId], { account });
   });
@@ -106,7 +106,7 @@ export function registerClassroomTools(server: McpServer): void {
   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 },
-    inputSchema: {
+    inputSchema: z.object({
       courseId: z.string().describe('Course ID'),
       students: z.boolean().optional().describe('Include students only'),
       teachers: z.boolean().optional().describe('Include teachers only'),
@@ -115,7 +115,7 @@ export function registerClassroomTools(server: McpServer): void {
       page: pageAliasParam,
       all: z.boolean().optional().describe('Fetch all pages'),
       account: accountParam,
-    },
+    }),
   }, async ({ courseId, students, teachers, max, pageToken, page, all, account }) => {
     const args = ['classroom', 'roster', courseId];
     if (students) args.push('--students');
@@ -130,7 +130,7 @@ export function registerClassroomTools(server: McpServer): void {
   server.registerTool('gog_classroom_coursework_list', {
     description: 'List coursework (assignments, questions, materials) for a course.',
     annotations: { readOnlyHint: true },
-    inputSchema: {
+    inputSchema: z.object({
       courseId: z.string().describe('Course ID'),
       state: z.string().optional().describe('Filter by coursework state (PUBLISHED, DRAFT, DELETED)'),
       topic: z.string().optional().describe('Filter by topic ID'),
@@ -141,7 +141,7 @@ export function registerClassroomTools(server: McpServer): void {
       all: z.boolean().optional().describe('Fetch all pages'),
       scanPages: z.number().optional().describe('Max pages to scan when filtering'),
       account: accountParam,
-    },
+    }),
   }, async ({ courseId, state, topic, orderBy, max, pageToken, page, all, scanPages, account }) => {
     const args = ['classroom', 'coursework', 'list', courseId];
     if (state) args.push(`--state=${state}`);
@@ -158,11 +158,11 @@ export function registerClassroomTools(server: McpServer): void {
   server.registerTool('gog_classroom_coursework_get', {
     description: 'Get a single coursework item by ID.',
     annotations: { readOnlyHint: true },
-    inputSchema: {
+    inputSchema: z.object({
       courseId: z.string().describe('Course ID'),
       courseworkId: z.string().describe('Coursework ID'),
       account: accountParam,
-    },
+    }),
   }, async ({ courseId, courseworkId, account }) => {
     return runOrDiagnose(['classroom', 'coursework', 'get', courseId, courseworkId], { account });
   });
@@ -170,7 +170,7 @@ export function registerClassroomTools(server: McpServer): void {
   server.registerTool('gog_classroom_submissions_list', {
     description: 'List student submissions for a coursework item.',
     annotations: { readOnlyHint: true },
-    inputSchema: {
+    inputSchema: z.object({
       courseId: z.string().describe('Course ID'),
       courseworkId: z.string().describe('Coursework ID'),
       state: z.string().optional().describe('Filter by submission state'),
@@ -181,7 +181,7 @@ export function registerClassroomTools(server: McpServer): void {
       page: pageAliasParam,
       all: z.boolean().optional().describe('Fetch all pages'),
       account: accountParam,
-    },
+    }),
   }, async ({ courseId, courseworkId, state, late, user, max, pageToken, page, all, account }) => {
     const args = ['classroom', 'submissions', 'list', courseId, courseworkId];
     if (state) args.push(`--state=${state}`);
@@ -197,12 +197,12 @@ export function registerClassroomTools(server: McpServer): void {
   server.registerTool('gog_classroom_submissions_get', {
     description: 'Get a single submission by ID.',
     annotations: { readOnlyHint: true },
-    inputSchema: {
+    inputSchema: z.object({
       courseId: z.string().describe('Course ID'),
       courseworkId: z.string().describe('Coursework ID'),
       submissionId: z.string().describe('Submission ID'),
       account: accountParam,
-    },
+    }),
   }, async ({ courseId, courseworkId, submissionId, account }) => {
     return runOrDiagnose(['classroom', 'submissions', 'get', courseId, courseworkId, submissionId], { account });
   });
@@ -210,14 +210,14 @@ export function registerClassroomTools(server: McpServer): void {
   server.registerTool('gog_classroom_submissions_grade', {
     description: 'Grade a student submission. Set draft and/or assigned grade values.',
     annotations: { destructiveHint: true },
-    inputSchema: {
+    inputSchema: z.object({
       courseId: z.string().describe('Course ID'),
       courseworkId: z.string().describe('Coursework ID'),
       submissionId: z.string().describe('Submission ID'),
       draft: z.string().optional().describe('Draft grade value'),
       assigned: z.string().optional().describe('Assigned (final) grade value'),
       account: accountParam,
-    },
+    }),
   }, async ({ courseId, courseworkId, submissionId, draft, assigned, account }) => {
     const args = ['classroom', 'submissions', 'grade', courseId, courseworkId, submissionId];
     if (draft) args.push(`--draft=${draft}`);
@@ -228,12 +228,12 @@ export function registerClassroomTools(server: McpServer): void {
   server.registerTool('gog_classroom_submissions_return', {
     description: 'Return a graded submission to the student.',
     annotations: { destructiveHint: true },
-    inputSchema: {
+    inputSchema: z.object({
       courseId: z.string().describe('Course ID'),
       courseworkId: z.string().describe('Coursework ID'),
       submissionId: z.string().describe('Submission ID'),
       account: accountParam,
-    },
+    }),
   }, async ({ courseId, courseworkId, submissionId, account }) => {
     return runOrDiagnose(['classroom', 'submissions', 'return', courseId, courseworkId, submissionId], { account });
   });
@@ -241,12 +241,12 @@ export function registerClassroomTools(server: McpServer): void {
   server.registerTool('gog_classroom_submissions_turn_in', {
     description: 'Turn in a student submission (student action).',
     annotations: { destructiveHint: true },
-    inputSchema: {
+    inputSchema: z.object({
       courseId: z.string().describe('Course ID'),
       courseworkId: z.string().describe('Coursework ID'),
       submissionId: z.string().describe('Submission ID'),
       account: accountParam,
-    },
+    }),
   }, async ({ courseId, courseworkId, submissionId, account }) => {
     return runOrDiagnose(['classroom', 'submissions', 'turn-in', courseId, courseworkId, submissionId], { account });
   });
@@ -254,12 +254,12 @@ export function registerClassroomTools(server: McpServer): void {
   server.registerTool('gog_classroom_submissions_reclaim', {
     description: 'Reclaim a turned-in submission (student action to edit a submission).',
     annotations: { destructiveHint: true },
-    inputSchema: {
+    inputSchema: z.object({
       courseId: z.string().describe('Course ID'),
       courseworkId: z.string().describe('Coursework ID'),
       submissionId: z.string().describe('Submission ID'),
       account: accountParam,
-    },
+    }),
   }, async ({ courseId, courseworkId, submissionId, account }) => {
     return runOrDiagnose(['classroom', 'submissions', 'reclaim', courseId, courseworkId, submissionId], { account });
   });
@@ -267,7 +267,7 @@ export function registerClassroomTools(server: McpServer): void {
   server.registerTool('gog_classroom_announcements_list', {
     description: 'List announcements in a Google Classroom course.',
     annotations: { readOnlyHint: true },
-    inputSchema: {
+    inputSchema: z.object({
       courseId: z.string().describe('Course ID'),
       state: z.string().optional().describe('Filter by announcement state'),
       orderBy: z.string().optional().describe('Sort order'),
@@ -276,7 +276,7 @@ export function registerClassroomTools(server: McpServer): void {
       page: pageAliasParam,
       all: z.boolean().optional().describe('Fetch all pages'),
       account: accountParam,
-    },
+    }),
   }, async ({ courseId, state, orderBy, max, pageToken, page, all, account }) => {
     const args = ['classroom', 'announcements', 'list', courseId];
     if (state) args.push(`--state=${state}`);
@@ -291,24 +291,24 @@ export function registerClassroomTools(server: McpServer): void {
   server.registerTool('gog_classroom_announcements_get', {
     description: 'Get a single announcement by ID.',
     annotations: { readOnlyHint: true },
-    inputSchema: {
+    inputSchema: z.object({
       courseId: z.string().describe('Course ID'),
       announcementId: z.string().describe('Announcement ID'),
       account: accountParam,
-    },
+    }),
   }, async ({ courseId, announcementId, account }) => {
     return runOrDiagnose(['classroom', 'announcements', 'get', courseId, announcementId], { account });
   });
 
   server.registerTool('gog_classroom_announcements_create', {
     description: 'Create an announcement in a Google Classroom course.',
-    inputSchema: {
+    inputSchema: z.object({
       courseId: z.string().describe('Course ID'),
       text: z.string().describe('Announcement text'),
       state: z.enum(['PUBLISHED', 'DRAFT']).optional().describe('State'),
       scheduled: z.string().optional().describe('Scheduled publish time'),
       account: accountParam,
-    },
+    }),
   }, async ({ courseId, text, state, scheduled, account }) => {
     const args = ['classroom', 'announcements', 'create', courseId, `--text=${text}`];
     if (state) args.push(`--state=${state}`);
@@ -319,14 +319,14 @@ export function registerClassroomTools(server: McpServer): void {
   server.registerTool('gog_classroom_topics_list', {
     description: 'List topics in a Google Classroom course.',
     annotations: { readOnlyHint: true },
-    inputSchema: {
+    inputSchema: z.object({
       courseId: z.string().describe('Course ID'),
       max: z.number().optional().describe('Max results per page'),
       pageToken: pageTokenParam,
       page: pageAliasParam,
       all: z.boolean().optional().describe('Fetch all pages'),
       account: accountParam,
-    },
+    }),
   }, async ({ courseId, max, pageToken, page, all, account }) => {
     const args = ['classroom', 'topics', 'list', courseId];
     if (max !== undefined) args.push(`--max=${max}`);
@@ -339,11 +339,11 @@ export function registerClassroomTools(server: McpServer): void {
   server.registerTool('gog_classroom_topics_get', {
     description: 'Get a single topic by ID.',
     annotations: { readOnlyHint: true },
-    inputSchema: {
+    inputSchema: z.object({
       courseId: z.string().describe('Course ID'),
       topicId: z.string().describe('Topic ID'),
       account: accountParam,
-    },
+    }),
   }, async ({ courseId, topicId, account }) => {
     return runOrDiagnose(['classroom', 'topics', 'get', courseId, topicId], { account });
   });
@@ -351,7 +351,7 @@ export function registerClassroomTools(server: McpServer): void {
   server.registerTool('gog_classroom_invitations_list', {
     description: 'List Google Classroom invitations.',
     annotations: { readOnlyHint: true },
-    inputSchema: {
+    inputSchema: z.object({
       course: z.string().optional().describe('Filter by course ID'),
       user: z.string().optional().describe('Filter by user ID'),
       max: z.number().optional().describe('Max results per page'),
@@ -359,7 +359,7 @@ export function registerClassroomTools(server: McpServer): void {
       page: pageAliasParam,
       all: z.boolean().optional().describe('Fetch all pages'),
       account: accountParam,
-    },
+    }),
   }, async ({ course, user, max, pageToken, page, all, account }) => {
     const args = ['classroom', 'invitations', 'list'];
     if (course) args.push(`--course=${course}`);
@@ -374,20 +374,20 @@ export function registerClassroomTools(server: McpServer): void {
   server.registerTool('gog_classroom_invitations_get', {
     description: 'Get a single invitation by ID.',
     annotations: { readOnlyHint: true },
-    inputSchema: {
+    inputSchema: z.object({
       invitationId: z.string().describe('Invitation ID'),
       account: accountParam,
-    },
+    }),
   }, async ({ invitationId, account }) => {
     return runOrDiagnose(['classroom', 'invitations', 'get', invitationId], { account });
   });
 
   server.registerTool('gog_classroom_invitations_accept', {
     description: 'Accept a Google Classroom invitation.',
-    inputSchema: {
+    inputSchema: z.object({
       invitationId: z.string().describe('Invitation ID'),
       account: accountParam,
-    },
+    }),
   }, async ({ invitationId, account }) => {
     return runOrDiagnose(['classroom', 'invitations', 'accept', invitationId], { account });
   });
@@ -395,10 +395,10 @@ export function registerClassroomTools(server: McpServer): void {
   server.registerTool('gog_classroom_profile_get', {
     description: 'Get a Google Classroom user profile. Omit userId to fetch the authenticated user.',
     annotations: { readOnlyHint: true },
-    inputSchema: {
+    inputSchema: z.object({
       userId: z.string().optional().describe('User ID (omit for self)'),
       account: accountParam,
-    },
+    }),
   }, async ({ userId, account }) => {
     const args = ['classroom', 'profile', 'get'];
     if (userId) args.push(userId);