@rnsk/toolkits 0.0.7 → 0.0.8

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

@@ -0,0 +1,110 @@
+// @ts-nocheck
+import { addCommentToAFile } from './add-comment-to-a-file.js';
+import { addReactionToAComment } from './add-reaction-to-a-comment.js';
+import { createAWebhook } from './create-a-webhook.js';
+import { createDevResources } from './create-dev-resources.js';
+import { createModifyDeleteVariables } from './create-modify-delete-variables.js';
+import { deleteAComment } from './delete-a-comment.js';
+import { deleteAReaction } from './delete-a-reaction.js';
+import { deleteAWebhook } from './delete-a-webhook.js';
+import { deleteDevResource } from './delete-dev-resource.js';
+import { designTokensToTailwind } from './design-tokens-to-tailwind.js';
+import { detectBackground } from './detect-background.js';
+import { discoverFigmaResources } from './discover-figma-resources.js';
+import { downloadFigmaImages } from './download-figma-images.js';
+import { extractDesignTokens } from './extract-design-tokens.js';
+import { extractPrototypeInteractions } from './extract-prototype-interactions.js';
+import { getActivityLogs } from './get-activity-logs.js';
+import { getAWebhook } from './get-a-webhook.js';
+import { getCommentsInAFile } from './get-comments-in-a-file.js';
+import { getComponent2 } from './get-component2.js';
+import { getComponentSet } from './get-component-set.js';
+import { getCurrentUser } from './get-current-user.js';
+import { getDevResources } from './get-dev-resources.js';
+import { getFileComponentSets } from './get-file-component-sets.js';
+import { getFileComponents } from './get-file-components.js';
+import { getFileJson } from './get-file-json.js';
+import { getFileMetadata } from './get-file-metadata.js';
+import { getFileNodes } from './get-file-nodes.js';
+import { getFileStyles } from './get-file-styles.js';
+import { getFilesInAProject } from './get-files-in-a-project.js';
+import { getImageFills } from './get-image-fills.js';
+import { getLibraryAnalyticsComponentActionData } from './get-library-analytics-component-action-data.js';
+import { getLibraryAnalyticsComponentUsageData } from './get-library-analytics-component-usage-data.js';
+import { getLibraryAnalyticsStyleActionData } from './get-library-analytics-style-action-data.js';
+import { getLibraryAnalyticsStyleUsageData } from './get-library-analytics-style-usage-data.js';
+import { getLibraryAnalyticsVariableActionData } from './get-library-analytics-variable-action-data.js';
+import { getLibraryAnalyticsVariableUsageData } from './get-library-analytics-variable-usage-data.js';
+import { getLocalVariables } from './get-local-variables.js';
+import { getPayments } from './get-payments.js';
+import { getProjectsInATeam } from './get-projects-in-a-team.js';
+import { getPublishedVariables } from './get-published-variables.js';
+import { getReactionsForAComment } from './get-reactions-for-a-comment.js';
+import { getScimServiceProviderConfig } from './get-scim-service-provider-config.js';
+import { getStyle } from './get-style.js';
+import { getTeamComponentSets } from './get-team-component-sets.js';
+import { getTeamComponents } from './get-team-components.js';
+import { getTeamStyles } from './get-team-styles.js';
+import { getTeamWebhooks } from './get-team-webhooks.js';
+import { getVersionsOfAFile } from './get-versions-of-a-file.js';
+import { getWebhookRequests } from './get-webhook-requests.js';
+import { renderImagesOfFileNodes } from './render-images-of-file-nodes.js';
+import { updateAWebhook } from './update-a-webhook.js';
+import { updateDevResources } from './update-dev-resources.js';
+export { addCommentToAFile, addReactionToAComment, createAWebhook, createDevResources, createModifyDeleteVariables, deleteAComment, deleteAReaction, deleteAWebhook, deleteDevResource, designTokensToTailwind, detectBackground, discoverFigmaResources, downloadFigmaImages, extractDesignTokens, extractPrototypeInteractions, getActivityLogs, getAWebhook, getCommentsInAFile, getComponent2, getComponentSet, getCurrentUser, getDevResources, getFileComponentSets, getFileComponents, getFileJson, getFileMetadata, getFileNodes, getFileStyles, getFilesInAProject, getImageFills, getLibraryAnalyticsComponentActionData, getLibraryAnalyticsComponentUsageData, getLibraryAnalyticsStyleActionData, getLibraryAnalyticsStyleUsageData, getLibraryAnalyticsVariableActionData, getLibraryAnalyticsVariableUsageData, getLocalVariables, getPayments, getProjectsInATeam, getPublishedVariables, getReactionsForAComment, getScimServiceProviderConfig, getStyle, getTeamComponentSets, getTeamComponents, getTeamStyles, getTeamWebhooks, getVersionsOfAFile, getWebhookRequests, renderImagesOfFileNodes, updateAWebhook, updateDevResources, };
+const auth = 'figmaToken';
+export const figmaTools = [
+    { name: 'figmaAddCommentToAFile', description: 'Posts a comment to a file or branch, optionally replying to a root comment.', tool: addCommentToAFile, requiredAuth: auth, scope: 'write' },
+    { name: 'figmaAddReactionToAComment', description: 'Posts an emoji reaction to a comment.', tool: addReactionToAComment, requiredAuth: auth, scope: 'write' },
+    { name: 'figmaCreateAWebhook', description: 'Creates a team/project/file webhook for Figma events.', tool: createAWebhook, requiredAuth: auth, scope: 'write' },
+    { name: 'figmaCreateDevResources', description: 'Attaches dev resources (Jira, GitHub, docs) to file nodes.', tool: createDevResources, requiredAuth: auth, scope: 'write' },
+    { name: 'figmaCreateModifyDeleteVariables', description: 'Batch creates, updates, or deletes variables, collections, modes, and values.', tool: createModifyDeleteVariables, requiredAuth: auth, scope: 'write' },
+    { name: 'figmaDeleteAComment', description: 'Deletes your comment from a file or branch.', tool: deleteAComment, requiredAuth: auth, scope: 'delete' },
+    { name: 'figmaDeleteAReaction', description: 'Removes your emoji reaction from a comment.', tool: deleteAReaction, requiredAuth: auth, scope: 'delete' },
+    { name: 'figmaDeleteAWebhook', description: 'Permanently deletes a webhook. Irreversible.', tool: deleteAWebhook, requiredAuth: auth, scope: 'delete' },
+    { name: 'figmaDeleteDevResource', description: 'Deletes a dev resource from a main file.', tool: deleteDevResource, requiredAuth: auth, scope: 'delete' },
+    { name: 'figmaDesignTokensToTailwind', description: 'Converts extracted design tokens into a Tailwind config plus font CSS. No auth needed.', tool: designTokensToTailwind, scope: 'read' },
+    { name: 'figmaDetectBackground', description: 'Finds background candidates behind target nodes with confidence scores.', tool: detectBackground, requiredAuth: auth, scope: 'read' },
+    { name: 'figmaDiscoverFigmaResources', description: 'Extracts IDs from any Figma URL and traverses team → projects → files → nodes.', tool: discoverFigmaResources, requiredAuth: auth, scope: 'read' },
+    { name: 'figmaDownloadFigmaImages', description: 'Renders nodes and downloads image bytes (base64) in PNG/SVG/JPG/PDF.', tool: downloadFigmaImages, requiredAuth: auth, scope: 'read' },
+    { name: 'figmaExtractDesignTokens', description: 'Extracts colors, typography, spacing, radii, and shadows from a file.', tool: extractDesignTokens, requiredAuth: auth, scope: 'read' },
+    { name: 'figmaExtractPrototypeInteractions', description: 'Extracts prototype flows, interactions, animations, and variant states.', tool: extractPrototypeInteractions, requiredAuth: auth, scope: 'read' },
+    { name: 'figmaGetActivityLogs', description: 'Retrieves org activity log events with filters and pagination.', tool: getActivityLogs, requiredAuth: auth, scope: 'read' },
+    { name: 'figmaGetAWebhook', description: 'Retrieves a webhook by ID.', tool: getAWebhook, requiredAuth: auth, scope: 'read' },
+    { name: 'figmaGetCommentsInAFile', description: 'Retrieves all comments from a file or branch.', tool: getCommentsInAFile, requiredAuth: auth, scope: 'read' },
+    { name: 'figmaGetComponent2', description: 'Fetches published component metadata by component key.', tool: getComponent2, requiredAuth: auth, scope: 'read' },
+    { name: 'figmaGetComponentSet', description: 'Fetches published component set metadata by set key.', tool: getComponentSet, requiredAuth: auth, scope: 'read' },
+    { name: 'figmaGetCurrentUser', description: 'Returns the authenticated user details.', tool: getCurrentUser, requiredAuth: auth, scope: 'read' },
+    { name: 'figmaGetDevResources', description: 'Lists dev resources on a main file, optionally filtered to nodes.', tool: getDevResources, requiredAuth: auth, scope: 'read' },
+    { name: 'figmaGetFileComponentSets', description: 'Lists published component sets from a main library file.', tool: getFileComponentSets, requiredAuth: auth, scope: 'read' },
+    { name: 'figmaGetFileComponents', description: 'Lists published components from a main library file.', tool: getFileComponents, requiredAuth: auth, scope: 'read' },
+    { name: 'figmaGetFileJson', description: 'Gets a Design file document tree, optionally scoped to nodes and depth.', tool: getFileJson, requiredAuth: auth, scope: 'read' },
+    { name: 'figmaGetFileMetadata', description: 'Gets file overview without the document tree.', tool: getFileMetadata, requiredAuth: auth, scope: 'read' },
+    { name: 'figmaGetFileNodes', description: 'Fetches JSON for known node IDs without full-file payloads.', tool: getFileNodes, requiredAuth: auth, scope: 'read' },
+    { name: 'figmaGetFileStyles', description: 'Lists published styles from a main library file.', tool: getFileStyles, requiredAuth: auth, scope: 'read' },
+    { name: 'figmaGetFilesInAProject', description: 'Lists files in a project, optionally with branch metadata.', tool: getFilesInAProject, requiredAuth: auth, scope: 'read' },
+    { name: 'figmaGetImageFills', description: 'Returns temporary download URLs for all image fills in a file.', tool: getImageFills, requiredAuth: auth, scope: 'read' },
+    { name: 'figmaGetLibraryAnalyticsComponentActionData', description: 'Weekly component insertions/detachments for a library.', tool: getLibraryAnalyticsComponentActionData, requiredAuth: auth, scope: 'read' },
+    { name: 'figmaGetLibraryAnalyticsComponentUsageData', description: 'Component usage totals for a library.', tool: getLibraryAnalyticsComponentUsageData, requiredAuth: auth, scope: 'read' },
+    { name: 'figmaGetLibraryAnalyticsStyleActionData', description: 'Weekly style insertions/detachments for a library.', tool: getLibraryAnalyticsStyleActionData, requiredAuth: auth, scope: 'read' },
+    { name: 'figmaGetLibraryAnalyticsStyleUsageData', description: 'Style usage totals for a library.', tool: getLibraryAnalyticsStyleUsageData, requiredAuth: auth, scope: 'read' },
+    { name: 'figmaGetLibraryAnalyticsVariableActionData', description: 'Weekly variable insertions/detachments for a library.', tool: getLibraryAnalyticsVariableActionData, requiredAuth: auth, scope: 'read' },
+    { name: 'figmaGetLibraryAnalyticsVariableUsageData', description: 'Variable usage totals for a library.', tool: getLibraryAnalyticsVariableUsageData, requiredAuth: auth, scope: 'read' },
+    { name: 'figmaGetLocalVariables', description: 'Gets all local/remote variables with mode-specific values.', tool: getLocalVariables, requiredAuth: auth, scope: 'read' },
+    { name: 'figmaGetPayments', description: 'Checks a user payment status for your plugin, widget, or Community file.', tool: getPayments, requiredAuth: auth, scope: 'read' },
+    { name: 'figmaGetProjectsInATeam', description: 'Lists projects in a team.', tool: getProjectsInATeam, requiredAuth: auth, scope: 'read' },
+    { name: 'figmaGetPublishedVariables', description: 'Gets published variables from a main library file.', tool: getPublishedVariables, requiredAuth: auth, scope: 'read' },
+    { name: 'figmaGetReactionsForAComment', description: 'Lists reactions on a comment with pagination.', tool: getReactionsForAComment, requiredAuth: auth, scope: 'read' },
+    { name: 'figmaGetScimServiceProviderConfig', description: 'Returns SCIM capabilities for account provisioning.', tool: getScimServiceProviderConfig, requiredAuth: auth, scope: 'read' },
+    { name: 'figmaGetStyle', description: 'Fetches published style metadata by style key.', tool: getStyle, requiredAuth: auth, scope: 'read' },
+    { name: 'figmaGetTeamComponentSets', description: 'Lists published component sets in a team library.', tool: getTeamComponentSets, requiredAuth: auth, scope: 'read' },
+    { name: 'figmaGetTeamComponents', description: 'Lists published components in a team library.', tool: getTeamComponents, requiredAuth: auth, scope: 'read' },
+    { name: 'figmaGetTeamStyles', description: 'Lists published styles in a team library.', tool: getTeamStyles, requiredAuth: auth, scope: 'read' },
+    { name: 'figmaGetTeamWebhooks', description: 'Lists webhooks for a team, project, or file context.', tool: getTeamWebhooks, requiredAuth: auth, scope: 'read' },
+    { name: 'figmaGetVersionsOfAFile', description: 'Retrieves version history for a file or branch.', tool: getVersionsOfAFile, requiredAuth: auth, scope: 'read' },
+    { name: 'figmaGetWebhookRequests', description: 'Shows 7-day delivery history for a webhook.', tool: getWebhookRequests, requiredAuth: auth, scope: 'read' },
+    { name: 'figmaRenderImagesOfFileNodes', description: 'Renders nodes as images and returns temporary URLs.', tool: renderImagesOfFileNodes, requiredAuth: auth, scope: 'read' },
+    { name: 'figmaUpdateAWebhook', description: 'Updates a webhook event type, endpoint, passcode, status, or description.', tool: updateAWebhook, requiredAuth: auth, scope: 'write' },
+    { name: 'figmaUpdateDevResources', description: 'Updates dev resource names and URLs by ID.', tool: updateDevResources, requiredAuth: auth, scope: 'write' },
+];
+//# sourceMappingURL=index.js.map

package/dist/toolkits/figma/tools/library-analytics-shared.d.ts

@@ -0,0 +1,4 @@
+export declare function libraryAnalyticsTool(label: string, resource: 'component' | 'style' | 'variable', metric: 'actions' | 'usages', groupBy: string[], withDates: boolean): import("ai").Tool<{
+    [x: string]: any;
+}, any>;
+//# sourceMappingURL=library-analytics-shared.d.ts.map

package/dist/toolkits/figma/tools/library-analytics-shared.js

@@ -0,0 +1,40 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { figmaRequest, figmaTokenField } from './client.js';
+export function libraryAnalyticsTool(label, resource, metric, groupBy, withDates) {
+    const schema = {
+        figmaToken: figmaTokenField,
+        fileKey: z.string().describe('Published Enterprise library file key'),
+        groupBy: z.enum(groupBy).describe('Grouping dimension; shapes the rows'),
+        cursor: z.string().optional().describe('Pagination cursor; omit for first page'),
+    };
+    if (withDates) {
+        schema.startDate = z.string().optional().describe('Range start YYYY-MM-DD (defaults to one year prior)');
+        schema.endDate = z.string().optional().describe('Range end YYYY-MM-DD (defaults to latest week)');
+    }
+    return tool({
+        description: `${label} for an Enterprise library. Requires library_analytics:read.`,
+        inputSchema: z.object(schema),
+        execute: async ({ figmaToken, fileKey, groupBy, cursor, startDate, endDate }) => {
+            try {
+                if (startDate && endDate && endDate < startDate) {
+                    return { error: 'endDate must not be before startDate' };
+                }
+                const result = await figmaRequest(figmaToken, `/v1/files/${fileKey}/analytics/${resource}/${metric}`, {
+                    query: { group_by: groupBy, cursor, start_date: startDate, end_date: endDate },
+                });
+                if (!result.ok)
+                    return { error: `Failed to get ${label}`, details: result.error };
+                return result.data;
+            }
+            catch (error) {
+                return {
+                    error: `Error getting ${label}`,
+                    message: error instanceof Error ? error.message : 'Unknown error',
+                };
+            }
+        },
+    });
+}
+//# sourceMappingURL=library-analytics-shared.js.map

package/dist/toolkits/figma/tools/render-images-of-file-nodes.d.ts

@@ -0,0 +1,15 @@
+export declare const renderImagesOfFileNodes: import("ai").Tool<{
+    figmaToken: string;
+    fileKey: string;
+    ids: string;
+    version?: string | undefined;
+    format?: "svg" | "png" | "jpg" | "pdf" | undefined;
+    scale?: number | undefined;
+    svgIncludeId?: boolean | undefined;
+    svgOutlineText?: boolean | undefined;
+    svgSimplifyStroke?: boolean | undefined;
+    contentsOnly?: boolean | undefined;
+    useAbsoluteBounds?: boolean | undefined;
+    svgIncludeNodeId?: boolean | undefined;
+}, any>;
+//# sourceMappingURL=render-images-of-file-nodes.d.ts.map

package/dist/toolkits/figma/tools/render-images-of-file-nodes.js

@@ -0,0 +1,49 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { figmaRequest, figmaTokenField } from './client.js';
+export const renderImagesOfFileNodes = tool({
+    description: 'Renders nodes as PNG/JPG/SVG/PDF and returns temporary (30-day) image URLs keyed by node ID. Null means that node failed (bad ID, invisible, 0% opacity). Capped at 32MP — lower scale for large nodes.',
+    inputSchema: z.object({
+        figmaToken: figmaTokenField,
+        fileKey: z.string().describe('File or branch key from the file URL'),
+        ids: z.string().describe("Comma-separated node IDs, e.g. '1:2,1:3'"),
+        format: z.enum(['jpg', 'pdf', 'png', 'svg']).optional().describe('Output format (default png)'),
+        scale: z.number().min(0.01).max(4).optional().describe('PNG/JPG scale 0.01-4 (ignored for SVG/PDF)'),
+        version: z.string().optional().describe('Version ID; omit for current'),
+        contentsOnly: z.boolean().optional().describe('Exclude overlapping content (default true)'),
+        useAbsoluteBounds: z.boolean().optional().describe('Full node dimensions, avoids text cropping'),
+        svgIncludeId: z.boolean().optional(),
+        svgOutlineText: z.boolean().optional(),
+        svgIncludeNodeId: z.boolean().optional(),
+        svgSimplifyStroke: z.boolean().optional(),
+    }),
+    execute: async ({ figmaToken, fileKey, ids, format, scale, version, contentsOnly, useAbsoluteBounds, svgIncludeId, svgOutlineText, svgIncludeNodeId, svgSimplifyStroke }) => {
+        try {
+            const result = await figmaRequest(figmaToken, `/v1/files/${fileKey}/images`, {
+                query: {
+                    ids,
+                    format,
+                    scale,
+                    version,
+                    contents_only: contentsOnly,
+                    use_absolute_bounds: useAbsoluteBounds,
+                    svg_include_id: svgIncludeId,
+                    svg_outline_text: svgOutlineText,
+                    svg_include_node_id: svgIncludeNodeId,
+                    svg_simplify_stroke: svgSimplifyStroke,
+                },
+            });
+            if (!result.ok)
+                return { error: 'Failed to render node images', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error rendering node images',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=render-images-of-file-nodes.js.map

package/dist/toolkits/figma/tools/update-a-webhook.d.ts

@@ -0,0 +1,10 @@
+export declare const updateAWebhook: import("ai").Tool<{
+    figmaToken: string;
+    webhookId: string;
+    status?: "ACTIVE" | "PAUSED" | undefined;
+    description?: string | undefined;
+    eventType?: "FILE_COMMENT" | "FILE_DELETE" | "FILE_UPDATE" | "FILE_VERSION_UPDATE" | "LIBRARY_PUBLISH" | "PING" | undefined;
+    endpoint?: string | undefined;
+    passcode?: string | undefined;
+}, any>;
+//# sourceMappingURL=update-a-webhook.d.ts.map

package/dist/toolkits/figma/tools/update-a-webhook.js

@@ -0,0 +1,45 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { figmaRequest, figmaTokenField } from './client.js';
+export const updateAWebhook = tool({
+    description: 'Updates a webhook event type, endpoint, passcode, status, or description. Only provided fields change.',
+    inputSchema: z.object({
+        figmaToken: figmaTokenField,
+        webhookId: z.string().describe('Webhook ID to update'),
+        eventType: z.enum(['FILE_COMMENT', 'FILE_DELETE', 'FILE_UPDATE', 'FILE_VERSION_UPDATE', 'LIBRARY_PUBLISH', 'PING']).optional(),
+        endpoint: z.string().optional().describe('New HTTPS endpoint (max 2048 chars)'),
+        passcode: z.string().optional().describe('New secret (max 100 chars)'),
+        status: z.enum(['ACTIVE', 'PAUSED']).optional(),
+        description: z.string().optional().describe('New description (max 140 chars; empty string removes)'),
+    }),
+    execute: async ({ figmaToken, webhookId, eventType, endpoint, passcode, status, description }) => {
+        try {
+            const body = {};
+            if (eventType)
+                body.event_type = eventType;
+            if (endpoint)
+                body.endpoint = endpoint;
+            if (passcode)
+                body.passcode = passcode;
+            if (status)
+                body.status = status;
+            if (description !== undefined)
+                body.description = description;
+            const result = await figmaRequest(figmaToken, `/v2/webhooks/${webhookId}`, {
+                method: 'PUT',
+                body,
+            });
+            if (!result.ok)
+                return { error: 'Failed to update webhook', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error updating webhook',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=update-a-webhook.js.map

package/dist/toolkits/figma/tools/update-dev-resources.d.ts

@@ -0,0 +1,10 @@
+export declare const updateDevResources: import("ai").Tool<{
+    figmaToken: string;
+    fileKey: string;
+    devResources: {
+        id: string;
+        url?: string | undefined;
+        name?: string | undefined;
+    }[];
+}, any>;
+//# sourceMappingURL=update-dev-resources.d.ts.map

package/dist/toolkits/figma/tools/update-dev-resources.js

@@ -0,0 +1,34 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { figmaRequest, figmaTokenField } from './client.js';
+export const updateDevResources = tool({
+    description: 'Updates the name and/or URL of dev resources by ID. Omitted fields are retained.',
+    inputSchema: z.object({
+        figmaToken: figmaTokenField,
+        fileKey: z.string().describe('Main file key containing the resources'),
+        devResources: z.array(z.object({
+            id: z.string().describe('Dev resource ID to update'),
+            name: z.string().optional().describe('New name'),
+            url: z.string().optional().describe('New URL'),
+        })).min(1),
+    }),
+    execute: async ({ figmaToken, fileKey, devResources }) => {
+        try {
+            const result = await figmaRequest(figmaToken, `/v1/files/${fileKey}/dev_resources`, {
+                method: 'PUT',
+                body: { dev_resources: devResources },
+            });
+            if (!result.ok)
+                return { error: 'Failed to update dev resources', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error updating dev resources',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=update-dev-resources.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