@rnsk/toolkits 0.0.6 → 0.0.7

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

@@ -0,0 +1,44 @@
+import { defineToolkit, defineTool } from '../../core/define.js';
+import { GMEET_ICON } from './icon.js';
+import { googleMeetTools } from './tools/index.js';
+export default defineToolkit({
+    id: 'google-meet',
+    displayName: 'Google Meet',
+    shortDescription: 'Create and manage Google Meet spaces, conference records, participants, recordings, and transcripts.',
+    category: 'Scheduling & Booking',
+    icon: GMEET_ICON,
+    auth: {
+        type: 'oauth2',
+        tokenField: 'googleMeetToken',
+        provider: {
+            slug: 'googlemeet',
+            env: { clientId: 'GOOGLE_MEET_CLIENT_ID', clientSecret: 'GOOGLE_MEET_CLIENT_SECRET' },
+            authorizeUrl: 'https://accounts.google.com/o/oauth2/v2/auth',
+            tokenUrl: 'https://oauth2.googleapis.com/token',
+            scopes: [
+                'https://www.googleapis.com/auth/meetings.space.created',
+                'https://www.googleapis.com/auth/meetings.space.readonly',
+                'https://www.googleapis.com/auth/meetings.space.settings',
+            ],
+            exchangeStyle: 'form',
+            extraAuthParams: { access_type: 'offline', prompt: 'consent' },
+            connectDescription: 'Connect Google Meet to create meeting spaces, manage conferences, and access recordings and transcripts.',
+            callbackPath: '/api/auth/googlemeet/callback',
+            stateCookie: 'google_meet_oauth_state',
+        },
+    },
+    allowedHosts: ['meet.googleapis.com'],
+    tools: googleMeetTools.map((entry) => defineTool({
+        name: entry.name,
+        description: entry.description,
+        tool: entry.tool,
+        requiredAuth: entry.requiredAuth,
+        scope: entry.scope,
+    })),
+    meta: {
+        since: '0.0.8',
+        homepage: 'https://meet.google.com',
+        docsUrl: 'https://developers.google.com/meet/api/reference/rest/v2',
+    },
+});
+//# sourceMappingURL=manifest.js.map

package/dist/toolkits/google-meet/tools/create-meet.d.ts

@@ -0,0 +1,5 @@
+export declare const createMeet: import("ai").Tool<{
+    googleMeetToken: string;
+    config?: Record<string, unknown> | undefined;
+}, any>;
+//# sourceMappingURL=create-meet.d.ts.map

package/dist/toolkits/google-meet/tools/create-meet.js

@@ -0,0 +1,33 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { googleMeetRequest } from './utils.js';
+export const createMeet = tool({
+    description: 'Creates a new Google Meet space with optional configuration. Capture meetingUri, meetingCode, and space.name from the response for downstream lookups.',
+    inputSchema: z.object({
+        googleMeetToken: z.string().describe('The Google Meet access token'),
+        config: z
+            .record(z.unknown())
+            .optional()
+            .describe('Optional meeting space configuration (accessType, moderation, artifactConfig, etc.)'),
+    }),
+    execute: async ({ googleMeetToken, config }) => {
+        try {
+            const result = await googleMeetRequest(googleMeetToken, '/spaces', {
+                method: 'POST',
+                body: config ? { config } : {},
+            });
+            if (!result.ok) {
+                return { error: 'Failed to create Google Meet space', details: result.data, statusCode: result.status };
+            }
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error creating Google Meet space',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=create-meet.js.map

package/dist/toolkits/google-meet/tools/end-active-conference.d.ts

@@ -0,0 +1,26 @@
+export declare const endActiveConference: import("ai").Tool<{
+    googleMeetToken: string;
+    space_name: string;
+}, {
+    error: string;
+    details: any;
+    statusCode: number;
+    success?: undefined;
+    message?: undefined;
+    data?: undefined;
+} | {
+    success: boolean;
+    message: string;
+    data: any;
+    error?: undefined;
+    details?: undefined;
+    statusCode?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    statusCode?: undefined;
+    success?: undefined;
+    data?: undefined;
+}>;
+//# sourceMappingURL=end-active-conference.d.ts.map

package/dist/toolkits/google-meet/tools/end-active-conference.js

@@ -0,0 +1,37 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { googleMeetRequest, normalizeSpaceName } from './utils.js';
+export const endActiveConference = tool({
+    description: 'Ends an active conference in a Google Meet space. Immediately drops all active participants — obtain explicit user confirmation before calling.',
+    inputSchema: z.object({
+        googleMeetToken: z.string().describe('The Google Meet access token'),
+        space_name: z
+            .string()
+            .describe("Resource name of the space (e.g. 'spaces/jQCFfuBOdN5z' or 'jQCFfuBOdN5z')"),
+    }),
+    execute: async ({ googleMeetToken, space_name }) => {
+        try {
+            const name = normalizeSpaceName(space_name);
+            const result = await googleMeetRequest(googleMeetToken, `/${name}:endActiveConference`, {
+                method: 'POST',
+                body: {},
+            });
+            if (!result.ok) {
+                return { error: 'Failed to end active conference', details: result.data, statusCode: result.status };
+            }
+            return {
+                success: true,
+                message: 'Active conference ended successfully',
+                data: result.data,
+            };
+        }
+        catch (error) {
+            return {
+                error: 'Error ending active conference',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=end-active-conference.js.map

package/dist/toolkits/google-meet/tools/get-conference-record-by-name.d.ts

@@ -0,0 +1,5 @@
+export declare const getConferenceRecordByName: import("ai").Tool<{
+    name: string;
+    googleMeetToken: string;
+}, any>;
+//# sourceMappingURL=get-conference-record-by-name.d.ts.map

package/dist/toolkits/google-meet/tools/get-conference-record-by-name.js

@@ -0,0 +1,30 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { googleMeetRequest, normalizeConferenceRecordName } from './utils.js';
+export const getConferenceRecordByName = tool({
+    description: 'Get a specific conference record by its resource name. Use when you have the conference record ID and need meeting instance details.',
+    inputSchema: z.object({
+        googleMeetToken: z.string().describe('The Google Meet access token'),
+        name: z
+            .string()
+            .describe("Conference record resource name (e.g. 'conferenceRecords/GLkPdCDLsjSXet2-QH9dDxIPOAIIigIgABgECA')"),
+    }),
+    execute: async ({ googleMeetToken, name }) => {
+        try {
+            const resource = normalizeConferenceRecordName(name);
+            const result = await googleMeetRequest(googleMeetToken, `/${resource}`);
+            if (!result.ok) {
+                return { error: 'Failed to get conference record', details: result.data, statusCode: result.status };
+            }
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error getting conference record',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=get-conference-record-by-name.js.map

package/dist/toolkits/google-meet/tools/get-meet.d.ts

@@ -0,0 +1,5 @@
+export declare const getMeet: import("ai").Tool<{
+    googleMeetToken: string;
+    space_name: string;
+}, any>;
+//# sourceMappingURL=get-meet.d.ts.map

package/dist/toolkits/google-meet/tools/get-meet.js

@@ -0,0 +1,30 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { googleMeetRequest, normalizeSpaceName } from './utils.js';
+export const getMeet = tool({
+    description: 'Retrieve details of a Google Meet space using its unique identifier. Newly created spaces may return incomplete data; retry after 1–3 seconds if needed.',
+    inputSchema: z.object({
+        googleMeetToken: z.string().describe('The Google Meet access token'),
+        space_name: z
+            .string()
+            .describe("The Google Meet space ID without the 'spaces/' prefix (e.g. 'mV63iV9-KxoB')"),
+    }),
+    execute: async ({ googleMeetToken, space_name }) => {
+        try {
+            const name = normalizeSpaceName(space_name);
+            const result = await googleMeetRequest(googleMeetToken, `/${name}`);
+            if (!result.ok) {
+                return { error: 'Failed to get Meet space details', details: result.data, statusCode: result.status };
+            }
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error getting Meet space details',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=get-meet.js.map

package/dist/toolkits/google-meet/tools/get-participant-session.d.ts

@@ -0,0 +1,5 @@
+export declare const getParticipantSession: import("ai").Tool<{
+    name: string;
+    googleMeetToken: string;
+}, any>;
+//# sourceMappingURL=get-participant-session.d.ts.map

package/dist/toolkits/google-meet/tools/get-participant-session.js

@@ -0,0 +1,29 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { googleMeetRequest } from './utils.js';
+export const getParticipantSession = tool({
+    description: 'Retrieves detailed information about a specific participant session from a Google Meet conference record.',
+    inputSchema: z.object({
+        googleMeetToken: z.string().describe('The Google Meet access token'),
+        name: z
+            .string()
+            .describe("Full resource name: 'conferenceRecords/{conference_record}/participants/{participant}/participantSessions/{participant_session}'"),
+    }),
+    execute: async ({ googleMeetToken, name }) => {
+        try {
+            const result = await googleMeetRequest(googleMeetToken, `/${name}`);
+            if (!result.ok) {
+                return { error: 'Failed to get participant session', details: result.data, statusCode: result.status };
+            }
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error getting participant session',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=get-participant-session.js.map

package/dist/toolkits/google-meet/tools/get-recordings-by-conference-record-id.d.ts

@@ -0,0 +1,7 @@
+export declare const getRecordingsByConferenceRecordId: import("ai").Tool<{
+    googleMeetToken: string;
+    conference_record_id: string;
+    page_size?: number | undefined;
+    page_token?: string | undefined;
+}, any>;
+//# sourceMappingURL=get-recordings-by-conference-record-id.d.ts.map

package/dist/toolkits/google-meet/tools/get-recordings-by-conference-record-id.js

@@ -0,0 +1,32 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { googleMeetRequest, normalizeConferenceRecordName } from './utils.js';
+export const getRecordingsByConferenceRecordId = tool({
+    description: 'Get recordings for a conference record by its unique identifier.',
+    inputSchema: z.object({
+        googleMeetToken: z.string().describe('The Google Meet access token'),
+        conference_record_id: z.string().describe('Unique identifier for the conference record'),
+        page_size: z.number().optional().describe('Maximum number of recordings to return'),
+        page_token: z.string().optional().describe('Page token from a previous list call'),
+    }),
+    execute: async ({ googleMeetToken, conference_record_id, page_size, page_token }) => {
+        try {
+            const parent = normalizeConferenceRecordName(conference_record_id);
+            const result = await googleMeetRequest(googleMeetToken, `/${parent}/recordings`, {
+                query: { pageSize: page_size, pageToken: page_token },
+            });
+            if (!result.ok) {
+                return { error: 'Failed to get recordings', details: result.data, statusCode: result.status };
+            }
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error getting recordings',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=get-recordings-by-conference-record-id.js.map

package/dist/toolkits/google-meet/tools/get-transcript-entry.d.ts

@@ -0,0 +1,5 @@
+export declare const getTranscriptEntry: import("ai").Tool<{
+    name: string;
+    googleMeetToken: string;
+}, any>;
+//# sourceMappingURL=get-transcript-entry.d.ts.map

package/dist/toolkits/google-meet/tools/get-transcript-entry.js

@@ -0,0 +1,29 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { googleMeetRequest } from './utils.js';
+export const getTranscriptEntry = tool({
+    description: 'Get a specific transcript entry by its full resource name.',
+    inputSchema: z.object({
+        googleMeetToken: z.string().describe('The Google Meet access token'),
+        name: z
+            .string()
+            .describe("Transcript entry resource name: 'conferenceRecords/{conference_record}/transcripts/{transcript}/entries/{entry}'"),
+    }),
+    execute: async ({ googleMeetToken, name }) => {
+        try {
+            const result = await googleMeetRequest(googleMeetToken, `/${name}`);
+            if (!result.ok) {
+                return { error: 'Failed to get transcript entry', details: result.data, statusCode: result.status };
+            }
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error getting transcript entry',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=get-transcript-entry.js.map

package/dist/toolkits/google-meet/tools/get-transcript.d.ts

@@ -0,0 +1,5 @@
+export declare const getTranscript: import("ai").Tool<{
+    name: string;
+    googleMeetToken: string;
+}, any>;
+//# sourceMappingURL=get-transcript.d.ts.map

package/dist/toolkits/google-meet/tools/get-transcript.js

@@ -0,0 +1,29 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { googleMeetRequest } from './utils.js';
+export const getTranscript = tool({
+    description: 'Get a specific transcript resource by its full resource name.',
+    inputSchema: z.object({
+        googleMeetToken: z.string().describe('The Google Meet access token'),
+        name: z
+            .string()
+            .describe("Transcript resource name: 'conferenceRecords/{conference_record}/transcripts/{transcript}'"),
+    }),
+    execute: async ({ googleMeetToken, name }) => {
+        try {
+            const result = await googleMeetRequest(googleMeetToken, `/${name}`);
+            if (!result.ok) {
+                return { error: 'Failed to get transcript', details: result.data, statusCode: result.status };
+            }
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error getting transcript',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=get-transcript.js.map

package/dist/toolkits/google-meet/tools/get-transcripts-by-conference-record-id.d.ts

@@ -0,0 +1,7 @@
+export declare const getTranscriptsByConferenceRecordId: import("ai").Tool<{
+    googleMeetToken: string;
+    conference_record_id: string;
+    page_size?: number | undefined;
+    page_token?: string | undefined;
+}, any>;
+//# sourceMappingURL=get-transcripts-by-conference-record-id.d.ts.map

package/dist/toolkits/google-meet/tools/get-transcripts-by-conference-record-id.js

@@ -0,0 +1,32 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { googleMeetRequest, normalizeConferenceRecordName } from './utils.js';
+export const getTranscriptsByConferenceRecordId = tool({
+    description: 'Get transcripts for a conference record by its unique identifier.',
+    inputSchema: z.object({
+        googleMeetToken: z.string().describe('The Google Meet access token'),
+        conference_record_id: z.string().describe('Unique identifier of the conference record'),
+        page_size: z.number().optional().describe('Maximum number of transcripts to return'),
+        page_token: z.string().optional().describe('Page token from a previous list call'),
+    }),
+    execute: async ({ googleMeetToken, conference_record_id, page_size, page_token }) => {
+        try {
+            const parent = normalizeConferenceRecordName(conference_record_id);
+            const result = await googleMeetRequest(googleMeetToken, `/${parent}/transcripts`, {
+                query: { pageSize: page_size, pageToken: page_token },
+            });
+            if (!result.ok) {
+                return { error: 'Failed to get transcripts', details: result.data, statusCode: result.status };
+            }
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error getting transcripts',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=get-transcripts-by-conference-record-id.js.map

package/dist/toolkits/google-meet/tools/index.d.ts

@@ -0,0 +1,156 @@
+import { createMeet } from './create-meet.js';
+import { endActiveConference } from './end-active-conference.js';
+import { getConferenceRecordByName } from './get-conference-record-by-name.js';
+import { getMeet } from './get-meet.js';
+import { getParticipantSession } from './get-participant-session.js';
+import { getRecordingsByConferenceRecordId } from './get-recordings-by-conference-record-id.js';
+import { getTranscript } from './get-transcript.js';
+import { getTranscriptEntry } from './get-transcript-entry.js';
+import { getTranscriptsByConferenceRecordId } from './get-transcripts-by-conference-record-id.js';
+import { listConferenceRecords } from './list-conference-records.js';
+import { listParticipants } from './list-participants.js';
+import { listParticipantSessions } from './list-participant-sessions.js';
+import { listRecordings } from './list-recordings.js';
+import { listTranscriptEntries } from './list-transcript-entries.js';
+import { updateSpace } from './update-space.js';
+export { createMeet, endActiveConference, getConferenceRecordByName, getMeet, getParticipantSession, getRecordingsByConferenceRecordId, getTranscript, getTranscriptEntry, getTranscriptsByConferenceRecordId, listConferenceRecords, listParticipants, listParticipantSessions, listRecordings, listTranscriptEntries, updateSpace, };
+export declare const googleMeetTools: ({
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        googleMeetToken: string;
+        config?: Record<string, unknown> | undefined;
+    }, any>;
+    requiredAuth: "googleMeetToken";
+    scope: "write";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        googleMeetToken: string;
+        space_name: string;
+    }, {
+        error: string;
+        details: any;
+        statusCode: number;
+        success?: undefined;
+        message?: undefined;
+        data?: undefined;
+    } | {
+        success: boolean;
+        message: string;
+        data: any;
+        error?: undefined;
+        details?: undefined;
+        statusCode?: undefined;
+    } | {
+        error: string;
+        message: string;
+        details?: undefined;
+        statusCode?: undefined;
+        success?: undefined;
+        data?: undefined;
+    }>;
+    requiredAuth: "googleMeetToken";
+    scope: "delete";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        name: string;
+        googleMeetToken: string;
+    }, any>;
+    requiredAuth: "googleMeetToken";
+    scope: "read";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        googleMeetToken: string;
+        space_name: string;
+    }, any>;
+    requiredAuth: "googleMeetToken";
+    scope: "read";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        googleMeetToken: string;
+        conference_record_id: string;
+        page_size?: number | undefined;
+        page_token?: string | undefined;
+    }, any>;
+    requiredAuth: "googleMeetToken";
+    scope: "read";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        googleMeetToken: string;
+        filter?: string | undefined;
+        page_size?: number | undefined;
+        page_token?: string | undefined;
+    }, any>;
+    requiredAuth: "googleMeetToken";
+    scope: "read";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        parent: string;
+        googleMeetToken: string;
+        filter?: string | undefined;
+        page_size?: number | undefined;
+        page_token?: string | undefined;
+    }, any>;
+    requiredAuth: "googleMeetToken";
+    scope: "read";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        googleMeetToken: string;
+        conference_record_id: string;
+        participant_id: string;
+        filter?: string | undefined;
+        page_size?: number | undefined;
+        page_token?: string | undefined;
+    }, any>;
+    requiredAuth: "googleMeetToken";
+    scope: "read";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        parent: string;
+        googleMeetToken: string;
+        page_size?: number | undefined;
+        page_token?: string | undefined;
+    }, any>;
+    requiredAuth: "googleMeetToken";
+    scope: "read";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        googleMeetToken: string;
+        conference_record_id: string;
+        transcript_id: string;
+        page_size?: number | undefined;
+        page_token?: string | undefined;
+    }, any>;
+    requiredAuth: "googleMeetToken";
+    scope: "read";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        name: string;
+        googleMeetToken: string;
+        config?: Record<string, unknown> | undefined;
+        updateMask?: string | undefined;
+    }, any>;
+    requiredAuth: "googleMeetToken";
+    scope: "write";
+})[];
+//# sourceMappingURL=index.d.ts.map