@rnsk/toolkits 0.0.7 → 0.0.8

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

@@ -0,0 +1,158 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { classroomRequest, googleClassroomTokenField } from './client.js';
+const assigneeMode = z.enum(['ALL_STUDENTS', 'INDIVIDUAL_STUDENTS']);
+const materialSchema = z.record(z.any()).describe('Material with exactly one of driveFile, link, form, youtubeVideo');
+const individualStudentsOptions = z.object({
+    studentIds: z.array(z.string()).describe('Students who can see the item'),
+});
+export const createAnnouncement = tool({
+    description: 'Creates an announcement (draft, published, or scheduled) in a course.',
+    inputSchema: z.object({
+        googleClassroomToken: googleClassroomTokenField,
+        courseId: z.string().describe('Course ID or alias'),
+        text: z.string().optional().describe('Announcement text'),
+        materials: z.array(materialSchema).optional(),
+        state: z.enum(['DRAFT', 'PUBLISHED', 'DELETED']).optional().describe('Defaults to PUBLISHED'),
+        scheduledTime: z.string().optional().describe('RFC3339 publish time'),
+        assigneeMode: assigneeMode.optional(),
+        individualStudentsOptions: individualStudentsOptions.optional(),
+    }),
+    execute: async ({ googleClassroomToken, courseId, ...body }) => {
+        try {
+            const result = await classroomRequest(googleClassroomToken, `/courses/${courseId}/announcements`, {
+                method: 'POST',
+                body,
+            });
+            if (!result.ok)
+                return { error: 'Failed to create announcement', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error creating announcement', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const deleteAnnouncement = tool({
+    description: 'Deletes an announcement. Confirm the announcement ID first.',
+    inputSchema: z.object({
+        googleClassroomToken: googleClassroomTokenField,
+        courseId: z.string(),
+        id: z.string().describe('Announcement ID to delete'),
+    }),
+    execute: async ({ googleClassroomToken, courseId, id }) => {
+        try {
+            const result = await classroomRequest(googleClassroomToken, `/courses/${courseId}/announcements/${id}`, {
+                method: 'DELETE',
+            });
+            if (!result.ok)
+                return { error: 'Failed to delete announcement', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error deleting announcement', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const getAnnouncement = tool({
+    description: 'Fetches an announcement by course and announcement ID.',
+    inputSchema: z.object({
+        googleClassroomToken: googleClassroomTokenField,
+        courseId: z.string().describe('Course ID or alias'),
+        id: z.string().describe('Announcement ID'),
+    }),
+    execute: async ({ googleClassroomToken, courseId, id }) => {
+        try {
+            const result = await classroomRequest(googleClassroomToken, `/courses/${courseId}/announcements/${id}`);
+            if (!result.ok)
+                return { error: 'Failed to get announcement', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error getting announcement', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const listAnnouncements = tool({
+    description: 'Pages through announcements in a course, newest or oldest first.',
+    inputSchema: z.object({
+        googleClassroomToken: googleClassroomTokenField,
+        courseId: z.string().describe('Course ID or alias'),
+        orderBy: z.enum(['updateTime asc', 'updateTime desc']).optional().describe('Sort order (default updateTime desc)'),
+        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}/announcements`, {
+                query: { orderBy, pageSize, pageToken },
+            });
+            if (!result.ok)
+                return { error: 'Failed to list announcements', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error listing announcements', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const modifyAnnouncementAssignees = tool({
+    description: 'Changes who can view an announcement: all students or add/remove individual students.',
+    inputSchema: z.object({
+        googleClassroomToken: googleClassroomTokenField,
+        courseId: z.string().describe('Course ID or alias'),
+        id: z.string().describe('Announcement ID'),
+        assigneeMode: assigneeMode,
+        modifyIndividualStudentsOptions: z.object({
+            addStudentIds: z.array(z.string()).optional(),
+            removeStudentIds: z.array(z.string()).optional(),
+        }).optional().describe('Student changes for INDIVIDUAL_STUDENTS mode'),
+    }),
+    execute: async ({ googleClassroomToken, courseId, id, ...body }) => {
+        try {
+            const result = await classroomRequest(googleClassroomToken, `/courses/${courseId}/announcements/${id}:modifyAssignees`, { method: 'POST', body });
+            if (!result.ok)
+                return { error: 'Failed to modify announcement assignees', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error modifying announcement assignees', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const patchAnnouncement = tool({
+    description: 'Updates announcement fields. Only fields in updateMask change (e.g. text,scheduledTime).',
+    inputSchema: z.object({
+        googleClassroomToken: googleClassroomTokenField,
+        courseId: z.string(),
+        id: z.string().describe('Announcement ID to update'),
+        updateMask: z.string().describe("Fields to update, e.g. 'text,state'"),
+        text: z.string().optional(),
+        materials: z.array(materialSchema).optional(),
+        state: z.enum(['DRAFT', 'PUBLISHED', 'DELETED']).optional(),
+        scheduledTime: z.string().optional().describe('RFC3339 publish time'),
+        assigneeMode: assigneeMode.optional(),
+        individualStudentsOptions: individualStudentsOptions.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}/announcements/${id}`, {
+                method: 'PATCH',
+                query: { updateMask },
+                body,
+            });
+            if (!result.ok)
+                return { error: 'Failed to patch announcement', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error patching announcement', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+//# sourceMappingURL=announcements.js.map

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

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+export declare const CLASSROOM_API_BASE = "https://classroom.googleapis.com/v1";
+export declare const googleClassroomTokenField: z.ZodString;
+export declare function buildQuery(params: Record<string, string | number | boolean | string[] | undefined>): string;
+export declare function classroomRequest(googleClassroomToken: string, path: string, options?: {
+    method?: string;
+    query?: Record<string, string | number | boolean | string[] | undefined>;
+    body?: unknown;
+}): Promise<{
+    ok: false;
+    error: any;
+    data?: undefined;
+} | {
+    ok: true;
+    data: any;
+    error?: undefined;
+}>;
+//# sourceMappingURL=client.d.ts.map

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

@@ -0,0 +1,41 @@
+// @ts-nocheck
+import { z } from 'zod';
+export const CLASSROOM_API_BASE = 'https://classroom.googleapis.com/v1';
+export const googleClassroomTokenField = z.string().describe('Google Classroom OAuth access token (Bearer)');
+export function buildQuery(params) {
+    const search = new URLSearchParams();
+    for (const [key, value] of Object.entries(params)) {
+        if (value === undefined)
+            continue;
+        if (Array.isArray(value)) {
+            for (const v of value)
+                search.append(key, String(v));
+        }
+        else {
+            search.set(key, String(value));
+        }
+    }
+    const qs = search.toString();
+    return qs ? `?${qs}` : '';
+}
+export async function classroomRequest(googleClassroomToken, path, options) {
+    const url = `${CLASSROOM_API_BASE}${path}${buildQuery(options?.query ?? {})}`;
+    const response = await fetch(url, {
+        method: options?.method ?? 'GET',
+        headers: {
+            Authorization: `Bearer ${googleClassroomToken}`,
+            ...(options?.body !== undefined ? { 'Content-Type': 'application/json' } : {}),
+        },
+        body: options?.body !== undefined ? JSON.stringify(options.body) : undefined,
+    });
+    if (!response.ok) {
+        const details = await response.json().catch(() => ({}));
+        return { ok: false, error: details };
+    }
+    if (response.status === 204) {
+        return { ok: true, data: { success: true } };
+    }
+    const data = await response.json().catch(() => ({}));
+    return { ok: true, data };
+}
+//# sourceMappingURL=client.js.map

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

@@ -0,0 +1,60 @@
+export declare const createCourse: import("ai").Tool<{
+    name: string;
+    googleClassroomToken: string;
+    ownerId: string;
+    description?: string | undefined;
+    descriptionHeading?: string | undefined;
+    room?: string | undefined;
+    section?: string | undefined;
+    courseState?: "COURSE_STATE_UNSPECIFIED" | "ACTIVE" | "ARCHIVED" | "PROVISIONED" | "DECLINED" | undefined;
+}, any>;
+export declare const deleteCourse: import("ai").Tool<{
+    id: string;
+    googleClassroomToken: string;
+}, any>;
+export declare const getCourse: import("ai").Tool<{
+    id: string;
+    googleClassroomToken: string;
+}, any>;
+export declare const listCourses: import("ai").Tool<{
+    googleClassroomToken: string;
+    pageToken?: string | undefined;
+    pageSize?: number | undefined;
+    studentId?: string | undefined;
+    teacherId?: string | undefined;
+    courseStates?: ("COURSE_STATE_UNSPECIFIED" | "ACTIVE" | "ARCHIVED" | "PROVISIONED" | "DECLINED")[] | undefined;
+}, any>;
+export declare const patchCourse: import("ai").Tool<{
+    id: string;
+    updateMask: string;
+    googleClassroomToken: string;
+    description?: string | undefined;
+    name?: string | undefined;
+    ownerId?: string | undefined;
+    descriptionHeading?: string | undefined;
+    room?: string | undefined;
+    section?: string | undefined;
+    courseState?: "COURSE_STATE_UNSPECIFIED" | "ACTIVE" | "ARCHIVED" | "PROVISIONED" | "DECLINED" | undefined;
+}, any>;
+export declare const updateCourse: import("ai").Tool<{
+    id: string;
+    name: string;
+    googleClassroomToken: string;
+    ownerId: string;
+    description?: string | undefined;
+    descriptionHeading?: string | undefined;
+    room?: string | undefined;
+    section?: string | undefined;
+    courseState?: "COURSE_STATE_UNSPECIFIED" | "ACTIVE" | "ARCHIVED" | "PROVISIONED" | "DECLINED" | undefined;
+}, any>;
+export declare const getGradingPeriodSettings: import("ai").Tool<{
+    googleClassroomToken: string;
+    courseId: string;
+}, any>;
+export declare const listCourseStudentGroups: import("ai").Tool<{
+    googleClassroomToken: string;
+    courseId: string;
+    pageToken?: string | undefined;
+    pageSize?: number | undefined;
+}, any>;
+//# sourceMappingURL=courses.d.ts.map

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