@rnsk/toolkits 0.0.7 → 0.0.9

package/dist/toolkits/google-ads/tools/create-callout-asset.d.ts

@@ -0,0 +1,23 @@
+export declare const createCalloutAsset: import("ai").Tool<{
+    googleAdsToken: string;
+    developerToken: string;
+    callout: {
+        calloutText: string;
+        startDate?: string | undefined;
+        endDate?: string | undefined;
+        adScheduleTargets?: {
+            dayOfWeek: "MONDAY" | "TUESDAY" | "WEDNESDAY" | "THURSDAY" | "FRIDAY" | "SATURDAY" | "SUNDAY";
+            startHour: number;
+            startMinute: "ZERO" | "FIFTEEN" | "THIRTY" | "FORTY_FIVE";
+            endHour: number;
+            endMinute: "ZERO" | "FIFTEEN" | "THIRTY" | "FORTY_FIVE";
+        }[] | undefined;
+    };
+    name?: string | undefined;
+    customerId?: string | undefined;
+    loginCustomerId?: string | undefined;
+    validateOnly?: boolean | undefined;
+    partialFailure?: boolean | undefined;
+    responseContentType?: "RESOURCE_NAME_ONLY" | "MUTABLE_RESOURCE" | undefined;
+}, any>;
+//# sourceMappingURL=create-callout-asset.d.ts.map

package/dist/toolkits/google-ads/tools/create-callout-asset.js

@@ -0,0 +1,62 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { adsMutate, customerIdField, developerTokenField, googleAdsTokenField, loginCustomerIdField, } from './client.js';
+const scheduleSchema = z.object({
+    dayOfWeek: z.enum(['MONDAY', 'TUESDAY', 'WEDNESDAY', 'THURSDAY', 'FRIDAY', 'SATURDAY', 'SUNDAY']).describe('Day when the callout is shown'),
+    startHour: z.number().min(0).max(23),
+    startMinute: z.enum(['ZERO', 'FIFTEEN', 'THIRTY', 'FORTY_FIVE']),
+    endHour: z.number().min(0).max(24),
+    endMinute: z.enum(['ZERO', 'FIFTEEN', 'THIRTY', 'FORTY_FIVE']),
+});
+export const createCalloutAsset = tool({
+    description: 'Creates an immutable account asset containing a validated callout. Associate the returned resource with mutateCustomerAssets using field_type CALLOUT; cleanup removes that association (assets cannot be deleted).',
+    inputSchema: z.object({
+        googleAdsToken: googleAdsTokenField,
+        developerToken: developerTokenField,
+        callout: z.object({
+            calloutText: z.string().min(1).max(25).describe('Callout text, up to 25 characters'),
+            startDate: z.string().optional().describe('First eligible date YYYY-MM-DD'),
+            endDate: z.string().optional().describe('Last eligible date YYYY-MM-DD'),
+            adScheduleTargets: z.array(scheduleSchema).max(42).optional().describe('Weekly serving intervals, at most six per day'),
+        }),
+        name: z.string().optional().describe('Optional internal name for the immutable asset'),
+        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, callout, name, validateOnly, partialFailure, responseContentType, customerId, loginCustomerId }) => {
+        try {
+            const calloutAsset = { calloutText: callout.calloutText };
+            if (callout.startDate)
+                calloutAsset.startDate = callout.startDate;
+            if (callout.endDate)
+                calloutAsset.endDate = callout.endDate;
+            if (callout.adScheduleTargets)
+                calloutAsset.adScheduleTargets = callout.adScheduleTargets;
+            const create = { calloutAsset };
+            if (name)
+                create.name = name;
+            const result = await adsMutate(googleAdsToken, developerToken, 'assets', {
+                customerId,
+                loginCustomerId,
+                operations: [{ create }],
+                validateOnly,
+                partialFailure,
+                responseContentType,
+            });
+            if (!result.ok)
+                return { error: 'Failed to create callout asset', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error creating callout asset',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=create-callout-asset.js.map

package/dist/toolkits/google-ads/tools/create-customer-list.d.ts

@@ -0,0 +1,9 @@
+export declare const createCustomerList: import("ai").Tool<{
+    name: string;
+    googleAdsToken: string;
+    developerToken: string;
+    description?: string | undefined;
+    customerId?: string | undefined;
+    loginCustomerId?: string | undefined;
+}, any>;
+//# sourceMappingURL=create-customer-list.d.ts.map

package/dist/toolkits/google-ads/tools/create-customer-list.js

@@ -0,0 +1,42 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { adsMutate, customerIdField, developerTokenField, googleAdsTokenField, loginCustomerIdField, } from './client.js';
+export const createCustomerList = tool({
+    description: 'Creates a customer list (UserList audience/remarketing list, not an account). Email-based lists must comply with Ads policies and consent laws; membership and targeting eligibility take hours to propagate.',
+    inputSchema: z.object({
+        googleAdsToken: googleAdsTokenField,
+        developerToken: developerTokenField,
+        name: z.string().describe('Name of the customer list (UserList)'),
+        description: z.string().optional().describe('Description of the customer list'),
+        customerId: customerIdField,
+        loginCustomerId: loginCustomerIdField,
+    }),
+    execute: async ({ googleAdsToken, developerToken, name, description, customerId, loginCustomerId }) => {
+        try {
+            const create = {
+                name,
+                crmBasedUserList: {},
+                membershipStatus: 'OPEN',
+            };
+            if (description)
+                create.description = description;
+            const result = await adsMutate(googleAdsToken, developerToken, 'userLists', {
+                customerId,
+                loginCustomerId,
+                operations: [{ create }],
+            });
+            if (!result.ok)
+                return { error: 'Failed to create customer list', details: result.error };
+            const data = result.data;
+            return { resourceName: data.results?.[0]?.resourceName, ...result.data };
+        }
+        catch (error) {
+            return {
+                error: 'Error creating customer list',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=create-customer-list.js.map

package/dist/toolkits/google-ads/tools/get-campaign-by-id.d.ts

@@ -0,0 +1,32 @@
+export declare const getCampaignById: import("ai").Tool<{
+    id: string;
+    googleAdsToken: string;
+    developerToken: string;
+    customerId?: string | undefined;
+    loginCustomerId?: string | undefined;
+}, {
+    error: string;
+    details?: undefined;
+    result?: undefined;
+    requestId?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    details: any;
+    result?: undefined;
+    requestId?: undefined;
+    message?: undefined;
+} | {
+    result: Record<string, unknown>;
+    requestId: string | undefined;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    result?: undefined;
+    requestId?: undefined;
+}>;
+//# sourceMappingURL=get-campaign-by-id.d.ts.map

package/dist/toolkits/google-ads/tools/get-campaign-by-id.js

@@ -0,0 +1,38 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { adsSearchStream, collectStreamRows, customerIdField, developerTokenField, googleAdsTokenField, loginCustomerIdField, normalizeCustomerId, } from './client.js';
+export const getCampaignById = tool({
+    description: 'Returns details of a Google Ads campaign by ID. Requires the correct customer_id — missing or mismatched IDs return empty results.',
+    inputSchema: z.object({
+        googleAdsToken: googleAdsTokenField,
+        developerToken: developerTokenField,
+        id: z.string().describe('Numeric ID of the campaign to retrieve'),
+        customerId: customerIdField,
+        loginCustomerId: loginCustomerIdField,
+    }),
+    execute: async ({ googleAdsToken, developerToken, id, customerId, loginCustomerId }) => {
+        try {
+            if (!/^\d+$/.test(id))
+                return { error: 'id must be a numeric campaign ID' };
+            const cid = normalizeCustomerId(customerId);
+            const result = await adsSearchStream(googleAdsToken, developerToken, {
+                customerId,
+                loginCustomerId,
+                query: `SELECT campaign.id, campaign.name, campaign.status, campaign.advertising_channel_type, campaign.advertising_channel_sub_type, campaign.start_date, campaign.end_date, campaign.campaign_budget, campaign.bidding_strategy, campaign.network_settings FROM campaign WHERE campaign.id = ${id} LIMIT 1`,
+            });
+            if (!result.ok)
+                return { error: 'Failed to get campaign', details: result.error };
+            const { rows, requestId } = collectStreamRows(result.data);
+            void cid;
+            return { result: rows[0] ?? {}, requestId };
+        }
+        catch (error) {
+            return {
+                error: 'Error getting campaign',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=get-campaign-by-id.js.map

package/dist/toolkits/google-ads/tools/get-campaign-by-name.d.ts

@@ -0,0 +1,32 @@
+export declare const getCampaignByName: import("ai").Tool<{
+    name: string;
+    googleAdsToken: string;
+    developerToken: string;
+    customerId?: string | undefined;
+    loginCustomerId?: string | undefined;
+}, {
+    error: string;
+    details?: undefined;
+    result?: undefined;
+    requestId?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    details: any;
+    result?: undefined;
+    requestId?: undefined;
+    message?: undefined;
+} | {
+    result: Record<string, unknown>;
+    requestId: string | undefined;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    result?: undefined;
+    requestId?: undefined;
+}>;
+//# sourceMappingURL=get-campaign-by-name.d.ts.map

package/dist/toolkits/google-ads/tools/get-campaign-by-name.js

@@ -0,0 +1,37 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { adsSearchStream, collectStreamRows, customerIdField, developerTokenField, googleAdsTokenField, loginCustomerIdField, } from './client.js';
+export const getCampaignByName = tool({
+    description: 'Retrieves a Google Ads campaign by its exact name using GAQL equality. Requires an active connection with valid customer_id.',
+    inputSchema: z.object({
+        googleAdsToken: googleAdsTokenField,
+        developerToken: developerTokenField,
+        name: z.string().describe('Exact campaign name to match'),
+        customerId: customerIdField,
+        loginCustomerId: loginCustomerIdField,
+    }),
+    execute: async ({ googleAdsToken, developerToken, name, customerId, loginCustomerId }) => {
+        try {
+            if (/['"\\\0\n\r]/.test(name)) {
+                return { error: 'name contains characters that cannot be embedded in a GAQL literal' };
+            }
+            const result = await adsSearchStream(googleAdsToken, developerToken, {
+                customerId,
+                loginCustomerId,
+                query: `SELECT campaign.id, campaign.name, campaign.status, campaign.advertising_channel_type, campaign.start_date, campaign.end_date, campaign.campaign_budget, campaign.network_settings FROM campaign WHERE campaign.name = '${name}' LIMIT 1`,
+            });
+            if (!result.ok)
+                return { error: 'Failed to get campaign', details: result.error };
+            const { rows, requestId } = collectStreamRows(result.data);
+            return { result: rows[0] ?? {}, requestId };
+        }
+        catch (error) {
+            return {
+                error: 'Error getting campaign',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=get-campaign-by-name.js.map

package/dist/toolkits/google-ads/tools/get-conversion-action-tag-snippets.d.ts

@@ -0,0 +1,28 @@
+export declare const getConversionActionTagSnippets: import("ai").Tool<{
+    googleAdsToken: string;
+    developerToken: string;
+    conversionActionId: string;
+    customerId?: string | undefined;
+    loginCustomerId?: string | undefined;
+}, {
+    error: string;
+    details?: undefined;
+    conversionAction?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    details: any;
+    conversionAction?: undefined;
+    message?: undefined;
+} | {
+    conversionAction: any;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    conversionAction?: undefined;
+}>;
+//# sourceMappingURL=get-conversion-action-tag-snippets.d.ts.map

package/dist/toolkits/google-ads/tools/get-conversion-action-tag-snippets.js

@@ -0,0 +1,33 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { GOOGLE_ADS_API_VERSION, adsRequest, customerIdField, developerTokenField, googleAdsTokenField, loginCustomerIdField, normalizeCustomerId, } from './client.js';
+export const getConversionActionTagSnippets = tool({
+    description: 'Retrieves provider-generated website or call conversion tag snippets for a conversion action. Use after creating a conversion action, before installing tags.',
+    inputSchema: z.object({
+        googleAdsToken: googleAdsTokenField,
+        developerToken: developerTokenField,
+        conversionActionId: z.string().regex(/^\d+$/).describe('Numeric conversion action ID'),
+        customerId: customerIdField,
+        loginCustomerId: loginCustomerIdField,
+    }),
+    execute: async ({ googleAdsToken, developerToken, conversionActionId, customerId, loginCustomerId }) => {
+        try {
+            const cid = normalizeCustomerId(customerId);
+            if (!cid)
+                return { error: 'customerId is required' };
+            const result = await adsRequest(googleAdsToken, developerToken, `/${GOOGLE_ADS_API_VERSION}/customers/${cid}/conversionActions/${conversionActionId}`, { loginCustomerId });
+            if (!result.ok) {
+                return { error: 'Failed to get conversion action tag snippets', details: result.error };
+            }
+            return { conversionAction: result.data };
+        }
+        catch (error) {
+            return {
+                error: 'Error getting conversion action tag snippets',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=get-conversion-action-tag-snippets.js.map

package/dist/toolkits/google-ads/tools/get-customer-lists.d.ts

@@ -0,0 +1,32 @@
+export declare const getCustomerLists: import("ai").Tool<{
+    googleAdsToken: string;
+    developerToken: string;
+    pageToken?: string | undefined;
+    customerId?: string | undefined;
+    loginCustomerId?: string | undefined;
+}, {
+    error: string;
+    details?: undefined;
+    userLists?: undefined;
+    nextPageToken?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    details: any;
+    userLists?: undefined;
+    nextPageToken?: undefined;
+    message?: undefined;
+} | {
+    userLists: (Record<string, unknown> | undefined)[];
+    nextPageToken: string | undefined;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    userLists?: undefined;
+    nextPageToken?: undefined;
+}>;
+//# sourceMappingURL=get-customer-lists.d.ts.map

package/dist/toolkits/google-ads/tools/get-customer-lists.js

@@ -0,0 +1,41 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { GOOGLE_ADS_API_VERSION, adsRequest, customerIdField, developerTokenField, googleAdsTokenField, loginCustomerIdField, normalizeCustomerId, } from './client.js';
+export const getCustomerLists = tool({
+    description: 'Lists customer lists (UserList audience/remarketing segments, not accounts) in Google Ads. Review all results before picking one — names may be similar and list IDs differ from account IDs.',
+    inputSchema: z.object({
+        googleAdsToken: googleAdsTokenField,
+        developerToken: developerTokenField,
+        pageToken: z.string().optional().describe('Pagination token from a previous nextPageToken'),
+        customerId: customerIdField,
+        loginCustomerId: loginCustomerIdField,
+    }),
+    execute: async ({ googleAdsToken, developerToken, pageToken, customerId, loginCustomerId }) => {
+        try {
+            const cid = normalizeCustomerId(customerId);
+            if (!cid)
+                return { error: 'customerId is required' };
+            const body = {
+                query: 'SELECT user_list.id, user_list.name, user_list.description, user_list.resource_name FROM user_list',
+            };
+            if (pageToken)
+                body.pageToken = pageToken;
+            const result = await adsRequest(googleAdsToken, developerToken, `/${GOOGLE_ADS_API_VERSION}/customers/${cid}/googleAds:search`, { method: 'POST', body, loginCustomerId });
+            if (!result.ok)
+                return { error: 'Failed to list customer lists', details: result.error };
+            const data = result.data;
+            return {
+                userLists: (data.results ?? []).map((r) => r.userList).filter(Boolean),
+                nextPageToken: data.nextPageToken,
+            };
+        }
+        catch (error) {
+            return {
+                error: 'Error listing customer lists',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=get-customer-lists.js.map

package/dist/toolkits/google-ads/tools/get-rmf-report.d.ts

@@ -0,0 +1,60 @@
+export declare const getRmfReport: import("ai").Tool<{
+    googleAdsToken: string;
+    developerToken: string;
+    report: "CUSTOMER" | "CAMPAIGN" | "AD_GROUP_AD" | "KEYWORD" | "SEARCH_TERM" | "DYNAMIC_SEARCH_AD_SEARCH_TERM" | "BIDDING_STRATEGY";
+    startDate?: string | undefined;
+    endDate?: string | undefined;
+    customerId?: string | undefined;
+    loginCustomerId?: string | undefined;
+    maxRows?: number | undefined;
+    optionalMetrics?: string[] | undefined;
+}, {
+    error: string;
+    details?: undefined;
+    report?: undefined;
+    dateRange?: undefined;
+    columns?: undefined;
+    requiredColumns?: undefined;
+    optionalMetrics?: undefined;
+    results?: undefined;
+    truncated?: undefined;
+    requestId?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    details: any;
+    report?: undefined;
+    dateRange?: undefined;
+    columns?: undefined;
+    requiredColumns?: undefined;
+    optionalMetrics?: undefined;
+    results?: undefined;
+    truncated?: undefined;
+    requestId?: undefined;
+    message?: undefined;
+} | {
+    report: "CUSTOMER" | "CAMPAIGN" | "AD_GROUP_AD" | "KEYWORD" | "SEARCH_TERM" | "DYNAMIC_SEARCH_AD_SEARCH_TERM" | "BIDDING_STRATEGY";
+    dateRange: string;
+    columns: string[];
+    requiredColumns: string[];
+    optionalMetrics: string[];
+    results: Record<string, unknown>[];
+    truncated: boolean;
+    requestId: string | undefined;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    report?: undefined;
+    dateRange?: undefined;
+    columns?: undefined;
+    requiredColumns?: undefined;
+    optionalMetrics?: undefined;
+    results?: undefined;
+    truncated?: undefined;
+    requestId?: undefined;
+}>;
+//# sourceMappingURL=get-rmf-report.d.ts.map

package/dist/toolkits/google-ads/tools/get-rmf-report.js

@@ -0,0 +1,97 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { adsSearchStream, collectStreamRows, customerIdField, developerTokenField, googleAdsTokenField, loginCustomerIdField, } from './client.js';
+const REPORT_TEMPLATES = {
+    CUSTOMER: {
+        from: 'customer',
+        requiredColumns: ['customer.id', 'customer.descriptive_name', 'metrics.clicks', 'metrics.impressions', 'metrics.cost_micros', 'metrics.conversions'],
+    },
+    CAMPAIGN: {
+        from: 'campaign',
+        requiredColumns: ['campaign.id', 'campaign.name', 'campaign.status', 'metrics.clicks', 'metrics.impressions', 'metrics.cost_micros', 'metrics.conversions'],
+    },
+    AD_GROUP_AD: {
+        from: 'ad_group_ad',
+        requiredColumns: ['campaign.name', 'ad_group.name', 'ad_group_ad.ad.id', 'ad_group_ad.status', 'metrics.clicks', 'metrics.impressions', 'metrics.cost_micros', 'metrics.conversions'],
+    },
+    KEYWORD: {
+        from: 'keyword_view',
+        requiredColumns: ['campaign.name', 'ad_group.name', 'ad_group_criterion.keyword.text', 'ad_group_criterion.keyword.match_type', 'metrics.clicks', 'metrics.impressions', 'metrics.cost_micros', 'metrics.conversions'],
+    },
+    SEARCH_TERM: {
+        from: 'search_term_view',
+        requiredColumns: ['campaign.name', 'ad_group.name', 'search_term_view.search_term', 'metrics.clicks', 'metrics.impressions', 'metrics.cost_micros', 'metrics.conversions'],
+    },
+    DYNAMIC_SEARCH_AD_SEARCH_TERM: {
+        from: 'dynamic_search_ads_search_term_view',
+        requiredColumns: ['campaign.name', 'ad_group.name', 'dynamic_search_ads_search_term_view.search_term', 'dynamic_search_ads_search_term_view.headline', 'metrics.clicks', 'metrics.impressions', 'metrics.cost_micros', 'metrics.conversions'],
+    },
+    BIDDING_STRATEGY: {
+        from: 'bidding_strategy',
+        requiredColumns: ['bidding_strategy.id', 'bidding_strategy.name', 'bidding_strategy.type', 'metrics.clicks', 'metrics.impressions', 'metrics.cost_micros', 'metrics.conversions'],
+    },
+};
+export const getRmfReport = tool({
+    description: 'Runs a bounded Google Ads report template (CUSTOMER, CAMPAIGN, AD_GROUP_AD, KEYWORD, SEARCH_TERM, DYNAMIC_SEARCH_AD_SEARCH_TERM, BIDDING_STRATEGY). Required columns are always selected; dates default to LAST_30_DAYS.',
+    inputSchema: z.object({
+        googleAdsToken: googleAdsTokenField,
+        developerToken: developerTokenField,
+        report: z.enum(['CUSTOMER', 'CAMPAIGN', 'AD_GROUP_AD', 'KEYWORD', 'SEARCH_TERM', 'DYNAMIC_SEARCH_AD_SEARCH_TERM', 'BIDDING_STRATEGY']).describe('Report template to execute'),
+        startDate: z.string().optional().describe('Inclusive start date YYYY-MM-DD'),
+        endDate: z.string().optional().describe('Inclusive end date YYYY-MM-DD'),
+        maxRows: z.number().min(1).max(10000).optional().describe('Maximum rows returned (default 1000)'),
+        optionalMetrics: z.array(z.string()).optional().describe('Additional metrics such as metrics.ctr'),
+        customerId: customerIdField,
+        loginCustomerId: loginCustomerIdField,
+    }),
+    execute: async ({ googleAdsToken, developerToken, report, startDate, endDate, maxRows, optionalMetrics, customerId, loginCustomerId }) => {
+        try {
+            const template = REPORT_TEMPLATES[report];
+            if (!template)
+                return { error: `Unknown report template: ${report}` };
+            const columns = [...template.requiredColumns, ...(optionalMetrics ?? [])];
+            const limit = maxRows ?? 1000;
+            let dateRange;
+            if (startDate || endDate) {
+                if (!startDate || !endDate)
+                    return { error: 'startDate and endDate must both be provided' };
+                if (!/^\d{4}-\d{2}-\d{2}$/.test(startDate) || !/^\d{4}-\d{2}-\d{2}$/.test(endDate)) {
+                    return { error: 'Dates must be YYYY-MM-DD' };
+                }
+                dateRange = `segments.date BETWEEN '${startDate}' AND '${endDate}'`;
+            }
+            else {
+                dateRange = 'segments.date DURING LAST_30_DAYS';
+            }
+            // One extra row detects truncation without silently dropping results.
+            const query = `SELECT ${columns.join(', ')} FROM ${template.from} WHERE ${dateRange} LIMIT ${limit + 1}`;
+            const result = await adsSearchStream(googleAdsToken, developerToken, {
+                customerId,
+                loginCustomerId,
+                query,
+            });
+            if (!result.ok)
+                return { error: 'Failed to run report', details: result.error };
+            const { rows, requestId } = collectStreamRows(result.data);
+            const truncated = rows.length > limit;
+            return {
+                report,
+                dateRange: startDate ? `${startDate}..${endDate}` : 'LAST_30_DAYS',
+                columns,
+                requiredColumns: template.requiredColumns,
+                optionalMetrics: optionalMetrics ?? [],
+                results: truncated ? rows.slice(0, limit) : rows,
+                truncated,
+                requestId,
+            };
+        }
+        catch (error) {
+            return {
+                error: 'Error running report',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=get-rmf-report.js.map