@rnsk/toolkits 0.0.6 → 0.0.8

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

@@ -0,0 +1,230 @@
+// @ts-nocheck
+import { addOrRemoveToCustomerList } from './add-or-remove-to-customer-list.js';
+import { createCalloutAsset } from './create-callout-asset.js';
+import { createCustomerList } from './create-customer-list.js';
+import { getCampaignById } from './get-campaign-by-id.js';
+import { getCampaignByName } from './get-campaign-by-name.js';
+import { getConversionActionTagSnippets } from './get-conversion-action-tag-snippets.js';
+import { getCustomerLists } from './get-customer-lists.js';
+import { getRmfReport } from './get-rmf-report.js';
+import { listAccessibleCustomers } from './list-accessible-customers.js';
+import { listSubAccounts } from './list-sub-accounts.js';
+import { mutateAdGroupAds } from './mutate-ad-group-ads.js';
+import { mutateAdGroupAssets } from './mutate-ad-group-assets.js';
+import { mutateAdGroupBidModifiers } from './mutate-ad-group-bid-modifiers.js';
+import { mutateAdGroupCriteria } from './mutate-ad-group-criteria.js';
+import { mutateAdGroups } from './mutate-ad-groups.js';
+import { mutateAssets } from './mutate-assets.js';
+import { mutateBiddingStrategies } from './mutate-bidding-strategies.js';
+import { mutateCampaignAssets } from './mutate-campaign-assets.js';
+import { mutateCampaignBudgets } from './mutate-campaign-budgets.js';
+import { mutateCampaignCriteria } from './mutate-campaign-criteria.js';
+import { mutateCampaignLabels } from './mutate-campaign-labels.js';
+import { mutateCampaigns } from './mutate-campaigns.js';
+import { mutateCampaignsV2 } from './mutate-campaigns-v2.js';
+import { mutateConversionActions } from './mutate-conversion-actions.js';
+import { mutateCustomerAssets } from './mutate-customer-assets.js';
+import { mutateLabels } from './mutate-labels.js';
+import { mutatePortfolioBiddingStrategies } from './mutate-portfolio-bidding-strategies.js';
+import { searchStreamGaql } from './search-stream-gaql.js';
+export { addOrRemoveToCustomerList, createCalloutAsset, createCustomerList, getCampaignById, getCampaignByName, getConversionActionTagSnippets, getCustomerLists, getRmfReport, listAccessibleCustomers, listSubAccounts, mutateAdGroupAds, mutateAdGroupAssets, mutateAdGroupBidModifiers, mutateAdGroupCriteria, mutateAdGroups, mutateAssets, mutateBiddingStrategies, mutateCampaignAssets, mutateCampaignBudgets, mutateCampaignCriteria, mutateCampaignLabels, mutateCampaigns, mutateCampaignsV2, mutateConversionActions, mutateCustomerAssets, mutateLabels, mutatePortfolioBiddingStrategies, searchStreamGaql, };
+const auth = 'googleAdsToken';
+export const googleAdsTools = [
+    {
+        name: 'googleAdsAddOrRemoveToCustomerList',
+        description: 'Adds or removes contacts from a customer list (UserList audience). Use for customer-match membership updates.',
+        tool: addOrRemoveToCustomerList,
+        requiredAuth: auth,
+        scope: 'write',
+    },
+    {
+        name: 'googleAdsCreateCalloutAsset',
+        description: 'Creates an immutable callout asset. Associate it with mutateCustomerAssets (CALLOUT) afterwards.',
+        tool: createCalloutAsset,
+        requiredAuth: auth,
+        scope: 'write',
+    },
+    {
+        name: 'googleAdsCreateCustomerList',
+        description: 'Creates a customer list (UserList audience/remarketing list). Use to start a new audience segment.',
+        tool: createCustomerList,
+        requiredAuth: auth,
+        scope: 'write',
+    },
+    {
+        name: 'googleAdsGetCampaignById',
+        description: 'Returns campaign details by numeric ID. Use when the campaign ID is known.',
+        tool: getCampaignById,
+        requiredAuth: auth,
+        scope: 'read',
+    },
+    {
+        name: 'googleAdsGetCampaignByName',
+        description: 'Retrieves a campaign by exact name. Use when only the campaign name is known.',
+        tool: getCampaignByName,
+        requiredAuth: auth,
+        scope: 'read',
+    },
+    {
+        name: 'googleAdsGetConversionActionTagSnippets',
+        description: 'Retrieves website/call tag snippets for a conversion action. Use after creating one, before installing tags.',
+        tool: getConversionActionTagSnippets,
+        requiredAuth: auth,
+        scope: 'read',
+    },
+    {
+        name: 'googleAdsGetCustomerLists',
+        description: 'Lists customer lists (audience segments). Use to discover list IDs before membership updates.',
+        tool: getCustomerLists,
+        requiredAuth: auth,
+        scope: 'read',
+    },
+    {
+        name: 'googleAdsGetRmfReport',
+        description: 'Runs a bounded report template (customer, campaign, ad, keyword, search term, bidding strategy). Use for standard performance reports.',
+        tool: getRmfReport,
+        requiredAuth: auth,
+        scope: 'read',
+    },
+    {
+        name: 'googleAdsListAccessibleCustomers',
+        description: 'Lists customer resource names accessible to the OAuth user. Use to discover which accounts are reachable.',
+        tool: listAccessibleCustomers,
+        requiredAuth: auth,
+        scope: 'read',
+    },
+    {
+        name: 'googleAdsListSubAccounts',
+        description: 'Lists child accounts under a manager (MCC) account. Use to pick which child account to target.',
+        tool: listSubAccounts,
+        requiredAuth: auth,
+        scope: 'read',
+    },
+    {
+        name: 'googleAdsMutateAdGroupAds',
+        description: 'Creates, updates, or removes ad group ads including responsive search ads.',
+        tool: mutateAdGroupAds,
+        requiredAuth: auth,
+        scope: 'write',
+    },
+    {
+        name: 'googleAdsMutateAdGroupAssets',
+        description: 'Links assets to ad groups (sitelinks, callouts, snippets, images). Use after creating assets.',
+        tool: mutateAdGroupAssets,
+        requiredAuth: auth,
+        scope: 'write',
+    },
+    {
+        name: 'googleAdsMutateAdGroupBidModifiers',
+        description: 'Creates, updates, or removes ad group bid modifiers (device, hotel criteria).',
+        tool: mutateAdGroupBidModifiers,
+        requiredAuth: auth,
+        scope: 'write',
+    },
+    {
+        name: 'googleAdsMutateAdGroupCriteria',
+        description: 'Manages ad group criteria (keywords, audiences, demographics, placements, topics, webpages, listing groups). Removes are irreversible.',
+        tool: mutateAdGroupCriteria,
+        requiredAuth: auth,
+        scope: 'write',
+    },
+    {
+        name: 'googleAdsMutateAdGroups',
+        description: 'Creates, updates, or removes ad groups in batch. Removes are irreversible.',
+        tool: mutateAdGroups,
+        requiredAuth: auth,
+        scope: 'write',
+    },
+    {
+        name: 'googleAdsMutateAssets',
+        description: 'Creates or updates assets (sitelinks, snippets, text, lead forms, promotions, calls, prices, media).',
+        tool: mutateAssets,
+        requiredAuth: auth,
+        scope: 'write',
+    },
+    {
+        name: 'googleAdsMutateBiddingStrategies',
+        description: 'Creates, updates, or removes portfolio bidding strategies (Target CPA/ROAS/Spend, Maximize Conversions/Value, Impression Share).',
+        tool: mutateBiddingStrategies,
+        requiredAuth: auth,
+        scope: 'write',
+    },
+    {
+        name: 'googleAdsMutateCampaignAssets',
+        description: 'Links assets to campaigns. Use after creating assets.',
+        tool: mutateCampaignAssets,
+        requiredAuth: auth,
+        scope: 'write',
+    },
+    {
+        name: 'googleAdsMutateCampaignBudgets',
+        description: 'Creates, updates, or removes campaign budgets. Use before creating campaigns.',
+        tool: mutateCampaignBudgets,
+        requiredAuth: auth,
+        scope: 'write',
+    },
+    {
+        name: 'googleAdsMutateCampaignCriteria',
+        description: 'Manages campaign-level targeting (locations, languages, negative keywords, devices, schedules, audiences, IP exclusions).',
+        tool: mutateCampaignCriteria,
+        requiredAuth: auth,
+        scope: 'write',
+    },
+    {
+        name: 'googleAdsMutateCampaignLabels',
+        description: 'Creates or removes campaign-label relationships for organizing and reporting.',
+        tool: mutateCampaignLabels,
+        requiredAuth: auth,
+        scope: 'write',
+    },
+    {
+        name: 'googleAdsMutateCampaigns',
+        description: 'Creates, updates, or removes campaigns in batch. Removes are irreversible.',
+        tool: mutateCampaigns,
+        requiredAuth: auth,
+        scope: 'write',
+    },
+    {
+        name: 'googleAdsMutateCampaignsV2',
+        description: 'Creates, updates, or removes search/display campaigns with typed bidding strategies.',
+        tool: mutateCampaignsV2,
+        requiredAuth: auth,
+        scope: 'write',
+    },
+    {
+        name: 'googleAdsMutateConversionActions',
+        description: 'Creates, updates, or removes conversion actions for conversion tracking.',
+        tool: mutateConversionActions,
+        requiredAuth: auth,
+        scope: 'write',
+    },
+    {
+        name: 'googleAdsMutateCustomerAssets',
+        description: 'Creates or removes customer-level asset associations. Removal is irreversible.',
+        tool: mutateCustomerAssets,
+        requiredAuth: auth,
+        scope: 'write',
+    },
+    {
+        name: 'googleAdsMutateLabels',
+        description: 'Creates, updates, or removes labels. Pair with campaign label mutations.',
+        tool: mutateLabels,
+        requiredAuth: auth,
+        scope: 'write',
+    },
+    {
+        name: 'googleAdsMutatePortfolioBiddingStrategies',
+        description: 'Creates, edits, or removes typed Target CPA / Target ROAS portfolio strategies.',
+        tool: mutatePortfolioBiddingStrategies,
+        requiredAuth: auth,
+        scope: 'write',
+    },
+    {
+        name: 'googleAdsSearchStreamGaql',
+        description: 'Executes an arbitrary GAQL query and aggregates streamed batches. Use for custom reports and lookups.',
+        tool: searchStreamGaql,
+        requiredAuth: auth,
+        scope: 'read',
+    },
+];
+//# sourceMappingURL=index.js.map

package/dist/toolkits/google-ads/tools/list-accessible-customers.d.ts

@@ -0,0 +1,5 @@
+export declare const listAccessibleCustomers: import("ai").Tool<{
+    googleAdsToken: string;
+    developerToken: string;
+}, any>;
+//# sourceMappingURL=list-accessible-customers.d.ts.map

package/dist/toolkits/google-ads/tools/list-accessible-customers.js

@@ -0,0 +1,26 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { GOOGLE_ADS_API_VERSION, adsRequest, developerTokenField, googleAdsTokenField, } from './client.js';
+export const listAccessibleCustomers = tool({
+    description: 'Lists Google Ads customer resource names directly accessible to the authenticated OAuth user. Google ignores customer_id for this endpoint; for MCC child names and hierarchy use listSubAccounts.',
+    inputSchema: z.object({
+        googleAdsToken: googleAdsTokenField,
+        developerToken: developerTokenField,
+    }),
+    execute: async ({ googleAdsToken, developerToken }) => {
+        try {
+            const result = await adsRequest(googleAdsToken, developerToken, `/${GOOGLE_ADS_API_VERSION}/customers:listAccessibleCustomers`);
+            if (!result.ok)
+                return { error: 'Failed to list accessible customers', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error listing accessible customers',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=list-accessible-customers.js.map

package/dist/toolkits/google-ads/tools/list-sub-accounts.d.ts

@@ -0,0 +1,51 @@
+export declare const listSubAccounts: import("ai").Tool<{
+    googleAdsToken: string;
+    developerToken: string;
+    pageToken?: string | undefined;
+    customerId?: string | undefined;
+    loginCustomerId?: string | undefined;
+}, {
+    error: string;
+    details?: undefined;
+    subAccounts?: undefined;
+    nextPageToken?: undefined;
+    fieldMask?: undefined;
+    requestId?: undefined;
+    queryResourceConsumption?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    details: any;
+    subAccounts?: undefined;
+    nextPageToken?: undefined;
+    fieldMask?: undefined;
+    requestId?: undefined;
+    queryResourceConsumption?: undefined;
+    message?: undefined;
+} | {
+    subAccounts: {
+        customerId: unknown;
+        resourceName: unknown;
+        descriptiveName: unknown;
+        manager: unknown;
+        status: unknown;
+        level: unknown;
+    }[];
+    nextPageToken: string | undefined;
+    fieldMask: string | undefined;
+    requestId: string | undefined;
+    queryResourceConsumption: string | undefined;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    subAccounts?: undefined;
+    nextPageToken?: undefined;
+    fieldMask?: undefined;
+    requestId?: undefined;
+    queryResourceConsumption?: undefined;
+}>;
+//# sourceMappingURL=list-sub-accounts.d.ts.map

package/dist/toolkits/google-ads/tools/list-sub-accounts.js

@@ -0,0 +1,55 @@
+// @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 listSubAccounts = tool({
+    description: 'Lists direct child/sub-accounts under a manager (MCC) account. Use before account-scoped calls so the user can pick which child account to target.',
+    inputSchema: z.object({
+        googleAdsToken: googleAdsTokenField,
+        developerToken: developerTokenField,
+        pageToken: z.string().optional().describe('Pagination token from a previous nextPageToken'),
+        customerId: customerIdField.describe('Manager/MCC customer ID whose sub-accounts should be listed'),
+        loginCustomerId: loginCustomerIdField,
+    }),
+    execute: async ({ googleAdsToken, developerToken, pageToken, customerId, loginCustomerId }) => {
+        try {
+            const cid = normalizeCustomerId(customerId);
+            if (!cid)
+                return { error: 'customerId (manager account) is required' };
+            const body = {
+                query: 'SELECT customer_client.client_customer, customer_client.id, customer_client.descriptive_name, customer_client.manager, customer_client.status, customer_client.level, customer_client.resource_name FROM customer_client',
+            };
+            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 sub accounts', details: result.error };
+            const data = result.data;
+            const subAccounts = (data.results ?? [])
+                .map((r) => r.customerClient)
+                .filter(Boolean)
+                .map((c) => ({
+                customerId: c.clientCustomer ?? c.id,
+                resourceName: c.resourceName,
+                descriptiveName: c.descriptiveName,
+                manager: c.manager,
+                status: c.status,
+                level: c.level,
+            }));
+            return {
+                subAccounts,
+                nextPageToken: data.nextPageToken,
+                fieldMask: data.fieldMask,
+                requestId: data.requestId,
+                queryResourceConsumption: data.queryResourceConsumption,
+            };
+        }
+        catch (error) {
+            return {
+                error: 'Error listing sub accounts',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=list-sub-accounts.js.map

package/dist/toolkits/google-ads/tools/mutate-ad-group-ads.d.ts

@@ -0,0 +1,11 @@
+export declare const mutateAdGroupAds: import("ai").Tool<{
+    googleAdsToken: string;
+    developerToken: string;
+    operations: Record<string, any>[];
+    customerId?: string | undefined;
+    loginCustomerId?: string | undefined;
+    validateOnly?: boolean | undefined;
+    partialFailure?: boolean | undefined;
+    responseContentType?: "RESOURCE_NAME_ONLY" | "MUTABLE_RESOURCE" | undefined;
+}, any>;
+//# sourceMappingURL=mutate-ad-group-ads.d.ts.map

package/dist/toolkits/google-ads/tools/mutate-ad-group-ads.js

@@ -0,0 +1,40 @@
+// @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('AdGroupAd operation: {create: {...}} for responsive search ads (ad_group, status, ad with responsive_search_ad headlines/descriptions and final_urls), {update: {...}, update_mask?}, or {remove: resourceName}. Snake_case keys accepted.');
+export const mutateAdGroupAds = tool({
+    description: 'Creates, updates, or removes ads in ad groups, including responsive search ads. Use after campaigns, budgets, ad groups, and keywords exist so the ad group has serving creative.',
+    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, 'adGroupAds', {
+                customerId,
+                loginCustomerId,
+                operations,
+                validateOnly,
+                partialFailure,
+                responseContentType,
+            });
+            if (!result.ok)
+                return { error: 'Failed to mutate ad group ads', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error mutating ad group ads',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=mutate-ad-group-ads.js.map

package/dist/toolkits/google-ads/tools/mutate-ad-group-assets.d.ts

@@ -0,0 +1,11 @@
+export declare const mutateAdGroupAssets: import("ai").Tool<{
+    googleAdsToken: string;
+    developerToken: string;
+    operations: Record<string, any>[];
+    customerId?: string | undefined;
+    loginCustomerId?: string | undefined;
+    validateOnly?: boolean | undefined;
+    partialFailure?: boolean | undefined;
+    responseContentType?: "RESOURCE_NAME_ONLY" | "MUTABLE_RESOURCE" | undefined;
+}, any>;
+//# sourceMappingURL=mutate-ad-group-assets.d.ts.map

package/dist/toolkits/google-ads/tools/mutate-ad-group-assets.js

@@ -0,0 +1,40 @@
+// @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('AdGroupAsset operation: {create: {ad_group, asset, field_type, status}}, {update: {...}, update_mask?}, or {remove: resourceName}. Snake_case keys accepted.');
+export const mutateAdGroupAssets = tool({
+    description: 'Creates, updates, or removes links between assets and ad groups. Use after creating assets to attach sitelinks, callouts, snippets, images, and other asset types at ad group level.',
+    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, 'adGroupAssets', {
+                customerId,
+                loginCustomerId,
+                operations,
+                validateOnly,
+                partialFailure,
+                responseContentType,
+            });
+            if (!result.ok)
+                return { error: 'Failed to mutate ad group assets', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error mutating ad group assets',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=mutate-ad-group-assets.js.map

package/dist/toolkits/google-ads/tools/mutate-ad-group-bid-modifiers.d.ts

@@ -0,0 +1,11 @@
+export declare const mutateAdGroupBidModifiers: import("ai").Tool<{
+    googleAdsToken: string;
+    developerToken: string;
+    operations: Record<string, any>[];
+    customerId?: string | undefined;
+    loginCustomerId?: string | undefined;
+    validateOnly?: boolean | undefined;
+    partialFailure?: boolean | undefined;
+    responseContentType?: "RESOURCE_NAME_ONLY" | "MUTABLE_RESOURCE" | undefined;
+}, any>;
+//# sourceMappingURL=mutate-ad-group-bid-modifiers.d.ts.map

package/dist/toolkits/google-ads/tools/mutate-ad-group-bid-modifiers.js

@@ -0,0 +1,40 @@
+// @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('AdGroupBidModifier operation: {create: {ad_group, bid_modifier, plus one criterion (device, hotel, ...)}}, {update: {...}, update_mask?}, or {remove: resourceName}. Snake_case keys accepted.');
+export const mutateAdGroupBidModifiers = tool({
+    description: 'Creates, updates, or removes ad group bid modifiers such as device bid adjustments or hotel-specific criteria.',
+    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, 'adGroupBidModifiers', {
+                customerId,
+                loginCustomerId,
+                operations,
+                validateOnly,
+                partialFailure,
+                responseContentType,
+            });
+            if (!result.ok)
+                return { error: 'Failed to mutate ad group bid modifiers', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error mutating ad group bid modifiers',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=mutate-ad-group-bid-modifiers.js.map

package/dist/toolkits/google-ads/tools/mutate-ad-group-criteria.d.ts

@@ -0,0 +1,11 @@
+export declare const mutateAdGroupCriteria: import("ai").Tool<{
+    googleAdsToken: string;
+    developerToken: string;
+    operations: Record<string, any>[];
+    customerId?: string | undefined;
+    loginCustomerId?: string | undefined;
+    validateOnly?: boolean | undefined;
+    partialFailure?: boolean | undefined;
+    responseContentType?: "RESOURCE_NAME_ONLY" | "MUTABLE_RESOURCE" | "UNSPECIFIED" | undefined;
+}, any>;
+//# sourceMappingURL=mutate-ad-group-criteria.d.ts.map

package/dist/toolkits/google-ads/tools/mutate-ad-group-criteria.js

@@ -0,0 +1,40 @@
+// @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('AdGroupCriterion operation with exactly one of create (ad_group plus keyword/audience/demographic/placement/topic/webpage/listing_group payload), update (resource_name plus fields), or remove (resource name, irreversible). Snake_case keys accepted.');
+export const mutateAdGroupCriteria = tool({
+    description: 'Creates, updates, or removes ad group criteria (keywords, audiences, demographics, placements, topics, webpages, listing groups). Removes are irreversible; use validateOnly to dry-run.',
+    inputSchema: z.object({
+        googleAdsToken: googleAdsTokenField,
+        developerToken: developerTokenField,
+        operations: z.array(operationSchema).min(1).max(5000),
+        validateOnly: z.boolean().optional().describe('Validate without applying changes'),
+        partialFailure: z.boolean().optional().describe('Valid ops succeed even if others fail (atomic otherwise)'),
+        responseContentType: z.enum(['UNSPECIFIED', '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, 'adGroupCriteria', {
+                customerId,
+                loginCustomerId,
+                operations,
+                validateOnly,
+                partialFailure,
+                responseContentType,
+            });
+            if (!result.ok)
+                return { error: 'Failed to mutate ad group criteria', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error mutating ad group criteria',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=mutate-ad-group-criteria.js.map

package/dist/toolkits/google-ads/tools/mutate-ad-groups.d.ts

@@ -0,0 +1,10 @@
+export declare const mutateAdGroups: import("ai").Tool<{
+    googleAdsToken: string;
+    developerToken: string;
+    operations: Record<string, any>[];
+    customerId?: string | undefined;
+    loginCustomerId?: string | undefined;
+    validateOnly?: boolean | undefined;
+    partialFailure?: boolean | undefined;
+}, any>;
+//# sourceMappingURL=mutate-ad-groups.d.ts.map

package/dist/toolkits/google-ads/tools/mutate-ad-groups.js

@@ -0,0 +1,38 @@
+// @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('AdGroup operation: {create: {name, campaign, type?, status?}}, {update: {resource_name, ...}}, or {remove: resourceName} (irreversible). Snake_case keys accepted.');
+export const mutateAdGroups = tool({
+    description: 'Creates, updates, or removes ad groups within campaigns in batch. Removes are irreversible — deleted ad groups cannot be recovered.',
+    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'),
+        customerId: customerIdField,
+        loginCustomerId: loginCustomerIdField,
+    }),
+    execute: async ({ googleAdsToken, developerToken, operations, validateOnly, partialFailure, customerId, loginCustomerId }) => {
+        try {
+            const result = await adsMutate(googleAdsToken, developerToken, 'adGroups', {
+                customerId,
+                loginCustomerId,
+                operations,
+                validateOnly,
+                partialFailure,
+            });
+            if (!result.ok)
+                return { error: 'Failed to mutate ad groups', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error mutating ad groups',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=mutate-ad-groups.js.map

package/dist/toolkits/google-ads/tools/mutate-assets.d.ts

@@ -0,0 +1,11 @@
+export declare const mutateAssets: import("ai").Tool<{
+    googleAdsToken: string;
+    developerToken: string;
+    operations: Record<string, any>[];
+    customerId?: string | undefined;
+    loginCustomerId?: string | undefined;
+    validateOnly?: boolean | undefined;
+    partialFailure?: boolean | undefined;
+    responseContentType?: "RESOURCE_NAME_ONLY" | "MUTABLE_RESOURCE" | undefined;
+}, any>;
+//# sourceMappingURL=mutate-assets.d.ts.map