@rnsk/toolkits 0.0.7 → 0.0.9

package/dist/toolkits/google-classroom/tools/courses.js

@@ -0,0 +1,189 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { classroomRequest, googleClassroomTokenField } from './client.js';
+const courseState = z.enum(['COURSE_STATE_UNSPECIFIED', 'ACTIVE', 'ARCHIVED', 'PROVISIONED', 'DECLINED']);
+export const createCourse = tool({
+    description: 'Creates a course. Use when a teacher needs a Classroom course before enrollment.',
+    inputSchema: z.object({
+        googleClassroomToken: googleClassroomTokenField,
+        name: z.string().max(750).describe('Course name (required)'),
+        ownerId: z.string().describe('Owner user ID or email (required)'),
+        descriptionHeading: z.string().max(360).optional(),
+        description: z.string().max(30000).optional(),
+        room: z.string().max(64).optional(),
+        section: z.string().max(2800).optional(),
+        courseState: courseState.optional().describe('Initial state'),
+    }),
+    execute: async ({ googleClassroomToken, ...body }) => {
+        try {
+            const result = await classroomRequest(googleClassroomToken, '/courses', { method: 'POST', body });
+            if (!result.ok)
+                return { error: 'Failed to create course', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error creating course', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const deleteCourse = tool({
+    description: 'Deletes a course. Confirm the course ID first; deletion removes access for all members.',
+    inputSchema: z.object({
+        googleClassroomToken: googleClassroomTokenField,
+        id: z.string().describe('Course ID or alias to delete'),
+    }),
+    execute: async ({ googleClassroomToken, id }) => {
+        try {
+            const result = await classroomRequest(googleClassroomToken, `/courses/${id}`, { method: 'DELETE' });
+            if (!result.ok)
+                return { error: 'Failed to delete course', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error deleting course', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const getCourse = tool({
+    description: 'Gets full details for a course by ID or alias.',
+    inputSchema: z.object({
+        googleClassroomToken: googleClassroomTokenField,
+        id: z.string().describe('Course ID or alias'),
+    }),
+    execute: async ({ googleClassroomToken, id }) => {
+        try {
+            const result = await classroomRequest(googleClassroomToken, `/courses/${id}`);
+            if (!result.ok)
+                return { error: 'Failed to get course', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error getting course', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const listCourses = tool({
+    description: 'Lists courses visible to you, with optional student/teacher/state filters and pagination.',
+    inputSchema: z.object({
+        googleClassroomToken: googleClassroomTokenField,
+        studentId: z.string().optional().describe("Filter to courses with this student ('me' or ID)"),
+        teacherId: z.string().optional().describe("Filter to courses taught by this teacher ('me' or ID)"),
+        courseStates: z.array(courseState).optional(),
+        pageSize: z.number().min(1).optional(),
+        pageToken: z.string().optional(),
+    }),
+    execute: async ({ googleClassroomToken, studentId, teacherId, courseStates, pageSize, pageToken }) => {
+        try {
+            const result = await classroomRequest(googleClassroomToken, '/courses', {
+                query: { studentId, teacherId, courseStates, pageSize, pageToken },
+            });
+            if (!result.ok)
+                return { error: 'Failed to list courses', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error listing courses', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const patchCourse = tool({
+    description: 'Partially updates a course. Only fields in updateMask change (e.g. name,section).',
+    inputSchema: z.object({
+        googleClassroomToken: googleClassroomTokenField,
+        id: z.string().describe('Course ID or alias to update'),
+        updateMask: z.string().describe("Comma-separated fields, e.g. 'name,section'"),
+        name: z.string().optional(),
+        descriptionHeading: z.string().optional(),
+        description: z.string().optional(),
+        room: z.string().optional(),
+        section: z.string().optional(),
+        courseState: courseState.optional(),
+        ownerId: z.string().optional().describe('New owner user ID'),
+    }),
+    execute: async ({ googleClassroomToken, id, updateMask, ...fields }) => {
+        try {
+            const body = {};
+            for (const [k, v] of Object.entries(fields))
+                if (v !== undefined)
+                    body[k] = v;
+            const result = await classroomRequest(googleClassroomToken, `/courses/${id}`, {
+                method: 'PATCH',
+                query: { updateMask },
+                body,
+            });
+            if (!result.ok)
+                return { error: 'Failed to patch course', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error patching course', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const updateCourse = tool({
+    description: 'Fully replaces a course (PUT). Requires id, name, and ownerId; other fields optional.',
+    inputSchema: z.object({
+        googleClassroomToken: googleClassroomTokenField,
+        id: z.string().describe('Course ID or alias to update'),
+        name: z.string().max(750),
+        ownerId: z.string().describe('Owner user ID or email (admins only to change)'),
+        descriptionHeading: z.string().optional(),
+        description: z.string().max(30000).optional(),
+        room: z.string().max(650).optional(),
+        section: z.string().max(2800).optional(),
+        courseState: courseState.optional(),
+    }),
+    execute: async ({ googleClassroomToken, id, ...body }) => {
+        try {
+            const result = await classroomRequest(googleClassroomToken, `/courses/${id}`, { method: 'PUT', body });
+            if (!result.ok)
+                return { error: 'Failed to update course', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error updating course', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const getGradingPeriodSettings = tool({
+    description: 'Gets grading periods configured for a course.',
+    inputSchema: z.object({
+        googleClassroomToken: googleClassroomTokenField,
+        courseId: z.string().describe('Course ID or alias'),
+    }),
+    execute: async ({ googleClassroomToken, courseId }) => {
+        try {
+            const result = await classroomRequest(googleClassroomToken, `/courses/${courseId}/gradingPeriodSettings`);
+            if (!result.ok)
+                return { error: 'Failed to get grading period settings', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error getting grading period settings', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const listCourseStudentGroups = tool({
+    description: 'Lists student groups in a course with pagination.',
+    inputSchema: z.object({
+        googleClassroomToken: googleClassroomTokenField,
+        courseId: z.string().describe('Course ID or alias'),
+        pageSize: z.number().min(0).optional(),
+        pageToken: z.string().optional(),
+    }),
+    execute: async ({ googleClassroomToken, courseId, pageSize, pageToken }) => {
+        try {
+            const result = await classroomRequest(googleClassroomToken, `/courses/${courseId}/studentGroups`, {
+                query: { pageSize, pageToken },
+            });
+            if (!result.ok)
+                return { error: 'Failed to list student groups', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error listing student groups', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+//# sourceMappingURL=courses.js.map

package/dist/toolkits/google-classroom/tools/coursework-addons.d.ts

@@ -0,0 +1,25 @@
+export declare const deleteCourseWorkAddOnAttachment: import("ai").Tool<{
+    attachmentId: string;
+    googleClassroomToken: string;
+    courseId: string;
+    itemId: string;
+}, any>;
+export declare const getCourseWorkAddOnAttachment: import("ai").Tool<{
+    attachmentId: string;
+    googleClassroomToken: string;
+    courseId: string;
+    postId: string;
+}, any>;
+export declare const listCourseWorkAddOnAttachments: import("ai").Tool<{
+    googleClassroomToken: string;
+    courseId: string;
+    postId: string;
+}, any>;
+export declare const getCourseWorkAddOnContext: import("ai").Tool<{
+    googleClassroomToken: string;
+    courseId: string;
+    itemId: string;
+    attachmentId?: string | undefined;
+    addOnToken?: string | undefined;
+}, any>;
+//# sourceMappingURL=coursework-addons.d.ts.map

package/dist/toolkits/google-classroom/tools/coursework-addons.js

@@ -0,0 +1,85 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { classroomRequest, googleClassroomTokenField } from './client.js';
+export const deleteCourseWorkAddOnAttachment = tool({
+    description: 'Deletes an add-on attachment from coursework. The add-on must have created it.',
+    inputSchema: z.object({
+        googleClassroomToken: googleClassroomTokenField,
+        courseId: z.string(),
+        itemId: z.string().describe('Coursework ID'),
+        attachmentId: z.string().describe('Attachment ID to delete'),
+    }),
+    execute: async ({ googleClassroomToken, courseId, itemId, attachmentId }) => {
+        try {
+            const result = await classroomRequest(googleClassroomToken, `/courses/${courseId}/courseWork/${itemId}/addOnAttachments/${attachmentId}`, { method: 'DELETE' });
+            if (!result.ok)
+                return { error: 'Failed to delete coursework add-on attachment', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error deleting coursework add-on attachment', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const getCourseWorkAddOnAttachment = tool({
+    description: 'Gets an add-on attachment from coursework. The requesting add-on must have created it.',
+    inputSchema: z.object({
+        googleClassroomToken: googleClassroomTokenField,
+        courseId: z.string(),
+        postId: z.string().describe('Coursework ID containing the attachment'),
+        attachmentId: z.string().describe('Attachment ID'),
+    }),
+    execute: async ({ googleClassroomToken, courseId, postId, attachmentId }) => {
+        try {
+            const result = await classroomRequest(googleClassroomToken, `/courses/${courseId}/courseWork/${postId}/addOnAttachments/${attachmentId}`);
+            if (!result.ok)
+                return { error: 'Failed to get coursework add-on attachment', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error getting coursework add-on attachment', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const listCourseWorkAddOnAttachments = tool({
+    description: 'Lists add-on attachments on coursework created by the add-on.',
+    inputSchema: z.object({
+        googleClassroomToken: googleClassroomTokenField,
+        courseId: z.string(),
+        postId: z.string().describe('Coursework ID'),
+    }),
+    execute: async ({ googleClassroomToken, courseId, postId }) => {
+        try {
+            const result = await classroomRequest(googleClassroomToken, `/courses/${courseId}/courseWork/${postId}/addOnAttachments`);
+            if (!result.ok)
+                return { error: 'Failed to list coursework add-on attachments', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error listing coursework add-on attachments', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const getCourseWorkAddOnContext = tool({
+    description: 'Gets add-on iframe metadata for coursework: user role, submission ID, grade support.',
+    inputSchema: z.object({
+        googleClassroomToken: googleClassroomTokenField,
+        courseId: z.string(),
+        itemId: z.string().describe('Coursework ID with the attached add-on'),
+        addOnToken: z.string().optional(),
+        attachmentId: z.string().optional().describe('Required except for Attachment Discovery iframe'),
+    }),
+    execute: async ({ googleClassroomToken, courseId, itemId, addOnToken, attachmentId }) => {
+        try {
+            const result = await classroomRequest(googleClassroomToken, `/courses/${courseId}/courseWork/${itemId}/addOnContext`, { query: { addOnToken, attachmentId } });
+            if (!result.ok)
+                return { error: 'Failed to get coursework add-on context', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error getting coursework add-on context', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+//# sourceMappingURL=coursework-addons.js.map

package/dist/toolkits/google-classroom/tools/coursework.d.ts

@@ -0,0 +1,113 @@
+export declare const createCourseWork: import("ai").Tool<{
+    title: string;
+    googleClassroomToken: string;
+    courseId: string;
+    workType: "ASSIGNMENT" | "SHORT_ANSWER_QUESTION" | "MULTIPLE_CHOICE_QUESTION";
+    description?: string | undefined;
+    state?: "DRAFT" | "PUBLISHED" | undefined;
+    materials?: Record<string, any>[] | undefined;
+    scheduledTime?: string | undefined;
+    maxPoints?: number | undefined;
+    dueDate?: {
+        year: number;
+        month: number;
+        day: number;
+    } | undefined;
+    dueTime?: {
+        hours: number;
+        minutes: number;
+        seconds?: number | undefined;
+        nanos?: number | undefined;
+    } | undefined;
+    topicId?: string | undefined;
+    assignment?: Record<string, any> | undefined;
+    multipleChoiceQuestion?: {
+        choices: string[];
+    } | undefined;
+    shortAnswerQuestion?: Record<string, any> | undefined;
+    submissionModificationMode?: "SUBMISSION_MODIFICATION_MODE_UNSPECIFIED" | "MODIFIABLE_UNTIL_TURNED_IN" | "MODIFIABLE" | undefined;
+}, any>;
+export declare const deleteCourseWork: import("ai").Tool<{
+    id: string;
+    googleClassroomToken: string;
+    courseId: string;
+}, any>;
+export declare const getCourseWork: import("ai").Tool<{
+    id: string;
+    googleClassroomToken: string;
+    courseId: string;
+}, any>;
+export declare const listCourseWork: import("ai").Tool<{
+    googleClassroomToken: string;
+    courseId: string;
+    pageToken?: string | undefined;
+    pageSize?: number | undefined;
+    orderBy?: string | undefined;
+    courseWorkStates?: ("DRAFT" | "PUBLISHED" | "DELETED" | "COURSE_WORK_STATE_UNSPECIFIED")[] | undefined;
+    previewVersion?: string | undefined;
+}, any>;
+export declare const patchCourseWork: import("ai").Tool<{
+    id: string;
+    updateMask: string;
+    googleClassroomToken: string;
+    courseId: string;
+    description?: string | undefined;
+    title?: string | undefined;
+    state?: "DRAFT" | "PUBLISHED" | "DELETED" | undefined;
+    materials?: Record<string, any>[] | undefined;
+    scheduledTime?: string | undefined;
+    assigneeMode?: "ALL_STUDENTS" | "INDIVIDUAL_STUDENTS" | undefined;
+    individualStudentsOptions?: {
+        studentIds: string[];
+    } | undefined;
+    maxPoints?: number | undefined;
+    dueDate?: {
+        year: number;
+        month: number;
+        day: number;
+    } | undefined;
+    dueTime?: {
+        hours: number;
+        minutes: number;
+        seconds?: number | undefined;
+        nanos?: number | undefined;
+    } | undefined;
+    topicId?: string | undefined;
+    submissionModificationMode?: string | undefined;
+    gradingPeriodId?: string | undefined;
+}, any>;
+export declare const modifyCourseWorkAssignees: import("ai").Tool<{
+    id: string;
+    googleClassroomToken: string;
+    courseId: string;
+    assigneeMode: "ALL_STUDENTS" | "INDIVIDUAL_STUDENTS";
+    modifyIndividualStudentsOptions?: {
+        addStudentIds?: string[] | undefined;
+        removeStudentIds?: string[] | undefined;
+    } | undefined;
+}, any>;
+export declare const listCourseWorkRubrics: import("ai").Tool<{
+    googleClassroomToken: string;
+    courseId: string;
+    courseWorkId: string;
+    pageToken?: string | undefined;
+    pageSize?: number | undefined;
+    previewVersion?: string | undefined;
+}, any>;
+export declare const listStudentSubmissions: import("ai").Tool<{
+    googleClassroomToken: string;
+    courseId: string;
+    courseWorkId: string;
+    states?: ("NEW" | "CREATED" | "TURNED_IN" | "RETURNED" | "RECLAIMED_BY_STUDENT")[] | undefined;
+    pageToken?: string | undefined;
+    pageSize?: number | undefined;
+    userId?: string | undefined;
+    late?: "LATE_ONLY" | "NOT_LATE_ONLY" | undefined;
+}, any>;
+export declare const reclaimStudentSubmission: import("ai").Tool<{
+    id: string;
+    googleClassroomToken: string;
+    courseId: string;
+    courseWorkId: string;
+}, any>;
+//# sourceMappingURL=coursework.d.ts.map

package/dist/toolkits/google-classroom/tools/coursework.js

@@ -0,0 +1,248 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { classroomRequest, googleClassroomTokenField } from './client.js';
+const workType = z.enum(['ASSIGNMENT', 'SHORT_ANSWER_QUESTION', 'MULTIPLE_CHOICE_QUESTION']);
+const dueDate = z.object({
+    year: z.number().min(1),
+    month: z.number().min(1).max(12),
+    day: z.number().min(1).max(31),
+});
+const dueTime = z.object({
+    hours: z.number().min(0).max(23),
+    minutes: z.number().min(0).max(59),
+    seconds: z.number().min(0).max(59).optional(),
+    nanos: z.number().min(0).optional(),
+});
+const materialSchema = z.record(z.any()).describe('Material with exactly one of driveFile, link, form, youtubeVideo');
+const assigneeMode = z.enum(['ALL_STUDENTS', 'INDIVIDUAL_STUDENTS']);
+export const createCourseWork = tool({
+    description: 'Creates coursework (assignment or question), published, drafted, or scheduled.',
+    inputSchema: z.object({
+        googleClassroomToken: googleClassroomTokenField,
+        courseId: z.string(),
+        title: z.string().describe('Coursework title (required)'),
+        workType: workType,
+        description: z.string().optional(),
+        materials: z.array(materialSchema).optional(),
+        state: z.enum(['DRAFT', 'PUBLISHED']).optional().describe('Defaults to PUBLISHED'),
+        maxPoints: z.number().min(0).optional(),
+        dueDate: dueDate.optional(),
+        dueTime: dueTime.optional(),
+        scheduledTime: z.string().optional().describe('RFC3339 auto-publish time'),
+        topicId: z.string().optional(),
+        assignment: z.record(z.any()).optional().describe('Details when workType is ASSIGNMENT'),
+        multipleChoiceQuestion: z.object({ choices: z.array(z.string()).min(2) }).optional(),
+        shortAnswerQuestion: z.record(z.any()).optional(),
+        submissionModificationMode: z.enum(['SUBMISSION_MODIFICATION_MODE_UNSPECIFIED', 'MODIFIABLE_UNTIL_TURNED_IN', 'MODIFIABLE']).optional(),
+    }),
+    execute: async ({ googleClassroomToken, courseId, ...body }) => {
+        try {
+            const result = await classroomRequest(googleClassroomToken, `/courses/${courseId}/courseWork`, {
+                method: 'POST',
+                body,
+            });
+            if (!result.ok)
+                return { error: 'Failed to create coursework', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error creating coursework', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const deleteCourseWork = tool({
+    description: 'Deletes coursework. Confirm course and coursework IDs first.',
+    inputSchema: z.object({
+        googleClassroomToken: googleClassroomTokenField,
+        courseId: z.string(),
+        id: z.string().describe('Coursework ID to delete'),
+    }),
+    execute: async ({ googleClassroomToken, courseId, id }) => {
+        try {
+            const result = await classroomRequest(googleClassroomToken, `/courses/${courseId}/courseWork/${id}`, {
+                method: 'DELETE',
+            });
+            if (!result.ok)
+                return { error: 'Failed to delete coursework', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error deleting coursework', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const getCourseWork = tool({
+    description: 'Gets coursework details by course and coursework ID.',
+    inputSchema: z.object({
+        googleClassroomToken: googleClassroomTokenField,
+        courseId: z.string().describe('Course ID or alias'),
+        id: z.string().describe('Coursework ID'),
+    }),
+    execute: async ({ googleClassroomToken, courseId, id }) => {
+        try {
+            const result = await classroomRequest(googleClassroomToken, `/courses/${courseId}/courseWork/${id}`);
+            if (!result.ok)
+                return { error: 'Failed to get coursework', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error getting coursework', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const listCourseWork = tool({
+    description: 'Lists coursework in a course with state filter and ordering. Defaults to PUBLISHED, newest first.',
+    inputSchema: z.object({
+        googleClassroomToken: googleClassroomTokenField,
+        courseId: z.string().describe('Course ID or alias'),
+        courseWorkStates: z.array(z.enum(['COURSE_WORK_STATE_UNSPECIFIED', 'DRAFT', 'PUBLISHED', 'DELETED'])).optional(),
+        orderBy: z.string().optional().describe("e.g. 'updateTime desc', 'dueDate asc'"),
+        pageSize: z.number().min(0).optional(),
+        pageToken: z.string().optional(),
+        previewVersion: z.string().optional(),
+    }),
+    execute: async ({ googleClassroomToken, courseId, ...query }) => {
+        try {
+            const result = await classroomRequest(googleClassroomToken, `/courses/${courseId}/courseWork`, { query });
+            if (!result.ok)
+                return { error: 'Failed to list coursework', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error listing coursework', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const patchCourseWork = tool({
+    description: 'Updates coursework fields. Only fields in updateMask change (title, dueDate, maxPoints, ...).',
+    inputSchema: z.object({
+        googleClassroomToken: googleClassroomTokenField,
+        courseId: z.string().describe('Course ID or alias'),
+        id: z.string().describe('Coursework ID to update'),
+        updateMask: z.string().describe("Fields to update, e.g. 'title,maxPoints'"),
+        title: z.string().max(3000).optional(),
+        description: z.string().max(30000).optional(),
+        materials: z.array(materialSchema).max(20).optional(),
+        state: z.enum(['DRAFT', 'PUBLISHED', 'DELETED']).optional(),
+        maxPoints: z.number().min(0).optional(),
+        dueDate: dueDate.optional(),
+        dueTime: dueTime.optional(),
+        scheduledTime: z.string().optional(),
+        topicId: z.string().optional(),
+        gradingPeriodId: z.string().optional(),
+        assigneeMode: assigneeMode.optional(),
+        individualStudentsOptions: z.object({ studentIds: z.array(z.string()) }).optional(),
+        submissionModificationMode: z.string().optional(),
+    }),
+    execute: async ({ googleClassroomToken, courseId, id, updateMask, ...fields }) => {
+        try {
+            const body = {};
+            for (const [k, v] of Object.entries(fields))
+                if (v !== undefined)
+                    body[k] = v;
+            const result = await classroomRequest(googleClassroomToken, `/courses/${courseId}/courseWork/${id}`, {
+                method: 'PATCH',
+                query: { updateMask },
+                body,
+            });
+            if (!result.ok)
+                return { error: 'Failed to patch coursework', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error patching coursework', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const modifyCourseWorkAssignees = tool({
+    description: 'Changes coursework visibility: all students or add/remove individual students.',
+    inputSchema: z.object({
+        googleClassroomToken: googleClassroomTokenField,
+        courseId: z.string().describe('Course ID or alias'),
+        id: z.string().describe('Coursework ID'),
+        assigneeMode: assigneeMode,
+        modifyIndividualStudentsOptions: z.object({
+            addStudentIds: z.array(z.string()).optional(),
+            removeStudentIds: z.array(z.string()).optional(),
+        }).optional(),
+    }),
+    execute: async ({ googleClassroomToken, courseId, id, ...body }) => {
+        try {
+            const result = await classroomRequest(googleClassroomToken, `/courses/${courseId}/courseWork/${id}:modifyAssignees`, { method: 'POST', body });
+            if (!result.ok)
+                return { error: 'Failed to modify coursework assignees', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error modifying coursework assignees', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const listCourseWorkRubrics = tool({
+    description: 'Lists grading rubrics for coursework you may view. At most 1 rubric is returned.',
+    inputSchema: z.object({
+        googleClassroomToken: googleClassroomTokenField,
+        courseId: z.string().describe('Course ID or alias'),
+        courseWorkId: z.string().describe('Coursework ID'),
+        pageSize: z.number().min(1).optional().describe('Max items (default and max 1)'),
+        pageToken: z.string().optional(),
+        previewVersion: z.string().optional(),
+    }),
+    execute: async ({ googleClassroomToken, courseId, courseWorkId, pageSize, pageToken, previewVersion }) => {
+        try {
+            const result = await classroomRequest(googleClassroomToken, `/courses/${courseId}/courseWork/${courseWorkId}/rubrics`, { query: { pageSize, pageToken, previewVersion } });
+            if (!result.ok)
+                return { error: 'Failed to list coursework rubrics', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error listing coursework rubrics', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const listStudentSubmissions = tool({
+    description: 'Lists submissions for coursework, filterable by student, state, and lateness. Use courseWorkId "-" for all coursework.',
+    inputSchema: z.object({
+        googleClassroomToken: googleClassroomTokenField,
+        courseId: z.string(),
+        courseWorkId: z.string().describe("Coursework ID, or '-' for all coursework"),
+        userId: z.string().optional().describe("Filter to a student ('me' or ID)"),
+        states: z.array(z.enum(['NEW', 'CREATED', 'TURNED_IN', 'RETURNED', 'RECLAIMED_BY_STUDENT'])).optional(),
+        late: z.enum(['LATE_ONLY', 'NOT_LATE_ONLY']).optional(),
+        pageSize: z.number().min(1).max(100).optional(),
+        pageToken: z.string().optional(),
+    }),
+    execute: async ({ googleClassroomToken, courseId, courseWorkId, ...query }) => {
+        try {
+            const result = await classroomRequest(googleClassroomToken, `/courses/${courseId}/courseWork/${courseWorkId}/studentSubmissions`, { query });
+            if (!result.ok)
+                return { error: 'Failed to list student submissions', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error listing student submissions', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const reclaimStudentSubmission = tool({
+    description: 'Reclaims a turned-in submission for editing, resetting it to CREATED.',
+    inputSchema: z.object({
+        googleClassroomToken: googleClassroomTokenField,
+        courseId: z.string(),
+        courseWorkId: z.string(),
+        id: z.string().describe('Submission ID to reclaim'),
+    }),
+    execute: async ({ googleClassroomToken, courseId, courseWorkId, id }) => {
+        try {
+            const result = await classroomRequest(googleClassroomToken, `/courses/${courseId}/courseWork/${courseWorkId}/studentSubmissions/${id}/reclaim`, { method: 'POST', body: {} });
+            if (!result.ok)
+                return { error: 'Failed to reclaim student submission', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error reclaiming student submission', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+//# sourceMappingURL=coursework.js.map