@rnsk/toolkits 0.0.5 → 0.0.7

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

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

@@ -0,0 +1,125 @@
+// @ts-nocheck
+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 const googleMeetTools = [
+    {
+        name: 'googleMeetCreateMeet',
+        description: 'Creates a new Google Meet space with optional configuration. Does not attach to any calendar event — calendar linking requires a separate Calendar tool call. Capture `meetingUri`, `meetingCode`, and `space.name` from ...',
+        tool: createMeet,
+        requiredAuth: 'googleMeetToken',
+        scope: 'write',
+    },
+    {
+        name: 'googleMeetEndActiveConference',
+        description: 'Ends an active conference in a Google Meet space. REQUIRES \'space_name\' parameter (e.g., \'spaces/jQCFfuBOdN5z\' or just \'jQCFfuBOdN5z\'). Use when you need to terminate an ongoing conference in a specified space. ...',
+        tool: endActiveConference,
+        requiredAuth: 'googleMeetToken',
+        scope: 'delete',
+    },
+    {
+        name: 'googleMeetGetConferenceRecordByName',
+        description: 'Tool to get a specific conference record by its resource name. Use when you have the conference record ID and need to retrieve detailed information about a single meeting instance.',
+        tool: getConferenceRecordByName,
+        requiredAuth: 'googleMeetToken',
+        scope: 'read',
+    },
+    {
+        name: 'googleMeetGetMeet',
+        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.',
+        tool: getMeet,
+        requiredAuth: 'googleMeetToken',
+        scope: 'read',
+    },
+    {
+        name: 'googleMeetGetParticipantSession',
+        description: 'Retrieves detailed information about a specific participant session from a Google Meet conference record. Returns session details including start time and end time for a single join/leave session. A participant sessio...',
+        tool: getParticipantSession,
+        requiredAuth: 'googleMeetToken',
+        scope: 'read',
+    },
+    {
+        name: 'googleMeetGetRecordingsByConferenceRecordId',
+        description: 'Retrieves recordings from Google Meet for a given conference record ID. Only returns recordings if recording was enabled and permitted by the organizer\'s domain policies; a valid conference_record_id does not guarant...',
+        tool: getRecordingsByConferenceRecordId,
+        requiredAuth: 'googleMeetToken',
+        scope: 'read',
+    },
+    {
+        name: 'googleMeetGetTranscript',
+        description: 'Retrieves a specific transcript by its resource name. Returns transcript details including state (STARTED, ENDED, FILE_GENERATED), start/end times, and Google Docs destination. PREREQUISITE: Obtain the transcript reso...',
+        tool: getTranscript,
+        requiredAuth: 'googleMeetToken',
+        scope: 'read',
+    },
+    {
+        name: 'googleMeetGetTranscriptEntry',
+        description: 'Fetches a single transcript entry by resource name for targeted inspection or incremental processing. Use when you have a specific transcript entry resource name and need to retrieve its details (text, speaker, timest...',
+        tool: getTranscriptEntry,
+        requiredAuth: 'googleMeetToken',
+        scope: 'read',
+    },
+    {
+        name: 'googleMeetGetTranscriptsByConferenceRecordId',
+        description: 'Retrieves all transcripts for a specific Google Meet conference using its conference_record_id. Transcripts require processing time after a meeting ends — empty results may be transient; retry after a delay before con...',
+        tool: getTranscriptsByConferenceRecordId,
+        requiredAuth: 'googleMeetToken',
+        scope: 'read',
+    },
+    {
+        name: 'googleMeetListConferenceRecords',
+        description: 'Tool to list conference records. Use when you need to retrieve a list of past conferences, optionally filtering them by criteria like meeting code, space name, or time range.',
+        tool: listConferenceRecords,
+        requiredAuth: 'googleMeetToken',
+        scope: 'read',
+    },
+    {
+        name: 'googleMeetListParticipants',
+        description: 'Lists the participants in a conference record. By default, ordered by join time descending. Use to retrieve all participants who joined a specific Google Meet conference, with support for filtering active participants...',
+        tool: listParticipants,
+        requiredAuth: 'googleMeetToken',
+        scope: 'read',
+    },
+    {
+        name: 'googleMeetListParticipantSessions',
+        description: 'Lists all participant sessions for a specific participant in a Google Meet conference. A participant session represents each unique join or leave session when a user joins a conference from a device. If a user joins m...',
+        tool: listParticipantSessions,
+        requiredAuth: 'googleMeetToken',
+        scope: 'read',
+    },
+    {
+        name: 'googleMeetListRecordings',
+        description: 'Tool to list recording resources from a conference record. Use when you need to retrieve recordings from a specific Google Meet conference. Recordings are created when meeting recording is enabled and saved to Google ...',
+        tool: listRecordings,
+        requiredAuth: 'googleMeetToken',
+        scope: 'read',
+    },
+    {
+        name: 'googleMeetListTranscriptEntries',
+        description: 'Tool to list structured transcript entries (speaker/time/text segments) for a specific Google Meet transcript. Use when you need to access the detailed content of a transcript, including individual spoken segments wit...',
+        tool: listTranscriptEntries,
+        requiredAuth: 'googleMeetToken',
+        scope: 'read',
+    },
+    {
+        name: 'googleMeetUpdateSpace',
+        description: 'Updates the settings of an existing Google Meet space. Requires organizer/host privileges and the meetings.space.created OAuth scope. REQUIRED PARAMETER: - name: The space identifier (e.g., \'spaces/jQCFfuBOdN5z\'). T...',
+        tool: updateSpace,
+        requiredAuth: 'googleMeetToken',
+        scope: 'write',
+    },
+];
+//# sourceMappingURL=index.js.map

package/dist/toolkits/google-meet/tools/list-conference-records.d.ts

@@ -0,0 +1,7 @@
+export declare const listConferenceRecords: import("ai").Tool<{
+    googleMeetToken: string;
+    filter?: string | undefined;
+    page_size?: number | undefined;
+    page_token?: string | undefined;
+}, any>;
+//# sourceMappingURL=list-conference-records.d.ts.map