@rnsk/toolkits 0.0.7 → 0.0.8

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

@@ -0,0 +1,81 @@
+// @ts-nocheck
+import { createCourseAlias, deleteCourseAlias, listCourseAliases } from './aliases.js';
+import { createAnnouncement, deleteAnnouncement, getAnnouncement, listAnnouncements, modifyAnnouncementAssignees, patchAnnouncement, } from './announcements.js';
+import { deleteAnnouncementAddOnAttachment, getAnnouncementAddOnAttachment, getAnnouncementAddOnContext, listAnnouncementAddOnAttachments, } from './announcement-addons.js';
+import { createCourse, deleteCourse, getCourse, getGradingPeriodSettings, listCourseStudentGroups, listCourses, patchCourse, updateCourse, } from './courses.js';
+import { createCourseWork, deleteCourseWork, getCourseWork, listCourseWork, listCourseWorkRubrics, listStudentSubmissions, modifyCourseWorkAssignees, patchCourseWork, reclaimStudentSubmission, } from './coursework.js';
+import { deleteCourseWorkAddOnAttachment, getCourseWorkAddOnAttachment, getCourseWorkAddOnContext, listCourseWorkAddOnAttachments, } from './coursework-addons.js';
+import { createInvitation, deleteInvitation, getInvitation, listInvitations } from './invitations.js';
+import { createCourseWorkMaterial, deleteCourseWorkMaterial, getCourseWorkMaterial, listCourseWorkMaterials, patchCourseWorkMaterial, } from './materials.js';
+import { getCourseWorkMaterialAddOnContext, listCourseWorkMaterialAddOnAttachments, } from './materials-addons.js';
+import { createRegistration, getUserProfile } from './misc.js';
+import { getPostAddOnContext, listPostAddOnAttachments } from './posts-addons.js';
+import { addStudentToCourse, deleteCourseStudent, deleteCourseTeacher, getCourseStudent, getTeacher, listCourseStudents, listCourseTeachers, listStudentGuardians, } from './roster.js';
+import { createCourseTopic, deleteCourseTopic, getCourseTopic, listCourseTopics, patchCourseTopic, } from './topics.js';
+export { createCourseAlias, deleteCourseAlias, listCourseAliases, createAnnouncement, deleteAnnouncement, getAnnouncement, listAnnouncements, modifyAnnouncementAssignees, patchAnnouncement, deleteAnnouncementAddOnAttachment, getAnnouncementAddOnAttachment, getAnnouncementAddOnContext, listAnnouncementAddOnAttachments, createCourse, deleteCourse, getCourse, getGradingPeriodSettings, listCourseStudentGroups, listCourses, patchCourse, updateCourse, createCourseWork, deleteCourseWork, getCourseWork, listCourseWork, listCourseWorkRubrics, listStudentSubmissions, modifyCourseWorkAssignees, patchCourseWork, reclaimStudentSubmission, deleteCourseWorkAddOnAttachment, getCourseWorkAddOnAttachment, getCourseWorkAddOnContext, listCourseWorkAddOnAttachments, createInvitation, deleteInvitation, getInvitation, listInvitations, createCourseWorkMaterial, deleteCourseWorkMaterial, getCourseWorkMaterial, listCourseWorkMaterials, patchCourseWorkMaterial, getCourseWorkMaterialAddOnContext, listCourseWorkMaterialAddOnAttachments, createRegistration, getUserProfile, getPostAddOnContext, listPostAddOnAttachments, addStudentToCourse, deleteCourseStudent, deleteCourseTeacher, getCourseStudent, getTeacher, listCourseStudents, listCourseTeachers, listStudentGuardians, createCourseTopic, deleteCourseTopic, getCourseTopic, listCourseTopics, patchCourseTopic, };
+const auth = 'googleClassroomToken';
+export const googleClassroomTools = [
+    { name: 'googleClassroomCreateCourse', description: 'Creates a course before enrollment.', tool: createCourse, requiredAuth: auth, scope: 'write' },
+    { name: 'googleClassroomDeleteCourse', description: 'Deletes a course. Confirm the ID first.', tool: deleteCourse, requiredAuth: auth, scope: 'delete' },
+    { name: 'googleClassroomGetCourse', description: 'Gets full course details by ID or alias.', tool: getCourse, requiredAuth: auth, scope: 'read' },
+    { name: 'googleClassroomListCourses', description: 'Lists your courses with filters and pagination.', tool: listCourses, requiredAuth: auth, scope: 'read' },
+    { name: 'googleClassroomPatchCourse', description: 'Partially updates a course via updateMask.', tool: patchCourse, requiredAuth: auth, scope: 'write' },
+    { name: 'googleClassroomUpdateCourse', description: 'Fully replaces a course (PUT).', tool: updateCourse, requiredAuth: auth, scope: 'write' },
+    { name: 'googleClassroomGetGradingPeriodSettings', description: 'Gets grading periods configured for a course.', tool: getGradingPeriodSettings, requiredAuth: auth, scope: 'read' },
+    { name: 'googleClassroomListCourseStudentGroups', description: 'Lists student groups in a course.', tool: listCourseStudentGroups, requiredAuth: auth, scope: 'read' },
+    { name: 'googleClassroomCreateCourseAlias', description: 'Adds an alternative identifier to a course.', tool: createCourseAlias, requiredAuth: auth, scope: 'write' },
+    { name: 'googleClassroomDeleteCourseAlias', description: 'Removes an alias from a course.', tool: deleteCourseAlias, requiredAuth: auth, scope: 'delete' },
+    { name: 'googleClassroomListCourseAliases', description: 'Lists all aliases for a course.', tool: listCourseAliases, requiredAuth: auth, scope: 'read' },
+    { name: 'googleClassroomCreateAnnouncement', description: 'Creates a draft, published, or scheduled announcement.', tool: createAnnouncement, requiredAuth: auth, scope: 'write' },
+    { name: 'googleClassroomDeleteAnnouncement', description: 'Deletes an announcement.', tool: deleteAnnouncement, requiredAuth: auth, scope: 'delete' },
+    { name: 'googleClassroomGetAnnouncement', description: 'Fetches an announcement by course and announcement ID.', tool: getAnnouncement, requiredAuth: auth, scope: 'read' },
+    { name: 'googleClassroomListAnnouncements', description: 'Pages through course announcements.', tool: listAnnouncements, requiredAuth: auth, scope: 'read' },
+    { name: 'googleClassroomModifyAnnouncementAssignees', description: 'Changes announcement visibility (all vs individual students).', tool: modifyAnnouncementAssignees, requiredAuth: auth, scope: 'write' },
+    { name: 'googleClassroomPatchAnnouncement', description: 'Updates announcement fields via updateMask.', tool: patchAnnouncement, requiredAuth: auth, scope: 'write' },
+    { name: 'googleClassroomGetAnnouncementAddOnContext', description: 'Gets add-on iframe metadata for an announcement.', tool: getAnnouncementAddOnContext, requiredAuth: auth, scope: 'read' },
+    { name: 'googleClassroomDeleteAnnouncementAddOnAttachment', description: 'Deletes an add-on attachment from an announcement.', tool: deleteAnnouncementAddOnAttachment, requiredAuth: auth, scope: 'delete' },
+    { name: 'googleClassroomGetAnnouncementAddOnAttachment', description: 'Gets an add-on attachment from an announcement.', tool: getAnnouncementAddOnAttachment, requiredAuth: auth, scope: 'read' },
+    { name: 'googleClassroomListAnnouncementAddOnAttachments', description: 'Lists add-on attachments on an announcement.', tool: listAnnouncementAddOnAttachments, requiredAuth: auth, scope: 'read' },
+    { name: 'googleClassroomCreateCourseWork', description: 'Creates an assignment or question, published, drafted, or scheduled.', tool: createCourseWork, requiredAuth: auth, scope: 'write' },
+    { name: 'googleClassroomDeleteCourseWork', description: 'Deletes coursework.', tool: deleteCourseWork, requiredAuth: auth, scope: 'delete' },
+    { name: 'googleClassroomGetCourseWork', description: 'Gets coursework details.', tool: getCourseWork, requiredAuth: auth, scope: 'read' },
+    { name: 'googleClassroomListCourseWork', description: 'Lists coursework with state filter and ordering.', tool: listCourseWork, requiredAuth: auth, scope: 'read' },
+    { name: 'googleClassroomPatchCourseWork', description: 'Updates coursework fields via updateMask.', tool: patchCourseWork, requiredAuth: auth, scope: 'write' },
+    { name: 'googleClassroomModifyCourseWorkAssignees', description: 'Changes coursework visibility (all vs individual students).', tool: modifyCourseWorkAssignees, requiredAuth: auth, scope: 'write' },
+    { name: 'googleClassroomListCourseWorkRubrics', description: 'Lists grading rubrics for coursework.', tool: listCourseWorkRubrics, requiredAuth: auth, scope: 'read' },
+    { name: 'googleClassroomListStudentSubmissions', description: 'Lists submissions for coursework with student/state/lateness filters.', tool: listStudentSubmissions, requiredAuth: auth, scope: 'read' },
+    { name: 'googleClassroomReclaimStudentSubmission', description: 'Reclaims a turned-in submission for editing.', tool: reclaimStudentSubmission, requiredAuth: auth, scope: 'write' },
+    { name: 'googleClassroomDeleteCourseWorkAddOnAttachment', description: 'Deletes an add-on attachment from coursework.', tool: deleteCourseWorkAddOnAttachment, requiredAuth: auth, scope: 'delete' },
+    { name: 'googleClassroomGetCourseWorkAddOnAttachment', description: 'Gets an add-on attachment from coursework.', tool: getCourseWorkAddOnAttachment, requiredAuth: auth, scope: 'read' },
+    { name: 'googleClassroomListCourseWorkAddOnAttachments', description: 'Lists add-on attachments on coursework.', tool: listCourseWorkAddOnAttachments, requiredAuth: auth, scope: 'read' },
+    { name: 'googleClassroomGetCourseWorkAddOnContext', description: 'Gets add-on iframe metadata for coursework.', tool: getCourseWorkAddOnContext, requiredAuth: auth, scope: 'read' },
+    { name: 'googleClassroomCreateCourseWorkMaterial', description: 'Creates a coursework material (resources/notes).', tool: createCourseWorkMaterial, requiredAuth: auth, scope: 'write' },
+    { name: 'googleClassroomGetCourseWorkMaterial', description: 'Gets a coursework material.', tool: getCourseWorkMaterial, requiredAuth: auth, scope: 'read' },
+    { name: 'googleClassroomListCourseWorkMaterials', description: 'Pages through coursework materials.', tool: listCourseWorkMaterials, requiredAuth: auth, scope: 'read' },
+    { name: 'googleClassroomDeleteCourseWorkMaterial', description: 'Deletes a coursework material.', tool: deleteCourseWorkMaterial, requiredAuth: auth, scope: 'delete' },
+    { name: 'googleClassroomPatchCourseWorkMaterial', description: 'Updates a coursework material via updateMask.', tool: patchCourseWorkMaterial, requiredAuth: auth, scope: 'write' },
+    { name: 'googleClassroomListCourseWorkMaterialAddOnAttachments', description: 'Lists add-on attachments on a coursework material.', tool: listCourseWorkMaterialAddOnAttachments, requiredAuth: auth, scope: 'read' },
+    { name: 'googleClassroomGetCourseWorkMaterialAddOnContext', description: 'Gets add-on iframe metadata for a coursework material.', tool: getCourseWorkMaterialAddOnContext, requiredAuth: auth, scope: 'read' },
+    { name: 'googleClassroomListPostAddOnAttachments', description: 'Lists add-on attachments on a post.', tool: listPostAddOnAttachments, requiredAuth: auth, scope: 'read' },
+    { name: 'googleClassroomGetPostAddOnContext', description: 'Gets add-on iframe metadata for a post.', tool: getPostAddOnContext, requiredAuth: auth, scope: 'read' },
+    { name: 'googleClassroomAddStudentToCourse', description: 'Enrolls a user as a student.', tool: addStudentToCourse, requiredAuth: auth, scope: 'write' },
+    { name: 'googleClassroomDeleteCourseStudent', description: 'Removes a student enrollment.', tool: deleteCourseStudent, requiredAuth: auth, scope: 'delete' },
+    { name: 'googleClassroomGetCourseStudent', description: 'Gets a student enrollment with profile details.', tool: getCourseStudent, requiredAuth: auth, scope: 'read' },
+    { name: 'googleClassroomListCourseStudents', description: 'Pages through enrolled students.', tool: listCourseStudents, requiredAuth: auth, scope: 'read' },
+    { name: 'googleClassroomListStudentGuardians', description: 'Lists guardians linked to a student.', tool: listStudentGuardians, requiredAuth: auth, scope: 'read' },
+    { name: 'googleClassroomDeleteCourseTeacher', description: 'Removes a teacher enrollment.', tool: deleteCourseTeacher, requiredAuth: auth, scope: 'delete' },
+    { name: 'googleClassroomGetTeacher', description: 'Gets a teacher enrollment with profile details.', tool: getTeacher, requiredAuth: auth, scope: 'read' },
+    { name: 'googleClassroomListCourseTeachers', description: 'Pages through enrolled teachers.', tool: listCourseTeachers, requiredAuth: auth, scope: 'read' },
+    { name: 'googleClassroomCreateCourseTopic', description: 'Creates a topic section in a course.', tool: createCourseTopic, requiredAuth: auth, scope: 'write' },
+    { name: 'googleClassroomDeleteCourseTopic', description: 'Deletes a course topic.', tool: deleteCourseTopic, requiredAuth: auth, scope: 'delete' },
+    { name: 'googleClassroomGetCourseTopic', description: 'Gets a course topic.', tool: getCourseTopic, requiredAuth: auth, scope: 'read' },
+    { name: 'googleClassroomListCourseTopics', description: 'Lists topics in a course.', tool: listCourseTopics, requiredAuth: auth, scope: 'read' },
+    { name: 'googleClassroomPatchCourseTopic', description: 'Renames a course topic.', tool: patchCourseTopic, requiredAuth: auth, scope: 'write' },
+    { name: 'googleClassroomCreateInvitation', description: 'Invites a user to a course as student or teacher.', tool: createInvitation, requiredAuth: auth, scope: 'write' },
+    { name: 'googleClassroomDeleteInvitation', description: 'Deletes an invitation.', tool: deleteInvitation, requiredAuth: auth, scope: 'delete' },
+    { name: 'googleClassroomGetInvitation', description: 'Gets an invitation by ID.', tool: getInvitation, requiredAuth: auth, scope: 'read' },
+    { name: 'googleClassroomListInvitations', description: 'Lists invitations filtered by user and/or course.', tool: listInvitations, requiredAuth: auth, scope: 'read' },
+    { name: 'googleClassroomCreateRegistration', description: 'Subscribes a Pub/Sub topic to Classroom push notifications.', tool: createRegistration, requiredAuth: auth, scope: 'write' },
+    { name: 'googleClassroomGetUserProfile', description: 'Gets a user profile by ID, email, or me.', tool: getUserProfile, requiredAuth: auth, scope: 'read' },
+];
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,22 @@
+export declare const createInvitation: import("ai").Tool<{
+    role: "STUDENT" | "TEACHER";
+    googleClassroomToken: string;
+    courseId: string;
+    userId: string;
+}, any>;
+export declare const deleteInvitation: import("ai").Tool<{
+    id: string;
+    googleClassroomToken: string;
+}, any>;
+export declare const getInvitation: import("ai").Tool<{
+    id: string;
+    googleClassroomToken: string;
+}, any>;
+export declare const listInvitations: import("ai").Tool<{
+    googleClassroomToken: string;
+    pageToken?: string | undefined;
+    pageSize?: number | undefined;
+    courseId?: string | undefined;
+    userId?: string | undefined;
+}, any>;
+//# sourceMappingURL=invitations.d.ts.map

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

@@ -0,0 +1,89 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { classroomRequest, googleClassroomTokenField } from './client.js';
+export const createInvitation = tool({
+    description: 'Invites a user to a course as a student or teacher.',
+    inputSchema: z.object({
+        googleClassroomToken: googleClassroomTokenField,
+        courseId: z.string(),
+        userId: z.string().describe('Invitee user ID or email'),
+        role: z.enum(['STUDENT', 'TEACHER']),
+    }),
+    execute: async ({ googleClassroomToken, courseId, userId, role }) => {
+        try {
+            const result = await classroomRequest(googleClassroomToken, '/invitations', {
+                method: 'POST',
+                body: { courseId, userId, role },
+            });
+            if (!result.ok)
+                return { error: 'Failed to create invitation', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error creating invitation', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const deleteInvitation = tool({
+    description: 'Deletes an invitation. Confirm the invitation ID first.',
+    inputSchema: z.object({
+        googleClassroomToken: googleClassroomTokenField,
+        id: z.string().describe('Invitation ID to delete'),
+    }),
+    execute: async ({ googleClassroomToken, id }) => {
+        try {
+            const result = await classroomRequest(googleClassroomToken, `/invitations/${id}`, { method: 'DELETE' });
+            if (!result.ok)
+                return { error: 'Failed to delete invitation', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error deleting invitation', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const getInvitation = tool({
+    description: 'Gets an invitation by ID.',
+    inputSchema: z.object({
+        googleClassroomToken: googleClassroomTokenField,
+        id: z.string().describe('Invitation ID'),
+    }),
+    execute: async ({ googleClassroomToken, id }) => {
+        try {
+            const result = await classroomRequest(googleClassroomToken, `/invitations/${id}`);
+            if (!result.ok)
+                return { error: 'Failed to get invitation', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error getting invitation', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const listInvitations = tool({
+    description: 'Lists invitations you may view. At least one of userId or courseId is required.',
+    inputSchema: z.object({
+        googleClassroomToken: googleClassroomTokenField,
+        userId: z.string().optional().describe("Filter by user ('me', ID, or email)"),
+        courseId: z.string().optional(),
+        pageSize: z.number().min(1).optional(),
+        pageToken: z.string().optional(),
+    }),
+    execute: async ({ googleClassroomToken, userId, courseId, pageSize, pageToken }) => {
+        try {
+            if (!userId && !courseId)
+                return { error: 'At least one of userId or courseId must be supplied' };
+            const result = await classroomRequest(googleClassroomToken, '/invitations', {
+                query: { userId, courseId, pageSize, pageToken },
+            });
+            if (!result.ok)
+                return { error: 'Failed to list invitations', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error listing invitations', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+//# sourceMappingURL=invitations.js.map

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

@@ -0,0 +1,13 @@
+export declare const listCourseWorkMaterialAddOnAttachments: import("ai").Tool<{
+    googleClassroomToken: string;
+    courseId: string;
+    itemId: string;
+}, any>;
+export declare const getCourseWorkMaterialAddOnContext: import("ai").Tool<{
+    googleClassroomToken: string;
+    courseId: string;
+    itemId: string;
+    attachmentId?: string | undefined;
+    addOnToken?: string | undefined;
+}, any>;
+//# sourceMappingURL=materials-addons.d.ts.map

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

@@ -0,0 +1,45 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { classroomRequest, googleClassroomTokenField } from './client.js';
+export const listCourseWorkMaterialAddOnAttachments = tool({
+    description: 'Lists add-on attachments on a coursework material created by the add-on.',
+    inputSchema: z.object({
+        googleClassroomToken: googleClassroomTokenField,
+        courseId: z.string(),
+        itemId: z.string().describe('Coursework material ID'),
+    }),
+    execute: async ({ googleClassroomToken, courseId, itemId }) => {
+        try {
+            const result = await classroomRequest(googleClassroomToken, `/courses/${courseId}/courseWorkMaterials/${itemId}/addOnAttachments`);
+            if (!result.ok)
+                return { error: 'Failed to list material add-on attachments', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error listing material add-on attachments', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const getCourseWorkMaterialAddOnContext = tool({
+    description: 'Gets add-on iframe metadata for a coursework material: role context, submission ID, grade support.',
+    inputSchema: z.object({
+        googleClassroomToken: googleClassroomTokenField,
+        courseId: z.string(),
+        itemId: z.string().describe('Coursework material 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}/courseWorkMaterials/${itemId}/addOnContext`, { query: { addOnToken, attachmentId } });
+            if (!result.ok)
+                return { error: 'Failed to get material add-on context', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error getting material add-on context', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+//# sourceMappingURL=materials-addons.js.map

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

@@ -0,0 +1,44 @@
+export declare const createCourseWorkMaterial: import("ai").Tool<{
+    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;
+    topicId?: string | undefined;
+    associatedWithDeveloper?: boolean | undefined;
+}, any>;
+export declare const getCourseWorkMaterial: import("ai").Tool<{
+    id: string;
+    googleClassroomToken: string;
+    courseId: string;
+}, any>;
+export declare const listCourseWorkMaterials: import("ai").Tool<{
+    googleClassroomToken: string;
+    courseId: string;
+    pageToken?: string | undefined;
+    pageSize?: number | undefined;
+    orderBy?: "updateTime asc" | "updateTime desc" | undefined;
+}, any>;
+export declare const deleteCourseWorkMaterial: import("ai").Tool<{
+    id: string;
+    googleClassroomToken: string;
+    courseId: string;
+}, any>;
+export declare const patchCourseWorkMaterial: import("ai").Tool<{
+    id: string;
+    updateMask: string;
+    googleClassroomToken: string;
+    courseId: string;
+    description?: string | undefined;
+    title?: string | undefined;
+    state?: "DRAFT" | "PUBLISHED" | "DELETED" | undefined;
+    scheduledTime?: string | undefined;
+    topicId?: string | undefined;
+}, any>;
+//# sourceMappingURL=materials.d.ts.map

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

@@ -0,0 +1,132 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { classroomRequest, googleClassroomTokenField } from './client.js';
+const materialSchema = z.record(z.any()).describe('Material with exactly one of driveFile, link, form, youtubeVideo');
+export const createCourseWorkMaterial = tool({
+    description: 'Creates a coursework material (resources/notes) in a course, published, drafted, or scheduled.',
+    inputSchema: z.object({
+        googleClassroomToken: googleClassroomTokenField,
+        courseId: z.string(),
+        title: z.string().optional(),
+        description: z.string().optional(),
+        materials: z.array(materialSchema).optional(),
+        state: z.enum(['DRAFT', 'PUBLISHED', 'DELETED']).optional(),
+        scheduledTime: z.string().optional().describe('RFC3339 publish time'),
+        topicId: z.string().optional(),
+        assigneeMode: z.enum(['ALL_STUDENTS', 'INDIVIDUAL_STUDENTS']).optional(),
+        individualStudentsOptions: z.object({ studentIds: z.array(z.string()) }).optional(),
+        associatedWithDeveloper: z.boolean().optional(),
+    }),
+    execute: async ({ googleClassroomToken, courseId, ...body }) => {
+        try {
+            const result = await classroomRequest(googleClassroomToken, `/courses/${courseId}/courseWorkMaterials`, {
+                method: 'POST',
+                body,
+            });
+            if (!result.ok)
+                return { error: 'Failed to create coursework material', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error creating coursework material', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const getCourseWorkMaterial = tool({
+    description: 'Gets a coursework material by course and material ID.',
+    inputSchema: z.object({
+        googleClassroomToken: googleClassroomTokenField,
+        courseId: z.string().describe('Course ID or alias'),
+        id: z.string().describe('Material ID'),
+    }),
+    execute: async ({ googleClassroomToken, courseId, id }) => {
+        try {
+            const result = await classroomRequest(googleClassroomToken, `/courses/${courseId}/courseWorkMaterials/${id}`);
+            if (!result.ok)
+                return { error: 'Failed to get coursework material', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error getting coursework material', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const listCourseWorkMaterials = tool({
+    description: 'Pages through coursework materials in a course, newest or oldest first.',
+    inputSchema: z.object({
+        googleClassroomToken: googleClassroomTokenField,
+        courseId: z.string(),
+        orderBy: z.enum(['updateTime asc', 'updateTime desc']).optional(),
+        pageSize: z.number().min(1).max(100).optional(),
+        pageToken: z.string().optional(),
+    }),
+    execute: async ({ googleClassroomToken, courseId, orderBy, pageSize, pageToken }) => {
+        try {
+            const result = await classroomRequest(googleClassroomToken, `/courses/${courseId}/courseWorkMaterials`, {
+                query: { orderBy, pageSize, pageToken },
+            });
+            if (!result.ok)
+                return { error: 'Failed to list coursework materials', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error listing coursework materials', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const deleteCourseWorkMaterial = tool({
+    description: 'Deletes a coursework material. Confirm course and material IDs first.',
+    inputSchema: z.object({
+        googleClassroomToken: googleClassroomTokenField,
+        courseId: z.string().describe('Course ID or alias'),
+        id: z.string().describe('Material ID to delete'),
+    }),
+    execute: async ({ googleClassroomToken, courseId, id }) => {
+        try {
+            const result = await classroomRequest(googleClassroomToken, `/courses/${courseId}/courseWorkMaterials/${id}`, {
+                method: 'DELETE',
+            });
+            if (!result.ok)
+                return { error: 'Failed to delete coursework material', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error deleting coursework material', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const patchCourseWorkMaterial = tool({
+    description: 'Updates a coursework material. Only fields in updateMask change (title, description, state, scheduledTime, topicId).',
+    inputSchema: z.object({
+        googleClassroomToken: googleClassroomTokenField,
+        courseId: z.string().describe('Course ID or alias'),
+        id: z.string().describe('Material ID to update'),
+        updateMask: z.string().describe("Fields to update, e.g. 'title,description'"),
+        title: z.string().max(3000).optional(),
+        description: z.string().max(30000).optional(),
+        state: z.enum(['DRAFT', 'PUBLISHED', 'DELETED']).optional(),
+        scheduledTime: z.string().optional(),
+        topicId: 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}/courseWorkMaterials/${id}`, {
+                method: 'PATCH',
+                query: { updateMask },
+                body,
+            });
+            if (!result.ok)
+                return { error: 'Failed to patch coursework material', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error patching coursework material', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+//# sourceMappingURL=materials.js.map

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

@@ -0,0 +1,20 @@
+export declare const createRegistration: import("ai").Tool<{
+    googleClassroomToken: string;
+    feed: {
+        feedType: "DOMAIN_ROSTER_CHANGES" | "COURSE_ROSTER_CHANGES" | "COURSE_WORK_CHANGES";
+        courseRosterChangesInfo?: {
+            courseId: string;
+        } | undefined;
+        courseWorkChangesInfo?: {
+            courseId: string;
+        } | undefined;
+    };
+    cloudPubsubTopic: {
+        topicName: string;
+    };
+}, any>;
+export declare const getUserProfile: import("ai").Tool<{
+    googleClassroomToken: string;
+    userId: string;
+}, any>;
+//# sourceMappingURL=misc.d.ts.map

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

@@ -0,0 +1,51 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { classroomRequest, googleClassroomTokenField } from './client.js';
+export const createRegistration = tool({
+    description: 'Subscribes a Cloud Pub/Sub topic to Classroom push notifications (roster or coursework changes). Requires push-notifications scope.',
+    inputSchema: z.object({
+        googleClassroomToken: googleClassroomTokenField,
+        feed: z.object({
+            feedType: z.enum(['DOMAIN_ROSTER_CHANGES', 'COURSE_ROSTER_CHANGES', 'COURSE_WORK_CHANGES']),
+            courseRosterChangesInfo: z.object({ courseId: z.string() }).optional().describe('Required for COURSE_ROSTER_CHANGES'),
+            courseWorkChangesInfo: z.object({ courseId: z.string() }).optional().describe('Required for COURSE_WORK_CHANGES'),
+        }),
+        cloudPubsubTopic: z.object({
+            topicName: z.string().describe("Topic 'projects/{project}/topics/{topic}' (Classroom needs publish rights)"),
+        }),
+    }),
+    execute: async ({ googleClassroomToken, feed, cloudPubsubTopic }) => {
+        try {
+            const result = await classroomRequest(googleClassroomToken, '/registrations', {
+                method: 'POST',
+                body: { feed, cloudPubsubTopic },
+            });
+            if (!result.ok)
+                return { error: 'Failed to create registration', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error creating registration', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const getUserProfile = tool({
+    description: 'Gets a user profile (name, email, photo, permissions) by ID, email, or me.',
+    inputSchema: z.object({
+        googleClassroomToken: googleClassroomTokenField,
+        userId: z.string().describe("User ID, email, or 'me'"),
+    }),
+    execute: async ({ googleClassroomToken, userId }) => {
+        try {
+            const result = await classroomRequest(googleClassroomToken, `/userProfiles/${userId}`);
+            if (!result.ok)
+                return { error: 'Failed to get user profile', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error getting user profile', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+//# sourceMappingURL=misc.js.map

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

@@ -0,0 +1,17 @@
+export declare const listPostAddOnAttachments: import("ai").Tool<{
+    googleClassroomToken: string;
+    courseId: string;
+    postId: string;
+    pageToken?: string | undefined;
+    pageSize?: number | undefined;
+    itemId?: string | undefined;
+}, any>;
+export declare const getPostAddOnContext: import("ai").Tool<{
+    googleClassroomToken: string;
+    courseId: string;
+    itemId: string;
+    postId: string;
+    attachmentId?: string | undefined;
+    addOnToken?: string | undefined;
+}, any>;
+//# sourceMappingURL=posts-addons.d.ts.map

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

@@ -0,0 +1,49 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { classroomRequest, googleClassroomTokenField } from './client.js';
+export const listPostAddOnAttachments = tool({
+    description: 'Lists add-on attachments on a post (announcement, coursework, or material). The add-on needs active attachments or create permission.',
+    inputSchema: z.object({
+        googleClassroomToken: googleClassroomTokenField,
+        courseId: z.string(),
+        postId: z.string().describe('Post ID under the course'),
+        itemId: z.string().optional().describe('Item ID enumerating attachments for (optional query param)'),
+        pageSize: z.number().min(1).max(20).optional(),
+        pageToken: z.string().optional(),
+    }),
+    execute: async ({ googleClassroomToken, courseId, postId, itemId, pageSize, pageToken }) => {
+        try {
+            const result = await classroomRequest(googleClassroomToken, `/courses/${courseId}/posts/${postId}/addOnAttachments`, { query: { itemId, pageSize, pageToken } });
+            if (!result.ok)
+                return { error: 'Failed to list post add-on attachments', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error listing post add-on attachments', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const getPostAddOnContext = tool({
+    description: 'Gets add-on iframe metadata for a post: user role (exactly one of student/teacher context), submission ID, grade support.',
+    inputSchema: z.object({
+        googleClassroomToken: googleClassroomTokenField,
+        courseId: z.string(),
+        postId: z.string().describe('Post ID (path, deprecated but required)'),
+        itemId: z.string().describe('Item 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, postId, itemId, addOnToken, attachmentId }) => {
+        try {
+            const result = await classroomRequest(googleClassroomToken, `/courses/${courseId}/posts/${postId}/addOnContext`, { query: { itemId, addOnToken, attachmentId } });
+            if (!result.ok)
+                return { error: 'Failed to get post add-on context', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error getting post add-on context', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+//# sourceMappingURL=posts-addons.js.map

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

@@ -0,0 +1,48 @@
+export declare const addStudentToCourse: import("ai").Tool<{
+    googleClassroomToken: string;
+    courseId: string;
+    userId: string;
+    enrollmentCode?: string | undefined;
+}, any>;
+export declare const deleteCourseStudent: import("ai").Tool<{
+    googleClassroomToken: string;
+    courseId: string;
+    userId: string;
+}, any>;
+export declare const getCourseStudent: import("ai").Tool<{
+    googleClassroomToken: string;
+    courseId: string;
+    userId: string;
+}, any>;
+export declare const listCourseStudents: import("ai").Tool<{
+    googleClassroomToken: string;
+    courseId: string;
+    pageToken?: string | undefined;
+    pageSize?: number | undefined;
+}, any>;
+export declare const listStudentGuardians: import("ai").Tool<{
+    googleClassroomToken: string;
+    studentId: string;
+    courseId: string;
+    pageToken?: string | undefined;
+    pageSize?: number | undefined;
+}, any>;
+export declare const deleteCourseTeacher: import("ai").Tool<{
+    googleClassroomToken: string;
+    courseId: string;
+    userId: string;
+}, any>;
+export declare const getTeacher: import("ai").Tool<{
+    googleClassroomToken: string;
+    courseId: string;
+    userId: string;
+    fields?: string | undefined;
+    quotaUser?: string | undefined;
+}, any>;
+export declare const listCourseTeachers: import("ai").Tool<{
+    googleClassroomToken: string;
+    courseId: string;
+    pageToken?: string | undefined;
+    pageSize?: number | undefined;
+}, any>;
+//# sourceMappingURL=roster.d.ts.map