@rnsk/toolkits 0.0.6 → 0.0.8

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

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

@@ -0,0 +1,31 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { googleMeetRequest } from './utils.js';
+export const listConferenceRecords = tool({
+    description: 'List conference records with optional filtering and pagination.',
+    inputSchema: z.object({
+        googleMeetToken: z.string().describe('The Google Meet access token'),
+        filter: z.string().optional().describe('Optional EBNF filter expression'),
+        page_size: z.number().optional().describe('Maximum number of conference records to return'),
+        page_token: z.string().optional().describe('Page token from a previous list call'),
+    }),
+    execute: async ({ googleMeetToken, filter, page_size, page_token }) => {
+        try {
+            const result = await googleMeetRequest(googleMeetToken, '/conferenceRecords', {
+                query: { filter, pageSize: page_size, pageToken: page_token },
+            });
+            if (!result.ok) {
+                return { error: 'Failed to list conference records', details: result.data, statusCode: result.status };
+            }
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error listing conference records',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=list-conference-records.js.map

package/dist/toolkits/google-meet/tools/list-participant-sessions.d.ts

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

package/dist/toolkits/google-meet/tools/list-participant-sessions.js

@@ -0,0 +1,34 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { googleMeetRequest, normalizeConferenceRecordName } from './utils.js';
+export const listParticipantSessions = tool({
+    description: 'List participant sessions for a participant within a conference record.',
+    inputSchema: z.object({
+        googleMeetToken: z.string().describe('The Google Meet access token'),
+        conference_record_id: z.string().describe('Unique identifier of the conference record'),
+        participant_id: z.string().describe('Unique identifier of the participant within the conference'),
+        filter: z.string().optional().describe('Optional EBNF filter expression'),
+        page_size: z.number().optional().describe('Maximum number of participant sessions to return'),
+        page_token: z.string().optional().describe('Page token from a previous list call'),
+    }),
+    execute: async ({ googleMeetToken, conference_record_id, participant_id, filter, page_size, page_token }) => {
+        try {
+            const parent = `${normalizeConferenceRecordName(conference_record_id)}/participants/${participant_id}`;
+            const result = await googleMeetRequest(googleMeetToken, `/${parent}/participantSessions`, {
+                query: { filter, pageSize: page_size, pageToken: page_token },
+            });
+            if (!result.ok) {
+                return { error: 'Failed to list participant sessions', details: result.data, statusCode: result.status };
+            }
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error listing participant sessions',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=list-participant-sessions.js.map

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

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

package/dist/toolkits/google-meet/tools/list-participants.js

@@ -0,0 +1,35 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { googleMeetRequest, normalizeConferenceRecordName } from './utils.js';
+export const listParticipants = tool({
+    description: 'List participants for a conference record.',
+    inputSchema: z.object({
+        googleMeetToken: z.string().describe('The Google Meet access token'),
+        parent: z
+            .string()
+            .describe("Conference record resource name (e.g. 'conferenceRecords/abc-123-def')"),
+        filter: z.string().optional().describe('Optional EBNF filter expression'),
+        page_size: z.number().optional().describe('Maximum number of participants to return'),
+        page_token: z.string().optional().describe('Page token from a previous list call'),
+    }),
+    execute: async ({ googleMeetToken, parent, filter, page_size, page_token }) => {
+        try {
+            const resource = normalizeConferenceRecordName(parent);
+            const result = await googleMeetRequest(googleMeetToken, `/${resource}/participants`, {
+                query: { filter, pageSize: page_size, pageToken: page_token },
+            });
+            if (!result.ok) {
+                return { error: 'Failed to list participants', details: result.data, statusCode: result.status };
+            }
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error listing participants',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=list-participants.js.map

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

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

package/dist/toolkits/google-meet/tools/list-recordings.js

@@ -0,0 +1,34 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { googleMeetRequest, normalizeConferenceRecordName } from './utils.js';
+export const listRecordings = tool({
+    description: 'List recordings for a conference record.',
+    inputSchema: z.object({
+        googleMeetToken: z.string().describe('The Google Meet access token'),
+        parent: z
+            .string()
+            .describe("Conference record resource name (e.g. 'conferenceRecords/abc-123-def')"),
+        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, parent, page_size, page_token }) => {
+        try {
+            const resource = normalizeConferenceRecordName(parent);
+            const result = await googleMeetRequest(googleMeetToken, `/${resource}/recordings`, {
+                query: { pageSize: page_size, pageToken: page_token },
+            });
+            if (!result.ok) {
+                return { error: 'Failed to list recordings', details: result.data, statusCode: result.status };
+            }
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error listing recordings',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=list-recordings.js.map

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

@@ -0,0 +1,8 @@
+export declare const listTranscriptEntries: import("ai").Tool<{
+    googleMeetToken: string;
+    conference_record_id: string;
+    transcript_id: string;
+    page_size?: number | undefined;
+    page_token?: string | undefined;
+}, any>;
+//# sourceMappingURL=list-transcript-entries.d.ts.map

package/dist/toolkits/google-meet/tools/list-transcript-entries.js

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

package/dist/toolkits/google-meet/tools/update-space.d.ts

@@ -0,0 +1,7 @@
+export declare const updateSpace: import("ai").Tool<{
+    name: string;
+    googleMeetToken: string;
+    config?: Record<string, unknown> | undefined;
+    updateMask?: string | undefined;
+}, any>;
+//# sourceMappingURL=update-space.d.ts.map

package/dist/toolkits/google-meet/tools/update-space.js

@@ -0,0 +1,42 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { googleMeetRequest, normalizeSpaceName } from './utils.js';
+export const updateSpace = tool({
+    description: 'Update configuration settings for an existing Google Meet space. Provide updateMask to specify which fields to change.',
+    inputSchema: z.object({
+        googleMeetToken: z.string().describe('The Google Meet access token'),
+        name: z
+            .string()
+            .describe("Google Meet space resource name (e.g. 'spaces/jQCFfuBOdN5z' or 'jQCFfuBOdN5z')"),
+        config: z
+            .record(z.unknown())
+            .optional()
+            .describe('Configuration settings to update for the meeting space'),
+        updateMask: z
+            .string()
+            .optional()
+            .describe('Comma-separated list of fully qualified field paths to update'),
+    }),
+    execute: async ({ googleMeetToken, name, config, updateMask }) => {
+        try {
+            const resource = normalizeSpaceName(name);
+            const result = await googleMeetRequest(googleMeetToken, `/${resource}`, {
+                method: 'PATCH',
+                body: config ? { config } : {},
+                query: updateMask ? { updateMask } : {},
+            });
+            if (!result.ok) {
+                return { error: 'Failed to update Google Meet space', details: result.data, statusCode: result.status };
+            }
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error updating Google Meet space',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=update-space.js.map

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

@@ -0,0 +1,14 @@
+export declare const GOOGLE_MEET_BASE = "https://meet.googleapis.com/v2";
+export declare function normalizeSpaceName(spaceName: string): string;
+export declare function normalizeConferenceRecordName(id: string): string;
+export declare function buildQueryString(params: Record<string, unknown>): string;
+export declare function googleMeetRequest(googleMeetToken: string, path: string, options?: {
+    method?: string;
+    body?: unknown;
+    query?: Record<string, unknown>;
+}): Promise<{
+    ok: boolean;
+    status: number;
+    data: any;
+}>;
+//# sourceMappingURL=utils.d.ts.map

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

@@ -0,0 +1,39 @@
+// @ts-nocheck
+export const GOOGLE_MEET_BASE = 'https://meet.googleapis.com/v2';
+export function normalizeSpaceName(spaceName) {
+    return spaceName.startsWith('spaces/') ? spaceName : `spaces/${spaceName}`;
+}
+export function normalizeConferenceRecordName(id) {
+    return id.startsWith('conferenceRecords/') ? id : `conferenceRecords/${id}`;
+}
+export function buildQueryString(params) {
+    const search = new URLSearchParams();
+    for (const [key, value] of Object.entries(params)) {
+        if (value !== undefined && value !== null && value !== '') {
+            search.set(key, String(value));
+        }
+    }
+    const qs = search.toString();
+    return qs ? `?${qs}` : '';
+}
+export async function googleMeetRequest(googleMeetToken, path, options) {
+    const normalizedPath = path.startsWith('/') ? path : `/${path}`;
+    const url = `${GOOGLE_MEET_BASE}${normalizedPath}${buildQueryString(options?.query ?? {})}`;
+    const headers = {
+        Authorization: `Bearer ${googleMeetToken}`,
+        Accept: 'application/json',
+    };
+    const method = options?.method ?? 'GET';
+    const fetchOptions = { method, headers };
+    if (options?.body !== undefined) {
+        headers['Content-Type'] = 'application/json';
+        fetchOptions.body = JSON.stringify(options.body);
+    }
+    const response = await fetch(url, fetchOptions);
+    if (response.status === 204) {
+        return { ok: response.ok, status: response.status, data: null };
+    }
+    const data = await response.json().catch(() => null);
+    return { ok: response.ok, status: response.status, data };
+}
+//# sourceMappingURL=utils.js.map

package/dist/toolkits/google-search-console/icon.d.ts

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

package/dist/toolkits/google-search-console/icon.js

@@ -0,0 +1,6 @@
+const SVG = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 40 40"><title>Google Search Console</title><g clip-path="url(#a)"><path fill="#fbbc04" d="m11.081 30.527-4.72 4.721a.933.933 0 0 1-1.317 0l-.292-.292a.933.933 0 0 1 0-1.316l4.72-4.721a.933.933 0 0 1 1.318 0l.291.291a.93.93 0 0 1 0 1.317"/><path fill="#4285f4" d="M23.75 32.5h6.042a6.04 6.04 0 0 0 6.041-6.042v-16.25a6.04 6.04 0 0 0-6.041-6.041 6.04 6.04 0 0 0-6.042 6.041z"/><path fill="#fbbc04" d="M13.75 32.5a6.04 6.04 0 0 0 6.042-6.042 6.04 6.04 0 0 0-6.042-6.041 6.04 6.04 0 0 0-6.042 6.041A6.04 6.04 0 0 0 13.75 32.5"/><path fill="#34a853" d="M27.97 32.5h-5.887a6.04 6.04 0 0 1-6.041-6.042v-7.916a6.04 6.04 0 0 1 6.041-6.042 6.04 6.04 0 0 1 6.042 6.042v13.804a.154.154 0 0 1-.154.154z"/><path fill="#1967d2" d="M28.125 32.346V18.542a6.04 6.04 0 0 0-4.375-5.807V32.5h4.22a.154.154 0 0 0 .155-.154"/><path fill="#ea4335" d="M19.792 26.575a6.04 6.04 0 0 0-3.75-5.59v5.59c0 1.72.72 3.273 1.875 4.373a6.02 6.02 0 0 0 1.875-4.373"/></g><defs><clipPath id="a"><path fill="#fff" d="M0 0h40v40H0z"/></clipPath></defs></svg>`;
+export const GSEARCHCONSOLE_ICON = {
+    kind: 'svg',
+    dataUri: `data:image/svg+xml;base64,${Buffer.from(SVG).toString('base64')}`,
+};
+//# sourceMappingURL=icon.js.map

package/dist/toolkits/google-search-console/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-search-console/manifest.js

@@ -0,0 +1,46 @@
+import { defineToolkit, defineTool } from '../../core/define.js';
+import { GSEARCHCONSOLE_ICON } from './icon.js';
+import { googleSearchConsoleTools } from './tools/index.js';
+export default defineToolkit({
+    id: 'google-search-console',
+    displayName: 'Google Search Console',
+    shortDescription: 'Manage Search Console properties, sitemaps, URL inspection, and search analytics queries.',
+    category: 'Data & Analytics',
+    icon: GSEARCHCONSOLE_ICON,
+    auth: {
+        type: 'oauth2',
+        tokenField: 'googleSearchConsoleToken',
+        provider: {
+            slug: 'google-search-console',
+            env: {
+                clientId: 'GOOGLE_SEARCH_CONSOLE_CLIENT_ID',
+                clientSecret: 'GOOGLE_SEARCH_CONSOLE_CLIENT_SECRET',
+            },
+            authorizeUrl: 'https://accounts.google.com/o/oauth2/v2/auth',
+            tokenUrl: 'https://oauth2.googleapis.com/token',
+            scopes: [
+                'https://www.googleapis.com/auth/webmasters',
+                'https://www.googleapis.com/auth/webmasters.readonly',
+            ],
+            exchangeStyle: 'form',
+            extraAuthParams: { access_type: 'offline', prompt: 'consent' },
+            connectDescription: 'Connect Google Search Console to manage sites, sitemaps, inspect URLs, and query search analytics.',
+            callbackPath: '/api/auth/google-search-console/callback',
+            stateCookie: 'google_search_console_oauth_state',
+        },
+    },
+    allowedHosts: ['www.googleapis.com', 'searchconsole.googleapis.com'],
+    tools: googleSearchConsoleTools.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://search.google.com/search-console',
+        docsUrl: 'https://developers.google.com/webmaster-tools/v1/api_reference_index',
+    },
+});
+//# sourceMappingURL=manifest.js.map

package/dist/toolkits/google-search-console/tools/add-site.d.ts

@@ -0,0 +1,29 @@
+export declare const addSite: import("ai").Tool<{
+    googleSearchConsoleToken: string;
+    site_url: string;
+}, {
+    error: string;
+    details: any;
+    statusCode: number;
+    success?: undefined;
+    site_url?: undefined;
+    data?: undefined;
+    message?: undefined;
+} | {
+    success: boolean;
+    site_url: string;
+    data: any;
+    error?: undefined;
+    details?: undefined;
+    statusCode?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    statusCode?: undefined;
+    success?: undefined;
+    site_url?: undefined;
+    data?: undefined;
+}>;
+//# sourceMappingURL=add-site.d.ts.map

package/dist/toolkits/google-search-console/tools/add-site.js

@@ -0,0 +1,27 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { encodeSiteUrl, webmastersRequest } from './utils.js';
+export const addSite = tool({
+    description: 'Add a site property to Google Search Console. For URL-prefix properties use the full URL with trailing slash.',
+    inputSchema: z.object({
+        googleSearchConsoleToken: z.string().describe('The Google Search Console access token'),
+        site_url: z.string().describe('The site URL to add (e.g. https://www.example.com/ or sc-domain:example.com)'),
+    }),
+    execute: async ({ googleSearchConsoleToken, site_url }) => {
+        try {
+            const result = await webmastersRequest(googleSearchConsoleToken, `/sites/${encodeSiteUrl(site_url)}`, { method: 'PUT' });
+            if (!result.ok) {
+                return { error: 'Failed to add site', details: result.data, statusCode: result.status };
+            }
+            return { success: true, site_url, data: result.data };
+        }
+        catch (error) {
+            return {
+                error: 'Error adding site',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=add-site.js.map

package/dist/toolkits/google-search-console/tools/delete-site.d.ts

@@ -0,0 +1,26 @@
+export declare const deleteSite: import("ai").Tool<{
+    googleSearchConsoleToken: string;
+    site_url: string;
+}, {
+    error: string;
+    details: any;
+    statusCode: number;
+    success?: undefined;
+    site_url?: undefined;
+    message?: undefined;
+} | {
+    success: boolean;
+    site_url: string;
+    error?: undefined;
+    details?: undefined;
+    statusCode?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    statusCode?: undefined;
+    success?: undefined;
+    site_url?: undefined;
+}>;
+//# sourceMappingURL=delete-site.d.ts.map

package/dist/toolkits/google-search-console/tools/delete-site.js

@@ -0,0 +1,27 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { encodeSiteUrl, webmastersRequest } from './utils.js';
+export const deleteSite = tool({
+    description: 'Remove a site property from Google Search Console.',
+    inputSchema: z.object({
+        googleSearchConsoleToken: z.string().describe('The Google Search Console access token'),
+        site_url: z.string().describe('The site URL to remove from Search Console'),
+    }),
+    execute: async ({ googleSearchConsoleToken, site_url }) => {
+        try {
+            const result = await webmastersRequest(googleSearchConsoleToken, `/sites/${encodeSiteUrl(site_url)}`, { method: 'DELETE' });
+            if (!result.ok) {
+                return { error: 'Failed to delete site', details: result.data, statusCode: result.status };
+            }
+            return { success: true, site_url };
+        }
+        catch (error) {
+            return {
+                error: 'Error deleting site',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=delete-site.js.map

package/dist/toolkits/google-search-console/tools/get-site.d.ts

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