@rnsk/toolkits 0.0.7 → 0.0.9

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

@@ -0,0 +1,70 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { classroomRequest, googleClassroomTokenField } from './client.js';
+export const createCourseAlias = tool({
+    description: 'Adds an alternative identifier to a course. d: aliases need domain admin; p: aliases any project user.',
+    inputSchema: z.object({
+        googleClassroomToken: googleClassroomTokenField,
+        courseId: z.string().describe('Course ID or existing alias'),
+        alias: z.string().max(256).describe("Alias to create, e.g. 'p:history301' or 'd:school_math'"),
+    }),
+    execute: async ({ googleClassroomToken, courseId, alias }) => {
+        try {
+            const result = await classroomRequest(googleClassroomToken, `/courses/${courseId}/aliases`, {
+                method: 'POST',
+                body: { alias },
+            });
+            if (!result.ok)
+                return { error: 'Failed to create course alias', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error creating course alias', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const deleteCourseAlias = tool({
+    description: 'Removes an alias from a course. Confirm course ID and alias name first.',
+    inputSchema: z.object({
+        googleClassroomToken: googleClassroomTokenField,
+        courseId: z.string().describe('Course ID or alias'),
+        alias: z.string().describe('Alias to delete (not the Classroom-assigned ID)'),
+    }),
+    execute: async ({ googleClassroomToken, courseId, alias }) => {
+        try {
+            const result = await classroomRequest(googleClassroomToken, `/courses/${courseId}/aliases/${alias}`, {
+                method: 'DELETE',
+            });
+            if (!result.ok)
+                return { error: 'Failed to delete course alias', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error deleting course alias', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const listCourseAliases = tool({
+    description: 'Lists all aliases for a course with pagination.',
+    inputSchema: z.object({
+        googleClassroomToken: googleClassroomTokenField,
+        courseId: z.string().describe('Course ID or alias'),
+        pageSize: z.number().optional(),
+        pageToken: z.string().optional(),
+    }),
+    execute: async ({ googleClassroomToken, courseId, pageSize, pageToken }) => {
+        try {
+            const result = await classroomRequest(googleClassroomToken, `/courses/${courseId}/aliases`, {
+                query: { pageSize, pageToken },
+            });
+            if (!result.ok)
+                return { error: 'Failed to list course aliases', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error listing course aliases', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+//# sourceMappingURL=aliases.js.map

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

@@ -0,0 +1,27 @@
+export declare const getAnnouncementAddOnContext: import("ai").Tool<{
+    googleClassroomToken: string;
+    courseId: string;
+    itemId: string;
+    attachmentId?: string | undefined;
+    addOnToken?: string | undefined;
+}, any>;
+export declare const deleteAnnouncementAddOnAttachment: import("ai").Tool<{
+    attachmentId: string;
+    googleClassroomToken: string;
+    courseId: string;
+    itemId: string;
+}, any>;
+export declare const getAnnouncementAddOnAttachment: import("ai").Tool<{
+    attachmentId: string;
+    googleClassroomToken: string;
+    courseId: string;
+    itemId: string;
+}, any>;
+export declare const listAnnouncementAddOnAttachments: import("ai").Tool<{
+    googleClassroomToken: string;
+    courseId: string;
+    itemId: string;
+    pageToken?: string | undefined;
+    pageSize?: number | undefined;
+}, any>;
+//# sourceMappingURL=announcement-addons.d.ts.map

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

@@ -0,0 +1,87 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { classroomRequest, googleClassroomTokenField } from './client.js';
+export const getAnnouncementAddOnContext = tool({
+    description: 'Gets add-on iframe metadata for an announcement: user role (student/teacher), submission ID, grade support.',
+    inputSchema: z.object({
+        googleClassroomToken: googleClassroomTokenField,
+        courseId: z.string(),
+        itemId: z.string().describe('Announcement ID with the attached add-on'),
+        addOnToken: z.string().optional().describe('Required unless the add-on has attachments or created the post'),
+        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}/announcements/${itemId}/addOnContext`, { query: { addOnToken, attachmentId } });
+            if (!result.ok)
+                return { error: 'Failed to get announcement add-on context', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error getting announcement add-on context', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const deleteAnnouncementAddOnAttachment = tool({
+    description: 'Deletes an add-on attachment from an announcement. The add-on must have created it.',
+    inputSchema: z.object({
+        googleClassroomToken: googleClassroomTokenField,
+        courseId: z.string(),
+        itemId: z.string().describe('Announcement ID'),
+        attachmentId: z.string().describe('Attachment ID to delete'),
+    }),
+    execute: async ({ googleClassroomToken, courseId, itemId, attachmentId }) => {
+        try {
+            const result = await classroomRequest(googleClassroomToken, `/courses/${courseId}/announcements/${itemId}/addOnAttachments/${attachmentId}`, { method: 'DELETE' });
+            if (!result.ok)
+                return { error: 'Failed to delete announcement add-on attachment', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error deleting announcement add-on attachment', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const getAnnouncementAddOnAttachment = tool({
+    description: 'Gets an add-on attachment from an announcement. The requesting add-on must have created it.',
+    inputSchema: z.object({
+        googleClassroomToken: googleClassroomTokenField,
+        courseId: z.string(),
+        itemId: z.string().describe('Announcement ID'),
+        attachmentId: z.string().describe('Attachment ID'),
+    }),
+    execute: async ({ googleClassroomToken, courseId, itemId, attachmentId }) => {
+        try {
+            const result = await classroomRequest(googleClassroomToken, `/courses/${courseId}/announcements/${itemId}/addOnAttachments/${attachmentId}`);
+            if (!result.ok)
+                return { error: 'Failed to get announcement add-on attachment', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error getting announcement add-on attachment', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const listAnnouncementAddOnAttachments = tool({
+    description: 'Lists add-on attachments under an announcement. The add-on needs active attachments or create permission.',
+    inputSchema: z.object({
+        googleClassroomToken: googleClassroomTokenField,
+        courseId: z.string(),
+        itemId: z.string().describe('Announcement ID'),
+        pageSize: z.number().min(1).max(20).optional(),
+        pageToken: z.string().optional(),
+    }),
+    execute: async ({ googleClassroomToken, courseId, itemId, pageSize, pageToken }) => {
+        try {
+            const result = await classroomRequest(googleClassroomToken, `/courses/${courseId}/announcements/${itemId}/addOnAttachments`, { query: { pageSize, pageToken } });
+            if (!result.ok)
+                return { error: 'Failed to list announcement add-on attachments', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error listing announcement add-on attachments', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+//# sourceMappingURL=announcement-addons.js.map

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

@@ -0,0 +1,54 @@
+export declare const createAnnouncement: import("ai").Tool<{
+    googleClassroomToken: string;
+    courseId: string;
+    state?: "DRAFT" | "PUBLISHED" | "DELETED" | undefined;
+    text?: string | undefined;
+    materials?: Record<string, any>[] | undefined;
+    scheduledTime?: string | undefined;
+    assigneeMode?: "ALL_STUDENTS" | "INDIVIDUAL_STUDENTS" | undefined;
+    individualStudentsOptions?: {
+        studentIds: string[];
+    } | undefined;
+}, any>;
+export declare const deleteAnnouncement: import("ai").Tool<{
+    id: string;
+    googleClassroomToken: string;
+    courseId: string;
+}, any>;
+export declare const getAnnouncement: import("ai").Tool<{
+    id: string;
+    googleClassroomToken: string;
+    courseId: string;
+}, any>;
+export declare const listAnnouncements: import("ai").Tool<{
+    googleClassroomToken: string;
+    courseId: string;
+    pageToken?: string | undefined;
+    pageSize?: number | undefined;
+    orderBy?: "updateTime asc" | "updateTime desc" | undefined;
+}, any>;
+export declare const modifyAnnouncementAssignees: 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 patchAnnouncement: import("ai").Tool<{
+    id: string;
+    updateMask: string;
+    googleClassroomToken: string;
+    courseId: string;
+    state?: "DRAFT" | "PUBLISHED" | "DELETED" | undefined;
+    text?: string | undefined;
+    materials?: Record<string, any>[] | undefined;
+    scheduledTime?: string | undefined;
+    assigneeMode?: "ALL_STUDENTS" | "INDIVIDUAL_STUDENTS" | undefined;
+    individualStudentsOptions?: {
+        studentIds: string[];
+    } | undefined;
+}, any>;
+//# sourceMappingURL=announcements.d.ts.map

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