@rnsk/toolkits 0.0.7 → 0.0.9

package/dist/toolkits/google-contacts/tools/contacts.js

@@ -0,0 +1,273 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { googleContactsTokenField, peopleRequest } from './client.js';
+const sourcesField = z.array(z.string()).optional().describe('Source types mask (defaults to CONTACT + PROFILE)');
+export const createContact = tool({
+    description: 'Creates one contact. Use batchCreateContacts for bulk. Only one entry per singleton field (names, birthdays, genders, biographies).',
+    inputSchema: z.object({
+        googleContactsToken: googleContactsTokenField,
+        personFields: z.string().describe("Required read mask for the response, e.g. 'names,emailAddresses,phoneNumbers'"),
+        sources: sourcesField,
+        person: z.record(z.any()).optional().describe('Person fields: names, emailAddresses, phoneNumbers, addresses, organizations, etc.'),
+        names: z.array(z.record(z.any())).optional().describe('Shortcut for person names'),
+        emailAddresses: z.array(z.record(z.any())).optional().describe('Shortcut for emails'),
+        phoneNumbers: z.array(z.record(z.any())).optional().describe('Shortcut for phones'),
+    }),
+    execute: async ({ googleContactsToken, personFields, sources, person, names, emailAddresses, phoneNumbers }) => {
+        try {
+            const body = { ...(person ?? {}) };
+            if (names)
+                body.names = names;
+            if (emailAddresses)
+                body.emailAddresses = emailAddresses;
+            if (phoneNumbers)
+                body.phoneNumbers = phoneNumbers;
+            const result = await peopleRequest(googleContactsToken, '/people:createContact', {
+                method: 'POST',
+                query: { personFields, sources },
+                body,
+            });
+            if (!result.ok)
+                return { error: 'Failed to create contact', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error creating contact', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const batchCreateContacts = tool({
+    description: 'Creates up to 200 contacts in one call. Each contact needs a contactPerson wrapper. Send mutates for the same user sequentially.',
+    inputSchema: z.object({
+        googleContactsToken: googleContactsTokenField,
+        contacts: z.array(z.record(z.any())).min(1).max(200).describe("Contacts with 'contactPerson' Person data"),
+        readMask: z.string().describe("Response fields, e.g. 'names,emailAddresses,phoneNumbers' (empty skips person data)"),
+        sources: sourcesField,
+    }),
+    execute: async ({ googleContactsToken, contacts, readMask, sources }) => {
+        try {
+            const result = await peopleRequest(googleContactsToken, '/people:batchCreateContacts', {
+                method: 'POST',
+                body: { contacts, readMask, sources },
+            });
+            if (!result.ok)
+                return { error: 'Failed to batch create contacts', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error batch creating contacts', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const updateContact = tool({
+    description: 'Updates a contact. Only updatePersonFields change; etag is required for concurrency. One entry per singleton field.',
+    inputSchema: z.object({
+        googleContactsToken: googleContactsTokenField,
+        resourceName: z.string().describe("Contact resource, e.g. 'people/c123'"),
+        updatePersonFields: z.string().describe("Fields to update, e.g. 'names,emailAddresses,phoneNumbers'"),
+        person: z.record(z.any()).describe('Person data including required etag'),
+        personFields: z.string().optional().describe('Response fields mask'),
+        sources: sourcesField,
+    }),
+    execute: async ({ googleContactsToken, resourceName, updatePersonFields, person, personFields, sources }) => {
+        try {
+            const result = await peopleRequest(googleContactsToken, `/people/${resourceName}:updateContact`, {
+                method: 'PATCH',
+                query: { updatePersonFields, personFields, sources },
+                body: person,
+            });
+            if (!result.ok)
+                return { error: 'Failed to update contact', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error updating contact', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const batchUpdateContacts = tool({
+    description: 'Updates up to 200 contacts at once. Map resource names to Person data with etags; updateMask selects fields, readMask selects response fields.',
+    inputSchema: z.object({
+        googleContactsToken: googleContactsTokenField,
+        contacts: z.record(z.any()).describe('Map of resource name → Person data (include etag per contact)'),
+        updateMask: z.string().describe("Fields to update, e.g. 'names,phoneNumbers,emailAddresses'"),
+        readMask: z.string().describe('Response fields (empty returns no person data)'),
+        sources: sourcesField,
+    }),
+    execute: async ({ googleContactsToken, contacts, updateMask, readMask, sources }) => {
+        try {
+            const result = await peopleRequest(googleContactsToken, '/people:batchUpdateContacts', {
+                method: 'POST',
+                body: { contacts, updateMask, readMask, sources },
+            });
+            if (!result.ok)
+                return { error: 'Failed to batch update contacts', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error batch updating contacts', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const deleteContact = tool({
+    description: 'Permanently deletes a contact. Irreversible — non-contact data is preserved.',
+    inputSchema: z.object({
+        googleContactsToken: googleContactsTokenField,
+        resourceName: z.string().describe("Contact resource, e.g. 'people/c123'"),
+    }),
+    execute: async ({ googleContactsToken, resourceName }) => {
+        try {
+            const result = await peopleRequest(googleContactsToken, `/people/${resourceName}:deleteContact`, {
+                method: 'DELETE',
+            });
+            if (!result.ok)
+                return { error: 'Failed to delete contact', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error deleting contact', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const batchDeleteContacts = tool({
+    description: 'Deletes up to 500 contacts in one call. Irreversible.',
+    inputSchema: z.object({
+        googleContactsToken: googleContactsTokenField,
+        resourceNames: z.array(z.string()).min(1).max(500).describe("Contacts to delete, e.g. ['people/c1','people/c2']"),
+    }),
+    execute: async ({ googleContactsToken, resourceNames }) => {
+        try {
+            const result = await peopleRequest(googleContactsToken, '/people:batchDeleteContacts', {
+                method: 'POST',
+                body: { resourceNames },
+            });
+            if (!result.ok)
+                return { error: 'Failed to batch delete contacts', details: result.error };
+            return { success: true, deletedCount: resourceNames.length };
+        }
+        catch (error) {
+            return { error: 'Error batch deleting contacts', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const getPerson = tool({
+    description: "Gets a person by resource name ('people/me' for yourself). personFields is required.",
+    inputSchema: z.object({
+        googleContactsToken: googleContactsTokenField,
+        resourceName: z.string().describe("Person resource, e.g. 'people/me' or 'people/123'"),
+        personFields: z.string().describe("Required response mask, e.g. 'names,emailAddresses,phoneNumbers'"),
+        sources: sourcesField,
+        requestMaskIncludeField: z.string().optional().describe('Extra person fields to include'),
+    }),
+    execute: async ({ googleContactsToken, resourceName, personFields, sources, requestMaskIncludeField }) => {
+        try {
+            const result = await peopleRequest(googleContactsToken, `/people/${resourceName}`, {
+                query: { personFields, sources, 'requestMask.includeField': requestMaskIncludeField },
+            });
+            if (!result.ok)
+                return { error: 'Failed to get person', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error getting person', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const batchGetPeople = tool({
+    description: 'Fetches up to 200 people in one call. Missing people return a status without person data.',
+    inputSchema: z.object({
+        googleContactsToken: googleContactsTokenField,
+        resourceNames: z.array(z.string()).min(1).max(200).describe("People to fetch, e.g. ['people/me']"),
+        personFields: z.string().describe('Required response mask'),
+        sources: sourcesField,
+    }),
+    execute: async ({ googleContactsToken, resourceNames, personFields, sources }) => {
+        try {
+            const result = await peopleRequest(googleContactsToken, '/people:batchGet', {
+                query: { resourceNames, personFields, sources },
+            });
+            if (!result.ok)
+                return { error: 'Failed to batch get people', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error batch getting people', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const listConnections = tool({
+    description: 'Lists your contacts with sorting, filtering, and incremental sync. Sync tokens expire after 7 days (410). Deleted contacts have metadata.deleted=true.',
+    inputSchema: z.object({
+        googleContactsToken: googleContactsTokenField,
+        personId: z.string().optional().describe("Whose connections (only 'people/me' is valid, default me)"),
+        personFields: z.string().optional().describe("Response mask (default 'names,emailAddresses,phoneNumbers')"),
+        pageSize: z.number().min(1).max(1000).optional(),
+        pageToken: z.string().optional().describe('Next page token (other params must match first call)'),
+        syncToken: z.string().optional().describe('Incremental sync token (other params must match)'),
+        requestSyncToken: z.boolean().optional().describe('Return nextSyncToken on the last page'),
+        sortOrder: z.enum(['LAST_MODIFIED_ASCENDING', 'LAST_MODIFIED_DESCENDING', 'FIRST_NAME_ASCENDING', 'LAST_NAME_ASCENDING']).optional(),
+    }),
+    execute: async ({ googleContactsToken, personId, personFields, pageSize, pageToken, syncToken, requestSyncToken, sortOrder }) => {
+        try {
+            const result = await peopleRequest(googleContactsToken, `/people/${personId ?? 'me'}/connections`, {
+                query: { personFields: personFields ?? 'names,emailAddresses,phoneNumbers', pageSize, pageToken, syncToken, requestSyncToken, sortOrder },
+            });
+            if (!result.ok)
+                return { error: 'Failed to list connections', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error listing connections', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const searchContacts = tool({
+    description: 'Searches your contacts by name, nickname, email, phone, or organization. Send an empty-query warmup first to refresh the cache.',
+    inputSchema: z.object({
+        googleContactsToken: googleContactsTokenField,
+        query: z.string().describe('Plain-text query (empty string warms the cache)'),
+        readMask: z.string().optional().describe("Response mask (default 'names,emailAddresses,phoneNumbers')"),
+        pageSize: z.number().min(0).max(100).optional().describe('Results to return (0-100, >30 capped to 30)'),
+        sources: z.array(z.enum(['CONTACT', 'PROFILE'])).optional(),
+    }),
+    execute: async ({ googleContactsToken, query, readMask, pageSize, sources }) => {
+        try {
+            const result = await peopleRequest(googleContactsToken, '/people:searchContacts', {
+                query: { query, readMask: readMask ?? 'names,emailAddresses,phoneNumbers', pageSize, sources },
+            });
+            if (!result.ok)
+                return { error: 'Failed to search contacts', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error searching contacts', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const copyOtherContactToMyContacts = tool({
+    description: 'Copies an auto-created Other contact into your permanent myContacts group, selecting fields via copyMask.',
+    inputSchema: z.object({
+        googleContactsToken: googleContactsTokenField,
+        otherContactsId: z.string().describe("Other contact ID, e.g. 'c3784554018371489636'"),
+        copyMask: z.array(z.enum(['emailAddresses', 'names', 'phoneNumbers'])).describe('Fields to copy'),
+        readMask: z.string().optional().describe('Response mask (defaults to copyMask plus metadata/membership)'),
+        sources: sourcesField,
+    }),
+    execute: async ({ googleContactsToken, otherContactsId, copyMask, readMask, sources }) => {
+        try {
+            const result = await peopleRequest(googleContactsToken, `/otherContacts/${otherContactsId}:copyToMyContactsGroup`, {
+                method: 'POST',
+                query: { readMask, sources },
+                body: { copyMask },
+            });
+            if (!result.ok)
+                return { error: 'Failed to copy other contact', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error copying other contact', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+//# sourceMappingURL=contacts.js.map

package/dist/toolkits/google-contacts/tools/directory.d.ts

@@ -0,0 +1,36 @@
+export declare const listDirectoryPeople: import("ai").Tool<{
+    readMask: string;
+    sources: string[];
+    googleContactsToken: string;
+    pageToken?: string | undefined;
+    pageSize?: number | undefined;
+    syncToken?: string | undefined;
+    requestSyncToken?: boolean | undefined;
+    mergeSources?: string[] | undefined;
+}, any>;
+export declare const searchDirectoryPeople: import("ai").Tool<{
+    query: string;
+    readMask: string;
+    sources: ("DIRECTORY_SOURCE_TYPE_DOMAIN_CONTACT" | "DIRECTORY_SOURCE_TYPE_DOMAIN_PROFILE")[];
+    googleContactsToken: string;
+    pageToken?: string | undefined;
+    pageSize?: number | undefined;
+    mergeSources?: string[] | undefined;
+}, any>;
+export declare const listOtherContacts: import("ai").Tool<{
+    readMask: string;
+    googleContactsToken: string;
+    pageToken?: string | undefined;
+    sources?: string[] | undefined;
+    pageSize?: number | undefined;
+    syncToken?: string | undefined;
+    requestSyncToken?: boolean | undefined;
+}, any>;
+export declare const searchOtherContacts: import("ai").Tool<{
+    query: string;
+    readMask: string;
+    googleContactsToken: string;
+    pageToken?: string | undefined;
+    pageSize?: number | undefined;
+}, any>;
+//# sourceMappingURL=directory.d.ts.map

package/dist/toolkits/google-contacts/tools/directory.js

@@ -0,0 +1,99 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { googleContactsTokenField, peopleRequest } from './client.js';
+export const listDirectoryPeople = tool({
+    description: 'Lists Workspace domain profiles and contacts. Deleted entries have metadata.deleted=true on sync. Not for read-after-write.',
+    inputSchema: z.object({
+        googleContactsToken: googleContactsTokenField,
+        readMask: z.string().describe("Response mask, e.g. 'names,emailAddresses'"),
+        sources: z.array(z.string()).min(1).describe("Sources: 'DIRECTORY_SOURCE_TYPE_DOMAIN_CONTACT' and/or 'DIRECTORY_SOURCE_TYPE_DOMAIN_PROFILE'"),
+        pageSize: z.number().min(1).max(1000).optional().describe('People per page (max 1000, default 100)'),
+        pageToken: z.string().optional(),
+        syncToken: z.string().optional().describe('Incremental sync token'),
+        requestSyncToken: z.boolean().optional(),
+        mergeSources: z.array(z.string()).optional().describe('Extra directory sources to merge'),
+    }),
+    execute: async ({ googleContactsToken, ...query }) => {
+        try {
+            const result = await peopleRequest(googleContactsToken, '/people:listDirectoryPeople', { query });
+            if (!result.ok)
+                return { error: 'Failed to list directory people', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error listing directory people', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const searchDirectoryPeople = tool({
+    description: 'Searches the Workspace domain directory by name/email prefix. Requires directory.readonly scope.',
+    inputSchema: z.object({
+        googleContactsToken: googleContactsTokenField,
+        query: z.string().describe('Prefix query, e.g. a name or email'),
+        readMask: z.string().describe("Response mask, e.g. 'names,emailAddresses,phoneNumbers'"),
+        sources: z.array(z.enum(['DIRECTORY_SOURCE_TYPE_DOMAIN_CONTACT', 'DIRECTORY_SOURCE_TYPE_DOMAIN_PROFILE'])).min(1),
+        pageSize: z.number().min(1).max(500).optional().describe('Results per page (max 500, default 25)'),
+        pageToken: z.string().optional().describe('Must match first call params'),
+        mergeSources: z.array(z.string()).optional(),
+    }),
+    execute: async ({ googleContactsToken, ...body }) => {
+        try {
+            const result = await peopleRequest(googleContactsToken, '/people:searchDirectoryPeople', {
+                method: 'POST',
+                body,
+            });
+            if (!result.ok)
+                return { error: 'Failed to search directory people', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error searching directory people', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const listOtherContacts = tool({
+    description: 'Lists auto-created Other contacts (from email interactions) outside your groups. Sync tokens expire after 7 days.',
+    inputSchema: z.object({
+        googleContactsToken: googleContactsTokenField,
+        readMask: z.string().describe("Response mask, e.g. 'names,emailAddresses,phoneNumbers'"),
+        pageSize: z.number().min(1).max(1000).optional().describe('Contacts per page (max 1000, default 25)'),
+        pageToken: z.string().optional().describe('Must match first call params'),
+        syncToken: z.string().optional().describe('Incremental sync (params must match)'),
+        requestSyncToken: z.boolean().optional(),
+        sources: z.array(z.string()).optional(),
+    }),
+    execute: async ({ googleContactsToken, ...query }) => {
+        try {
+            const result = await peopleRequest(googleContactsToken, '/otherContacts', { query });
+            if (!result.ok)
+                return { error: 'Failed to list other contacts', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error listing other contacts', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const searchOtherContacts = tool({
+    description: 'Prefix-searches Other contacts by name, email, or phone. Send an empty-query warmup first for fresh results.',
+    inputSchema: z.object({
+        googleContactsToken: googleContactsTokenField,
+        query: z.string().describe("Prefix query, e.g. 'John' (empty warms the cache)"),
+        readMask: z.string().describe("Response mask, e.g. 'names,emailAddresses,phoneNumbers'"),
+        pageSize: z.number().min(1).max(30).optional().describe('Results per page (max 30, default 25)'),
+        pageToken: z.string().optional(),
+    }),
+    execute: async ({ googleContactsToken, ...query }) => {
+        try {
+            const result = await peopleRequest(googleContactsToken, '/otherContacts:search', { query });
+            if (!result.ok)
+                return { error: 'Failed to search other contacts', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error searching other contacts', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+//# sourceMappingURL=directory.js.map

package/dist/toolkits/google-contacts/tools/groups.d.ts

@@ -0,0 +1,68 @@
+export declare const createContactGroup: import("ai").Tool<{
+    name: string;
+    googleContactsToken: string;
+    clientData?: {
+        value: string;
+        key: string;
+    }[] | undefined;
+    readGroupFields?: string | undefined;
+}, any>;
+export declare const getContactGroup: import("ai").Tool<{
+    googleContactsToken: string;
+    contactGroupId: string;
+    groupFields?: string | undefined;
+    maxMembers?: number | undefined;
+}, any>;
+export declare const batchGetContactGroups: import("ai").Tool<{
+    googleContactsToken: string;
+    resourceNames: string[];
+    groupFields?: string | undefined;
+    maxMembers?: number | undefined;
+}, any>;
+export declare const listContactGroups: import("ai").Tool<{
+    googleContactsToken: string;
+    pageToken?: string | undefined;
+    pageSize?: number | undefined;
+    syncToken?: string | undefined;
+    groupFields?: string | undefined;
+}, any>;
+export declare const updateContactGroup: import("ai").Tool<{
+    resourceName: string;
+    name: string;
+    googleContactsToken: string;
+    etag: string;
+    clientData?: {
+        value: string;
+        key: string;
+    }[] | undefined;
+    readGroupFields?: string | undefined;
+    groupType?: string | undefined;
+    updateGroupFields?: string | undefined;
+}, any>;
+export declare const deleteContactGroup: import("ai").Tool<{
+    googleContactsToken: string;
+    contactGroupId: string;
+    deleteContacts?: boolean | undefined;
+}, {
+    error: string;
+    details: any;
+    success?: undefined;
+    message?: undefined;
+} | {
+    success: boolean;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    success?: undefined;
+}>;
+export declare const modifyContactGroupMembers: import("ai").Tool<{
+    googleContactsToken: string;
+    contactGroupId: string;
+    resourceNamesToAdd?: string[] | undefined;
+    resourceNamesToRemove?: string[] | undefined;
+}, any>;
+//# sourceMappingURL=groups.d.ts.map

package/dist/toolkits/google-contacts/tools/groups.js

@@ -0,0 +1,169 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { googleContactsTokenField, normalizeGroupId, peopleRequest } from './client.js';
+export const createContactGroup = tool({
+    description: 'Creates a contact group with a unique name. Duplicate names return HTTP 409.',
+    inputSchema: z.object({
+        googleContactsToken: googleContactsTokenField,
+        name: z.string().min(1).describe('Group name, unique among your groups'),
+        clientData: z.array(z.object({ key: z.string(), value: z.string() })).optional().describe('Custom key-value data'),
+        readGroupFields: z.string().optional().describe("Response mask (default 'metadata,groupType,name')"),
+    }),
+    execute: async ({ googleContactsToken, name, clientData, readGroupFields }) => {
+        try {
+            const body = { contactGroup: { name } };
+            if (clientData)
+                body.contactGroup.clientData = clientData;
+            const result = await peopleRequest(googleContactsToken, '/contactGroups', {
+                method: 'POST',
+                query: { readGroupFields },
+                body,
+            });
+            if (!result.ok)
+                return { error: 'Failed to create contact group', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error creating contact group', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const getContactGroup = tool({
+    description: 'Gets a contact group (name, member count, metadata) by resource name.',
+    inputSchema: z.object({
+        googleContactsToken: googleContactsTokenField,
+        contactGroupId: z.string().min(1).describe("Group ID or resource, e.g. 'myContacts' or 'contactGroups/abc'"),
+        groupFields: z.string().optional().describe("Response mask (default 'metadata,groupType,memberCount,name')"),
+        maxMembers: z.number().min(1).optional().describe('Max member names to include'),
+    }),
+    execute: async ({ googleContactsToken, contactGroupId, groupFields, maxMembers }) => {
+        try {
+            const result = await peopleRequest(googleContactsToken, `/${normalizeGroupId(contactGroupId)}`, {
+                query: { groupFields, maxMembers },
+            });
+            if (!result.ok)
+                return { error: 'Failed to get contact group', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error getting contact group', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const batchGetContactGroups = tool({
+    description: 'Gets up to 200 contact groups in one call — metadata, member counts, or member names.',
+    inputSchema: z.object({
+        googleContactsToken: googleContactsTokenField,
+        resourceNames: z.array(z.string()).min(1).max(200).describe("Groups, e.g. ['contactGroups/myContacts']"),
+        groupFields: z.string().optional().describe("Response mask, e.g. 'groupType,name,memberCount'"),
+        maxMembers: z.number().min(0).optional().describe('Max members per group (unset returns all)'),
+    }),
+    execute: async ({ googleContactsToken, resourceNames, groupFields, maxMembers }) => {
+        try {
+            const result = await peopleRequest(googleContactsToken, '/contactGroups:batchGet', {
+                query: { resourceNames, groupFields, maxMembers },
+            });
+            if (!result.ok)
+                return { error: 'Failed to batch get contact groups', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error batch getting contact groups', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const listContactGroups = tool({
+    description: 'Lists all your contact groups (My Contacts, Starred, custom). Members are not populated here.',
+    inputSchema: z.object({
+        googleContactsToken: googleContactsTokenField,
+        pageSize: z.number().min(1).max(1000).optional().describe('Groups per page (1-1000, default 30)'),
+        pageToken: z.string().optional(),
+        syncToken: z.string().optional().describe('Return only changes since this token'),
+        groupFields: z.string().optional().describe("Response mask (default 'metadata,groupType,memberCount,name')"),
+    }),
+    execute: async ({ googleContactsToken, pageSize, pageToken, syncToken, groupFields }) => {
+        try {
+            const result = await peopleRequest(googleContactsToken, '/contactGroups', {
+                query: { pageSize, pageToken, syncToken, groupFields },
+            });
+            if (!result.ok)
+                return { error: 'Failed to list contact groups', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error listing contact groups', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const updateContactGroup = tool({
+    description: 'Renames a contact group or updates its client data. Needs resourceName, etag, and name.',
+    inputSchema: z.object({
+        googleContactsToken: googleContactsTokenField,
+        resourceName: z.string().describe("Group resource, e.g. 'contactGroups/abc'"),
+        etag: z.string().describe('Current etag for concurrency'),
+        name: z.string().describe('New unique group name'),
+        groupType: z.string().optional(),
+        clientData: z.array(z.object({ key: z.string(), value: z.string() })).optional(),
+        readGroupFields: z.string().optional().describe('Response mask'),
+        updateGroupFields: z.string().optional().describe("Fields to update, e.g. 'name,clientData'"),
+    }),
+    execute: async ({ googleContactsToken, resourceName, readGroupFields, updateGroupFields, ...group }) => {
+        try {
+            const result = await peopleRequest(googleContactsToken, `/${resourceName}`, {
+                method: 'PUT',
+                query: { readGroupFields, updateGroupFields },
+                body: { contactGroup: { resourceName, ...group } },
+            });
+            if (!result.ok)
+                return { error: 'Failed to update contact group', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error updating contact group', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const deleteContactGroup = tool({
+    description: 'Deletes a contact group. Irreversible. Set deleteContacts to also delete its contacts.',
+    inputSchema: z.object({
+        googleContactsToken: googleContactsTokenField,
+        contactGroupId: z.string().min(1).describe("Group ID or resource, e.g. 'contactGroups/abc'"),
+        deleteContacts: z.boolean().optional().describe('Also delete all contacts in the group (default false)'),
+    }),
+    execute: async ({ googleContactsToken, contactGroupId, deleteContacts }) => {
+        try {
+            const result = await peopleRequest(googleContactsToken, `/${normalizeGroupId(contactGroupId)}`, {
+                method: 'DELETE',
+                query: { deleteContacts },
+            });
+            if (!result.ok)
+                return { error: 'Failed to delete contact group', details: result.error };
+            return { success: true };
+        }
+        catch (error) {
+            return { error: 'Error deleting contact group', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const modifyContactGroupMembers = tool({
+    description: 'Adds/removes group members (max 1000 combined). Only myContacts and starred accept new members; a contact must keep at least one group.',
+    inputSchema: z.object({
+        googleContactsToken: googleContactsTokenField,
+        contactGroupId: z.string().describe("Group ID, 'myContacts', 'starred', or full resource name"),
+        resourceNamesToAdd: z.array(z.string()).optional().describe("Contacts to add, e.g. ['people/c1']"),
+        resourceNamesToRemove: z.array(z.string()).optional().describe('Contacts to remove'),
+    }),
+    execute: async ({ googleContactsToken, contactGroupId, resourceNamesToAdd, resourceNamesToRemove }) => {
+        try {
+            const result = await peopleRequest(googleContactsToken, `/${normalizeGroupId(contactGroupId)}/members:modify`, { method: 'POST', body: { resourceNamesToAdd, resourceNamesToRemove } });
+            if (!result.ok)
+                return { error: 'Failed to modify contact group members', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error modifying contact group members', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+//# sourceMappingURL=groups.js.map