@rnsk/toolkits 0.0.7 → 0.0.8

package/dist/toolkits/google-ads/tools/mutate-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('Asset operation: {create: {text_asset/callout_asset/structured_snippet_asset/sitelink_asset/lead_form_asset/promotion_asset/call_asset/price_asset/...}}, or {update: {...}, update_mask?}. Assets cannot be removed via API. Snake_case keys accepted.');
+export const mutateAssets = tool({
+    description: 'Creates or updates Google Ads assets (sitelinks, snippets, text, lead forms, promotions, calls, prices, media). Use createCalloutAsset for validated immutable callouts. Assets cannot be removed — cleanup removes associations.',
+    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, 'assets', {
+                customerId,
+                loginCustomerId,
+                operations,
+                validateOnly,
+                partialFailure,
+                responseContentType,
+            });
+            if (!result.ok)
+                return { error: 'Failed to mutate assets', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error mutating assets',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=mutate-assets.js.map

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

@@ -0,0 +1,11 @@
+export declare const mutateBiddingStrategies: 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-bidding-strategies.d.ts.map

package/dist/toolkits/google-ads/tools/mutate-bidding-strategies.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('BiddingStrategy operation: {create: {name, plus one scheme (target_cpa/target_roas/target_spend/maximize_conversions/maximize_conversion_value/target_impression_share)}}, {update: {...}, update_mask?}, or {remove: resourceName}. Snake_case keys accepted.');
+export const mutateBiddingStrategies = tool({
+    description: 'Creates, updates, or removes portfolio bidding strategies (Target CPA/ROAS/Spend, Maximize Conversions/Conversion Value, Target Impression Share).',
+    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 bidding strategies', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error mutating bidding strategies',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=mutate-bidding-strategies.js.map

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

@@ -0,0 +1,11 @@
+export declare const mutateCampaignAssets: 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-campaign-assets.d.ts.map

package/dist/toolkits/google-ads/tools/mutate-campaign-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('CampaignAsset operation: {create: {campaign, asset, field_type, status}}, {update: {...}, update_mask?}, or {remove: resourceName}. Snake_case keys accepted.');
+export const mutateCampaignAssets = tool({
+    description: 'Creates, updates, or removes links between assets and campaigns. Use after creating assets to attach sitelinks, callouts, snippets, and other asset types at campaign 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, 'campaignAssets', {
+                customerId,
+                loginCustomerId,
+                operations,
+                validateOnly,
+                partialFailure,
+                responseContentType,
+            });
+            if (!result.ok)
+                return { error: 'Failed to mutate campaign assets', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error mutating campaign assets',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=mutate-campaign-assets.js.map

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

@@ -0,0 +1,11 @@
+export declare const mutateCampaignBudgets: 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-campaign-budgets.d.ts.map

package/dist/toolkits/google-ads/tools/mutate-campaign-budgets.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('CampaignBudget operation: {create: {name, amount_micros/total_amount_micros, delivery_method, explicitly_shared, period, type}}, {update: {...}, update_mask?}, or {remove: resourceName}. Create budgets before campaigns. Snake_case keys accepted.');
+export const mutateCampaignBudgets = tool({
+    description: 'Creates, updates, or removes campaign budgets. Use before creating campaigns — campaign creation requires an existing campaign_budget resource name.',
+    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, 'campaignBudgets', {
+                customerId,
+                loginCustomerId,
+                operations,
+                validateOnly,
+                partialFailure,
+                responseContentType,
+            });
+            if (!result.ok)
+                return { error: 'Failed to mutate campaign budgets', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error mutating campaign budgets',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=mutate-campaign-budgets.js.map

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

@@ -0,0 +1,11 @@
+export declare const mutateCampaignCriteria: 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-campaign-criteria.d.ts.map

package/dist/toolkits/google-ads/tools/mutate-campaign-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('CampaignCriterion operation: {create: {campaign, negative?, status?, bid_modifier?, plus one criterion (location/language/keyword/device/ad_schedule/ip_block/audience)}}, {update: {...}, update_mask?}, or {remove: resourceName}. Snake_case keys accepted.');
+export const mutateCampaignCriteria = tool({
+    description: 'Creates, updates, or removes campaign-level targeting criteria (locations, languages, negative keywords, devices, schedules, audiences, IP exclusions).',
+    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, 'campaignCriteria', {
+                customerId,
+                loginCustomerId,
+                operations,
+                validateOnly,
+                partialFailure,
+                responseContentType,
+            });
+            if (!result.ok)
+                return { error: 'Failed to mutate campaign criteria', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error mutating campaign criteria',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=mutate-campaign-criteria.js.map

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

@@ -0,0 +1,10 @@
+export declare const mutateCampaignLabels: 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-campaign-labels.d.ts.map

package/dist/toolkits/google-ads/tools/mutate-campaign-labels.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('CampaignLabel operation: {create: {campaign, label}} or {remove: customers/{id}/campaignLabels/{campaignId}~{labelId}}. Snake_case keys accepted.');
+export const mutateCampaignLabels = tool({
+    description: 'Creates or removes relationships between campaigns and labels. Use after creating labels to organize campaigns for filtering and reporting.',
+    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, 'campaignLabels', {
+                customerId,
+                loginCustomerId,
+                operations,
+                validateOnly,
+                partialFailure,
+            });
+            if (!result.ok)
+                return { error: 'Failed to mutate campaign labels', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error mutating campaign labels',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=mutate-campaign-labels.js.map

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

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

package/dist/toolkits/google-ads/tools/mutate-campaigns-v2.js

@@ -0,0 +1,58 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { adsMutate, customerIdField, developerTokenField, googleAdsTokenField, loginCustomerIdField, } from './client.js';
+const campaignPayload = z.record(z.any()).describe('Campaign fields with typed bidding: name, status, campaign_budget (required for create), advertising_channel_type (search/display), manual_cpc/target_cpa/target_roas/target_spend/maximize_conversions/maximize_conversion_value/target_impression_share, bidding_strategy, network_settings, dates, tracking. Snake_case keys accepted.');
+const operationSchema = z.object({
+    operationType: z.enum(['create', 'update', 'remove']).describe('Type of operation'),
+    create: campaignPayload.optional(),
+    update: campaignPayload.optional(),
+    remove: z.string().optional().describe('Campaign resource name to remove (irreversible)'),
+    updateMask: z.string().optional().describe('Optional comma-separated update field paths (explicit paths take precedence)'),
+});
+export const mutateCampaignsV2 = tool({
+    description: 'Creates, updates, or removes search/display campaigns in batch with typed standard bidding strategies. Removes are irreversible; use validateOnly to test first.',
+    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 normalized = operations.map((op) => {
+                if (op.operationType === 'create')
+                    return { create: op.create };
+                if (op.operationType === 'update') {
+                    const entry = { update: op.update };
+                    if (op.updateMask)
+                        entry.updateMask = op.updateMask;
+                    return entry;
+                }
+                return { remove: op.remove };
+            });
+            const result = await adsMutate(googleAdsToken, developerToken, 'campaigns', {
+                customerId,
+                loginCustomerId,
+                operations: normalized,
+                validateOnly,
+                partialFailure,
+                responseContentType,
+            });
+            if (!result.ok)
+                return { error: 'Failed to mutate campaigns', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error mutating campaigns',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=mutate-campaigns-v2.js.map

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

@@ -0,0 +1,16 @@
+export declare const mutateCampaigns: import("ai").Tool<{
+    googleAdsToken: string;
+    developerToken: string;
+    operations: {
+        operationType: "create" | "update" | "remove";
+        create?: Record<string, any> | undefined;
+        update?: Record<string, any> | undefined;
+        remove?: string | undefined;
+    }[];
+    customerId?: string | undefined;
+    loginCustomerId?: string | undefined;
+    validateOnly?: boolean | undefined;
+    partialFailure?: boolean | undefined;
+    responseContentType?: string | undefined;
+}, any>;
+//# sourceMappingURL=mutate-campaigns.d.ts.map

package/dist/toolkits/google-ads/tools/mutate-campaigns.js

@@ -0,0 +1,53 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { adsMutate, customerIdField, developerTokenField, googleAdsTokenField, loginCustomerIdField, toGoogleAdsJson, } from './client.js';
+const campaignPayload = z.record(z.any()).describe('Campaign fields: name, status, campaign_budget (existing budget resource name, required for create — amount lives on the CampaignBudget resource), advertising_channel_type, network_settings, bidding_strategy or manual_cpc, dates, tracking, geo_target_type_setting. Snake_case keys accepted.');
+const operationSchema = z.object({
+    operationType: z.enum(['create', 'update', 'remove']).describe('Type of operation'),
+    create: campaignPayload.optional(),
+    update: campaignPayload.optional(),
+    remove: z.string().optional().describe('Campaign resource name to remove (irreversible)'),
+});
+export const mutateCampaigns = tool({
+    description: 'Creates, updates, or removes campaigns in batch. Removes are irreversible — deleted campaigns cannot be recovered. Use validateOnly to test changes first.',
+    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.string().optional().describe("RESOURCE_NAME_ONLY or MUTABLE_RESOURCE"),
+        customerId: customerIdField,
+        loginCustomerId: loginCustomerIdField,
+    }),
+    execute: async ({ googleAdsToken, developerToken, operations, validateOnly, partialFailure, responseContentType, customerId, loginCustomerId }) => {
+        try {
+            const normalized = operations.map((op) => {
+                if (op.operationType === 'create')
+                    return { create: op.create };
+                if (op.operationType === 'update')
+                    return { update: op.update };
+                return { remove: op.remove };
+            });
+            const result = await adsMutate(googleAdsToken, developerToken, 'campaigns', {
+                customerId,
+                loginCustomerId,
+                operations: toGoogleAdsJson(normalized),
+                validateOnly,
+                partialFailure,
+                responseContentType,
+            });
+            if (!result.ok)
+                return { error: 'Failed to mutate campaigns', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error mutating campaigns',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=mutate-campaigns.js.map

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

@@ -0,0 +1,11 @@
+export declare const mutateConversionActions: 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-conversion-actions.d.ts.map

package/dist/toolkits/google-ads/tools/mutate-conversion-actions.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('ConversionAction operation: {create: {name, status, type, category, primary_for_goal, lookback windows, value_settings, counting_type, attribution_model_settings}}, {update: {...}, update_mask?}, or {remove: resourceName}. Snake_case keys accepted.');
+export const mutateConversionActions = tool({
+    description: 'Creates, updates, or removes conversion actions for conversion tracking configuration. Installing website/app tags remains a separate step.',
+    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, 'conversionActions', {
+                customerId,
+                loginCustomerId,
+                operations,
+                validateOnly,
+                partialFailure,
+                responseContentType,
+            });
+            if (!result.ok)
+                return { error: 'Failed to mutate conversion actions', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error mutating conversion actions',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=mutate-conversion-actions.js.map

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

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

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

@@ -0,0 +1,51 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { adsMutate, customerIdField, developerTokenField, googleAdsTokenField, loginCustomerIdField, } from './client.js';
+const operationSchema = z.object({
+    create: z
+        .object({
+        asset: z.string().describe('Asset resource name customers/{id}/assets/{assetId}'),
+        fieldType: z.string().describe('Asset field type, e.g. CALLOUT, SITELINK, STRUCTURED_SNIPPET'),
+    })
+        .optional(),
+    remove: z
+        .string()
+        .optional()
+        .describe('CustomerAsset resource name customers/{id}/customerAssets/{assetId}~{fieldType} (irreversible)'),
+});
+export const mutateCustomerAssets = tool({
+    description: 'Creates or removes customer-level asset associations (callouts, sitelinks, snippets across the account). Removal is irreversible; recreate to restore. Use after creating assets.',
+    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, 'customerAssets', {
+                customerId,
+                loginCustomerId,
+                operations: operations,
+                validateOnly,
+                partialFailure,
+                responseContentType,
+            });
+            if (!result.ok)
+                return { error: 'Failed to mutate customer assets', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error mutating customer assets',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=mutate-customer-assets.js.map

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

@@ -0,0 +1,11 @@
+export declare const mutateLabels: 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-labels.d.ts.map

package/dist/toolkits/google-ads/tools/mutate-labels.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('Label operation: {create: {name, text_label?}}, {update: {...}, update_mask?}, or {remove: resourceName}. Pair with campaign label mutations. Snake_case keys accepted.');
+export const mutateLabels = tool({
+    description: 'Creates, updates, or removes labels. Pair with campaign label mutations to organize campaigns and support filtering.',
+    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, 'labels', {
+                customerId,
+                loginCustomerId,
+                operations,
+                validateOnly,
+                partialFailure,
+                responseContentType,
+            });
+            if (!result.ok)
+                return { error: 'Failed to mutate labels', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error mutating labels',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=mutate-labels.js.map

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

@@ -0,0 +1,11 @@
+export declare const mutatePortfolioBiddingStrategies: 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-portfolio-bidding-strategies.d.ts.map