@rnsk/toolkits 0.0.11 → 0.0.12

package/dist/toolkits/zoho/tools/create-zoho-record.js

@@ -0,0 +1,35 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { zohoFetch } from './utils.js';
+export const ZohoCreateZohoRecord = tool({
+    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 while others fail.',
+    inputSchema: z.object({
+        zohoToken: z.string().describe('Zoho OAuth access token (Zoho-oauthtoken).'),
+        data: z.array(z.record(z.any())).describe('A list of dictionaries representing the records to be created. Each dictionary contains field API names as keys and their values. Required fields depend on the module (e.g., Last_Name is required for '),
+        lar_id: z.string().optional().describe('The layout ID or lead assignment rule ID (lar_id) to be used if required.'),
+        trigger: z.array(z.string()).optional().describe('List of triggers to invoke during record creation (e.g., [\'workflow\', \'blueprint\']). Enabling triggers can cause side effects (emails sent, other records modified) — only include when such effects'),
+        module_api_name: z.string().describe('The API name of the module to create a record in. Standard modules use PascalCase (e.g., \'Leads\', \'Contacts\', \'Accounts\', \'Deals\', \'Tasks\', \'Campaigns\'). Custom modules must use their exac'),
+    }),
+    execute: async (params) => {
+        const { zohoToken, ...rest } = params;
+        if (!zohoToken)
+            return { error: 'Zoho token is required. Connect Zoho CRM first.' };
+        try {
+            const { moduleApiName, data, trigger, larId } = rest;
+            const body = { data };
+            if (trigger)
+                body.trigger = trigger;
+            if (larId)
+                body.lar_id = larId;
+            const res = await zohoFetch(`/${moduleApiName}`, { zohoToken, method: 'POST', body });
+            if (!res.ok)
+                return { error: 'Failed to create record', details: res.data };
+            return res.data;
+        }
+        catch (e) {
+            return { error: 'Error in ZohoCreateZohoRecord', message: e instanceof Error ? e.message : 'Unknown error' };
+        }
+    },
+});
+//# sourceMappingURL=create-zoho-record.js.map

package/dist/toolkits/zoho/tools/create-zoho-tag.d.ts

@@ -0,0 +1,7 @@
+export declare const ZohoCreateZohoTag: import("ai").Tool<{
+    name: string;
+    zohoToken: string;
+    module_api_name: string;
+    color_code?: string | undefined;
+}, any>;
+//# sourceMappingURL=create-zoho-tag.d.ts.map

package/dist/toolkits/zoho/tools/create-zoho-tag.js

@@ -0,0 +1,30 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { zohoFetch } from './utils.js';
+export const ZohoCreateZohoTag = tool({
+    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 assigned. Tags must have unique names within a module and can be assigned custom colors from a predefined palette. Creating ',
+    inputSchema: z.object({
+        zohoToken: z.string().describe('Zoho OAuth access token (Zoho-oauthtoken).'),
+        name: z.string().describe('The name of the tag to create. Maximum 25 characters. Cannot contain \'<\', \'>\', commas, or emojis.'),
+        color_code: z.string().optional().describe('Hex color code for the tag. Must be one of the 13 allowed colors: #F17574 (red), #F48435 (orange), #E7A826 (yellow), #A8C026 (lime), #63C57E (green), #1DB9B4 (teal), #57B1FD (blue), #879BFC (indigo), '),
+        module_api_name: z.string().describe('The API name of the Zoho CRM module to create the tag in. Supported modules: Leads, Accounts, Contacts, Deals, Campaigns, Tasks, Cases, Events, Calls, Solutions, Products, Vendors, Price Books, Quotes'),
+    }),
+    execute: async (params) => {
+        const { zohoToken, ...rest } = params;
+        if (!zohoToken)
+            return { error: 'Zoho token is required. Connect Zoho CRM first.' };
+        try {
+            const { moduleApiName, name, colorCode } = rest;
+            const body = { tags: [{ name, color_code: colorCode }] };
+            const res = await zohoFetch(`/settings/tags?module=${moduleApiName}`, { zohoToken, method: 'POST', body });
+            if (!res.ok)
+                return { error: 'Failed to create tag', details: res.data };
+            return res.data;
+        }
+        catch (e) {
+            return { error: 'Error in ZohoCreateZohoTag', message: e instanceof Error ? e.message : 'Unknown error' };
+        }
+    },
+});
+//# sourceMappingURL=create-zoho-tag.js.map

package/dist/toolkits/zoho/tools/delete-account.d.ts

@@ -0,0 +1,6 @@
+export declare const ZohoDeleteAccount: import("ai").Tool<{
+    account_id: string;
+    zohoToken: string;
+    wf_trigger?: boolean | undefined;
+}, any>;
+//# sourceMappingURL=delete-account.d.ts.map

package/dist/toolkits/zoho/tools/delete-account.js

@@ -0,0 +1,29 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { zohoFetch } from './utils.js';
+export const ZohoDeleteAccount = tool({
+    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 account record that is no longer needed or was created in error. This action is irreversible — the account cannot be recovere',
+    inputSchema: z.object({
+        zohoToken: z.string().describe('Zoho OAuth access token (Zoho-oauthtoken).'),
+        account_id: z.string().describe('The unique identifier of the account to delete. Must be a valid Zoho CRM account ID.'),
+        wf_trigger: z.boolean().optional().describe('Whether to trigger workflow rules during deletion. Set to true to execute workflows, false to skip them. If not specified, default behavior applies.'),
+    }),
+    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/${p.account_id}`;
+            const res = await zohoFetch(path, { zohoToken, method: 'DELETE' });
+            if (!res.ok)
+                return { error: 'Failed to delete', details: res.data };
+            return res.data;
+        }
+        catch (e) {
+            return { error: 'Error in ZohoDeleteAccount', message: e instanceof Error ? e.message : 'Unknown error' };
+        }
+    },
+});
+//# sourceMappingURL=delete-account.js.map

package/dist/toolkits/zoho/tools/delete-contact.d.ts

@@ -0,0 +1,6 @@
+export declare const ZohoDeleteContact: import("ai").Tool<{
+    contact_id: string;
+    zohoToken: string;
+    wf_trigger?: boolean | undefined;
+}, any>;
+//# sourceMappingURL=delete-contact.d.ts.map

package/dist/toolkits/zoho/tools/delete-contact.js

@@ -0,0 +1,29 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { zohoFetch } from './utils.js';
+export const ZohoDeleteContact = tool({
+    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 from the CRM. All associated subforms and related data are automatically deleted.',
+    inputSchema: z.object({
+        zohoToken: z.string().describe('Zoho OAuth access token (Zoho-oauthtoken).'),
+        contact_id: z.string().describe('The unique identifier of the contact to delete'),
+        wf_trigger: z.boolean().optional().describe('Whether to trigger workflows during deletion. If true, all associated workflows execute. Defaults to true if not 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 = `/Contacts/${p.contact_id}`;
+            const res = await zohoFetch(path, { zohoToken, method: 'DELETE' });
+            if (!res.ok)
+                return { error: 'Failed to delete', details: res.data };
+            return res.data;
+        }
+        catch (e) {
+            return { error: 'Error in ZohoDeleteContact', message: e instanceof Error ? e.message : 'Unknown error' };
+        }
+    },
+});
+//# sourceMappingURL=delete-contact.js.map

package/dist/toolkits/zoho/tools/delete-deal.d.ts

@@ -0,0 +1,6 @@
+export declare const ZohoDeleteDeal: import("ai").Tool<{
+    zohoToken: string;
+    deal_id: string;
+    wf_trigger?: boolean | undefined;
+}, any>;
+//# sourceMappingURL=delete-deal.d.ts.map

package/dist/toolkits/zoho/tools/delete-deal.js

@@ -0,0 +1,29 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { zohoFetch } from './utils.js';
+export const ZohoDeleteDeal = tool({
+    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 CRM system. The deal will be moved to the recycle bin initially and can be restored from there within the configured rete',
+    inputSchema: z.object({
+        zohoToken: z.string().describe('Zoho OAuth access token (Zoho-oauthtoken).'),
+        deal_id: z.string().describe('The unique identifier of the deal to delete. This is the Zoho CRM record ID for the deal'),
+        wf_trigger: z.boolean().optional().describe('Whether to trigger workflow rules after deletion. Set to true to execute workflows, or false to skip them. When workflows execute, side effects like notifications and automations may occur'),
+    }),
+    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/${p.deal_id}`;
+            const res = await zohoFetch(path, { zohoToken, method: 'DELETE' });
+            if (!res.ok)
+                return { error: 'Failed to delete', details: res.data };
+            return res.data;
+        }
+        catch (e) {
+            return { error: 'Error in ZohoDeleteDeal', message: e instanceof Error ? e.message : 'Unknown error' };
+        }
+    },
+});
+//# sourceMappingURL=delete-deal.js.map

package/dist/toolkits/zoho/tools/get-account.d.ts

@@ -0,0 +1,6 @@
+export declare const ZohoGetAccount: import("ai").Tool<{
+    account_id: string;
+    zohoToken: string;
+    fields?: string | undefined;
+}, any>;
+//# sourceMappingURL=get-account.d.ts.map

package/dist/toolkits/zoho/tools/get-account.js

@@ -0,0 +1,34 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { zohoFetch } from './utils.js';
+export const ZohoGetAccount = tool({
+    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 to fetch a single account\'s information by its ID rather than searching or listing multiple accounts. Unlike bulk reco',
+    inputSchema: z.object({
+        zohoToken: z.string().describe('Zoho OAuth access token (Zoho-oauthtoken).'),
+        fields: z.string().optional().describe('Comma-separated API names of fields to retrieve (max 50 fields). If not specified, all available fields for the account are returned. Common fields: Account_Name, Website, Phone, Email, Industry, Annu'),
+        account_id: z.string().describe('The unique identifier of the Account record to retrieve.'),
+    }),
+    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/${p.account_id}`;
+            const query = {};
+            if (p.fields)
+                query.fields = p.fields;
+            if (p.module_api_name)
+                query.module = p.module_api_name;
+            const res = await zohoFetch(path, { zohoToken, method: 'GET', query });
+            if (!res.ok)
+                return { error: 'Failed to get', details: res.data };
+            return res.data;
+        }
+        catch (e) {
+            return { error: 'Error in ZohoGetAccount', message: e instanceof Error ? e.message : 'Unknown error' };
+        }
+    },
+});
+//# sourceMappingURL=get-account.js.map

package/dist/toolkits/zoho/tools/get-call.d.ts

@@ -0,0 +1,6 @@
+export declare const ZohoGetCall: import("ai").Tool<{
+    zohoToken: string;
+    record_id: string;
+    fields?: string | undefined;
+}, any>;
+//# sourceMappingURL=get-call.d.ts.map

package/dist/toolkits/zoho/tools/get-call.js

@@ -0,0 +1,34 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { zohoFetch } from './utils.js';
+export const ZohoGetCall = tool({
+    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, duration, type, participants, outcome, and associated contacts or deals. This action is read-only and does not modify a',
+    inputSchema: z.object({
+        zohoToken: z.string().describe('Zoho OAuth access token (Zoho-oauthtoken).'),
+        fields: z.string().optional().describe('Comma-separated API names of specific fields to retrieve (max 50). If not specified, all standard fields are returned. Common fields: Subject, Call_Type, Call_Start_Time, Call_Duration, Call_Purpose, '),
+        record_id: z.string().describe('The unique identifier of the Call record to retrieve. Must be a valid Zoho CRM record ID.'),
+    }),
+    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/${p.record_id}`;
+            const query = {};
+            if (p.fields)
+                query.fields = p.fields;
+            if (p.module_api_name)
+                query.module = p.module_api_name;
+            const res = await zohoFetch(path, { zohoToken, method: 'GET', query });
+            if (!res.ok)
+                return { error: 'Failed to get', details: res.data };
+            return res.data;
+        }
+        catch (e) {
+            return { error: 'Error in ZohoGetCall', message: e instanceof Error ? e.message : 'Unknown error' };
+        }
+    },
+});
+//# sourceMappingURL=get-call.js.map

package/dist/toolkits/zoho/tools/get-contact.d.ts

@@ -0,0 +1,5 @@
+export declare const ZohoGetContact: import("ai").Tool<{
+    zohoToken: string;
+    record_id: string;
+}, any>;
+//# sourceMappingURL=get-contact.d.ts.map

package/dist/toolkits/zoho/tools/get-contact.js

@@ -0,0 +1,33 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { zohoFetch } from './utils.js';
+export const ZohoGetContact = tool({
+    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. Use this action when you need to fetch detailed information about a specific contact using its record ID.',
+    inputSchema: z.object({
+        zohoToken: z.string().describe('Zoho OAuth access token (Zoho-oauthtoken).'),
+        record_id: z.string().describe('The unique ID of the contact record to retrieve. Must be a valid Zoho CRM contact record ID.'),
+    }),
+    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/${p.record_id}`;
+            const query = {};
+            if (p.fields)
+                query.fields = p.fields;
+            if (p.module_api_name)
+                query.module = p.module_api_name;
+            const res = await zohoFetch(path, { zohoToken, method: 'GET', query });
+            if (!res.ok)
+                return { error: 'Failed to get', details: res.data };
+            return res.data;
+        }
+        catch (e) {
+            return { error: 'Error in ZohoGetContact', message: e instanceof Error ? e.message : 'Unknown error' };
+        }
+    },
+});
+//# sourceMappingURL=get-contact.js.map

package/dist/toolkits/zoho/tools/get-email-drafts.d.ts

@@ -0,0 +1,6 @@
+export declare const ZohoGetEmailDrafts: import("ai").Tool<{
+    record: string;
+    zohoToken: string;
+    module: string;
+}, any>;
+//# sourceMappingURL=get-email-drafts.d.ts.map

package/dist/toolkits/zoho/tools/get-email-drafts.js

@@ -0,0 +1,34 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { zohoFetch } from './utils.js';
+export const ZohoGetEmailDrafts = tool({
+    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 returns draft metadata including recipients, subject, content, attachments, and scheduling details.',
+    inputSchema: z.object({
+        zohoToken: z.string().describe('Zoho OAuth access token (Zoho-oauthtoken).'),
+        module: z.string().describe('The API name of the CRM module containing the record. Examples: \'Leads\', \'Contacts\', \'Accounts\', \'Deals\', \'Cases\', etc. Must be the exact module API name, not the UI display label.'),
+        record: z.string().describe('Entity ID of the record for which to retrieve email drafts.'),
+    }),
+    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 = `/${p.module}/${p.record}/__email_drafts`;
+            const query = {};
+            if (p.fields)
+                query.fields = p.fields;
+            if (p.module_api_name)
+                query.module = p.module_api_name;
+            const res = await zohoFetch(path, { zohoToken, method: 'GET', query });
+            if (!res.ok)
+                return { error: 'Failed to get', details: res.data };
+            return res.data;
+        }
+        catch (e) {
+            return { error: 'Error in ZohoGetEmailDrafts', message: e instanceof Error ? e.message : 'Unknown error' };
+        }
+    },
+});
+//# sourceMappingURL=get-email-drafts.js.map

package/dist/toolkits/zoho/tools/get-event.d.ts

@@ -0,0 +1,5 @@
+export declare const ZohoGetEvent: import("ai").Tool<{
+    zohoToken: string;
+    record_id: string;
+}, any>;
+//# sourceMappingURL=get-event.d.ts.map

package/dist/toolkits/zoho/tools/get-event.js

@@ -0,0 +1,33 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { zohoFetch } from './utils.js';
+export const ZohoGetEvent = tool({
+    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 fetch detailed information about a specific event/meeting, including participants, location, timing, and related records',
+    inputSchema: z.object({
+        zohoToken: z.string().describe('Zoho OAuth access token (Zoho-oauthtoken).'),
+        record_id: z.string().describe('The unique identifier of the event record to retrieve'),
+    }),
+    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/${p.record_id}`;
+            const query = {};
+            if (p.fields)
+                query.fields = p.fields;
+            if (p.module_api_name)
+                query.module = p.module_api_name;
+            const res = await zohoFetch(path, { zohoToken, method: 'GET', query });
+            if (!res.ok)
+                return { error: 'Failed to get', details: res.data };
+            return res.data;
+        }
+        catch (e) {
+            return { error: 'Error in ZohoGetEvent', message: e instanceof Error ? e.message : 'Unknown error' };
+        }
+    },
+});
+//# sourceMappingURL=get-event.js.map

package/dist/toolkits/zoho/tools/get-from-addresses.d.ts

@@ -0,0 +1,4 @@
+export declare const ZohoGetFromAddresses: import("ai").Tool<{
+    zohoToken: string;
+}, any>;
+//# sourceMappingURL=get-from-addresses.d.ts.map

package/dist/toolkits/zoho/tools/get-from-addresses.js

@@ -0,0 +1,32 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { zohoFetch } from './utils.js';
+export const ZohoGetFromAddresses = tool({
+    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 email settings. Returns organization, user, alias, and chat email addresses configured in the CRM.',
+    inputSchema: z.object({
+        zohoToken: z.string().describe('Zoho OAuth access token (Zoho-oauthtoken).'),
+    }),
+    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 = `/settings/emails/from_addresses`;
+            const query = {};
+            if (p.fields)
+                query.fields = p.fields;
+            if (p.module_api_name)
+                query.module = p.module_api_name;
+            const res = await zohoFetch(path, { zohoToken, method: 'GET', query });
+            if (!res.ok)
+                return { error: 'Failed to get', details: res.data };
+            return res.data;
+        }
+        catch (e) {
+            return { error: 'Error in ZohoGetFromAddresses', message: e instanceof Error ? e.message : 'Unknown error' };
+        }
+    },
+});
+//# sourceMappingURL=get-from-addresses.js.map

package/dist/toolkits/zoho/tools/get-module-fields.d.ts

@@ -0,0 +1,8 @@
+export declare const ZohoGetModuleFields: import("ai").Tool<{
+    zohoToken: string;
+    module_api_name: string;
+    type?: string | undefined;
+    include?: string | undefined;
+    field_unique_id?: string | undefined;
+}, any>;
+//# sourceMappingURL=get-module-fields.d.ts.map

package/dist/toolkits/zoho/tools/get-module-fields.js

@@ -0,0 +1,36 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { zohoFetch } from './utils.js';
+export const ZohoGetModuleFields = tool({
+    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 before creating or updating records, avoiding INVALID_DATA errors. Returns information about standard fields, custom fields,',
+    inputSchema: z.object({
+        zohoToken: z.string().describe('Zoho OAuth access token (Zoho-oauthtoken).'),
+        type: z.string().optional().describe('Filter fields by usage type. Values: \'all\' (both used and unused fields) or \'unused\' (unused fields only). If not specified, returns all used fields.'),
+        include: z.string().optional().describe('Include additional permission details in the response. Use \'allowed_permissions_to_update\' to get default field permissions (read-only, read-write, hidden).'),
+        field_unique_id: z.string().optional().describe('The unique ID of a specific field to retrieve. When provided, only that single field\'s metadata is returned. If not specified, all fields for the module are returned.'),
+        module_api_name: z.string().describe('The API name of the module to retrieve field metadata for. Examples: \'Leads\', \'Contacts\', \'Accounts\', \'Deals\', \'Tasks\', \'Cases\', \'Events\', \'Calls\', etc. For custom modules, use the exa'),
+    }),
+    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 = `/settings/fields`;
+            const query = {};
+            if (p.fields)
+                query.fields = p.fields;
+            if (p.module_api_name)
+                query.module = p.module_api_name;
+            const res = await zohoFetch(path, { zohoToken, method: 'GET', query });
+            if (!res.ok)
+                return { error: 'Failed to get', details: res.data };
+            return res.data;
+        }
+        catch (e) {
+            return { error: 'Error in ZohoGetModuleFields', message: e instanceof Error ? e.message : 'Unknown error' };
+        }
+    },
+});
+//# sourceMappingURL=get-module-fields.js.map

package/dist/toolkits/zoho/tools/get-note.d.ts

@@ -0,0 +1,6 @@
+export declare const ZohoGetNote: import("ai").Tool<{
+    zohoToken: string;
+    note_id: string;
+    fields?: string | undefined;
+}, any>;
+//# sourceMappingURL=get-note.d.ts.map

package/dist/toolkits/zoho/tools/get-note.js

@@ -0,0 +1,34 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { zohoFetch } from './utils.js';
+export const ZohoGetNote = tool({
+    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 need to fetch detailed information about a specific note, such as reading meeting notes, viewing customer interaction s',
+    inputSchema: z.object({
+        zohoToken: z.string().describe('Zoho OAuth access token (Zoho-oauthtoken).'),
+        fields: z.string().min(1).optional().describe('Comma-separated API names of the fields to retrieve. Common fields: Note_Title, Note_Content, Parent_Id, Owner, Created_Time, Modified_Time, Created_By, Modified_By. This parameter is required by the '),
+        note_id: z.string().describe('The unique identifier of the note to retrieve'),
+    }),
+    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 = `/Notes/${p.note_id}`;
+            const query = {};
+            if (p.fields)
+                query.fields = p.fields;
+            if (p.module_api_name)
+                query.module = p.module_api_name;
+            const res = await zohoFetch(path, { zohoToken, method: 'GET', query });
+            if (!res.ok)
+                return { error: 'Failed to get', details: res.data };
+            return res.data;
+        }
+        catch (e) {
+            return { error: 'Error in ZohoGetNote', message: e instanceof Error ? e.message : 'Unknown error' };
+        }
+    },
+});
+//# sourceMappingURL=get-note.js.map

package/dist/toolkits/zoho/tools/get-record-emails.d.ts

@@ -0,0 +1,9 @@
+export declare const ZohoGetRecordEmails: import("ai").Tool<{
+    zohoToken: string;
+    record_id: string;
+    module_api_name: string;
+    type?: string | undefined;
+    index?: string | undefined;
+    owner_id?: string | undefined;
+}, any>;
+//# sourceMappingURL=get-record-emails.d.ts.map

package/dist/toolkits/zoho/tools/get-record-emails.js

@@ -0,0 +1,37 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { zohoFetch } from './utils.js';
+export const ZohoGetRecordEmails = tool({
+    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. The response includes email metadata such as subject, sender, recipients, timestamps, and status information. Supports pag',
+    inputSchema: z.object({
+        zohoToken: z.string().describe('Zoho OAuth access token (Zoho-oauthtoken).'),
+        type: z.string().optional().describe('Type of emails to filter.'),
+        index: z.string().optional().describe('Pagination control parameter. Use the \'next_index\' value from the previous response\'s info object to retrieve the next batch of emails. Start without this parameter to get the first page.'),
+        owner_id: z.string().optional().describe('The ID of the user whose emails you want to fetch. IMPORTANT: This parameter can only be used when type=\'user_emails\'. It will be ignored if type is set to any other value.'),
+        record_id: z.string().describe('The unique identifier of the record whose emails you want to retrieve.'),
+        module_api_name: z.string().describe('The API name of the module containing the record. Common modules: \'Leads\', \'Contacts\', \'Accounts\', \'Deals\', \'Quotes\', \'Invoices\', \'Sales_Orders\', \'Purchase_Orders\', or custom modules. '),
+    }),
+    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 = `/${p.module_api_name}/${p.record_id}/Emails`;
+            const query = {};
+            if (p.fields)
+                query.fields = p.fields;
+            if (p.module_api_name)
+                query.module = p.module_api_name;
+            const res = await zohoFetch(path, { zohoToken, method: 'GET', query });
+            if (!res.ok)
+                return { error: 'Failed to get', details: res.data };
+            return res.data;
+        }
+        catch (e) {
+            return { error: 'Error in ZohoGetRecordEmails', message: e instanceof Error ? e.message : 'Unknown error' };
+        }
+    },
+});
+//# sourceMappingURL=get-record-emails.js.map

package/dist/toolkits/zoho/tools/get-related-lists.d.ts

@@ -0,0 +1,6 @@
+export declare const ZohoGetRelatedLists: import("ai").Tool<{
+    zohoToken: string;
+    module_api_name: string;
+    layout_id?: string | undefined;
+}, any>;
+//# sourceMappingURL=get-related-lists.d.ts.map

package/dist/toolkits/zoho/tools/get-related-lists.js

@@ -0,0 +1,29 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { zohoFetch } from './utils.js';
+export const ZohoGetRelatedLists = tool({
+    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 related_list_api_name. Returns api_name, display_label, href, and other details for each related list available in the modul',
+    inputSchema: z.object({
+        zohoToken: z.string().describe('Zoho OAuth access token (Zoho-oauthtoken).'),
+        layout_id: z.string().optional().describe('Optional layout ID to filter related lists by specific layout. If not specified, returns related lists for all layouts of the module.'),
+        module_api_name: z.string().describe('The API name of the module to retrieve related list metadata for. Examples: \'Leads\', \'Contacts\', \'Accounts\', \'Deals\', \'Tasks\', etc. This must be a valid module API name in Zoho CRM.'),
+    }),
+    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 = `/settings/related_lists`;
+            const res = await zohoFetch(path, { zohoToken, method: 'GET', query: p });
+            if (!res.ok)
+                return { error: 'Failed', details: res.data };
+            return res.data;
+        }
+        catch (e) {
+            return { error: 'Error in ZohoGetRelatedLists', message: e instanceof Error ? e.message : 'Unknown error' };
+        }
+    },
+});
+//# sourceMappingURL=get-related-lists.js.map

package/dist/toolkits/zoho/tools/get-related-records.d.ts

@@ -0,0 +1,15 @@
+export declare const ZohoGetRelatedRecords: import("ai").Tool<{
+    fields: string;
+    zohoToken: string;
+    record_id: string;
+    module_api_name: string;
+    related_list_api_name: string;
+    page?: number | undefined;
+    per_page?: number | undefined;
+    ids?: string | undefined;
+    page_token?: string | undefined;
+    sort_by?: string | undefined;
+    converted?: string | undefined;
+    sort_order?: string | undefined;
+}, any>;
+//# sourceMappingURL=get-related-records.d.ts.map