@rnsk/toolkits 0.0.7 → 0.0.9

package/dist/toolkits/gitlab/tools/pipelines.js

@@ -0,0 +1,66 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { gitlabRequest, encodeId } from './client.js';
+const tokenField = z.string().optional().describe('Injected by system; do not provide');
+const projectField = z
+    .union([z.string(), z.number()])
+    .describe('Project ID or URL-encoded path (e.g. 123 or "group/project")');
+export const gitlabListPipelines = tool({
+    description: 'List GitLab CI/CD pipelines for a project. Use when the user asks to see pipeline runs, build status, or CI history.',
+    inputSchema: z.object({
+        gitlabToken: tokenField,
+        projectId: projectField,
+        status: z.enum(['running', 'pending', 'success', 'failed', 'canceled', 'skipped', 'manual']).optional().describe('Filter by pipeline status'),
+        ref: z.string().optional().describe('Filter by branch or tag name'),
+        perPage: z.number().min(1).max(100).optional().default(20).describe('Results per page (max 100)'),
+        page: z.number().min(1).optional().default(1).describe('Page number'),
+    }),
+    execute: async ({ gitlabToken, projectId, status, ref, perPage = 20, page = 1 }) => {
+        return gitlabRequest(gitlabToken, `/projects/${encodeId(projectId)}/pipelines`, {
+            query: { status, ref, per_page: perPage, page },
+        });
+    },
+});
+export const gitlabGetPipeline = tool({
+    description: 'Get a single GitLab pipeline by ID. Use when the user asks for details or status of a specific pipeline run.',
+    inputSchema: z.object({
+        gitlabToken: tokenField,
+        projectId: projectField,
+        pipelineId: z.union([z.string(), z.number()]).describe('Pipeline ID'),
+    }),
+    execute: async ({ gitlabToken, projectId, pipelineId }) => {
+        return gitlabRequest(gitlabToken, `/projects/${encodeId(projectId)}/pipelines/${pipelineId}`);
+    },
+});
+export const gitlabCreatePipeline = tool({
+    description: 'Create (trigger) a new GitLab CI/CD pipeline run for a branch or tag. Use when the user wants to run or retrigger CI.',
+    inputSchema: z.object({
+        gitlabToken: tokenField,
+        projectId: projectField,
+        ref: z.string().describe('Branch or tag to run the pipeline on, e.g. "main"'),
+        variables: z.array(z.object({ key: z.string(), value: z.string() })).optional().describe('CI/CD variables for the pipeline run'),
+    }),
+    execute: async ({ gitlabToken, projectId, ref, variables }) => {
+        return gitlabRequest(gitlabToken, `/projects/${encodeId(projectId)}/pipeline`, {
+            method: 'POST',
+            body: { ref, variables },
+        });
+    },
+});
+export const gitlabListJobs = tool({
+    description: 'List jobs for a GitLab pipeline. Use when the user asks to see jobs, stages, or which job failed in a pipeline.',
+    inputSchema: z.object({
+        gitlabToken: tokenField,
+        projectId: projectField,
+        pipelineId: z.union([z.string(), z.number()]).describe('Pipeline ID'),
+        perPage: z.number().min(1).max(100).optional().default(20).describe('Results per page (max 100)'),
+        page: z.number().min(1).optional().default(1).describe('Page number'),
+    }),
+    execute: async ({ gitlabToken, projectId, pipelineId, perPage = 20, page = 1 }) => {
+        return gitlabRequest(gitlabToken, `/projects/${encodeId(projectId)}/pipelines/${pipelineId}/jobs`, {
+            query: { per_page: perPage, page },
+        });
+    },
+});
+//# sourceMappingURL=pipelines.js.map

package/dist/toolkits/gitlab/tools/projects.d.ts

@@ -0,0 +1,36 @@
+export declare const gitlabListProjects: import("ai").Tool<{
+    perPage: number;
+    page: number;
+    sort?: "asc" | "desc" | undefined;
+    search?: string | undefined;
+    owned?: boolean | undefined;
+    orderBy?: "path" | "id" | "name" | "updated_at" | "created_at" | "last_activity_at" | undefined;
+    gitlabToken?: string | undefined;
+    membership?: boolean | undefined;
+}, any>;
+export declare const gitlabGetProject: import("ai").Tool<{
+    projectId: string | number;
+    gitlabToken?: string | undefined;
+}, any>;
+export declare const gitlabCreateProject: import("ai").Tool<{
+    name: string;
+    description?: string | undefined;
+    visibility?: "private" | "public" | "internal" | undefined;
+    gitlabToken?: string | undefined;
+    initializeWithReadme?: boolean | undefined;
+    defaultBranch?: string | undefined;
+    namespaceId?: string | number | undefined;
+}, any>;
+export declare const gitlabUpdateProject: import("ai").Tool<{
+    projectId: string | number;
+    description?: string | undefined;
+    visibility?: "private" | "public" | "internal" | undefined;
+    name?: string | undefined;
+    gitlabToken?: string | undefined;
+    defaultBranch?: string | undefined;
+}, any>;
+export declare const gitlabDeleteProject: import("ai").Tool<{
+    projectId: string | number;
+    gitlabToken?: string | undefined;
+}, any>;
+//# sourceMappingURL=projects.d.ts.map

package/dist/toolkits/gitlab/tools/projects.js

@@ -0,0 +1,94 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { gitlabRequest, encodeId } from './client.js';
+const tokenField = z.string().optional().describe('Injected by system; do not provide');
+const projectField = z
+    .union([z.string(), z.number()])
+    .describe('Project ID or URL-encoded path (e.g. 123 or "group/project")');
+export const gitlabListProjects = tool({
+    description: 'List GitLab projects for the authenticated user. Use when the user asks to see their projects, browse repos, or find a project by name. Supports search, ownership filter, and pagination.',
+    inputSchema: z.object({
+        gitlabToken: tokenField,
+        search: z.string().optional().describe('Search query to filter projects by name or path'),
+        owned: z.boolean().optional().describe('Limit to projects explicitly owned by the authenticated user'),
+        membership: z.boolean().optional().describe('Limit to projects the user is a member of'),
+        orderBy: z.enum(['id', 'name', 'path', 'created_at', 'updated_at', 'last_activity_at']).optional().describe('Field to order results by'),
+        sort: z.enum(['asc', 'desc']).optional().describe('Sort direction'),
+        perPage: z.number().min(1).max(100).optional().default(20).describe('Results per page (max 100)'),
+        page: z.number().min(1).optional().default(1).describe('Page number'),
+    }),
+    execute: async ({ gitlabToken, search, owned, membership, orderBy, sort, perPage = 20, page = 1 }) => {
+        return gitlabRequest(gitlabToken, '/projects', {
+            query: { search, owned, membership, order_by: orderBy, sort, per_page: perPage, page },
+        });
+    },
+});
+export const gitlabGetProject = tool({
+    description: 'Get detailed information about a single GitLab project. Use when the user asks for project details, settings, or stats for a specific project.',
+    inputSchema: z.object({
+        gitlabToken: tokenField,
+        projectId: projectField,
+    }),
+    execute: async ({ gitlabToken, projectId }) => {
+        return gitlabRequest(gitlabToken, `/projects/${encodeId(projectId)}`);
+    },
+});
+export const gitlabCreateProject = tool({
+    description: 'Create a new GitLab project. Use when the user wants to create a project or repository on GitLab.',
+    inputSchema: z.object({
+        gitlabToken: tokenField,
+        name: z.string().describe('New project name'),
+        description: z.string().optional().describe('Project description'),
+        visibility: z.enum(['private', 'internal', 'public']).optional().describe('Project visibility level'),
+        initializeWithReadme: z.boolean().optional().describe('Initialize the project with a README'),
+        defaultBranch: z.string().optional().describe('Default branch name, e.g. "main"'),
+        namespaceId: z.union([z.string(), z.number()]).optional().describe('Namespace (group or user) ID to create the project under'),
+    }),
+    execute: async ({ gitlabToken, name, description, visibility, initializeWithReadme, defaultBranch, namespaceId }) => {
+        return gitlabRequest(gitlabToken, '/projects', {
+            method: 'POST',
+            body: {
+                name,
+                description,
+                visibility,
+                initialize_with_readme: initializeWithReadme,
+                default_branch: defaultBranch,
+                namespace_id: namespaceId,
+            },
+        });
+    },
+});
+export const gitlabUpdateProject = tool({
+    description: 'Update a GitLab project (name, description, visibility, default branch). Use when the user wants to edit project settings.',
+    inputSchema: z.object({
+        gitlabToken: tokenField,
+        projectId: projectField,
+        name: z.string().optional().describe('New project name'),
+        description: z.string().optional().describe('New project description'),
+        visibility: z.enum(['private', 'internal', 'public']).optional().describe('New visibility level'),
+        defaultBranch: z.string().optional().describe('New default branch'),
+    }),
+    execute: async ({ gitlabToken, projectId, name, description, visibility, defaultBranch }) => {
+        return gitlabRequest(gitlabToken, `/projects/${encodeId(projectId)}`, {
+            method: 'PUT',
+            body: {
+                name,
+                description,
+                visibility,
+                default_branch: defaultBranch,
+            },
+        });
+    },
+});
+export const gitlabDeleteProject = tool({
+    description: 'Delete a GitLab project. Use only when the user explicitly asks to delete or remove a project. This is irreversible.',
+    inputSchema: z.object({
+        gitlabToken: tokenField,
+        projectId: projectField,
+    }),
+    execute: async ({ gitlabToken, projectId }) => {
+        return gitlabRequest(gitlabToken, `/projects/${encodeId(projectId)}`, { method: 'DELETE' });
+    },
+});
+//# sourceMappingURL=projects.js.map

package/dist/toolkits/gitlab/tools/repository.d.ts

@@ -0,0 +1,21 @@
+export declare const gitlabListBranches: import("ai").Tool<{
+    projectId: string | number;
+    perPage: number;
+    page: number;
+    search?: string | undefined;
+    gitlabToken?: string | undefined;
+}, any>;
+export declare const gitlabListCommits: import("ai").Tool<{
+    projectId: string | number;
+    perPage: number;
+    page: number;
+    gitlabToken?: string | undefined;
+    refName?: string | undefined;
+}, any>;
+export declare const gitlabGetFile: import("ai").Tool<{
+    projectId: string | number;
+    ref: string;
+    filePath: string;
+    gitlabToken?: string | undefined;
+}, any>;
+//# sourceMappingURL=repository.d.ts.map

package/dist/toolkits/gitlab/tools/repository.js

@@ -0,0 +1,53 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { gitlabRequest, encodeId } from './client.js';
+const tokenField = z.string().optional().describe('Injected by system; do not provide');
+const projectField = z
+    .union([z.string(), z.number()])
+    .describe('Project ID or URL-encoded path (e.g. 123 or "group/project")');
+export const gitlabListBranches = tool({
+    description: 'List branches of a GitLab project repository. Use when the user asks to see branches or find a branch name.',
+    inputSchema: z.object({
+        gitlabToken: tokenField,
+        projectId: projectField,
+        search: z.string().optional().describe('Search branches by name'),
+        perPage: z.number().min(1).max(100).optional().default(20).describe('Results per page (max 100)'),
+        page: z.number().min(1).optional().default(1).describe('Page number'),
+    }),
+    execute: async ({ gitlabToken, projectId, search, perPage = 20, page = 1 }) => {
+        return gitlabRequest(gitlabToken, `/projects/${encodeId(projectId)}/repository/branches`, {
+            query: { search, per_page: perPage, page },
+        });
+    },
+});
+export const gitlabListCommits = tool({
+    description: 'List commits of a GitLab project repository. Use when the user asks to see commit history or recent changes.',
+    inputSchema: z.object({
+        gitlabToken: tokenField,
+        projectId: projectField,
+        refName: z.string().optional().describe('Branch, tag, or commit SHA to list commits from (defaults to the default branch)'),
+        perPage: z.number().min(1).max(100).optional().default(20).describe('Results per page (max 100)'),
+        page: z.number().min(1).optional().default(1).describe('Page number'),
+    }),
+    execute: async ({ gitlabToken, projectId, refName, perPage = 20, page = 1 }) => {
+        return gitlabRequest(gitlabToken, `/projects/${encodeId(projectId)}/repository/commits`, {
+            query: { ref_name: refName, per_page: perPage, page },
+        });
+    },
+});
+export const gitlabGetFile = tool({
+    description: 'Get the content of a file from a GitLab project repository. The file path is URL-encoded automatically. Use when the user asks to read a file from a project.',
+    inputSchema: z.object({
+        gitlabToken: tokenField,
+        projectId: projectField,
+        filePath: z.string().describe('Path of the file in the repository, e.g. "README.md" or "src/index.ts"'),
+        ref: z.string().optional().default('main').describe('Branch, tag, or commit SHA (defaults to "main")'),
+    }),
+    execute: async ({ gitlabToken, projectId, filePath, ref = 'main' }) => {
+        return gitlabRequest(gitlabToken, `/projects/${encodeId(projectId)}/repository/files/${encodeId(filePath)}`, {
+            query: { ref },
+        });
+    },
+});
+//# sourceMappingURL=repository.js.map

package/dist/toolkits/gitlab/tools/users-groups.d.ts

@@ -0,0 +1,11 @@
+export declare const gitlabGetCurrentUser: import("ai").Tool<{
+    gitlabToken?: string | undefined;
+}, any>;
+export declare const gitlabListGroups: import("ai").Tool<{
+    perPage: number;
+    page: number;
+    search?: string | undefined;
+    owned?: boolean | undefined;
+    gitlabToken?: string | undefined;
+}, any>;
+//# sourceMappingURL=users-groups.d.ts.map

package/dist/toolkits/gitlab/tools/users-groups.js

@@ -0,0 +1,30 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { gitlabRequest } from './client.js';
+const tokenField = z.string().optional().describe('Injected by system; do not provide');
+export const gitlabGetCurrentUser = tool({
+    description: 'Get the authenticated GitLab user profile. Use when the user asks who they are logged in as, or to get their username, ID, or email.',
+    inputSchema: z.object({
+        gitlabToken: tokenField,
+    }),
+    execute: async ({ gitlabToken }) => {
+        return gitlabRequest(gitlabToken, '/user');
+    },
+});
+export const gitlabListGroups = tool({
+    description: 'List GitLab groups visible to the authenticated user. Use when the user asks to see their groups or namespaces.',
+    inputSchema: z.object({
+        gitlabToken: tokenField,
+        search: z.string().optional().describe('Search groups by name or path'),
+        owned: z.boolean().optional().describe('Limit to groups explicitly owned by the user'),
+        perPage: z.number().min(1).max(100).optional().default(20).describe('Results per page (max 100)'),
+        page: z.number().min(1).optional().default(1).describe('Page number'),
+    }),
+    execute: async ({ gitlabToken, search, owned, perPage = 20, page = 1 }) => {
+        return gitlabRequest(gitlabToken, '/groups', {
+            query: { search, owned, per_page: perPage, page },
+        });
+    },
+});
+//# sourceMappingURL=users-groups.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