@rnsk/toolkits 0.0.7 → 0.0.9

package/dist/toolkits/google-ads/tools/mutate-portfolio-bidding-strategies.js

@@ -0,0 +1,41 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { adsMutate, customerIdField, developerTokenField, googleAdsTokenField, loginCustomerIdField, } from './client.js';
+const operationSchema = z.record(z.any()).describe('Portfolio strategy operation: {create: {name, target_cpa?/target_roas? (+ floors/ceilings), currency_code? (create-only, manager accounts)}}, {update: {resource_name, ...}}, {remove: resourceName}, update_mask?. Transition all campaigns before removal. Snake_case keys accepted.');
+export const mutatePortfolioBiddingStrategies = tool({
+    description: 'Creates, edits, or removes typed Target CPA / Target ROAS portfolio strategies. Attach with mutateCampaigns, read with getRmfReport, and transition all campaigns before removal.',
+    inputSchema: z.object({
+        googleAdsToken: googleAdsTokenField,
+        developerToken: developerTokenField,
+        operations: z.array(operationSchema).min(1),
+        validateOnly: z.boolean().optional().describe('Validate without applying changes'),
+        partialFailure: z.boolean().optional().describe('Valid ops succeed even if others fail'),
+        responseContentType: z.enum(['RESOURCE_NAME_ONLY', 'MUTABLE_RESOURCE']).optional().describe('How much of each mutated resource to return'),
+        customerId: customerIdField,
+        loginCustomerId: loginCustomerIdField,
+    }),
+    execute: async ({ googleAdsToken, developerToken, operations, validateOnly, partialFailure, responseContentType, customerId, loginCustomerId }) => {
+        try {
+            const result = await adsMutate(googleAdsToken, developerToken, 'biddingStrategies', {
+                customerId,
+                loginCustomerId,
+                operations,
+                validateOnly,
+                partialFailure,
+                responseContentType,
+            });
+            if (!result.ok) {
+                return { error: 'Failed to mutate portfolio bidding strategies', details: result.error };
+            }
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error mutating portfolio bidding strategies',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=mutate-portfolio-bidding-strategies.js.map

package/dist/toolkits/google-ads/tools/search-stream-gaql.d.ts

@@ -0,0 +1,37 @@
+export declare const searchStreamGaql: import("ai").Tool<{
+    query: string;
+    googleAdsToken: string;
+    developerToken: string;
+    customerId?: string | undefined;
+    loginCustomerId?: string | undefined;
+    summaryRowSetting?: "UNSPECIFIED" | "NO_SUMMARY_ROW" | "SUMMARY_ROW_ONLY" | "SUMMARY_ROW_WITH_RESULTS" | undefined;
+}, {
+    error: string;
+    details?: undefined;
+    results?: undefined;
+    requestId?: undefined;
+    summaryRow?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    details: any;
+    results?: undefined;
+    requestId?: undefined;
+    summaryRow?: undefined;
+    message?: undefined;
+} | {
+    results: Record<string, unknown>[];
+    requestId: string | undefined;
+    summaryRow: Record<string, unknown> | undefined;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    results?: undefined;
+    requestId?: undefined;
+    summaryRow?: undefined;
+}>;
+//# sourceMappingURL=search-stream-gaql.d.ts.map

package/dist/toolkits/google-ads/tools/search-stream-gaql.js

@@ -0,0 +1,41 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { adsSearchStream, collectStreamRows, customerIdField, developerTokenField, googleAdsTokenField, loginCustomerIdField, } from './client.js';
+export const searchStreamGaql = tool({
+    description: 'Executes a GAQL query (SELECT ... FROM ... WHERE ...) and aggregates every streamed batch in order. Select only needed fields with WHERE and LIMIT for large reports.',
+    inputSchema: z.object({
+        googleAdsToken: googleAdsTokenField,
+        developerToken: developerTokenField,
+        query: z.string().describe('GAQL query string, e.g. SELECT campaign.name FROM campaign LIMIT 50'),
+        summaryRowSetting: z
+            .enum(['UNSPECIFIED', 'NO_SUMMARY_ROW', 'SUMMARY_ROW_ONLY', 'SUMMARY_ROW_WITH_RESULTS'])
+            .optional()
+            .describe('Whether to include an aggregated summary row'),
+        customerId: customerIdField,
+        loginCustomerId: loginCustomerIdField,
+    }),
+    execute: async ({ googleAdsToken, developerToken, query, summaryRowSetting, customerId, loginCustomerId }) => {
+        try {
+            if (!/^\s*select\s/i.test(query))
+                return { error: 'query must be a SELECT GAQL query' };
+            const result = await adsSearchStream(googleAdsToken, developerToken, {
+                customerId,
+                loginCustomerId,
+                query,
+                summaryRowSetting,
+            });
+            if (!result.ok)
+                return { error: 'Failed to execute GAQL query', details: result.error };
+            const { rows, requestId, summaryRow } = collectStreamRows(result.data);
+            return { results: rows, requestId, summaryRow };
+        }
+        catch (error) {
+            return {
+                error: 'Error executing GAQL query',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=search-stream-gaql.js.map

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

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

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

@@ -0,0 +1,11 @@
+const SVG = `<svg width="284px" height="284px" viewBox="-14 0 284 284" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" preserveAspectRatio="xMidYMid">
+    <g>
+        <path d="M256.003159,247.933017 C256.055907,258.030289 251.77298,267.664804 244.241349,274.390297 C236.709718,281.11579 226.653817,284.285366 216.626905,283.094249 C198.58347,280.424364 185.360959,264.722632 185.800619,246.488035 L185.800619,36.8452103 C185.364944,18.5907614 198.619678,2.88144681 216.687112,0.238996295 C226.704325,-0.933476157 236.743571,2.24455542 244.261279,8.9678962 C251.778988,15.691237 256.053811,25.3147619 256.003159,35.4002282 L256.003159,247.933017 Z" fill="#F9AB00"></path>
+        <path d="M35.1010243,213.193238 C54.4867848,213.193238 70.2020487,228.908502 70.2020487,248.294263 C70.2020487,267.680023 54.4867848,283.395287 35.1010243,283.395287 C15.7152639,283.395287 0,267.680023 0,248.294263 C0,228.908502 15.7152639,213.193238 35.1010243,213.193238 Z M127.459466,106.806429 C107.981896,107.874068 92.8698765,124.212107 93.3217628,143.713681 L93.3217628,237.998765 C93.3217628,263.58699 104.580582,279.120548 121.077461,282.431965 C131.434034,284.530959 142.185473,281.860819 150.356699,275.160414 C158.527925,268.460009 163.252393,258.439904 163.222912,247.872809 L163.222912,142.088076 C163.240039,132.641687 159.462041,123.584285 152.737293,116.950107 C146.012546,110.315928 136.904752,106.661084 127.459466,106.806429 L127.459466,106.806429 Z" fill="#E37400"></path>
+    </g>
+</svg>`;
+export const GANALYTICS_ICON = {
+    kind: 'svg',
+    dataUri: `data:image/svg+xml;base64,${Buffer.from(SVG).toString('base64')}`,
+};
+//# sourceMappingURL=icon.js.map

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

@@ -0,0 +1,48 @@
+import { defineToolkit, defineTool } from '../../core/define.js';
+import { inferToolScope } from '../../core/scope.js';
+import { GANALYTICS_ICON } from './icon.js';
+import { googleAnalyticsTools } from './tools/index.js';
+export default defineToolkit({
+    id: 'google-analytics',
+    displayName: 'Google Analytics',
+    shortDescription: 'Run GA4 reports, manage audiences, properties, and Measurement Protocol events.',
+    category: 'Analytics & Data',
+    icon: GANALYTICS_ICON,
+    auth: {
+        type: 'oauth2',
+        tokenField: 'googleAnalyticsToken',
+        provider: {
+            slug: 'google-analytics',
+            env: { clientId: 'GOOGLE_ANALYTICS_CLIENT_ID', clientSecret: 'GOOGLE_ANALYTICS_CLIENT_SECRET' },
+            authorizeUrl: 'https://accounts.google.com/o/oauth2/v2/auth',
+            tokenUrl: 'https://oauth2.googleapis.com/token',
+            scopes: [
+                'https://www.googleapis.com/auth/analytics.readonly',
+                'https://www.googleapis.com/auth/analytics.edit',
+            ],
+            exchangeStyle: 'form',
+            extraAuthParams: { access_type: 'offline', prompt: 'consent' },
+            connectDescription: 'Connect Google Analytics for GA4 reports, audiences, properties, and admin.',
+            callbackPath: '/api/auth/google-analytics/callback',
+            stateCookie: 'google_analytics_oauth_state',
+        },
+    },
+    allowedHosts: [
+        'analyticsadmin.googleapis.com',
+        'analyticsdata.googleapis.com',
+        'www.google-analytics.com',
+    ],
+    tools: googleAnalyticsTools.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://analytics.google.com',
+        docsUrl: 'https://developers.google.com/analytics',
+    },
+});
+//# sourceMappingURL=manifest.js.map

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

@@ -0,0 +1,73 @@
+export declare const getAccount: import("ai").Tool<{
+    name: string;
+    googleAnalyticsToken: string;
+}, any>;
+export declare const listAccountsV1Beta: import("ai").Tool<{
+    googleAnalyticsToken: string;
+    pageToken?: string | undefined;
+    pageSize?: number | undefined;
+    showDeleted?: boolean | undefined;
+}, any>;
+export declare const listAccountSummaries: import("ai").Tool<{
+    googleAnalyticsToken: string;
+    pageToken?: string | undefined;
+    pageSize?: number | undefined;
+}, any>;
+export declare const provisionAccountTicket: import("ai").Tool<{
+    redirectUri: string;
+    account: {
+        regionCode: string;
+        displayName: string;
+    };
+    googleAnalyticsToken: string;
+}, any>;
+export declare const getProperty: import("ai").Tool<{
+    name: string;
+    googleAnalyticsToken: string;
+}, any>;
+export declare const listPropertiesFiltered: import("ai").Tool<{
+    filter: string;
+    googleAnalyticsToken: string;
+    pageToken?: string | undefined;
+    pageSize?: number | undefined;
+    showDeleted?: boolean | undefined;
+}, any>;
+export declare const updateProperty: import("ai").Tool<{
+    name: string;
+    updateMask: string;
+    googleAnalyticsToken: string;
+    parent?: string | undefined;
+    currencyCode?: string | undefined;
+    displayName?: string | undefined;
+    timeZone?: string | undefined;
+    industryCategory?: string | undefined;
+    propertyType?: "PROPERTY_TYPE_UNSPECIFIED" | "PROPERTY_TYPE_ORDINARY" | "PROPERTY_TYPE_SUBPROPERTY" | "PROPERTY_TYPE_ROLLUP" | undefined;
+}, any>;
+export declare const createRollupProperty: import("ai").Tool<{
+    account: string;
+    googleAnalyticsToken: string;
+    displayName: string;
+    timeZone: string;
+    sourceProperties?: string[] | undefined;
+}, any>;
+export declare const getPropertyQuotasSnapshot: import("ai").Tool<{
+    property: string;
+    googleAnalyticsToken: string;
+}, any>;
+export declare const getAttributionSettings: import("ai").Tool<{
+    name: string;
+    googleAnalyticsToken: string;
+}, any>;
+export declare const getDataRetentionSettings: import("ai").Tool<{
+    name: string;
+    googleAnalyticsToken: string;
+}, any>;
+export declare const getDataSharingSettings: import("ai").Tool<{
+    name: string;
+    googleAnalyticsToken: string;
+}, any>;
+export declare const getGoogleSignalsSettings: import("ai").Tool<{
+    name: string;
+    googleAnalyticsToken: string;
+}, any>;
+//# sourceMappingURL=admin.d.ts.map

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

@@ -0,0 +1,238 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { ADMIN_V1BETA, gaGet, gaPost, gaRequest, googleAnalyticsTokenField, normalizeProperty, paginationSchema, } from './client.js';
+export const getAccount = tool({
+    description: 'Gets a single account by resource name. Confirm the name (accounts/{id}) via listAccountsV1Beta first.',
+    inputSchema: z.object({
+        googleAnalyticsToken: googleAnalyticsTokenField,
+        name: z.string().describe("Account 'accounts/{id}'"),
+    }),
+    execute: async ({ googleAnalyticsToken, name }) => {
+        try {
+            return await gaGet(googleAnalyticsToken, ADMIN_V1BETA, name);
+        }
+        catch (error) {
+            return { error: 'Error getting account', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const listAccountsV1Beta = tool({
+    description: 'Lists all accounts accessible to the caller (v1beta). Soft-deleted accounts are excluded unless showDeleted is set.',
+    inputSchema: z.object({
+        googleAnalyticsToken: googleAnalyticsTokenField,
+        ...paginationSchema,
+        showDeleted: z.boolean().optional().describe('Include soft-deleted accounts'),
+    }),
+    execute: async ({ googleAnalyticsToken, pageSize, pageToken, showDeleted }) => {
+        try {
+            const result = await gaRequest(googleAnalyticsToken, ADMIN_V1BETA, '/accounts', {
+                pageSize, pageToken, showDeleted,
+            });
+            if (!result.ok)
+                return { error: 'Failed to list accounts', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error listing accounts', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const listAccountSummaries = tool({
+    description: 'Lists high-level summaries of all accessible accounts and their properties without fetching full details.',
+    inputSchema: z.object({
+        googleAnalyticsToken: googleAnalyticsTokenField,
+        ...paginationSchema,
+    }),
+    execute: async ({ googleAnalyticsToken, pageSize, pageToken }) => {
+        try {
+            const result = await gaRequest(googleAnalyticsToken, ADMIN_V1BETA, '/accountSummaries', { pageSize, pageToken });
+            if (!result.ok)
+                return { error: 'Failed to list account summaries', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error listing account summaries', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const provisionAccountTicket = tool({
+    description: 'Provisions an account ticket for creating a new account. Returns a ticket the user accepts via Terms of Service at redirectUri.',
+    inputSchema: z.object({
+        googleAnalyticsToken: googleAnalyticsTokenField,
+        account: z.object({
+            displayName: z.string().describe('Human-readable account name'),
+            regionCode: z.string().describe("Business country as CLDR region code, e.g. 'US'"),
+        }).describe('Account details to create'),
+        redirectUri: z.string().describe('Redirect URI (registered in Cloud Console) after ToS acceptance'),
+    }),
+    execute: async ({ googleAnalyticsToken, account, redirectUri }) => gaPost(googleAnalyticsToken, ADMIN_V1BETA, 'accounts:provisionAccountTicket', { account, redirectUri }, undefined, 'provision account ticket'),
+});
+export const getProperty = tool({
+    description: 'Gets a single GA4 property (display name, time zone, currency, settings) by resource name.',
+    inputSchema: z.object({
+        googleAnalyticsToken: googleAnalyticsTokenField,
+        name: z.string().describe("Property 'properties/{id}'"),
+    }),
+    execute: async ({ googleAnalyticsToken, name }) => {
+        try {
+            return await gaGet(googleAnalyticsToken, ADMIN_V1BETA, name);
+        }
+        catch (error) {
+            return { error: 'Error getting property', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const listPropertiesFiltered = tool({
+    description: "Lists GA4 properties by filter ('parent:accounts/123', 'ancestor:accounts/123', or 'firebase_project:...'). Preferred over the deprecated unfiltered list.",
+    inputSchema: z.object({
+        googleAnalyticsToken: googleAnalyticsTokenField,
+        filter: z.string().describe("Filter, e.g. 'parent:accounts/123' or 'ancestor:accounts/123'"),
+        ...paginationSchema,
+        showDeleted: z.boolean().optional().describe('Include soft-deleted properties'),
+    }),
+    execute: async ({ googleAnalyticsToken, filter, pageSize, pageToken, showDeleted }) => {
+        try {
+            const result = await gaRequest(googleAnalyticsToken, ADMIN_V1BETA, '/properties', {
+                filter, pageSize, pageToken, showDeleted,
+            });
+            if (!result.ok)
+                return { error: 'Failed to list properties', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error listing properties', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const updateProperty = tool({
+    description: 'Updates a property (displayName, timeZone, currencyCode). Only updateMask fields change — use snake_case names or "*" for full replace.',
+    inputSchema: z.object({
+        googleAnalyticsToken: googleAnalyticsTokenField,
+        name: z.string().describe("Property 'properties/{id}'"),
+        updateMask: z.string().describe("Fields to update, e.g. 'display_name,time_zone' or '*'"),
+        displayName: z.string().max(100).optional(),
+        timeZone: z.string().optional().describe("IANA time zone, e.g. 'America/Los_Angeles'"),
+        currencyCode: z.string().optional().describe("ISO 4217 code, e.g. 'USD'"),
+        industryCategory: z.string().optional(),
+        propertyType: z.enum(['PROPERTY_TYPE_UNSPECIFIED', 'PROPERTY_TYPE_ORDINARY', 'PROPERTY_TYPE_SUBPROPERTY', 'PROPERTY_TYPE_ROLLUP']).optional(),
+        parent: z.string().optional().describe("Logical parent 'accounts/{id}' or 'properties/{id}'"),
+    }),
+    execute: async ({ googleAnalyticsToken, name, updateMask, ...fields }) => {
+        try {
+            const body = { name };
+            const keyMap = {
+                displayName: 'displayName', timeZone: 'timeZone', currencyCode: 'currencyCode',
+                industryCategory: 'industryCategory', propertyType: 'propertyType', parent: 'parent',
+            };
+            for (const [k, v] of Object.entries(fields)) {
+                if (v !== undefined && keyMap[k])
+                    body[keyMap[k]] = v;
+            }
+            const result = await gaRequest(googleAnalyticsToken, ADMIN_V1BETA, `/${name}`, {
+                method: 'PATCH', query: { updateMask }, body,
+            });
+            if (!result.ok)
+                return { error: 'Failed to update property', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error updating property', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const createRollupProperty = tool({
+    description: 'Creates a roll-up property aggregating multiple GA4 source properties into one view.',
+    inputSchema: z.object({
+        googleAnalyticsToken: googleAnalyticsTokenField,
+        account: z.string().describe("Parent account 'accounts/{id}'"),
+        displayName: z.string().describe('Display name for the roll-up property'),
+        timeZone: z.string().describe("IANA time zone, e.g. 'America/Los_Angeles'"),
+        sourceProperties: z.array(z.string()).optional().describe("Source properties, e.g. ['properties/123']"),
+    }),
+    execute: async ({ googleAnalyticsToken, account, displayName, timeZone, sourceProperties }) => {
+        const body = { account, displayName, timeZone };
+        if (sourceProperties)
+            body.sourceProperties = sourceProperties;
+        return gaPost(googleAnalyticsToken, ADMIN_V1BETA, 'properties:createRollupProperty', body, undefined, 'create roll-up property');
+    },
+});
+export const getPropertyQuotasSnapshot = tool({
+    description: 'Gets property quota usage by category (core, funnel, realtime snapshots). Data can lag real consumption — treat as approximate.',
+    inputSchema: z.object({
+        googleAnalyticsToken: googleAnalyticsTokenField,
+        property: z.string().describe("Property 'properties/{id}' (bare ID accepted)"),
+    }),
+    execute: async ({ googleAnalyticsToken, property }) => {
+        try {
+            const result = await gaRequest(googleAnalyticsToken, ADMIN_V1BETA, `/${normalizeProperty(property)}:getPropertyQuotasSnapshot`);
+            if (!result.ok)
+                return { error: 'Failed to get property quotas snapshot', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error getting property quotas snapshot', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const getAttributionSettings = tool({
+    description: 'Gets attribution configuration (models, lookback windows, conversion export) for a property.',
+    inputSchema: z.object({
+        googleAnalyticsToken: googleAnalyticsTokenField,
+        name: z.string().describe("Attribution settings 'properties/{id}/attributionSettings'"),
+    }),
+    execute: async ({ googleAnalyticsToken, name }) => {
+        try {
+            return await gaGet(googleAnalyticsToken, ADMIN_V1BETA, name);
+        }
+        catch (error) {
+            return { error: 'Error getting attribution settings', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const getDataRetentionSettings = tool({
+    description: 'Gets event-level and user-level data retention durations and reset settings for a property.',
+    inputSchema: z.object({
+        googleAnalyticsToken: googleAnalyticsTokenField,
+        name: z.string().describe("Retention settings 'properties/{id}/dataRetentionSettings'"),
+    }),
+    execute: async ({ googleAnalyticsToken, name }) => {
+        try {
+            return await gaGet(googleAnalyticsToken, ADMIN_V1BETA, name);
+        }
+        catch (error) {
+            return { error: 'Error getting data retention settings', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const getDataSharingSettings = tool({
+    description: 'Gets data-sharing configuration for an account (support, sales, product sharing flags).',
+    inputSchema: z.object({
+        googleAnalyticsToken: googleAnalyticsTokenField,
+        name: z.string().describe("Sharing settings 'accounts/{id}/dataSharingSettings'"),
+    }),
+    execute: async ({ googleAnalyticsToken, name }) => {
+        try {
+            return await gaGet(googleAnalyticsToken, ADMIN_V1BETA, name);
+        }
+        catch (error) {
+            return { error: 'Error getting data sharing settings', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const getGoogleSignalsSettings = tool({
+    description: 'Gets Google Signals configuration (enabled state, consent status) for a property.',
+    inputSchema: z.object({
+        googleAnalyticsToken: googleAnalyticsTokenField,
+        name: z.string().describe("Signals settings 'properties/{id}/googleSignalsSettings'"),
+    }),
+    execute: async ({ googleAnalyticsToken, name }) => {
+        try {
+            return await gaGet(googleAnalyticsToken, ADMIN_V1BETA, name);
+        }
+        catch (error) {
+            return { error: 'Error getting Google Signals settings', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+//# sourceMappingURL=admin.js.map

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

@@ -0,0 +1,81 @@
+export declare const getAudience: import("ai").Tool<{
+    googleAnalyticsToken: string;
+    propertyId: string;
+    audienceId: string;
+}, any>;
+export declare const listAudiences: import("ai").Tool<{
+    parent: string;
+    googleAnalyticsToken: string;
+    pageToken?: string | undefined;
+    pageSize?: number | undefined;
+}, any>;
+export declare const createAudienceExport: import("ai").Tool<{
+    parent: string;
+    audience: string;
+    googleAnalyticsToken: string;
+    dimensions?: {
+        dimensionName: string;
+    }[] | undefined;
+}, any>;
+export declare const getAudienceExport: import("ai").Tool<{
+    name: string;
+    googleAnalyticsToken: string;
+}, any>;
+export declare const listAudienceExports: import("ai").Tool<{
+    parent: string;
+    googleAnalyticsToken: string;
+    pageToken?: string | undefined;
+    pageSize?: number | undefined;
+}, any>;
+export declare const queryAudienceExport: import("ai").Tool<{
+    name: string;
+    googleAnalyticsToken: string;
+    limit?: number | undefined;
+    offset?: number | undefined;
+}, any>;
+export declare const createAudienceList: import("ai").Tool<{
+    parent: string;
+    dimensions: {
+        dimensionName: string;
+    }[];
+    audience: string;
+    googleAnalyticsToken: string;
+    webhookNotification?: Record<string, any> | undefined;
+}, any>;
+export declare const getAudienceList: import("ai").Tool<{
+    name: string;
+    googleAnalyticsToken: string;
+}, any>;
+export declare const listAudienceLists: import("ai").Tool<{
+    parent: string;
+    googleAnalyticsToken: string;
+    pageToken?: string | undefined;
+    pageSize?: number | undefined;
+}, any>;
+export declare const queryAudienceList: import("ai").Tool<{
+    name: string;
+    googleAnalyticsToken: string;
+    limit?: number | undefined;
+    offset?: number | undefined;
+}, any>;
+export declare const createRecurringAudienceList: import("ai").Tool<{
+    parent: string;
+    dimensions: {
+        dimensionName: string;
+    }[];
+    audience: string;
+    googleAnalyticsToken: string;
+    webhookNotification?: Record<string, any> | undefined;
+    activeDaysRemaining?: number | undefined;
+}, any>;
+export declare const getRecurringAudienceList: import("ai").Tool<{
+    name: string;
+    googleAnalyticsToken: string;
+}, any>;
+export declare const listRecurringAudienceLists: import("ai").Tool<{
+    parent: string;
+    googleAnalyticsToken: string;
+    pageToken?: string | undefined;
+    pageSize?: number | undefined;
+}, any>;
+//# sourceMappingURL=audiences.d.ts.map