@rnsk/toolkits 0.0.6 → 0.0.8

package/dist/toolkits/gmail/tools/get-auto-forwarding.js

@@ -0,0 +1,30 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+export const getAutoForwarding = tool({
+    description: 'Get Gmail auto-forwarding settings for the authenticated mailbox.',
+    inputSchema: z.object({
+        gmailToken: z.string().optional().describe('Injected by system; do not provide'),
+    }),
+    execute: async ({ gmailToken }) => {
+        try {
+            const response = await fetch('https://gmail.googleapis.com/gmail/v1/users/me/settings/autoForwarding', {
+                headers: {
+                    Authorization: `Bearer ${gmailToken}`,
+                },
+            });
+            if (!response.ok) {
+                const error = await response.json();
+                return { error: 'Failed to get auto-forwarding settings', details: error };
+            }
+            const data = await response.json();
+            return { success: true, autoForwarding: data };
+        }
+        catch (error) {
+            return {
+                error: 'Error getting auto-forwarding settings',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=get-auto-forwarding.js.map

package/dist/toolkits/gmail/tools/get-contacts.d.ts

@@ -0,0 +1,8 @@
+export declare const getContacts: import("ai").Tool<{
+    personFields: string;
+    includeOtherContacts: boolean;
+    gmailToken?: string | undefined;
+    pageToken?: string | undefined;
+    resourceName?: string | undefined;
+}, any>;
+//# sourceMappingURL=get-contacts.d.ts.map

package/dist/toolkits/gmail/tools/get-contacts.js

@@ -0,0 +1,50 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+export const getContacts = tool({
+    description: 'Fetch Google contacts for the authenticated account using the People API.',
+    inputSchema: z.object({
+        gmailToken: z.string().optional().describe('Injected by system; do not provide'),
+        resourceName: z.string().optional().describe('Optional contact resource name to fetch, e.g. people/c123'),
+        personFields: z.string().optional().default('names,emailAddresses,phoneNumbers,organizations').describe('Comma-separated person fields to return'),
+        pageToken: z.string().optional().describe('Pagination token for connection lists'),
+        includeOtherContacts: z.boolean().optional().default(false).describe('Whether to fetch Other Contacts instead of saved contacts'),
+    }),
+    execute: async ({ gmailToken, resourceName, personFields, pageToken, includeOtherContacts }) => {
+        try {
+            let url;
+            if (resourceName) {
+                url = new URL(`https://people.googleapis.com/v1/${resourceName}`);
+                url.searchParams.append('personFields', personFields);
+            }
+            else if (includeOtherContacts) {
+                url = new URL('https://people.googleapis.com/v1/otherContacts');
+                url.searchParams.append('readMask', personFields);
+            }
+            else {
+                url = new URL('https://people.googleapis.com/v1/people/me/connections');
+                url.searchParams.append('personFields', personFields);
+            }
+            if (pageToken && !resourceName) {
+                url.searchParams.append('pageToken', pageToken);
+            }
+            const response = await fetch(url.toString(), {
+                headers: {
+                    Authorization: `Bearer ${gmailToken}`,
+                },
+            });
+            if (!response.ok) {
+                const error = await response.json();
+                return { error: 'Failed to get contacts', details: error };
+            }
+            const data = await response.json();
+            return { success: true, ...data };
+        }
+        catch (error) {
+            return {
+                error: 'Error getting contacts',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=get-contacts.js.map

package/dist/toolkits/gmail/tools/get-filter.d.ts

@@ -0,0 +1,23 @@
+export declare const getFilter: import("ai").Tool<{
+    id: string;
+    gmailToken?: string | undefined;
+}, {
+    error: string;
+    details: any;
+    success?: undefined;
+    filter?: undefined;
+    message?: undefined;
+} | {
+    success: boolean;
+    filter: any;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    success?: undefined;
+    filter?: undefined;
+}>;
+//# sourceMappingURL=get-filter.d.ts.map

package/dist/toolkits/gmail/tools/get-filter.js

@@ -0,0 +1,31 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+export const getFilter = tool({
+    description: 'Retrieve a Gmail filter by ID.',
+    inputSchema: z.object({
+        gmailToken: z.string().optional().describe('Injected by system; do not provide'),
+        id: z.string().describe('The filter ID to retrieve'),
+    }),
+    execute: async ({ gmailToken, id }) => {
+        try {
+            const response = await fetch(`https://gmail.googleapis.com/gmail/v1/users/me/settings/filters/${id}`, {
+                headers: {
+                    Authorization: `Bearer ${gmailToken}`,
+                },
+            });
+            if (!response.ok) {
+                const error = await response.json();
+                return { error: 'Failed to get filter', details: error };
+            }
+            const data = await response.json();
+            return { success: true, filter: data };
+        }
+        catch (error) {
+            return {
+                error: 'Error getting filter',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=get-filter.js.map

package/dist/toolkits/gmail/tools/index.d.ts

@@ -14,4 +14,17 @@ export * from './list-labels.js';
 export * from './modify-message-labels.js';
 export * from './trash-message.js';
 export * from './untrash-message.js';
+export * from './batch-delete-messages.js';
+export * from './batch-modify-messages.js';
+export * from './create-filter.js';
+export * from './create-label.js';
+export * from './delete-filter.js';
+export * from './delete-label.js';
+export * from './delete-message.js';
+export * from './delete-thread.js';
+export * from './forward-message.js';
+export * from './get-attachment.js';
+export * from './get-auto-forwarding.js';
+export * from './get-contacts.js';
+export * from './get-filter.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/toolkits/gmail/tools/index.js

@@ -14,4 +14,17 @@ export * from './list-labels.js';
 export * from './modify-message-labels.js';
 export * from './trash-message.js';
 export * from './untrash-message.js';
+export * from './batch-delete-messages.js';
+export * from './batch-modify-messages.js';
+export * from './create-filter.js';
+export * from './create-label.js';
+export * from './delete-filter.js';
+export * from './delete-label.js';
+export * from './delete-message.js';
+export * from './delete-thread.js';
+export * from './forward-message.js';
+export * from './get-attachment.js';
+export * from './get-auto-forwarding.js';
+export * from './get-contacts.js';
+export * from './get-filter.js';
 //# sourceMappingURL=index.js.map

package/dist/toolkits/gmail/tools/utils.d.ts

@@ -38,4 +38,27 @@ export declare function extractMessageDetails(data: any, maxBodyLength?: number)
     messageIdHeader: any;
     body: string;
 } | null;
+export declare function encodeBase64Mime(data: string): string;
+export declare function chunkBase64(data: string): string;
+export declare function getHeaderValue(headers: Array<{
+    name?: string;
+    value?: string;
+}> | undefined, name: string): string | undefined;
+export declare function collectAttachments(payload: any): Array<{
+    attachmentId: string;
+    filename: string;
+    mimeType: string;
+}>;
+export declare function encodeMultipartMessage(params: {
+    to: string;
+    subject: string;
+    body: string;
+    cc?: string;
+    bcc?: string;
+    attachments?: Array<{
+        filename: string;
+        mimeType: string;
+        data: string;
+    }>;
+}): string;
 //# sourceMappingURL=utils.d.ts.map

package/dist/toolkits/gmail/tools/utils.js

@@ -94,4 +94,55 @@ export function extractMessageDetails(data, maxBodyLength = 4000) {
         body,
     };
 }
+export function encodeBase64Mime(data) {
+    return data.replace(/-/g, '+').replace(/_/g, '/').replace(/\s/g, '');
+}
+export function chunkBase64(data) {
+    return data.match(/.{1,76}/g)?.join('\r\n') || data;
+}
+export function getHeaderValue(headers, name) {
+    return headers?.find((header) => header.name?.toLowerCase() === name.toLowerCase())?.value;
+}
+export function collectAttachments(payload) {
+    const attachments = [];
+    const walk = (part) => {
+        const attachmentId = part?.body?.attachmentId;
+        const filename = part?.filename;
+        if (attachmentId && filename) {
+            attachments.push({
+                attachmentId,
+                filename,
+                mimeType: part.mimeType || 'application/octet-stream',
+            });
+        }
+        for (const child of part?.parts || []) {
+            walk(child);
+        }
+    };
+    walk(payload);
+    return attachments;
+}
+export function encodeMultipartMessage(params) {
+    const boundary = `rnsk-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+    const headers = [
+        `To: ${params.to}`,
+        params.cc ? `Cc: ${params.cc}` : '',
+        params.bcc ? `Bcc: ${params.bcc}` : '',
+        `Subject: ${params.subject}`,
+        'MIME-Version: 1.0',
+        `Content-Type: multipart/mixed; boundary="${boundary}"`,
+    ].filter(Boolean);
+    const parts = [
+        `--${boundary}`,
+        'Content-Type: text/plain; charset="UTF-8"',
+        'Content-Transfer-Encoding: 7bit',
+        '',
+        params.body,
+    ];
+    for (const attachment of params.attachments || []) {
+        parts.push(`--${boundary}`, `Content-Type: ${attachment.mimeType}; name="${attachment.filename}"`, 'Content-Transfer-Encoding: base64', `Content-Disposition: attachment; filename="${attachment.filename}"`, '', chunkBase64(encodeBase64Mime(attachment.data)));
+    }
+    parts.push(`--${boundary}--`);
+    return encodeBase64Url([...headers, '', ...parts].join('\r\n'));
+}
 //# sourceMappingURL=utils.js.map

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

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

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

@@ -0,0 +1,18 @@
+const SVG = `<svg width="800px" height="800px" viewBox="0 -13 256 256" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" preserveAspectRatio="xMidYMid">
+    <g>
+				<path d="M5.888,166.405103 L90.88,20.9 C101.676138,27.2558621 156.115862,57.3844138 164.908138,63.1135172 L79.9161379,208.627448 C70.6206897,220.906621 -5.888,185.040138 5.888,166.396276 L5.888,166.405103 Z" fill="#FBBC04">
+
+</path>
+				<path d="M250.084224,166.401789 L165.092224,20.9055131 C153.210293,1.13172 127.619121,-6.05393517 106.600638,5.62496138 C85.582155,17.3038579 79.182155,42.4624786 91.0640861,63.1190303 L176.056086,208.632961 C187.938017,228.397927 213.52919,235.583582 234.547672,223.904686 C254.648086,212.225789 261.966155,186.175582 250.084224,166.419444 L250.084224,166.401789 Z" fill="#4285F4">
+
+</path>
+				<ellipse fill="#34A853" cx="42.6637241" cy="187.924414" rx="42.6637241" ry="41.6044138">
+
+</ellipse>
+    </g>
+</svg>`;
+export const GADS_ICON = {
+    kind: 'svg',
+    dataUri: `data:image/svg+xml;base64,${Buffer.from(SVG).toString('base64')}`,
+};
+//# sourceMappingURL=icon.js.map

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

@@ -0,0 +1,41 @@
+import { defineToolkit, defineTool } from '../../core/define.js';
+import { inferToolScope } from '../../core/scope.js';
+import { GADS_ICON } from './icon.js';
+import { googleAdsTools } from './tools/index.js';
+export default defineToolkit({
+    id: 'google-ads',
+    displayName: 'Google Ads',
+    shortDescription: 'Manage campaigns, ad groups, ads, budgets, audiences, and reports in Google Ads.',
+    category: 'Advertising & Marketing',
+    icon: GADS_ICON,
+    auth: {
+        type: 'oauth2',
+        tokenField: 'googleAdsToken',
+        provider: {
+            slug: 'google-ads',
+            env: { clientId: 'GOOGLE_ADS_CLIENT_ID', clientSecret: 'GOOGLE_ADS_CLIENT_SECRET' },
+            authorizeUrl: 'https://accounts.google.com/o/oauth2/v2/auth',
+            tokenUrl: 'https://oauth2.googleapis.com/token',
+            scopes: ['https://www.googleapis.com/auth/adwords'],
+            exchangeStyle: 'form',
+            extraAuthParams: { access_type: 'offline', prompt: 'consent' },
+            connectDescription: 'Connect Google Ads to manage campaigns, audiences, and reports.',
+            callbackPath: '/api/auth/google-ads/callback',
+            stateCookie: 'google_ads_oauth_state',
+        },
+    },
+    allowedHosts: ['googleads.googleapis.com'],
+    tools: googleAdsTools.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://ads.google.com',
+        docsUrl: 'https://developers.google.com/google-ads/api/docs/start',
+    },
+});
+//# sourceMappingURL=manifest.js.map

package/dist/toolkits/google-ads/tools/add-or-remove-to-customer-list.d.ts

@@ -0,0 +1,30 @@
+export declare const addOrRemoveToCustomerList: import("ai").Tool<{
+    resourceName: string;
+    googleAdsToken: string;
+    developerToken: string;
+    emails: string[];
+    operation?: "create" | "remove" | undefined;
+    customerId?: string | undefined;
+    loginCustomerId?: string | undefined;
+}, {
+    error: string;
+    details?: undefined;
+    status?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    details: any;
+    status?: undefined;
+    message?: undefined;
+} | {
+    status: string;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    status?: undefined;
+}>;
+//# sourceMappingURL=add-or-remove-to-customer-list.d.ts.map

package/dist/toolkits/google-ads/tools/add-or-remove-to-customer-list.js

@@ -0,0 +1,69 @@
+// @ts-nocheck
+import { createHash } from 'node:crypto';
+import { tool } from 'ai';
+import { z } from 'zod';
+import { GOOGLE_ADS_API_VERSION, adsRequest, customerIdField, developerTokenField, googleAdsTokenField, loginCustomerIdField, normalizeCustomerId, } from './client.js';
+function hashEmail(email) {
+    return createHash('sha256').update(email.trim().toLowerCase()).digest('hex');
+}
+export const addOrRemoveToCustomerList = tool({
+    description: 'Adds or removes contacts from a customer list (UserList audience, not an account) via an offline user data job. Changes take 6-12 hours to reflect. Emails must comply with Ads policies and privacy/consent laws.',
+    inputSchema: z.object({
+        googleAdsToken: googleAdsTokenField,
+        developerToken: developerTokenField,
+        resourceName: z.string().describe('UserList resource name, e.g. customers/123/userLists/456'),
+        emails: z.array(z.string()).min(1).describe('Contact emails to add or remove (normalized and SHA-256 hashed automatically)'),
+        operation: z.enum(['create', 'remove']).optional().describe('Operation to perform (default create)'),
+        customerId: customerIdField,
+        loginCustomerId: loginCustomerIdField,
+    }),
+    execute: async ({ googleAdsToken, developerToken, resourceName, emails, operation, customerId, loginCustomerId }) => {
+        try {
+            const cid = normalizeCustomerId(customerId);
+            if (!cid)
+                return { error: 'customerId is required' };
+            const op = operation ?? 'create';
+            const base = `/${GOOGLE_ADS_API_VERSION}/customers/${cid}/offlineUserDataJobs`;
+            const createResult = await adsRequest(googleAdsToken, developerToken, `${base}:create`, {
+                method: 'POST',
+                loginCustomerId,
+                body: {
+                    job: {
+                        type: 'CUSTOMER_MATCH_USER_LIST',
+                        customerMatchUserListMetadata: { userList: resourceName },
+                    },
+                },
+            });
+            if (!createResult.ok)
+                return { error: 'Failed to create user data job', details: createResult.error };
+            const jobName = createResult.data?.resourceName;
+            if (!jobName)
+                return { error: 'Failed to create user data job', details: createResult.data };
+            const operations = emails.map((email) => ({
+                [op]: { userIdentifiers: [{ hashedEmail: hashEmail(email) }] },
+            }));
+            const addResult = await adsRequest(googleAdsToken, developerToken, `${base}/${jobName.split('/').pop()}:addOperations`, {
+                method: 'POST',
+                loginCustomerId,
+                body: { operations, enablePartialFailure: true },
+            });
+            if (!addResult.ok)
+                return { error: 'Failed to add members to user data job', details: addResult.error };
+            const runResult = await adsRequest(googleAdsToken, developerToken, `${base}/${jobName.split('/').pop()}:run`, {
+                method: 'POST',
+                loginCustomerId,
+                body: {},
+            });
+            if (!runResult.ok)
+                return { error: 'Failed to run user data job', details: runResult.error };
+            return { status: `User data job ${jobName} is running for ${emails.length} contact(s)` };
+        }
+        catch (error) {
+            return {
+                error: 'Error updating customer list',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=add-or-remove-to-customer-list.js.map

package/dist/toolkits/google-ads/tools/client.d.ts

@@ -0,0 +1,62 @@
+import { z } from 'zod';
+export declare const GOOGLE_ADS_API_BASE = "https://googleads.googleapis.com";
+export declare const GOOGLE_ADS_API_VERSION = "v23";
+export declare const googleAdsTokenField: z.ZodString;
+export declare const developerTokenField: z.ZodString;
+export declare const customerIdField: z.ZodOptional<z.ZodString>;
+export declare const loginCustomerIdField: z.ZodOptional<z.ZodString>;
+export declare function normalizeCustomerId(id?: string): string;
+export declare function adsRequest(googleAdsToken: string, developerToken: string, path: string, options?: {
+    method?: string;
+    body?: unknown;
+    loginCustomerId?: string;
+}): Promise<{
+    ok: false;
+    error: any;
+    data?: undefined;
+} | {
+    ok: true;
+    data: any;
+    error?: undefined;
+}>;
+export declare function toGoogleAdsJson(value: unknown): unknown;
+export interface MutateOptions {
+    customerId?: string;
+    loginCustomerId?: string;
+    operations: Array<Record<string, unknown>>;
+    validateOnly?: boolean;
+    partialFailure?: boolean;
+    responseContentType?: string;
+}
+export declare function adsMutate(googleAdsToken: string, developerToken: string, resource: string, opts: MutateOptions): Promise<{
+    ok: false;
+    error: any;
+    data?: undefined;
+} | {
+    ok: true;
+    data: any;
+    error?: undefined;
+}>;
+export interface SearchOptions {
+    customerId?: string;
+    loginCustomerId?: string;
+    query: string;
+    pageToken?: string;
+    pageSize?: number;
+    summaryRowSetting?: string;
+}
+export declare function adsSearchStream(googleAdsToken: string, developerToken: string, opts: SearchOptions): Promise<{
+    ok: false;
+    error: any;
+    data?: undefined;
+} | {
+    ok: true;
+    data: any;
+    error?: undefined;
+}>;
+export declare function collectStreamRows(data: unknown): {
+    rows: Array<Record<string, unknown>>;
+    requestId?: string;
+    summaryRow?: Record<string, unknown>;
+};
+//# sourceMappingURL=client.d.ts.map

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

@@ -0,0 +1,102 @@
+// @ts-nocheck
+import { z } from 'zod';
+export const GOOGLE_ADS_API_BASE = 'https://googleads.googleapis.com';
+export const GOOGLE_ADS_API_VERSION = 'v23';
+export const googleAdsTokenField = z.string().describe('The Google Ads OAuth access token (Bearer)');
+export const developerTokenField = z
+    .string()
+    .describe('Google Ads developer token from the API Center (sent as developer-token header)');
+export const customerIdField = z
+    .string()
+    .optional()
+    .describe('Target Google Ads customer ID; hyphens and spaces are stripped. For MCC workflows pass the child/sub-account ID.');
+export const loginCustomerIdField = z
+    .string()
+    .optional()
+    .describe('Manager (MCC) customer ID sent as login-customer-id header. Omit for direct accounts.');
+export function normalizeCustomerId(id) {
+    return (id ?? '').replace(/[-\s]/g, '');
+}
+function buildHeaders(googleAdsToken, developerToken, loginCustomerId) {
+    const headers = {
+        Authorization: `Bearer ${googleAdsToken}`,
+        'developer-token': developerToken,
+        'Content-Type': 'application/json',
+    };
+    const loginId = normalizeCustomerId(loginCustomerId);
+    if (loginId)
+        headers['login-customer-id'] = loginId;
+    return headers;
+}
+export async function adsRequest(googleAdsToken, developerToken, path, options) {
+    const response = await fetch(`${GOOGLE_ADS_API_BASE}${path}`, {
+        method: options?.method ?? 'GET',
+        headers: buildHeaders(googleAdsToken, developerToken, options?.loginCustomerId),
+        body: options?.body !== undefined ? JSON.stringify(options.body) : undefined,
+    });
+    if (!response.ok) {
+        const details = await response.json().catch(() => ({}));
+        return { ok: false, error: details };
+    }
+    if (response.status === 204) {
+        return { ok: true, data: { success: true } };
+    }
+    const data = await response.json().catch(() => ({}));
+    return { ok: true, data };
+}
+function toCamelKey(key) {
+    return key.replace(/_([a-z0-9])/g, (_, c) => c.toUpperCase());
+}
+export function toGoogleAdsJson(value) {
+    if (Array.isArray(value))
+        return value.map(toGoogleAdsJson);
+    if (value && typeof value === 'object') {
+        const out = {};
+        for (const [k, v] of Object.entries(value)) {
+            out[toCamelKey(k)] = toGoogleAdsJson(v);
+        }
+        return out;
+    }
+    return value;
+}
+export async function adsMutate(googleAdsToken, developerToken, resource, opts) {
+    const customerId = normalizeCustomerId(opts.customerId);
+    if (!customerId)
+        return { ok: false, error: { message: 'customerId is required' } };
+    const body = {
+        operations: toGoogleAdsJson(opts.operations),
+    };
+    if (opts.validateOnly !== undefined)
+        body.validateOnly = opts.validateOnly;
+    if (opts.partialFailure !== undefined)
+        body.partialFailure = opts.partialFailure;
+    if (opts.responseContentType !== undefined)
+        body.responseContentType = opts.responseContentType;
+    return adsRequest(googleAdsToken, developerToken, `/${GOOGLE_ADS_API_VERSION}/customers/${customerId}/${resource}:mutate`, { method: 'POST', body, loginCustomerId: opts.loginCustomerId });
+}
+export async function adsSearchStream(googleAdsToken, developerToken, opts) {
+    const customerId = normalizeCustomerId(opts.customerId);
+    if (!customerId)
+        return { ok: false, error: { message: 'customerId is required' } };
+    const body = { query: opts.query };
+    if (opts.summaryRowSetting)
+        body.summaryRowSetting = opts.summaryRowSetting;
+    return adsRequest(googleAdsToken, developerToken, `/${GOOGLE_ADS_API_VERSION}/customers/${customerId}/googleAds:searchStream`, { method: 'POST', body, loginCustomerId: opts.loginCustomerId });
+}
+export function collectStreamRows(data) {
+    const rows = [];
+    let requestId;
+    let summaryRow;
+    const batches = Array.isArray(data) ? data : [data];
+    for (const batch of batches) {
+        const b = batch;
+        if (typeof b?.requestId === 'string' && !requestId)
+            requestId = b.requestId;
+        for (const r of b?.results ?? [])
+            rows.push(r);
+        if (b?.summaryRow && !summaryRow)
+            summaryRow = b.summaryRow;
+    }
+    return { rows, requestId, summaryRow };
+}
+//# sourceMappingURL=client.js.map

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