@rnsk/toolkits 0.0.7 → 0.0.9

package/dist/toolkits/google-analytics/tools/links.js

@@ -0,0 +1,56 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { ADMIN_V1ALPHA, ADMIN_V1BETA, gaGet, gaList, googleAnalyticsTokenField, normalizeProperty, paginationSchema, } from './client.js';
+const propertyField = z.string().describe("Property 'properties/{id}' (bare numeric ID accepted)");
+function makeListTool(toolName, description, resource, action, base = ADMIN_V1BETA, extraSchema = {}) {
+    return tool({
+        description,
+        inputSchema: z.object({
+            googleAnalyticsToken: googleAnalyticsTokenField,
+            parent: propertyField,
+            ...paginationSchema,
+            ...extraSchema,
+        }),
+        execute: async ({ googleAnalyticsToken, parent, pageSize, pageToken, ...rest }) => {
+            const extra = {};
+            for (const [k, v] of Object.entries(rest))
+                if (v !== undefined)
+                    extra[k] = v;
+            return gaList(googleAnalyticsToken, base, parent.startsWith('properties/') || parent.startsWith('accounts/') ? parent : normalizeProperty(parent), resource, { pageSize, pageToken, extra }, action);
+        },
+    });
+}
+export const listAdsenseLinks = makeListTool('listAdsenseLinks', 'Lists AdSense links on a property.', 'adsenseLinks', 'list AdSense links');
+export const listBigqueryLinks = makeListTool('listBigqueryLinks', 'Lists BigQuery export links on a property.', 'bigqueryLinks', 'list BigQuery links');
+export const listChannelGroups = makeListTool('listChannelGroups', 'Lists channel groups that categorize traffic sources in reports.', 'channelGroups', 'list channel groups');
+export const listConversionEvents = makeListTool('listConversionEvents', 'Lists conversion events configured on a property.', 'conversionEvents', 'list conversion events');
+export const listKeyEvents = makeListTool('listKeyEvents', 'Lists key events (successor of conversion events) on a property.', 'keyEvents', 'list key events');
+export const getKeyEvent = tool({
+    description: 'Gets a single key event by resource name. Read-only; create/update/delete require the Analytics UI.',
+    inputSchema: z.object({
+        googleAnalyticsToken: googleAnalyticsTokenField,
+        name: z.string().describe("Key event 'properties/{id}/keyEvents/{event}'"),
+    }),
+    execute: async ({ googleAnalyticsToken, name }) => {
+        try {
+            return await gaGet(googleAnalyticsToken, ADMIN_V1BETA, name);
+        }
+        catch (error) {
+            return { error: 'Error getting key event', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const listDataStreams = makeListTool('listDataStreams', 'Lists data streams (web, iOS, Android) on a property.', 'dataStreams', 'list data streams');
+export const listDv360AdLinks = makeListTool('listDv360AdLinks', 'Lists Display & Video 360 advertiser links on a property.', 'displayVideo360AdvertiserLinks', 'list DV360 advertiser links');
+export const listDv360LinkProposals = makeListTool('listDv360LinkProposals', 'Lists Display & Video 360 link proposals on a property.', 'displayVideo360AdvertiserLinkProposals', 'list DV360 link proposals');
+export const listEventCreateRules = makeListTool('listEventCreateRules', 'Lists event-create rules (derived events) on a property.', 'eventCreateRules', 'list event create rules');
+export const listFirebaseLinks = makeListTool('listFirebaseLinks', 'Lists Firebase links on a property.', 'firebaseLinks', 'list Firebase links');
+export const listGoogleAdsLinks = makeListTool('listGoogleAdsLinks', 'Lists Google Ads links on a property.', 'googleAdsLinks', 'list Google Ads links');
+export const listMeasurementProtocolSecrets = makeListTool('listMeasurementProtocolSecrets', 'Lists Measurement Protocol secrets (api_secret values live under data streams — reuse them for sendEvents).', 'measurementProtocolSecrets', 'list Measurement Protocol secrets');
+export const listSearchAds360Links = makeListTool('listSearchAds360Links', 'Lists Search Ads 360 links on a property.', 'searchAds360Links', 'list Search Ads 360 links');
+export const listSkAdNetworkSchemas = makeListTool('listSkAdNetworkSchemas', 'Lists SKAdNetwork conversion-value schemas for an iOS data stream. At most one schema per property.', 'skadnetworkConversionValueSchemas', 'list SKAdNetwork schemas', ADMIN_V1ALPHA);
+export const listSubpropertyEventFilters = makeListTool('listSubpropertyEventFilters', 'Lists subproperty event filters on a property.', 'subpropertyEventFilters', 'list subproperty event filters', ADMIN_V1ALPHA);
+export const listSubpropertySyncConfigs = makeListTool('listSubpropertySyncConfigs', 'Lists subproperty sync configurations on a property.', 'subpropertySyncConfigs', 'list subproperty sync configs', ADMIN_V1ALPHA);
+export const listReportingDataAnnotations = makeListTool('listReportingDataAnnotations', 'Lists reporting data annotations (notes on report data) on a property. Supports filter expressions.', 'reportingDataAnnotations', 'list reporting data annotations', ADMIN_V1ALPHA, { filter: z.string().optional().describe('Filter expression for annotations') });
+//# sourceMappingURL=links.js.map

package/dist/toolkits/google-analytics/tools/measurement.d.ts

@@ -0,0 +1,3 @@
+export declare const sendEvents: import("ai").Tool<any, any>;
+export declare const validateEvents: import("ai").Tool<any, any>;
+//# sourceMappingURL=measurement.d.ts.map

package/dist/toolkits/google-analytics/tools/measurement.js

@@ -0,0 +1,55 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+const mpEvent = z.object({
+    name: z.string().max(40).describe("Event name, e.g. 'purchase', 'login', 'page_view'"),
+    params: z.record(z.any()).optional().describe("Parameters, e.g. {currency:'USD', value:42.5, transaction_id:'T12345'}"),
+});
+const mpBody = {
+    measurementId: z.string().describe("Web stream measurement ID, e.g. 'G-XXXXXXX'"),
+    apiSecret: z.string().describe('Measurement Protocol API secret (see listMeasurementProtocolSecrets)'),
+    clientId: z.string().describe('Client ID (same value used client-side for session stitching)'),
+    events: z.array(mpEvent).min(1).max(25).describe('1-25 events per request'),
+    userId: z.string().optional(),
+    timestampMicros: z.number().optional().describe('Unix microseconds; defaults to collection time'),
+    userProperties: z.record(z.any()).optional(),
+    consent: z.object({
+        adUserData: z.string().optional().describe("'GRANTED' or 'DENIED'"),
+        adPersonalization: z.string().optional().describe("'GRANTED' or 'DENIED'"),
+    }).catchall(z.unknown()).optional(),
+};
+async function postMeasurementProtocol(measurementId, apiSecret, payload, debug, action) {
+    try {
+        const base = debug ? 'https://www.google-analytics.com/debug/mp/collect' : 'https://www.google-analytics.com/mp/collect';
+        const url = `${base}?measurement_id=${encodeURIComponent(measurementId)}&api_secret=${encodeURIComponent(apiSecret)}`;
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(payload),
+        });
+        if (!response.ok) {
+            const details = await response.text().catch(() => '');
+            return { error: `Failed to ${action} (HTTP ${response.status})`, details };
+        }
+        const data = await response.json().catch(() => ({}));
+        return debug ? data : { success: true, ...(typeof data === 'object' ? data : {}) };
+    }
+    catch (error) {
+        return { error: `Error while trying to ${action}`, message: error instanceof Error ? error.message : 'Unknown error' };
+    }
+}
+function toPayload(input) {
+    const { measurementId, apiSecret, ...rest } = input;
+    return rest;
+}
+export const sendEvents = tool({
+    description: 'Sends server-side events via Measurement Protocol (API-secret auth, no OAuth). Events appear in reports within 24-48h. Validate first with validateEvents.',
+    inputSchema: z.object(mpBody),
+    execute: async (input) => postMeasurementProtocol(input.measurementId, input.apiSecret, toPayload(input), false, 'send events'),
+});
+export const validateEvents = tool({
+    description: 'Validates Measurement Protocol events against the debug endpoint without recording them. Fix validationMessages before calling sendEvents.',
+    inputSchema: z.object(mpBody),
+    execute: async (input) => postMeasurementProtocol(input.measurementId, input.apiSecret, toPayload(input), true, 'validate events'),
+});
+//# sourceMappingURL=measurement.js.map

package/dist/toolkits/google-analytics/tools/reports.d.ts

@@ -0,0 +1,136 @@
+import { z } from 'zod';
+export declare const runReport: import("ai").Tool<{
+    property: string;
+    googleAnalyticsToken: string;
+    limit?: number | undefined;
+    dimensions?: z.objectOutputType<{
+        name: z.ZodString;
+    }, z.ZodUnknown, "strip">[] | undefined;
+    metricAggregations?: string[] | undefined;
+    dateRanges?: z.objectOutputType<{
+        startDate: z.ZodString;
+        endDate: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+    }, z.ZodUnknown, "strip">[] | undefined;
+    metrics?: z.objectOutputType<{
+        name: z.ZodString;
+    }, z.ZodUnknown, "strip">[] | undefined;
+    dimensionFilter?: Record<string, any> | undefined;
+    metricFilter?: Record<string, any> | undefined;
+    orderBys?: Record<string, any>[] | undefined;
+    offset?: number | undefined;
+    currencyCode?: string | undefined;
+    cohortSpec?: Record<string, any> | undefined;
+    comparisons?: Record<string, any>[] | undefined;
+    keepEmptyRows?: boolean | undefined;
+    returnPropertyQuota?: boolean | undefined;
+}, unknown>;
+export declare const batchRunReports: import("ai").Tool<{
+    property: string;
+    requests: Record<string, any>[];
+    googleAnalyticsToken: string;
+}, unknown>;
+export declare const runPivotReport: import("ai").Tool<{
+    property: string;
+    googleAnalyticsToken: string;
+    limit?: number | undefined;
+    dimensions?: z.objectOutputType<{
+        name: z.ZodString;
+    }, z.ZodUnknown, "strip">[] | undefined;
+    dateRanges?: z.objectOutputType<{
+        startDate: z.ZodString;
+        endDate: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+    }, z.ZodUnknown, "strip">[] | undefined;
+    metrics?: z.objectOutputType<{
+        name: z.ZodString;
+    }, z.ZodUnknown, "strip">[] | undefined;
+    dimensionFilter?: Record<string, any> | undefined;
+    metricFilter?: Record<string, any> | undefined;
+    orderBys?: Record<string, any>[] | undefined;
+    offset?: number | undefined;
+    currencyCode?: string | undefined;
+    cohortSpec?: Record<string, any> | undefined;
+    comparisons?: Record<string, any>[] | undefined;
+    keepEmptyRows?: boolean | undefined;
+    returnPropertyQuota?: boolean | undefined;
+    pivots?: Record<string, any>[] | undefined;
+}, unknown>;
+export declare const batchRunPivotReports: import("ai").Tool<{
+    property: string;
+    requests: Record<string, any>[];
+    googleAnalyticsToken: string;
+}, unknown>;
+export declare const runRealtimeReport: import("ai").Tool<{
+    property: string;
+    googleAnalyticsToken: string;
+    limit?: number | undefined;
+    dimensions?: z.objectOutputType<{
+        name: z.ZodString;
+    }, z.ZodUnknown, "strip">[] | undefined;
+    metricAggregations?: string[] | undefined;
+    metrics?: z.objectOutputType<{
+        name: z.ZodString;
+    }, z.ZodUnknown, "strip">[] | undefined;
+    dimensionFilter?: Record<string, any> | undefined;
+    metricFilter?: Record<string, any> | undefined;
+    orderBys?: Record<string, any>[] | undefined;
+    returnPropertyQuota?: boolean | undefined;
+    minuteRanges?: Record<string, any>[] | undefined;
+}, unknown>;
+export declare const runFunnelReport: import("ai").Tool<{
+    property: string;
+    googleAnalyticsToken: string;
+    funnel: Record<string, any>;
+    limit?: number | undefined;
+    dateRanges?: z.objectOutputType<{
+        startDate: z.ZodString;
+        endDate: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+    }, z.ZodUnknown, "strip">[] | undefined;
+    dimensionFilter?: Record<string, any> | undefined;
+    returnPropertyQuota?: boolean | undefined;
+    segments?: Record<string, any>[] | undefined;
+    funnelBreakdown?: Record<string, any> | undefined;
+    funnelNextAction?: Record<string, any> | undefined;
+    funnelVisualizationType?: string | undefined;
+}, unknown>;
+export declare const checkCompatibility: import("ai").Tool<{
+    property: string;
+    googleAnalyticsToken: string;
+    dimensions?: z.objectOutputType<{
+        name: z.ZodString;
+    }, z.ZodUnknown, "strip">[] | undefined;
+    metrics?: z.objectOutputType<{
+        name: z.ZodString;
+    }, z.ZodUnknown, "strip">[] | undefined;
+    dimensionFilter?: Record<string, any> | undefined;
+    metricFilter?: Record<string, any> | undefined;
+    compatibilityFilter?: "DIMENSION_COMPATIBILITY_FILTER_UNSPECIFIED" | "COMPATIBLE" | "INCOMPATIBLE" | undefined;
+}, unknown>;
+export declare const getMetadata: import("ai").Tool<{
+    name: string;
+    googleAnalyticsToken: string;
+}, any>;
+export declare const createReportTask: import("ai").Tool<{
+    parent: string;
+    googleAnalyticsToken: string;
+    reportDefinition?: Record<string, any> | undefined;
+}, any>;
+export declare const getReportTask: import("ai").Tool<{
+    name: string;
+    googleAnalyticsToken: string;
+}, any>;
+export declare const listReportTasks: import("ai").Tool<{
+    parent: string;
+    googleAnalyticsToken: string;
+    pageToken?: string | undefined;
+    pageSize?: number | undefined;
+}, any>;
+export declare const queryReportTask: import("ai").Tool<{
+    name: string;
+    googleAnalyticsToken: string;
+    limit?: number | undefined;
+    offset?: number | undefined;
+}, any>;
+//# sourceMappingURL=reports.d.ts.map

package/dist/toolkits/google-analytics/tools/reports.js

@@ -0,0 +1,200 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { DATA_V1ALPHA, DATA_V1BETA, gaList, gaPost, gaRequest, googleAnalyticsTokenField, namedDimension, namedMetric, normalizeProperty, paginationSchema, } from './client.js';
+const dateRange = z
+    .object({
+    startDate: z.string().describe("Start date 'YYYY-MM-DD', 'today', 'yesterday', or 'NdaysAgo'"),
+    endDate: z.string().describe("End date 'YYYY-MM-DD', 'today', 'yesterday', or 'NdaysAgo'"),
+    name: z.string().optional(),
+})
+    .catchall(z.unknown());
+const reportBody = {
+    dateRanges: z.array(dateRange).optional().describe('Date ranges (one required for most reports)'),
+    dimensions: z.array(namedDimension).optional().describe("Dimensions, e.g. [{name:'country'}] — confirm apiNames via getMetadata"),
+    metrics: z.array(namedMetric).optional().describe("Metrics, e.g. [{name:'activeUsers'}] (max 10) — confirm apiNames via getMetadata"),
+    dimensionFilter: z.record(z.any()).optional().describe('Dimension filter expression'),
+    metricFilter: z.record(z.any()).optional().describe('Metric filter expression'),
+    orderBys: z.array(z.record(z.any())).optional().describe("Ordering, e.g. [{desc:true,metric:{metricName:'activeUsers'}}]"),
+    limit: z.number().min(1).max(250000).optional().describe('Rows to return'),
+    offset: z.number().min(0).optional().describe('0-based start row for pagination'),
+    currencyCode: z.string().optional().describe("ISO 4217 currency, e.g. 'USD'"),
+    cohortSpec: z.record(z.any()).optional(),
+    comparisons: z.array(z.record(z.any())).optional(),
+    keepEmptyRows: z.boolean().optional(),
+    returnPropertyQuota: z.boolean().optional().describe('Include quota state in response'),
+};
+function reportExecute(base, suffix, action, extraBody) {
+    return async ({ googleAnalyticsToken, property, ...body }) => {
+        const payload = {};
+        for (const [k, v] of Object.entries(body))
+            if (v !== undefined)
+                payload[k] = v;
+        extraBody?.(payload);
+        return gaPost(googleAnalyticsToken, base, `${normalizeProperty(property)}:${suffix}`, payload, undefined, action);
+    };
+}
+const propertyField = z.string().describe("GA4 property 'properties/{id}' (bare numeric ID accepted)");
+export const runReport = tool({
+    description: 'Runs a standard GA4 report (dimensions × metrics over date ranges). Confirm dimension/metric apiNames via getMetadata first; check compatibility for risky combos.',
+    inputSchema: z.object({ googleAnalyticsToken: googleAnalyticsTokenField, property: propertyField, ...reportBody, metricAggregations: z.array(z.string()).optional() }),
+    execute: reportExecute(DATA_V1BETA, 'runReport', 'run report'),
+});
+export const batchRunReports = tool({
+    description: 'Runs multiple standard reports for one property in a single call. Each entry is a full runReport-style request.',
+    inputSchema: z.object({
+        googleAnalyticsToken: googleAnalyticsTokenField,
+        property: propertyField,
+        requests: z.array(z.record(z.any())).min(1).describe('Report requests (runReport bodies without property)'),
+    }),
+    execute: reportExecute(DATA_V1BETA, 'batchRunReports', 'batch run reports', (payload) => {
+        const { requests } = payload;
+        delete payload.requests;
+        payload.requests = requests;
+    }),
+});
+export const runPivotReport = tool({
+    description: 'Runs a pivot-table report (multi-dimensional cross-tab). Define pivots with fieldNames, limit, and metricAggregations.',
+    inputSchema: z.object({
+        googleAnalyticsToken: googleAnalyticsTokenField,
+        property: propertyField,
+        metrics: z.array(namedMetric).min(1).describe('At least one metric is required'),
+        pivots: z.array(z.record(z.any())).optional().describe("Pivots, e.g. [{fieldNames:['country'],limit:10}]"),
+        ...reportBody,
+    }),
+    execute: reportExecute(DATA_V1BETA, 'runPivotReport', 'run pivot report'),
+});
+export const batchRunPivotReports = tool({
+    description: 'Runs multiple pivot reports for one property in a single call.',
+    inputSchema: z.object({
+        googleAnalyticsToken: googleAnalyticsTokenField,
+        property: propertyField,
+        requests: z.array(z.record(z.any())).min(1).describe('Pivot report requests (runPivotReport bodies without property)'),
+    }),
+    execute: reportExecute(DATA_V1BETA, 'batchRunPivotReports', 'batch run pivot reports'),
+});
+export const runRealtimeReport = tool({
+    description: 'Runs a realtime report (last 30 minutes of activity). No date ranges; use minuteRanges and metricAggregations instead.',
+    inputSchema: z.object({
+        googleAnalyticsToken: googleAnalyticsTokenField,
+        property: propertyField,
+        dimensions: z.array(namedDimension).optional(),
+        metrics: z.array(namedMetric).optional(),
+        dimensionFilter: z.record(z.any()).optional(),
+        metricFilter: z.record(z.any()).optional(),
+        orderBys: z.array(z.record(z.any())).optional(),
+        limit: z.number().min(1).optional(),
+        minuteRanges: z.array(z.record(z.any())).optional().describe("Minute ranges, e.g. [{startMinutesAgo:29,endMinutesAgo:0}]"),
+        metricAggregations: z.array(z.string()).optional(),
+        returnPropertyQuota: z.boolean().optional(),
+    }),
+    execute: reportExecute(DATA_V1BETA, 'runRealtimeReport', 'run realtime report'),
+});
+export const runFunnelReport = tool({
+    description: 'Runs a funnel analysis report. Funnel needs steps[{name, filterExpression}]; step order in the response comes from step attributes, not row order.',
+    inputSchema: z.object({
+        googleAnalyticsToken: googleAnalyticsTokenField,
+        property: propertyField,
+        funnel: z.record(z.any()).describe("Funnel config with 'steps' (each step: name + filterExpression using funnelEventFilter/funnelFieldFilter)"),
+        dateRanges: z.array(dateRange).optional(),
+        segments: z.array(z.record(z.any())).max(4).optional().describe('Up to 4 segments, each yields its own row'),
+        dimensionFilter: z.record(z.any()).optional(),
+        funnelBreakdown: z.record(z.any()).optional(),
+        funnelNextAction: z.record(z.any()).optional(),
+        funnelVisualizationType: z.string().optional(),
+        limit: z.number().min(1).max(250000).optional(),
+        returnPropertyQuota: z.boolean().optional(),
+    }),
+    execute: reportExecute(DATA_V1BETA, 'runFunnelReport', 'run funnel report'),
+});
+export const checkCompatibility = tool({
+    description: 'Lists dimensions/metrics compatible with a report request. Call before runReport when mixing custom or unusual fields.',
+    inputSchema: z.object({
+        googleAnalyticsToken: googleAnalyticsTokenField,
+        property: propertyField,
+        dimensions: z.array(namedDimension).optional(),
+        metrics: z.array(namedMetric).max(10).optional().describe('Max 10 metrics'),
+        dimensionFilter: z.record(z.any()).optional(),
+        metricFilter: z.record(z.any()).optional(),
+        compatibilityFilter: z.enum(['DIMENSION_COMPATIBILITY_FILTER_UNSPECIFIED', 'COMPATIBLE', 'INCOMPATIBLE']).optional(),
+    }),
+    execute: reportExecute(DATA_V1BETA, 'checkCompatibility', 'check compatibility'),
+});
+export const getMetadata = tool({
+    description: 'Gets report metadata (available dimensions, metrics, comparisons) for a property. Always derive apiNames from here instead of hardcoding.',
+    inputSchema: z.object({
+        googleAnalyticsToken: googleAnalyticsTokenField,
+        name: z.string().describe("Metadata name 'properties/{id}/metadata' (bare ID accepted)"),
+    }),
+    execute: async ({ googleAnalyticsToken, name }) => {
+        try {
+            const full = name.includes('/metadata') ? name : `${normalizeProperty(name)}/metadata`;
+            const result = await gaRequest(googleAnalyticsToken, DATA_V1BETA, `/${full}`);
+            if (!result.ok)
+                return { error: 'Failed to get metadata', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error getting metadata', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const createReportTask = tool({
+    description: 'Creates an async report task for large/complex event-data reports. Poll getReportTask until ACTIVE, then queryReportTask for rows.',
+    inputSchema: z.object({
+        googleAnalyticsToken: googleAnalyticsTokenField,
+        parent: z.string().describe("Property 'properties/{id}' (bare ID accepted)"),
+        reportDefinition: z.record(z.any()).optional().describe('Report definition (metrics, dimensions, dateRanges, limit up to 250000)'),
+    }),
+    execute: async ({ googleAnalyticsToken, parent, reportDefinition }) => {
+        const body = {};
+        if (reportDefinition)
+            body.reportDefinition = reportDefinition;
+        return gaPost(googleAnalyticsToken, DATA_V1ALPHA, `${normalizeProperty(parent)}/reportTasks`, body, undefined, 'create report task');
+    },
+});
+export const getReportTask = tool({
+    description: 'Gets report-task metadata (processing state, definition). Use after createReportTask to check readiness.',
+    inputSchema: z.object({
+        googleAnalyticsToken: googleAnalyticsTokenField,
+        name: z.string().describe("Report task 'properties/{id}/reportTasks/{taskId}'"),
+    }),
+    execute: async ({ googleAnalyticsToken, name }) => {
+        try {
+            const result = await gaRequest(googleAnalyticsToken, DATA_V1ALPHA, `/${name}`);
+            if (!result.ok)
+                return { error: 'Failed to get report task', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error getting report task', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const listReportTasks = tool({
+    description: 'Lists report tasks for a property to find and reuse existing tasks.',
+    inputSchema: z.object({
+        googleAnalyticsToken: googleAnalyticsTokenField,
+        parent: z.string().describe("Property 'properties/{id}' (bare ID accepted)"),
+        ...paginationSchema,
+    }),
+    execute: async ({ googleAnalyticsToken, parent, pageSize, pageToken }) => gaList(googleAnalyticsToken, DATA_V1ALPHA, normalizeProperty(parent), 'reportTasks', { pageSize, pageToken }, 'list report tasks'),
+});
+export const queryReportTask = tool({
+    description: 'Retrieves rows from an ACTIVE report task. Errors unless the task state is ACTIVE — check getReportTask first.',
+    inputSchema: z.object({
+        googleAnalyticsToken: googleAnalyticsTokenField,
+        name: z.string().describe("Report task 'properties/{id}/reportTasks/{taskId}'"),
+        limit: z.number().min(1).max(250000).optional().describe('Rows to return (default 10000, capped by task limit)'),
+        offset: z.number().min(0).optional().describe('0-based row offset; omit or 0 for first page'),
+    }),
+    execute: async ({ googleAnalyticsToken, name, limit, offset }) => {
+        const body = {};
+        if (limit !== undefined)
+            body.limit = limit;
+        if (offset !== undefined)
+            body.offset = offset;
+        return gaPost(googleAnalyticsToken, DATA_V1ALPHA, `${name}:query`, body, undefined, 'query report task');
+    },
+});
+//# sourceMappingURL=reports.js.map

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

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

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

@@ -0,0 +1,42 @@
+const SVG = `<svg version="1.1" id="Livello_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
+	 viewBox="0 0 578.9 500" enable-background="new 0 0 578.9 500" xml:space="preserve">
+<g>
+	<path fill="#0F9D58" d="M52.6,52.6h473.7v394.7H52.6V52.6z"/>
+	<path fill="#57BB8A" d="M394.7,263.2c16.4,0,29.6-13.3,29.6-29.6s-13.3-29.6-29.6-29.6s-29.6,13.3-29.6,29.6
+		S378.4,263.2,394.7,263.2L394.7,263.2z M394.7,282.9c-31.7,0-65.8,16.8-65.8,37.6v21.6h131.6v-21.6
+		C460.5,299.7,426.4,282.9,394.7,282.9z M184.2,263.2c16.4,0,29.6-13.3,29.6-29.6s-13.3-29.6-29.6-29.6s-29.6,13.3-29.6,29.6
+		S167.9,263.2,184.2,263.2L184.2,263.2z M184.2,282.9c-31.7,0-65.8,16.8-65.8,37.6v21.6H250v-21.6
+		C250,299.7,215.9,282.9,184.2,282.9z"/>
+	<path fill="#F7F7F7" d="M289.5,236.8c21.8,0,39.5-17.7,39.4-39.5c0-21.8-17.7-39.5-39.5-39.4c-21.8,0-39.4,17.7-39.4,39.5
+		C250,219.2,267.7,236.8,289.5,236.8z M289.5,263.2c-44.4,0-92.1,23.6-92.1,52.6v26.3h184.2v-26.3
+		C381.6,286.7,333.9,263.2,289.5,263.2z"/>
+	<path fill="#F1F1F1" d="M342.1,421.1h118.4v26.3H342.1V421.1z"/>
+	<path fill="#F4B400" d="M539.5,0h-500C17.7,0,0,17.7,0,39.5v421.1C0,482.3,17.7,500,39.5,500h500c21.8,0,39.5-17.7,39.5-39.5V39.5
+		C578.9,17.7,561.3,0,539.5,0z M526.3,447.4H52.6V52.6h473.7V447.4z"/>
+	<path opacity="0.2" fill="#FFFFFF" enable-background="new    " d="M539.5,0h-500C17.7,0,0,17.7,0,39.5v3.3C0,21,17.7,3.3,39.5,3.3
+		h500c21.8,0,39.5,17.7,39.5,39.5v-3.3C578.9,17.7,561.3,0,539.5,0z"/>
+	<path opacity="0.2" fill="#BF360C" enable-background="new    " d="M539.5,496.7h-500C17.7,496.7,0,479,0,457.2v3.3
+		C0,482.3,17.7,500,39.5,500h500c21.8,0,39.5-17.7,39.5-39.5v-3.3C578.9,479,561.3,496.7,539.5,496.7z"/>
+	
+		<linearGradient id="SVGID_1_" gradientUnits="userSpaceOnUse" x1="154.8649" y1="295.747" x2="154.8649" y2="282.6343" gradientTransform="matrix(12.992 0 0 -4 -1584.6235 1631.0867)">
+		<stop  offset="0" style="stop-color:#BF360C;stop-opacity:0.2"/>
+		<stop  offset="1" style="stop-color:#BF360C;stop-opacity:2.000000e-02"/>
+	</linearGradient>
+	<path fill="url(#SVGID_1_)" d="M460.3,447.4H341.9l52.6,52.6h118.3L460.3,447.4z"/>
+	<path opacity="0.2" fill="#263238" enable-background="new    " d="M52.6,49.3h473.7v3.3H52.6V49.3z"/>
+	<path opacity="0.2" fill="#FFFFFF" enable-background="new    " d="M52.6,447.4h473.7v3.3H52.6V447.4z"/>
+	
+		<radialGradient id="SVGID_2_" cx="131.4012" cy="367.2001" r="18.1966" gradientTransform="matrix(38.0002 0 0 -38 -4973.3276 13965.3232)" gradientUnits="userSpaceOnUse">
+		<stop  offset="0" style="stop-color:#FFFFFF;stop-opacity:0.1"/>
+		<stop  offset="1" style="stop-color:#FFFFFF;stop-opacity:0"/>
+	</radialGradient>
+	<path fill="url(#SVGID_2_)" d="M539.5,0h-500C17.7,0,0,17.7,0,39.5v421.1C0,482.3,17.7,500,39.5,500h500
+		c21.8,0,39.5-17.7,39.5-39.5V39.5C578.9,17.7,561.3,0,539.5,0z"/>
+</g>
+</svg>
+`;
+export const GCLASSROOM_ICON = {
+    kind: 'svg',
+    dataUri: `data:image/svg+xml;base64,${Buffer.from(SVG).toString('base64')}`,
+};
+//# sourceMappingURL=icon.js.map

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

@@ -0,0 +1,67 @@
+import { defineToolkit, defineTool } from '../../core/define.js';
+import { inferToolScope } from '../../core/scope.js';
+import { GCLASSROOM_ICON } from './icon.js';
+import { googleClassroomTools } from './tools/index.js';
+export default defineToolkit({
+    id: 'google-classroom',
+    displayName: 'Google Classroom',
+    shortDescription: 'Manage courses, coursework, rosters, announcements, and grades in Google Classroom.',
+    category: 'Education & LMS',
+    icon: GCLASSROOM_ICON,
+    auth: {
+        type: 'oauth2',
+        tokenField: 'googleClassroomToken',
+        provider: {
+            slug: 'google-classroom',
+            env: { clientId: 'GOOGLE_CLASSROOM_CLIENT_ID', clientSecret: 'GOOGLE_CLASSROOM_CLIENT_SECRET' },
+            authorizeUrl: 'https://accounts.google.com/o/oauth2/v2/auth',
+            tokenUrl: 'https://oauth2.googleapis.com/token',
+            scopes: [
+                'https://www.googleapis.com/auth/classroom.courses',
+                'https://www.googleapis.com/auth/classroom.courses.readonly',
+                'https://www.googleapis.com/auth/classroom.rosters',
+                'https://www.googleapis.com/auth/classroom.rosters.readonly',
+                'https://www.googleapis.com/auth/classroom.profile.emails',
+                'https://www.googleapis.com/auth/classroom.profile.photos',
+                'https://www.googleapis.com/auth/classroom.coursework.me',
+                'https://www.googleapis.com/auth/classroom.coursework.me.readonly',
+                'https://www.googleapis.com/auth/classroom.coursework.students',
+                'https://www.googleapis.com/auth/classroom.coursework.students.readonly',
+                'https://www.googleapis.com/auth/classroom.courseworkmaterials',
+                'https://www.googleapis.com/auth/classroom.courseworkmaterials.readonly',
+                'https://www.googleapis.com/auth/classroom.announcements',
+                'https://www.googleapis.com/auth/classroom.announcements.readonly',
+                'https://www.googleapis.com/auth/classroom.topics',
+                'https://www.googleapis.com/auth/classroom.topics.readonly',
+                'https://www.googleapis.com/auth/classroom.guardianlinks.students',
+                'https://www.googleapis.com/auth/classroom.guardianlinks.students.readonly',
+                'https://www.googleapis.com/auth/classroom.guardians',
+                'https://www.googleapis.com/auth/classroom.guardians.readonly',
+                'https://www.googleapis.com/auth/classroom.addons.student',
+                'https://www.googleapis.com/auth/classroom.addons.teacher',
+                'https://www.googleapis.com/auth/classroom.push-notifications',
+                'https://www.googleapis.com/auth/classroom.invitations',
+                'https://www.googleapis.com/auth/classroom.invitations.readonly',
+            ],
+            exchangeStyle: 'form',
+            extraAuthParams: { access_type: 'offline', prompt: 'consent' },
+            connectDescription: 'Connect Google Classroom to manage courses, coursework, rosters, and announcements.',
+            callbackPath: '/api/auth/google-classroom/callback',
+            stateCookie: 'google_classroom_oauth_state',
+        },
+    },
+    allowedHosts: ['classroom.googleapis.com'],
+    tools: googleClassroomTools.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://classroom.google.com',
+        docsUrl: 'https://developers.google.com/classroom',
+    },
+});
+//# sourceMappingURL=manifest.js.map

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

@@ -0,0 +1,17 @@
+export declare const createCourseAlias: import("ai").Tool<{
+    googleClassroomToken: string;
+    courseId: string;
+    alias: string;
+}, any>;
+export declare const deleteCourseAlias: import("ai").Tool<{
+    googleClassroomToken: string;
+    courseId: string;
+    alias: string;
+}, any>;
+export declare const listCourseAliases: import("ai").Tool<{
+    googleClassroomToken: string;
+    courseId: string;
+    pageToken?: string | undefined;
+    pageSize?: number | undefined;
+}, any>;
+//# sourceMappingURL=aliases.d.ts.map