@rnsk/toolkits 0.0.7 → 0.0.9

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

@@ -0,0 +1,180 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { classroomRequest, googleClassroomTokenField } from './client.js';
+export const addStudentToCourse = tool({
+    description: 'Enrolls a user as a student. Admins enroll directly; others need the enrollment code.',
+    inputSchema: z.object({
+        googleClassroomToken: googleClassroomTokenField,
+        courseId: z.string().describe('Course ID or alias'),
+        userId: z.string().describe("User ID, email, or 'me'"),
+        enrollmentCode: z.string().optional().describe('Required for self-enrollment'),
+    }),
+    execute: async ({ googleClassroomToken, courseId, userId, enrollmentCode }) => {
+        try {
+            const body = { userId };
+            if (enrollmentCode)
+                body.enrollmentCode = enrollmentCode;
+            const result = await classroomRequest(googleClassroomToken, `/courses/${courseId}/students`, {
+                method: 'POST',
+                body,
+            });
+            if (!result.ok)
+                return { error: 'Failed to add student', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error adding student', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const deleteCourseStudent = tool({
+    description: 'Removes a student enrollment, revoking access to materials and participation.',
+    inputSchema: z.object({
+        googleClassroomToken: googleClassroomTokenField,
+        courseId: z.string().describe('Course ID or alias'),
+        userId: z.string().describe("Student ID, email, or 'me'"),
+    }),
+    execute: async ({ googleClassroomToken, courseId, userId }) => {
+        try {
+            const result = await classroomRequest(googleClassroomToken, `/courses/${courseId}/students/${userId}`, {
+                method: 'DELETE',
+            });
+            if (!result.ok)
+                return { error: 'Failed to delete student', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error deleting student', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const getCourseStudent = tool({
+    description: 'Gets a student enrollment with profile and Drive folder details.',
+    inputSchema: z.object({
+        googleClassroomToken: googleClassroomTokenField,
+        courseId: z.string().describe('Course ID or alias'),
+        userId: z.string().describe("Student ID, email, or 'me'"),
+    }),
+    execute: async ({ googleClassroomToken, courseId, userId }) => {
+        try {
+            const result = await classroomRequest(googleClassroomToken, `/courses/${courseId}/students/${userId}`);
+            if (!result.ok)
+                return { error: 'Failed to get student', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error getting student', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const listCourseStudents = tool({
+    description: 'Pages through enrolled students in a course.',
+    inputSchema: z.object({
+        googleClassroomToken: googleClassroomTokenField,
+        courseId: z.string().describe('Course ID or alias'),
+        pageSize: z.number().min(1).max(100).optional(),
+        pageToken: z.string().optional(),
+    }),
+    execute: async ({ googleClassroomToken, courseId, pageSize, pageToken }) => {
+        try {
+            const result = await classroomRequest(googleClassroomToken, `/courses/${courseId}/students`, {
+                query: { pageSize, pageToken },
+            });
+            if (!result.ok)
+                return { error: 'Failed to list students', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error listing students', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const listStudentGuardians = tool({
+    description: 'Lists guardians linked to a student in a course, with pagination.',
+    inputSchema: z.object({
+        googleClassroomToken: googleClassroomTokenField,
+        courseId: z.string().describe('Course ID or alias'),
+        studentId: z.string().describe("Student ID, email, or 'me'"),
+        pageSize: z.number().min(1).max(100).optional(),
+        pageToken: z.string().optional(),
+    }),
+    execute: async ({ googleClassroomToken, courseId, studentId, pageSize, pageToken }) => {
+        try {
+            const result = await classroomRequest(googleClassroomToken, `/courses/${courseId}/students/${studentId}/guardians`, { query: { pageSize, pageToken } });
+            if (!result.ok)
+                return { error: 'Failed to list student guardians', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error listing student guardians', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const deleteCourseTeacher = tool({
+    description: 'Removes a teacher enrollment, revoking teaching access. The course owner cannot be removed this way.',
+    inputSchema: z.object({
+        googleClassroomToken: googleClassroomTokenField,
+        courseId: z.string().describe('Course ID or alias'),
+        userId: z.string().describe("Teacher ID, email, or 'me'"),
+    }),
+    execute: async ({ googleClassroomToken, courseId, userId }) => {
+        try {
+            const result = await classroomRequest(googleClassroomToken, `/courses/${courseId}/teachers/${userId}`, {
+                method: 'DELETE',
+            });
+            if (!result.ok)
+                return { error: 'Failed to delete teacher', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error deleting teacher', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const getTeacher = tool({
+    description: 'Gets a teacher enrollment with profile details.',
+    inputSchema: z.object({
+        googleClassroomToken: googleClassroomTokenField,
+        courseId: z.string().describe('Course ID or alias'),
+        userId: z.string().describe('Teacher ID or email'),
+        fields: z.string().optional().describe('Partial-response field selector'),
+        quotaUser: z.string().optional().describe('Quota attribution string (server-side apps)'),
+    }),
+    execute: async ({ googleClassroomToken, courseId, userId, fields, quotaUser }) => {
+        try {
+            const result = await classroomRequest(googleClassroomToken, `/courses/${courseId}/teachers/${userId}`, {
+                query: { fields, quotaUser },
+            });
+            if (!result.ok)
+                return { error: 'Failed to get teacher', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error getting teacher', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const listCourseTeachers = tool({
+    description: 'Pages through enrolled teachers in a course.',
+    inputSchema: z.object({
+        googleClassroomToken: googleClassroomTokenField,
+        courseId: z.string(),
+        pageSize: z.number().min(1).max(100).optional(),
+        pageToken: z.string().optional(),
+    }),
+    execute: async ({ googleClassroomToken, courseId, pageSize, pageToken }) => {
+        try {
+            const result = await classroomRequest(googleClassroomToken, `/courses/${courseId}/teachers`, {
+                query: { pageSize, pageToken },
+            });
+            if (!result.ok)
+                return { error: 'Failed to list teachers', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error listing teachers', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+//# sourceMappingURL=roster.js.map

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

@@ -0,0 +1,29 @@
+export declare const createCourseTopic: import("ai").Tool<{
+    name: string;
+    googleClassroomToken: string;
+    courseId: string;
+}, any>;
+export declare const deleteCourseTopic: import("ai").Tool<{
+    id: string;
+    googleClassroomToken: string;
+    courseId: string;
+}, any>;
+export declare const getCourseTopic: import("ai").Tool<{
+    id: string;
+    googleClassroomToken: string;
+    courseId: string;
+}, any>;
+export declare const listCourseTopics: import("ai").Tool<{
+    googleClassroomToken: string;
+    courseId: string;
+    pageToken?: string | undefined;
+    pageSize?: number | undefined;
+}, any>;
+export declare const patchCourseTopic: import("ai").Tool<{
+    id: string;
+    googleClassroomToken: string;
+    courseId: string;
+    name?: string | undefined;
+    updateMask?: string | undefined;
+}, any>;
+//# sourceMappingURL=topics.d.ts.map

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

@@ -0,0 +1,117 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { classroomRequest, googleClassroomTokenField } from './client.js';
+export const createCourseTopic = tool({
+    description: 'Creates a named topic section to organize course content.',
+    inputSchema: z.object({
+        googleClassroomToken: googleClassroomTokenField,
+        courseId: z.string(),
+        name: z.string().describe('Topic name, e.g. Homework'),
+    }),
+    execute: async ({ googleClassroomToken, courseId, name }) => {
+        try {
+            const result = await classroomRequest(googleClassroomToken, `/courses/${courseId}/topics`, {
+                method: 'POST',
+                body: { name },
+            });
+            if (!result.ok)
+                return { error: 'Failed to create topic', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error creating topic', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const deleteCourseTopic = tool({
+    description: 'Deletes a topic. Confirm course and topic IDs first.',
+    inputSchema: z.object({
+        googleClassroomToken: googleClassroomTokenField,
+        courseId: z.string(),
+        id: z.string().describe('Topic ID to delete'),
+    }),
+    execute: async ({ googleClassroomToken, courseId, id }) => {
+        try {
+            const result = await classroomRequest(googleClassroomToken, `/courses/${courseId}/topics/${id}`, {
+                method: 'DELETE',
+            });
+            if (!result.ok)
+                return { error: 'Failed to delete topic', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error deleting topic', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const getCourseTopic = tool({
+    description: 'Gets a topic by course and topic ID.',
+    inputSchema: z.object({
+        googleClassroomToken: googleClassroomTokenField,
+        courseId: z.string().describe('Course ID or alias'),
+        id: z.string().describe('Topic ID'),
+    }),
+    execute: async ({ googleClassroomToken, courseId, id }) => {
+        try {
+            const result = await classroomRequest(googleClassroomToken, `/courses/${courseId}/topics/${id}`);
+            if (!result.ok)
+                return { error: 'Failed to get topic', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error getting topic', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const listCourseTopics = tool({
+    description: 'Lists topics 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}/topics`, {
+                query: { pageSize, pageToken },
+            });
+            if (!result.ok)
+                return { error: 'Failed to list topics', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error listing topics', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const patchCourseTopic = tool({
+    description: "Renames a topic. Currently only 'name' is updatable via updateMask.",
+    inputSchema: z.object({
+        googleClassroomToken: googleClassroomTokenField,
+        courseId: z.string(),
+        id: z.string().describe('Topic ID'),
+        name: z.string().optional().describe('New topic name'),
+        updateMask: z.string().optional().describe("Fields to update, e.g. 'name'"),
+    }),
+    execute: async ({ googleClassroomToken, courseId, id, name, updateMask }) => {
+        try {
+            const body = {};
+            if (name !== undefined)
+                body.name = name;
+            const result = await classroomRequest(googleClassroomToken, `/courses/${courseId}/topics/${id}`, {
+                method: 'PATCH',
+                query: { updateMask: updateMask ?? 'name' },
+                body,
+            });
+            if (!result.ok)
+                return { error: 'Failed to patch topic', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error patching topic', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+//# sourceMappingURL=topics.js.map

package/dist/toolkits/google-contacts/icon.d.ts

@@ -0,0 +1,5 @@
+export declare const GCONTACTS_ICON: {
+    kind: "svg";
+    dataUri: string;
+};
+//# sourceMappingURL=icon.d.ts.map

package/dist/toolkits/google-contacts/icon.js

@@ -0,0 +1,6 @@
+const SVG = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 500 500"><path fill="#86a9ff" d="M199 244c-89 0-161 71-161 160v67c0 16 13 29 29 29h77l77-256z"/><path fill="#578cff" d="M462 349c0-58-48-105-106-105h-77v256h77c58 0 106-47 106-106"/><path fill="#0057cc" d="M115 349c0-58 48-105 106-105h58c58 0 106 47 106 105v45c0 59-48 106-106 106H144c-16 0-29-13-29-29z"/><circle cx="250" cy="99.4" r="99.4" fill="#0057cc"/></svg>`;
+export const GCONTACTS_ICON = {
+    kind: 'svg',
+    dataUri: `data:image/svg+xml;base64,${Buffer.from(SVG).toString('base64')}`,
+};
+//# sourceMappingURL=icon.js.map

package/dist/toolkits/google-contacts/manifest.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("../../index.js").ToolkitManifest;
+export default _default;
+//# sourceMappingURL=manifest.d.ts.map

package/dist/toolkits/google-contacts/manifest.js

@@ -0,0 +1,48 @@
+import { defineToolkit, defineTool } from '../../core/define.js';
+import { inferToolScope } from '../../core/scope.js';
+import { GCONTACTS_ICON } from './icon.js';
+import { googleContactsTools } from './tools/index.js';
+export default defineToolkit({
+    id: 'google-contacts',
+    displayName: 'Google Contacts',
+    shortDescription: 'Create, search, and manage Google Contacts people, groups, and directory profiles.',
+    category: 'CRM',
+    icon: GCONTACTS_ICON,
+    auth: {
+        type: 'oauth2',
+        tokenField: 'googleContactsToken',
+        provider: {
+            slug: 'google-contacts',
+            env: { clientId: 'GOOGLE_CONTACTS_CLIENT_ID', clientSecret: 'GOOGLE_CONTACTS_CLIENT_SECRET' },
+            authorizeUrl: 'https://accounts.google.com/o/oauth2/v2/auth',
+            tokenUrl: 'https://oauth2.googleapis.com/token',
+            scopes: [
+                'https://www.googleapis.com/auth/contacts',
+                'https://www.googleapis.com/auth/contacts.readonly',
+                'https://www.googleapis.com/auth/contacts.other.readonly',
+                'https://www.googleapis.com/auth/directory.readonly',
+                'https://www.googleapis.com/auth/userinfo.email',
+                'https://www.googleapis.com/auth/userinfo.profile',
+            ],
+            exchangeStyle: 'form',
+            extraAuthParams: { access_type: 'offline', prompt: 'consent' },
+            connectDescription: 'Connect Google Contacts to manage people, groups, and directory profiles.',
+            callbackPath: '/api/auth/google-contacts/callback',
+            stateCookie: 'google_contacts_oauth_state',
+        },
+    },
+    allowedHosts: ['people.googleapis.com'],
+    tools: googleContactsTools.map((entry) => defineTool({
+        name: entry.name,
+        description: entry.description,
+        tool: entry.tool,
+        requiredAuth: entry.requiredAuth,
+        scope: entry.scope ?? inferToolScope(entry.name),
+    })),
+    meta: {
+        since: '0.0.8',
+        homepage: 'https://contacts.google.com',
+        docsUrl: 'https://developers.google.com/people',
+    },
+});
+//# sourceMappingURL=manifest.js.map

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

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+export declare const PEOPLE_API_BASE = "https://people.googleapis.com/v1";
+export declare const googleContactsTokenField: z.ZodString;
+export declare function buildQuery(params: Record<string, string | number | boolean | string[] | undefined>): string;
+export declare function peopleRequest(googleContactsToken: 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;
+}>;
+export declare function normalizeGroupId(id: string): string;
+//# sourceMappingURL=client.d.ts.map

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

@@ -0,0 +1,44 @@
+// @ts-nocheck
+import { z } from 'zod';
+export const PEOPLE_API_BASE = 'https://people.googleapis.com/v1';
+export const googleContactsTokenField = z.string().describe('Google Contacts (People API) 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 peopleRequest(googleContactsToken, path, options) {
+    const url = `${PEOPLE_API_BASE}${path}${buildQuery(options?.query ?? {})}`;
+    const response = await fetch(url, {
+        method: options?.method ?? 'GET',
+        headers: {
+            Authorization: `Bearer ${googleContactsToken}`,
+            ...(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 };
+}
+export function normalizeGroupId(id) {
+    return id.startsWith('contactGroups/') ? id : `contactGroups/${id}`;
+}
+//# sourceMappingURL=client.js.map

package/dist/toolkits/google-contacts/tools/contacts.d.ts

@@ -0,0 +1,94 @@
+export declare const createContact: import("ai").Tool<{
+    personFields: string;
+    googleContactsToken: string;
+    sources?: string[] | undefined;
+    person?: Record<string, any> | undefined;
+    names?: Record<string, any>[] | undefined;
+    emailAddresses?: Record<string, any>[] | undefined;
+    phoneNumbers?: Record<string, any>[] | undefined;
+}, any>;
+export declare const batchCreateContacts: import("ai").Tool<{
+    readMask: string;
+    googleContactsToken: string;
+    contacts: Record<string, any>[];
+    sources?: string[] | undefined;
+}, any>;
+export declare const updateContact: import("ai").Tool<{
+    resourceName: string;
+    googleContactsToken: string;
+    person: Record<string, any>;
+    updatePersonFields: string;
+    personFields?: string | undefined;
+    sources?: string[] | undefined;
+}, any>;
+export declare const batchUpdateContacts: import("ai").Tool<{
+    readMask: string;
+    googleContactsToken: string;
+    contacts: Record<string, any>;
+    updateMask: string;
+    sources?: string[] | undefined;
+}, any>;
+export declare const deleteContact: import("ai").Tool<{
+    resourceName: string;
+    googleContactsToken: string;
+}, any>;
+export declare const batchDeleteContacts: import("ai").Tool<{
+    googleContactsToken: string;
+    resourceNames: string[];
+}, {
+    error: string;
+    details: any;
+    success?: undefined;
+    deletedCount?: undefined;
+    message?: undefined;
+} | {
+    success: boolean;
+    deletedCount: number;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    success?: undefined;
+    deletedCount?: undefined;
+}>;
+export declare const getPerson: import("ai").Tool<{
+    resourceName: string;
+    personFields: string;
+    googleContactsToken: string;
+    sources?: string[] | undefined;
+    requestMaskIncludeField?: string | undefined;
+}, any>;
+export declare const batchGetPeople: import("ai").Tool<{
+    personFields: string;
+    googleContactsToken: string;
+    resourceNames: string[];
+    sources?: string[] | undefined;
+}, any>;
+export declare const listConnections: import("ai").Tool<{
+    googleContactsToken: string;
+    pageToken?: string | undefined;
+    personFields?: string | undefined;
+    pageSize?: number | undefined;
+    personId?: string | undefined;
+    syncToken?: string | undefined;
+    requestSyncToken?: boolean | undefined;
+    sortOrder?: "LAST_MODIFIED_ASCENDING" | "LAST_MODIFIED_DESCENDING" | "FIRST_NAME_ASCENDING" | "LAST_NAME_ASCENDING" | undefined;
+}, any>;
+export declare const searchContacts: import("ai").Tool<{
+    query: string;
+    googleContactsToken: string;
+    readMask?: string | undefined;
+    sources?: ("CONTACT" | "PROFILE")[] | undefined;
+    pageSize?: number | undefined;
+}, any>;
+export declare const copyOtherContactToMyContacts: import("ai").Tool<{
+    googleContactsToken: string;
+    otherContactsId: string;
+    copyMask: ("names" | "emailAddresses" | "phoneNumbers")[];
+    readMask?: string | undefined;
+    sources?: string[] | undefined;
+}, any>;
+//# sourceMappingURL=contacts.d.ts.map