@rnsk/toolkits 0.0.10 → 0.0.12

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

@@ -0,0 +1,175 @@
+// @ts-nocheck
+import { ZohoConvertZohoLead } from './convert-zoho-lead.js';
+import { ZohoCreateContact } from './create-contact.js';
+import { ZohoCreateDeal } from './create-deal.js';
+import { ZohoCreateEmailDraft } from './create-email-draft.js';
+import { ZohoCreateEvent } from './create-event.js';
+import { ZohoCreateLead } from './create-lead.js';
+import { ZohoCreateNote } from './create-note.js';
+import { ZohoCreateZohoRecord } from './create-zoho-record.js';
+import { ZohoCreateZohoTag } from './create-zoho-tag.js';
+import { ZohoDeleteAccount } from './delete-account.js';
+import { ZohoDeleteContact } from './delete-contact.js';
+import { ZohoDeleteDeal } from './delete-deal.js';
+import { ZohoGetAccount } from './get-account.js';
+import { ZohoGetCall } from './get-call.js';
+import { ZohoGetContact } from './get-contact.js';
+import { ZohoGetEmailDrafts } from './get-email-drafts.js';
+import { ZohoGetEvent } from './get-event.js';
+import { ZohoGetFromAddresses } from './get-from-addresses.js';
+import { ZohoGetModuleFields } from './get-module-fields.js';
+import { ZohoGetNote } from './get-note.js';
+import { ZohoGetRecordEmails } from './get-record-emails.js';
+import { ZohoGetRelatedLists } from './get-related-lists.js';
+import { ZohoGetRelatedRecords } from './get-related-records.js';
+import { ZohoGetTask } from './get-task.js';
+import { ZohoGetUser } from './get-user.js';
+import { ZohoGetZohoRecords } from './get-zoho-records.js';
+import { ZohoGetZohoUsers } from './get-zoho-users.js';
+import { ZohoListAccounts } from './list-accounts.js';
+import { ZohoListCalls } from './list-calls.js';
+import { ZohoListContacts } from './list-contacts.js';
+import { ZohoListDeals } from './list-deals.js';
+import { ZohoListEvents } from './list-events.js';
+import { ZohoListLeads } from './list-leads.js';
+import { ZohoListModules } from './list-modules.js';
+import { ZohoListNotes } from './list-notes.js';
+import { ZohoListRecordAttachments } from './list-record-attachments.js';
+import { ZohoListTasks } from './list-tasks.js';
+import { ZohoSearchAccounts } from './search-accounts.js';
+import { ZohoSearchCalls } from './search-calls.js';
+import { ZohoSearchContacts } from './search-contacts.js';
+import { ZohoSearchDeals } from './search-deals.js';
+import { ZohoSearchEvents } from './search-events.js';
+import { ZohoSearchLeads } from './search-leads.js';
+import { ZohoSearchNotes } from './search-notes.js';
+import { ZohoSearchTasks } from './search-tasks.js';
+import { ZohoSearchZohoRecords } from './search-zoho-records.js';
+import { ZohoUpdateAccount } from './update-account.js';
+import { ZohoUpdateCall } from './update-call.js';
+import { ZohoUpdateDeal } from './update-deal.js';
+import { ZohoUpdateEmailDraft } from './update-email-draft.js';
+import { ZohoUpdateEvent } from './update-event.js';
+import { ZohoUpdateLead } from './update-lead.js';
+import { ZohoUpdateNote } from './update-note.js';
+import { ZohoUpdateRelatedRecords } from './update-related-records.js';
+import { ZohoUpdateZohoRecord } from './update-zoho-record.js';
+import { ZohoUploadAttachment } from './upload-attachment.js';
+import { ZohoValidateCredential } from './validate-credential.js';
+export { ZohoConvertZohoLead };
+export { ZohoCreateContact };
+export { ZohoCreateDeal };
+export { ZohoCreateEmailDraft };
+export { ZohoCreateEvent };
+export { ZohoCreateLead };
+export { ZohoCreateNote };
+export { ZohoCreateZohoRecord };
+export { ZohoCreateZohoTag };
+export { ZohoDeleteAccount };
+export { ZohoDeleteContact };
+export { ZohoDeleteDeal };
+export { ZohoGetAccount };
+export { ZohoGetCall };
+export { ZohoGetContact };
+export { ZohoGetEmailDrafts };
+export { ZohoGetEvent };
+export { ZohoGetFromAddresses };
+export { ZohoGetModuleFields };
+export { ZohoGetNote };
+export { ZohoGetRecordEmails };
+export { ZohoGetRelatedLists };
+export { ZohoGetRelatedRecords };
+export { ZohoGetTask };
+export { ZohoGetUser };
+export { ZohoGetZohoRecords };
+export { ZohoGetZohoUsers };
+export { ZohoListAccounts };
+export { ZohoListCalls };
+export { ZohoListContacts };
+export { ZohoListDeals };
+export { ZohoListEvents };
+export { ZohoListLeads };
+export { ZohoListModules };
+export { ZohoListNotes };
+export { ZohoListRecordAttachments };
+export { ZohoListTasks };
+export { ZohoSearchAccounts };
+export { ZohoSearchCalls };
+export { ZohoSearchContacts };
+export { ZohoSearchDeals };
+export { ZohoSearchEvents };
+export { ZohoSearchLeads };
+export { ZohoSearchNotes };
+export { ZohoSearchTasks };
+export { ZohoSearchZohoRecords };
+export { ZohoUpdateAccount };
+export { ZohoUpdateCall };
+export { ZohoUpdateDeal };
+export { ZohoUpdateEmailDraft };
+export { ZohoUpdateEvent };
+export { ZohoUpdateLead };
+export { ZohoUpdateNote };
+export { ZohoUpdateRelatedRecords };
+export { ZohoUpdateZohoRecord };
+export { ZohoUploadAttachment };
+export { ZohoValidateCredential };
+export const zohoTools = [
+    { name: 'ZohoConvertZohoLead', description: 'Converts a lead into a contact, account, and optionally a deal in Zoho CRM.', tool: ZohoConvertZohoLead, requiredAuth: 'zohoToken', scope: 'write' },
+    { name: 'ZohoCreateContact', description: 'Creates a new contact record in Zoho CRM. Use this action when you need to add a new contact to the CRM system. The Last_Name field is mandatory and must be provided with a non-emp', tool: ZohoCreateContact, requiredAuth: 'zohoToken', scope: 'write' },
+    { name: 'ZohoCreateDeal', description: 'Creates a new deal in Zoho CRM representing a sales opportunity with deal name, stage, amount, and closing date. Use this action when you need to create a sales deal or opportunity', tool: ZohoCreateDeal, requiredAuth: 'zohoToken', scope: 'write' },
+    { name: 'ZohoCreateEmailDraft', description: 'Creates email drafts for a specific record in Zoho CRM. Email drafts are saved but not sent, allowing for review and editing before sending. Use this action when you need to prepar', tool: ZohoCreateEmailDraft, requiredAuth: 'zohoToken', scope: 'write' },
+    { name: 'ZohoCreateEvent', description: 'Creates a new Event record in Zoho CRM. Events represent scheduled activities like meetings, calls, or appointments. Use this action when you need to schedule a new event or meetin', tool: ZohoCreateEvent, requiredAuth: 'zohoToken', scope: 'write' },
+    { name: 'ZohoCreateLead', description: 'Creates a new lead record in Zoho CRM with the specified details. The only mandatory field is Last_Name - all other fields are optional. Use this action when you need to add a new ', tool: ZohoCreateLead, requiredAuth: 'zohoToken', scope: 'write' },
+    { name: 'ZohoCreateNote', description: 'Creates a new note attached to a specific record in Zoho CRM. Notes are text annotations that can be added to any standard or custom module record. Use this action when you need to', tool: ZohoCreateNote, requiredAuth: 'zohoToken', scope: 'write' },
+    { name: 'ZohoCreateZohoRecord', description: 'Creates new records in a specified module in Zoho CRM. Bulk operations may partially succeed — inspect each item\'s status field in the response, as some records may be created whi', tool: ZohoCreateZohoRecord, requiredAuth: 'zohoToken', scope: 'write' },
+    { name: 'ZohoCreateZohoTag', description: 'Creates a new tag in Zoho CRM for a specific module. Tags help organize and categorize CRM records. Each module can have up to 100 tags, and each record can have up to 10 tags assi', tool: ZohoCreateZohoTag, requiredAuth: 'zohoToken', scope: 'write' },
+    { name: 'ZohoDeleteAccount', description: 'Deletes an existing account record from Zoho CRM. This action permanently removes the account and cannot be undone through the API. Use this action when you need to remove an accou', tool: ZohoDeleteAccount, requiredAuth: 'zohoToken', scope: 'delete' },
+    { name: 'ZohoDeleteContact', description: 'Deletes a contact from Zoho CRM. This action is irreversible — the contact cannot be recovered once deleted. Use this action when you need to permanently remove a contact record fr', tool: ZohoDeleteContact, requiredAuth: 'zohoToken', scope: 'delete' },
+    { name: 'ZohoDeleteDeal', description: 'Deletes a deal record from Zoho CRM. This action is irreversible — once deleted, the deal cannot be recovered. Use this action when you need to permanently remove a deal from the C', tool: ZohoDeleteDeal, requiredAuth: 'zohoToken', scope: 'delete' },
+    { name: 'ZohoGetAccount', description: 'Retrieves a specific Account record from Zoho CRM by its unique identifier. Returns complete account details including all standard and custom fields. Use this action when you need', tool: ZohoGetAccount, requiredAuth: 'zohoToken', scope: 'read' },
+    { name: 'ZohoGetCall', description: 'Retrieves a specific Call record by its unique identifier from Zoho CRM. Use this action when you need to fetch detailed information about a particular call, including its subject,', tool: ZohoGetCall, requiredAuth: 'zohoToken', scope: 'read' },
+    { name: 'ZohoGetContact', description: 'Retrieves a single contact record by ID from Zoho CRM. Returns the complete contact details including owner information, account associations, address fields, and all custom fields', tool: ZohoGetContact, requiredAuth: 'zohoToken', scope: 'read' },
+    { name: 'ZohoGetEmailDrafts', description: 'Retrieves email drafts associated with a specific record in Zoho CRM. Use this action when you need to view unsent email drafts that have been composed for a CRM record. This retur', tool: ZohoGetEmailDrafts, requiredAuth: 'zohoToken', scope: 'read' },
+    { name: 'ZohoGetEvent', description: 'Retrieves a specific event record from Zoho CRM by its unique identifier. Returns complete event details including all standard and custom fields. Use this action when you need to ', tool: ZohoGetEvent, requiredAuth: 'zohoToken', scope: 'read' },
+    { name: 'ZohoGetFromAddresses', description: 'Retrieves the list of from addresses configured for email operations in Zoho CRM. Use this action when you need to get available email addresses for sending emails or configuring e', tool: ZohoGetFromAddresses, requiredAuth: 'zohoToken', scope: 'read' },
+    { name: 'ZohoGetModuleFields', description: 'Retrieves field metadata for a Zoho CRM module including API names, data types, permissions, and configuration details. Use this tool to discover correct field names and types befo', tool: ZohoGetModuleFields, requiredAuth: 'zohoToken', scope: 'read' },
+    { name: 'ZohoGetNote', description: 'Retrieves a single note by its unique identifier from Zoho CRM. Returns the note\'s title, content, parent record reference, owner details, and timestamps. Use this action when you', tool: ZohoGetNote, requiredAuth: 'zohoToken', scope: 'read' },
+    { name: 'ZohoGetRecordEmails', description: 'Retrieves all emails associated with a specific record in Zoho CRM. Use this action when you need to fetch email history for a lead, contact, account, deal, or other CRM record. Th', tool: ZohoGetRecordEmails, requiredAuth: 'zohoToken', scope: 'read' },
+    { name: 'ZohoGetRelatedLists', description: 'Retrieves related list metadata for a Zoho CRM module to discover correct api_name values. Use this before updating related records to avoid INVALID_DATA errors from incorrect rela', tool: ZohoGetRelatedLists, requiredAuth: 'zohoToken', scope: 'read' },
+    { name: 'ZohoGetRelatedRecords', description: 'Fetch related-list records (e.g., Notes, Attachments, Emails) for a Zoho CRM parent record using related_list_api_name. Use ZOHO_GET_RELATED_LISTS first to discover the correct api', tool: ZohoGetRelatedRecords, requiredAuth: 'zohoToken', scope: 'read' },
+    { name: 'ZohoGetTask', description: 'Retrieves a specific task record by its ID from Zoho CRM. Returns complete task data including all standard and custom fields, subforms, and multi-user lookup fields that are only ', tool: ZohoGetTask, requiredAuth: 'zohoToken', scope: 'read' },
+    { name: 'ZohoGetUser', description: 'Retrieves a specific user from Zoho CRM by their user ID. Returns detailed user information including name, email, role, profile, status, and preferences. Use this action when you ', tool: ZohoGetUser, requiredAuth: 'zohoToken', scope: 'read' },
+    { name: 'ZohoGetZohoRecords', description: 'Retrieves records from a specified module in Zoho CRM. Notes: - Discrete (page/per_page) pagination is limited to the first 2,000 records. To retrieve records beyond this, use toke', tool: ZohoGetZohoRecords, requiredAuth: 'zohoToken', scope: 'read' },
+    { name: 'ZohoGetZohoUsers', description: 'Tool to retrieve users from Zoho CRM. Use when you need to fetch user information such as IDs, names, emails, roles, or status for setting Owner fields or performing user-related o', tool: ZohoGetZohoUsers, requiredAuth: 'zohoToken', scope: 'read' },
+    { name: 'ZohoListAccounts', description: 'Retrieves a list of account records from Zoho CRM with pagination and filtering support. Use this action when you need to fetch multiple account records from the Accounts module, o', tool: ZohoListAccounts, requiredAuth: 'zohoToken', scope: 'read' },
+    { name: 'ZohoListCalls', description: 'Retrieves Call activity records from Zoho CRM with pagination support. Use this action when you need to list calls logged in the CRM, filter by custom views, or retrieve specific C', tool: ZohoListCalls, requiredAuth: 'zohoToken', scope: 'read' },
+    { name: 'ZohoListContacts', description: 'Retrieves contact records from Zoho CRM with support for pagination, filtering, and sorting. Use this action when you need to fetch a list of contacts from Zoho CRM. This is a spec', tool: ZohoListContacts, requiredAuth: 'zohoToken', scope: 'read' },
+    { name: 'ZohoListDeals', description: 'Retrieves a list of deals from Zoho CRM with support for filtering, sorting, and pagination. Use this action when you need to fetch deal records from Zoho CRM, whether all deals or', tool: ZohoListDeals, requiredAuth: 'zohoToken', scope: 'read' },
+    { name: 'ZohoListEvents', description: 'Lists events (meetings) from Zoho CRM with pagination and filtering support. Use this action when you need to retrieve scheduled events, meetings, or appointments from Zoho CRM for', tool: ZohoListEvents, requiredAuth: 'zohoToken', scope: 'read' },
+    { name: 'ZohoListLeads', description: 'Retrieves lead records from Zoho CRM\'s Leads module with pagination support. Use this action when you need to list, filter, or paginate through leads in the CRM. Supports both dis', tool: ZohoListLeads, requiredAuth: 'zohoToken', scope: 'read' },
+    { name: 'ZohoListModules', description: 'Lists all available Zoho CRM modules (standard + custom) to reliably select module API names/IDs for operations. Use this tool before calling other module-specific operations to en', tool: ZohoListModules, requiredAuth: 'zohoToken', scope: 'read' },
+    { name: 'ZohoListNotes', description: 'Retrieves a list of notes from Zoho CRM across all modules. Notes are returned in chronological order (oldest first by default). Use this action when you need to view all notes in ', tool: ZohoListNotes, requiredAuth: 'zohoToken', scope: 'read' },
+    { name: 'ZohoListRecordAttachments', description: 'Tool to list attachment metadata (id, File_Name, Size, Created_Time, etc.) for a specific Zoho CRM record. Use when you need to identify attachments before downloading them via oth', tool: ZohoListRecordAttachments, requiredAuth: 'zohoToken', scope: 'read' },
+    { name: 'ZohoListTasks', description: 'Retrieves tasks from the Tasks module in Zoho CRM with support for filtering, pagination, and sorting. Use this action when you need to fetch a list of tasks, either all tasks or s', tool: ZohoListTasks, requiredAuth: 'zohoToken', scope: 'read' },
+    { name: 'ZohoSearchAccounts', description: 'Search for Account records within Zoho CRM using server-side queries. Returns accounts matching the specified criteria, email, phone, or keyword. Use this action when you need to f', tool: ZohoSearchAccounts, requiredAuth: 'zohoToken', scope: 'read' },
+    { name: 'ZohoSearchCalls', description: 'Search for Call records in Zoho CRM using server-side queries. Returns calls matching the specified criteria, email, phone, or keyword. Use this action when you need to find specif', tool: ZohoSearchCalls, requiredAuth: 'zohoToken', scope: 'read' },
+    { name: 'ZohoSearchContacts', description: 'Search for contacts in Zoho CRM using server-side queries by criteria, email, phone, or keyword. This action performs efficient server-side filtering in the Contacts module, avoidi', tool: ZohoSearchContacts, requiredAuth: 'zohoToken', scope: 'read' },
+    { name: 'ZohoSearchDeals', description: 'Search for Deal records in Zoho CRM using server-side queries. Supports searching by criteria (field conditions), email, phone, or keyword. Use this action when you need to find sp', tool: ZohoSearchDeals, requiredAuth: 'zohoToken', scope: 'read' },
+    { name: 'ZohoSearchEvents', description: 'Search for Events in Zoho CRM using server-side queries. Supports searching by field criteria, email, phone, or keyword. Use this action when you need to find specific events (meet', tool: ZohoSearchEvents, requiredAuth: 'zohoToken', scope: 'read' },
+    { name: 'ZohoSearchLeads', description: 'Search for lead records in Zoho CRM using server-side queries. Use this action when you need to find specific leads by criteria (field conditions), email address, phone number, or ', tool: ZohoSearchLeads, requiredAuth: 'zohoToken', scope: 'read' },
+    { name: 'ZohoSearchNotes', description: 'Search for notes in Zoho CRM using server-side queries. Allows searching notes by criteria (field conditions), keyword, email, or phone number. Use this action when you need to fin', tool: ZohoSearchNotes, requiredAuth: 'zohoToken', scope: 'read' },
+    { name: 'ZohoSearchTasks', description: 'Search for tasks in Zoho CRM using flexible criteria including subject, status, priority, or due date. Use this action when you need to find specific task records by criteria, emai', tool: ZohoSearchTasks, requiredAuth: 'zohoToken', scope: 'read' },
+    { name: 'ZohoSearchZohoRecords', description: 'Search for records within a Zoho CRM module using server-side queries. Use when you need to find specific records by criteria, email, phone, or keyword instead of listing all recor', tool: ZohoSearchZohoRecords, requiredAuth: 'zohoToken', scope: 'read' },
+    { name: 'ZohoUpdateAccount', description: 'Updates an existing Account record in Zoho CRM with the specified field values. Only the fields provided in the request will be updated; other fields remain unchanged. Use this act', tool: ZohoUpdateAccount, requiredAuth: 'zohoToken', scope: 'write' },
+    { name: 'ZohoUpdateCall', description: 'Updates existing call records in the Calls module in Zoho CRM. Supports updating up to 100 call records per API call. Use this action when you need to modify call details such as c', tool: ZohoUpdateCall, requiredAuth: 'zohoToken', scope: 'write' },
+    { name: 'ZohoUpdateDeal', description: 'Updates an existing deal in Zoho CRM. Use this action when you need to modify specific fields of a deal record, such as updating the deal amount, stage, closing date, or associated', tool: ZohoUpdateDeal, requiredAuth: 'zohoToken', scope: 'write' },
+    { name: 'ZohoUpdateEmailDraft', description: 'Updates an existing email draft associated with a record in Zoho CRM. Requires the draft ID, sender address, and text format. Use this action when you need to modify the recipients', tool: ZohoUpdateEmailDraft, requiredAuth: 'zohoToken', scope: 'write' },
+    { name: 'ZohoUpdateEvent', description: 'Updates existing events in Zoho CRM. Supports updating up to 100 events per API call. Use this action when you need to modify event details such as title, start/end times, location', tool: ZohoUpdateEvent, requiredAuth: 'zohoToken', scope: 'write' },
+    { name: 'ZohoUpdateLead', description: 'Updates existing lead records in Zoho CRM. Supports updating up to 100 leads per API call. Use this action when you need to modify lead information such as contact details, lead st', tool: ZohoUpdateLead, requiredAuth: 'zohoToken', scope: 'write' },
+    { name: 'ZohoUpdateNote', description: 'Updates an existing note in Zoho CRM. Only the Note_Title and Note_Content fields can be modified. Read-only fields (Owner, Modified_Time, Created_Time, Modified_By, Created_By) ca', tool: ZohoUpdateNote, requiredAuth: 'zohoToken', scope: 'write' },
+    { name: 'ZohoUpdateRelatedRecords', description: 'Associates or updates relationships between records across different modules in Zoho CRM. This action creates or modifies relationships between a parent record and related records.', tool: ZohoUpdateRelatedRecords, requiredAuth: 'zohoToken', scope: 'write' },
+    { name: 'ZohoUpdateZohoRecord', description: 'Updates existing records in a specified module in Zoho CRM. Supports updating up to 100 records per API call. Use field API names (not display names) for all field updates. The \'i', tool: ZohoUpdateZohoRecord, requiredAuth: 'zohoToken', scope: 'write' },
+    { name: 'ZohoUploadAttachment', description: 'Tool to upload a file as an Attachment to a specific Zoho CRM record. Use when you need to store files (PDFs, documents, images) in a record\'s Attachments section.', tool: ZohoUploadAttachment, requiredAuth: 'zohoToken', scope: 'write' },
+    { name: 'ZohoValidateCredential', description: 'Validates Zoho CRM credentials by retrieving current user information. Returns user details if credentials are valid. Use this action when you need to verify that API credentials a', tool: ZohoValidateCredential, requiredAuth: 'zohoToken', scope: 'read' },
+];
+//# sourceMappingURL=index.js.map

package/dist/toolkits/zoho/tools/list-accounts.d.ts

@@ -0,0 +1,14 @@
+export declare const ZohoListAccounts: import("ai").Tool<{
+    fields: string;
+    zohoToken: string;
+    page?: number | undefined;
+    per_page?: number | undefined;
+    page_token?: string | undefined;
+    sort_by?: string | undefined;
+    sort_order?: string | undefined;
+    cvid?: number | undefined;
+    approved?: string | undefined;
+    territory_id?: string | undefined;
+    include_child?: boolean | undefined;
+}, any>;
+//# sourceMappingURL=list-accounts.d.ts.map

package/dist/toolkits/zoho/tools/list-accounts.js

@@ -0,0 +1,60 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { zohoFetch } from './utils.js';
+export const ZohoListAccounts = tool({
+    description: 'Retrieves a list of account records from Zoho CRM with pagination and filtering support. Use this action when you need to fetch multiple account records from the Accounts module, optionally filtered by territory, approval status, or custom views. Supports both discrete pagination (first 2,000 record',
+    inputSchema: z.object({
+        zohoToken: z.string().describe('Zoho OAuth access token (Zoho-oauthtoken).'),
+        cvid: z.number().int().optional().describe('Custom view ID to filter the account records. Cannot be used together with sort_by. Note: This parameter is ignored when page_token is provided.'),
+        page: z.number().int().min(1).optional().describe('Page number to retrieve. Without page_token, only the first 2,000 records are accessible using page/per_page. Maximum page number is floor(2000/per_page). Do not use together with page_token.'),
+        fields: z.string().describe('Comma-separated API names of the account fields to retrieve (max 50). This parameter is mandatory in Zoho CRM v8 API. Common fields: Account_Name, Phone, Website, Industry, Annual_Revenue, Owner, Rati'),
+        sort_by: z.string().optional().describe('Valid fields for sorting Zoho CRM Accounts records.'),
+        approved: z.string().optional().describe('Filter accounts by approval status: \'true\' for approved, \'false\' for not approved, \'both\' for all.'),
+        per_page: z.number().int().min(1).max(200).optional().describe('Number of account records per page (max is 200). Default is 25 to avoid token bloat.'),
+        page_token: z.string().optional().describe('Token-based pagination parameter to fetch account records beyond the 2,000-record discrete limit. Use the info.next_page_token from the previous response. Cannot be used together with page.'),
+        sort_order: z.string().optional().describe('Sort order for Accounts records.'),
+        territory_id: z.string().optional().describe('Territory ID to filter accounts by territory assignment.'),
+        include_child: z.boolean().optional().describe('Whether to include accounts from child territories when territory_id is specified.'),
+    }),
+    execute: async (params) => {
+        const { zohoToken, ...rest } = params;
+        if (!zohoToken)
+            return { error: 'Zoho token is required. Connect Zoho CRM first.' };
+        try {
+            const p = rest;
+            const path = `/Accounts`;
+            const query = {};
+            if (p.fields)
+                query.fields = p.fields;
+            if (p.page)
+                query.page = p.page;
+            if (p.per_page)
+                query.per_page = p.per_page;
+            if (p.per_page)
+                query.per_page = p.per_page;
+            if (p.sort_by)
+                query.sort_by = p.sort_by;
+            if (p.sort_order)
+                query.sort_order = p.sort_order;
+            if (p.cvid)
+                query.cvid = p.cvid;
+            if (p.page_token)
+                query.page_token = p.page_token;
+            if (p.approved)
+                query.approved = p.approved;
+            if (p.territoryId)
+                query.territory_id = p.territoryId;
+            if (p.includeChild !== undefined)
+                query.include_child = p.includeChild;
+            const res = await zohoFetch(path, { zohoToken, method: 'GET', query });
+            if (!res.ok)
+                return { error: 'Failed to list', details: res.data };
+            return res.data;
+        }
+        catch (e) {
+            return { error: 'Error in ZohoListAccounts', message: e instanceof Error ? e.message : 'Unknown error' };
+        }
+    },
+});
+//# sourceMappingURL=list-accounts.js.map

package/dist/toolkits/zoho/tools/list-calls.d.ts

@@ -0,0 +1,12 @@
+export declare const ZohoListCalls: import("ai").Tool<{
+    fields: string;
+    zohoToken: string;
+    page?: number | undefined;
+    per_page?: number | undefined;
+    ids?: string | undefined;
+    page_token?: string | undefined;
+    sort_by?: string | undefined;
+    sort_order?: string | undefined;
+    cvid?: number | undefined;
+}, any>;
+//# sourceMappingURL=list-calls.d.ts.map

package/dist/toolkits/zoho/tools/list-calls.js

@@ -0,0 +1,58 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { zohoFetch } from './utils.js';
+export const ZohoListCalls = tool({
+    description: 'Retrieves Call activity records from Zoho CRM with pagination support. Use this action when you need to list calls logged in the CRM, filter by custom views, or retrieve specific Call records by ID. Call records represent phone call activities associated with Contacts, Leads, or other CRM records.',
+    inputSchema: z.object({
+        zohoToken: z.string().describe('Zoho OAuth access token (Zoho-oauthtoken).'),
+        ids: z.string().optional().describe('Comma-separated Call record IDs to fetch specific records. Note: This parameter is ignored when page_token is provided.'),
+        cvid: z.number().int().optional().describe('Custom view ID to filter the Call records. Cannot be used together with sort_by. Note: This parameter is ignored when page_token is provided.'),
+        page: z.number().int().min(1).optional().describe('Page number to retrieve. Without page_token, only the first 2,000 Call records are accessible using page/per_page. Maximum page number is floor(2000/per_page). Do not use together with page_token.'),
+        fields: z.string().describe('Comma-separated API names of Call fields to retrieve (max 50). Required parameter. Common Call fields: Subject, Call_Type, Call_Start_Time, Call_Duration, Call_Purpose, Call_Agenda, Call_Result, Descr'),
+        sort_by: z.string().optional().describe('Valid fields for sorting Zoho CRM Call records.'),
+        per_page: z.number().int().min(1).max(200).optional().describe('Number of Call records per page (maximum is 200). Applies to both page and page_token pagination. Defaults to 25 for optimal response size.'),
+        page_token: z.string().optional().describe('Token-based pagination parameter to fetch Call records beyond the 2,000-record discrete limit. Use the info.next_page_token from the previous response. Cannot be used together with page.'),
+        sort_order: z.string().optional().describe('Sort order for Call records.'),
+    }),
+    execute: async (params) => {
+        const { zohoToken, ...rest } = params;
+        if (!zohoToken)
+            return { error: 'Zoho token is required. Connect Zoho CRM first.' };
+        try {
+            const p = rest;
+            const path = `/Calls`;
+            const query = {};
+            if (p.fields)
+                query.fields = p.fields;
+            if (p.page)
+                query.page = p.page;
+            if (p.per_page)
+                query.per_page = p.per_page;
+            if (p.per_page)
+                query.per_page = p.per_page;
+            if (p.sort_by)
+                query.sort_by = p.sort_by;
+            if (p.sort_order)
+                query.sort_order = p.sort_order;
+            if (p.cvid)
+                query.cvid = p.cvid;
+            if (p.page_token)
+                query.page_token = p.page_token;
+            if (p.approved)
+                query.approved = p.approved;
+            if (p.territoryId)
+                query.territory_id = p.territoryId;
+            if (p.includeChild !== undefined)
+                query.include_child = p.includeChild;
+            const res = await zohoFetch(path, { zohoToken, method: 'GET', query });
+            if (!res.ok)
+                return { error: 'Failed to list', details: res.data };
+            return res.data;
+        }
+        catch (e) {
+            return { error: 'Error in ZohoListCalls', message: e instanceof Error ? e.message : 'Unknown error' };
+        }
+    },
+});
+//# sourceMappingURL=list-calls.js.map

package/dist/toolkits/zoho/tools/list-contacts.d.ts

@@ -0,0 +1,12 @@
+export declare const ZohoListContacts: import("ai").Tool<{
+    zohoToken: string;
+    page?: number | undefined;
+    per_page?: number | undefined;
+    ids?: string | undefined;
+    page_token?: string | undefined;
+    fields?: string | undefined;
+    sort_by?: string | undefined;
+    sort_order?: string | undefined;
+    cvid?: number | undefined;
+}, any>;
+//# sourceMappingURL=list-contacts.d.ts.map

package/dist/toolkits/zoho/tools/list-contacts.js

@@ -0,0 +1,58 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { zohoFetch } from './utils.js';
+export const ZohoListContacts = tool({
+    description: 'Retrieves contact records from Zoho CRM with support for pagination, filtering, and sorting. Use this action when you need to fetch a list of contacts from Zoho CRM. This is a specialized action focused on the Contacts module with contact-specific field defaults and optimizations. For retrieving rec',
+    inputSchema: z.object({
+        zohoToken: z.string().describe('Zoho OAuth access token (Zoho-oauthtoken).'),
+        ids: z.string().optional().describe('Comma-separated contact record IDs to fetch specific contacts. Note: This parameter is ignored when page_token is provided.'),
+        cvid: z.number().int().optional().describe('Custom view ID to filter the contact records. Cannot be used together with sort_by. Note: This parameter is ignored when page_token is provided.'),
+        page: z.number().int().min(1).optional().describe('Page number to retrieve. Without page_token, only the first 2,000 records are accessible using page/per_page. Maximum page number is floor(2000/per_page). Do not use together with page_token.'),
+        fields: z.string().min(1).optional().describe('Comma-separated API names of the contact fields to retrieve (max 50). At least one field must be specified (empty string not allowed). Common contact fields: First_Name, Last_Name, Email, Phone, Mobil'),
+        sort_by: z.string().optional().describe('Valid fields for sorting Zoho CRM contact records.'),
+        per_page: z.number().int().min(1).max(200).optional().describe('Number of contact records per page. Maximum is 200. Applies to both page and page_token pagination.'),
+        page_token: z.string().optional().describe('Token-based pagination parameter to fetch contacts beyond the 2,000-record discrete limit. Use the info.next_page_token from the previous response. Cannot be used together with page.'),
+        sort_order: z.string().optional().describe('Sort order for contact records.'),
+    }),
+    execute: async (params) => {
+        const { zohoToken, ...rest } = params;
+        if (!zohoToken)
+            return { error: 'Zoho token is required. Connect Zoho CRM first.' };
+        try {
+            const p = rest;
+            const path = `/Contacts`;
+            const query = {};
+            if (p.fields)
+                query.fields = p.fields;
+            if (p.page)
+                query.page = p.page;
+            if (p.per_page)
+                query.per_page = p.per_page;
+            if (p.per_page)
+                query.per_page = p.per_page;
+            if (p.sort_by)
+                query.sort_by = p.sort_by;
+            if (p.sort_order)
+                query.sort_order = p.sort_order;
+            if (p.cvid)
+                query.cvid = p.cvid;
+            if (p.page_token)
+                query.page_token = p.page_token;
+            if (p.approved)
+                query.approved = p.approved;
+            if (p.territoryId)
+                query.territory_id = p.territoryId;
+            if (p.includeChild !== undefined)
+                query.include_child = p.includeChild;
+            const res = await zohoFetch(path, { zohoToken, method: 'GET', query });
+            if (!res.ok)
+                return { error: 'Failed to list', details: res.data };
+            return res.data;
+        }
+        catch (e) {
+            return { error: 'Error in ZohoListContacts', message: e instanceof Error ? e.message : 'Unknown error' };
+        }
+    },
+});
+//# sourceMappingURL=list-contacts.js.map

package/dist/toolkits/zoho/tools/list-deals.d.ts

@@ -0,0 +1,15 @@
+export declare const ZohoListDeals: import("ai").Tool<{
+    zohoToken: string;
+    page?: number | undefined;
+    per_page?: number | undefined;
+    ids?: string | undefined;
+    page_token?: string | undefined;
+    fields?: string | undefined;
+    sort_by?: string | undefined;
+    converted?: string | undefined;
+    sort_order?: string | undefined;
+    cvid?: number | undefined;
+    territory_id?: string | undefined;
+    include_child?: boolean | undefined;
+}, any>;
+//# sourceMappingURL=list-deals.d.ts.map

package/dist/toolkits/zoho/tools/list-deals.js

@@ -0,0 +1,61 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { zohoFetch } from './utils.js';
+export const ZohoListDeals = tool({
+    description: 'Retrieves a list of deals from Zoho CRM with support for filtering, sorting, and pagination. Use this action when you need to fetch deal records from Zoho CRM, whether all deals or filtered by specific criteria. The action supports both discrete pagination (page/per_page) for the first 2,000 deals a',
+    inputSchema: z.object({
+        zohoToken: z.string().describe('Zoho OAuth access token (Zoho-oauthtoken).'),
+        ids: z.string().optional().describe('Comma-separated deal IDs to fetch specific deals. Note: This parameter is ignored when page_token is provided.'),
+        cvid: z.number().int().optional().describe('Custom view ID to filter the deals. Cannot be used together with sort_by. Note: This parameter is ignored when page_token is provided.'),
+        page: z.number().int().min(1).optional().describe('Page number to retrieve. Without page_token, only the first 2,000 deals are accessible using page/per_page. Maximum page number is floor(2000/per_page). Do not use together with page_token.'),
+        fields: z.string().min(1).optional().describe('Comma-separated API names of the deal fields to retrieve (max 50). At least one field must be specified (empty string not allowed). Common deal fields: Deal_Name, Amount, Stage, Closing_Date, Account_'),
+        sort_by: z.string().optional().describe('Valid fields for sorting Zoho CRM deals.'),
+        per_page: z.number().int().min(1).max(200).optional().describe('Number of deals per page (default 25, max is 200). Applies to both page and page_token pagination.'),
+        converted: z.string().optional().describe('Filter by conversion status: \'true\', \'false\', or \'both\'.'),
+        page_token: z.string().optional().describe('Token-based pagination parameter to fetch deals beyond the 2,000-record discrete limit. Use the info.next_page_token from the previous response. Cannot be used together with page.'),
+        sort_order: z.string().optional().describe('Sort order for deals.'),
+        territory_id: z.string().optional().describe('Territory identifier to filter deals by territory.'),
+        include_child: z.boolean().optional().describe('Include child territory records (default: false). Only applicable when territory_id is provided.'),
+    }),
+    execute: async (params) => {
+        const { zohoToken, ...rest } = params;
+        if (!zohoToken)
+            return { error: 'Zoho token is required. Connect Zoho CRM first.' };
+        try {
+            const p = rest;
+            const path = `/Deals`;
+            const query = {};
+            if (p.fields)
+                query.fields = p.fields;
+            if (p.page)
+                query.page = p.page;
+            if (p.per_page)
+                query.per_page = p.per_page;
+            if (p.per_page)
+                query.per_page = p.per_page;
+            if (p.sort_by)
+                query.sort_by = p.sort_by;
+            if (p.sort_order)
+                query.sort_order = p.sort_order;
+            if (p.cvid)
+                query.cvid = p.cvid;
+            if (p.page_token)
+                query.page_token = p.page_token;
+            if (p.approved)
+                query.approved = p.approved;
+            if (p.territoryId)
+                query.territory_id = p.territoryId;
+            if (p.includeChild !== undefined)
+                query.include_child = p.includeChild;
+            const res = await zohoFetch(path, { zohoToken, method: 'GET', query });
+            if (!res.ok)
+                return { error: 'Failed to list', details: res.data };
+            return res.data;
+        }
+        catch (e) {
+            return { error: 'Error in ZohoListDeals', message: e instanceof Error ? e.message : 'Unknown error' };
+        }
+    },
+});
+//# sourceMappingURL=list-deals.js.map

package/dist/toolkits/zoho/tools/list-events.d.ts

@@ -0,0 +1,12 @@
+export declare const ZohoListEvents: import("ai").Tool<{
+    fields: string;
+    zohoToken: string;
+    page?: number | undefined;
+    per_page?: number | undefined;
+    ids?: string | undefined;
+    page_token?: string | undefined;
+    sort_by?: string | undefined;
+    sort_order?: string | undefined;
+    cvid?: number | undefined;
+}, any>;
+//# sourceMappingURL=list-events.d.ts.map

package/dist/toolkits/zoho/tools/list-events.js

@@ -0,0 +1,58 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { zohoFetch } from './utils.js';
+export const ZohoListEvents = tool({
+    description: 'Lists events (meetings) from Zoho CRM with pagination and filtering support. Use this action when you need to retrieve scheduled events, meetings, or appointments from Zoho CRM for calendar management, reporting, or synchronization purposes. Note: In Zoho CRM UI, Events are displayed as \'Meetings\'',
+    inputSchema: z.object({
+        zohoToken: z.string().describe('Zoho OAuth access token (Zoho-oauthtoken).'),
+        ids: z.string().optional().describe('Comma-separated event record IDs to fetch specific events. This parameter is ignored when page_token is provided.'),
+        cvid: z.number().int().optional().describe('Custom view ID to filter the events. Cannot be used together with sort_by. This parameter is ignored when page_token is provided.'),
+        page: z.number().int().min(1).optional().describe('Page number to retrieve. Without page_token, only the first 2,000 events are accessible. Maximum page number is floor(2000/per_page). Cannot be used together with page_token.'),
+        fields: z.string().describe('Comma-separated API names of fields to retrieve (max 50). This parameter is required by the Zoho CRM API. Common Events fields: Event_Title, Start_DateTime, End_DateTime, Location, Venue, Description,'),
+        sort_by: z.string().optional().describe('Valid fields for sorting Zoho CRM Events.'),
+        per_page: z.number().int().min(1).max(200).optional().describe('Number of events per page (max 200). Default: 25. Applies to both page and page_token pagination.'),
+        page_token: z.string().optional().describe('Token-based pagination to fetch events beyond the 2,000-record limit. Use next_page_token from the previous response. Cannot be used with page parameter.'),
+        sort_order: z.string().optional().describe('Sort order for events.'),
+    }),
+    execute: async (params) => {
+        const { zohoToken, ...rest } = params;
+        if (!zohoToken)
+            return { error: 'Zoho token is required. Connect Zoho CRM first.' };
+        try {
+            const p = rest;
+            const path = `/Events`;
+            const query = {};
+            if (p.fields)
+                query.fields = p.fields;
+            if (p.page)
+                query.page = p.page;
+            if (p.per_page)
+                query.per_page = p.per_page;
+            if (p.per_page)
+                query.per_page = p.per_page;
+            if (p.sort_by)
+                query.sort_by = p.sort_by;
+            if (p.sort_order)
+                query.sort_order = p.sort_order;
+            if (p.cvid)
+                query.cvid = p.cvid;
+            if (p.page_token)
+                query.page_token = p.page_token;
+            if (p.approved)
+                query.approved = p.approved;
+            if (p.territoryId)
+                query.territory_id = p.territoryId;
+            if (p.includeChild !== undefined)
+                query.include_child = p.includeChild;
+            const res = await zohoFetch(path, { zohoToken, method: 'GET', query });
+            if (!res.ok)
+                return { error: 'Failed to list', details: res.data };
+            return res.data;
+        }
+        catch (e) {
+            return { error: 'Error in ZohoListEvents', message: e instanceof Error ? e.message : 'Unknown error' };
+        }
+    },
+});
+//# sourceMappingURL=list-events.js.map

package/dist/toolkits/zoho/tools/list-leads.d.ts

@@ -0,0 +1,13 @@
+export declare const ZohoListLeads: import("ai").Tool<{
+    zohoToken: string;
+    page?: number | undefined;
+    per_page?: number | undefined;
+    ids?: string | undefined;
+    page_token?: string | undefined;
+    fields?: string | undefined;
+    sort_by?: string | undefined;
+    converted?: string | undefined;
+    sort_order?: string | undefined;
+    cvid?: number | undefined;
+}, any>;
+//# sourceMappingURL=list-leads.d.ts.map