@rnsk/toolkits 0.0.11 → 0.0.12

package/dist/toolkits/zoho/icon.js

@@ -0,0 +1,125 @@
+const SVG = `<svg xmlns="http://www.w3.org/2000/svg" version="1.1" viewBox="0.00 0.00 48.00 48.00">
+<g stroke-width="2.00" fill="none" stroke-linecap="butt">
+<path stroke="#f29293" vector-effect="non-scaling-stroke" d="
+  M 22.72 3.60
+  Q 19.65 4.02 16.22 4.53
+  Q 11.84 5.18 9.89 6.08
+  Q 3.79 8.90 2.53 16.25
+  Q 2.13 18.61 3.58 25.11"
+/>
+<path stroke="#fcd98e" vector-effect="non-scaling-stroke" d="
+  M 3.58 25.11
+  Q 3.99 28.48 4.57 32.23
+  Q 5.28 36.78 6.50 38.94
+  C 9.53 44.32 14.77 46.04 20.68 45.17
+  Q 23.09 44.82 25.53 44.39"
+/>
+<path stroke="#91b6da" vector-effect="non-scaling-stroke" d="
+  M 25.53 44.39
+  C 29.75 43.78 35.24 43.43 38.66 41.65
+  Q 44.52 38.58 45.48 31.26
+  Q 45.72 29.47 44.61 23.94"
+/>
+<path stroke="#84cca4" vector-effect="non-scaling-stroke" d="
+  M 44.61 23.94
+  Q 44.08 20.18 43.45 16.12
+  Q 42.64 10.96 41.23 8.62
+  Q 37.94 3.17 30.75 2.49
+  Q 29.00 2.32 22.72 3.60"
+/>
+<path stroke="#15837f" vector-effect="non-scaling-stroke" d="
+  M 44.61 23.94
+  Q 39.61 27.27 36.08 24.01"
+/>
+<path stroke="#84cca4" vector-effect="non-scaling-stroke" d="
+  M 36.08 24.01
+  L 34.51 14.35
+  A 4.02 4.01 -9.0 0 0 29.94 11.03
+  L 23.08 12.08"
+/>
+<path stroke="#765f38" vector-effect="non-scaling-stroke" d="
+  M 23.08 12.08
+  Q 28.56 8.10 22.72 3.60"
+/>
+<path stroke="#f29293" vector-effect="non-scaling-stroke" d="
+  M 23.08 12.08
+  Q 19.11 12.69 15.21 13.35
+  C 9.32 14.34 11.17 19.35 11.82 23.49"
+/>
+<path stroke="#ef6c22" vector-effect="non-scaling-stroke" d="
+  M 11.82 23.49
+  Q 6.56 20.66 3.58 25.11"
+/>
+<path stroke="#91b6da" vector-effect="non-scaling-stroke" d="
+  M 36.08 24.01
+  L 36.97 30.06
+  A 3.91 3.90 -8.8 0 1 33.72 34.49
+  L 24.66 35.94"
+/>
+<path stroke="#fcd98e" vector-effect="non-scaling-stroke" d="
+  M 24.66 35.94
+  L 18.02 36.95
+  A 3.97 3.96 -9.0 0 1 13.51 33.68
+  L 11.82 23.49"
+/>
+<path stroke="#8e9069" vector-effect="non-scaling-stroke" d="
+  M 24.66 35.94
+  Q 19.39 40.68 25.53 44.39"
+/>
+</g>
+<path fill="#089949" d="
+  M 44.61 23.94
+  Q 39.61 27.27 36.08 24.01
+  L 34.51 14.35
+  A 4.02 4.01 -9.0 0 0 29.94 11.03
+  L 23.08 12.08
+  Q 28.56 8.10 22.72 3.60
+  Q 29.00 2.32 30.75 2.49
+  Q 37.94 3.17 41.23 8.62
+  Q 42.64 10.96 43.45 16.12
+  Q 44.08 20.18 44.61 23.94
+  Z"
+/>
+<path fill="#e42527" d="
+  M 22.72 3.60
+  Q 28.56 8.10 23.08 12.08
+  Q 19.11 12.69 15.21 13.35
+  C 9.32 14.34 11.17 19.35 11.82 23.49
+  Q 6.56 20.66 3.58 25.11
+  Q 2.13 18.61 2.53 16.25
+  Q 3.79 8.90 9.89 6.08
+  Q 11.84 5.18 16.22 4.53
+  Q 19.65 4.02 22.72 3.60
+  Z"
+/>
+<path fill="#f9b21d" d="
+  M 11.82 23.49
+  L 13.51 33.68
+  A 3.97 3.96 -9.0 0 0 18.02 36.95
+  L 24.66 35.94
+  Q 19.39 40.68 25.53 44.39
+  Q 23.09 44.82 20.68 45.17
+  C 14.77 46.04 9.53 44.32 6.50 38.94
+  Q 5.28 36.78 4.57 32.23
+  Q 3.99 28.48 3.58 25.11
+  Q 6.56 20.66 11.82 23.49
+  Z"
+/>
+<path fill="#226db4" d="
+  M 36.08 24.01
+  Q 39.61 27.27 44.61 23.94
+  Q 45.72 29.47 45.48 31.26
+  Q 44.52 38.58 38.66 41.65
+  C 35.24 43.43 29.75 43.78 25.53 44.39
+  Q 19.39 40.68 24.66 35.94
+  L 33.72 34.49
+  A 3.91 3.90 -8.8 0 0 36.97 30.06
+  L 36.08 24.01
+  Z"
+/>
+</svg>`;
+export const ZOHO_ICON = {
+    kind: 'svg',
+    dataUri: `data:image/svg+xml;base64,${Buffer.from(SVG).toString('base64')}`,
+};
+//# sourceMappingURL=icon.js.map

package/dist/toolkits/zoho/manifest.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("../../index.js").ToolkitManifest;
+export default _default;
+//# sourceMappingURL=manifest.d.ts.map

package/dist/toolkits/zoho/manifest.js

@@ -0,0 +1,54 @@
+import { defineToolkit, defineTool } from '../../core/define.js';
+import { ZOHO_ICON } from './icon.js';
+import { zohoTools } from './tools/index.js';
+export default defineToolkit({
+    id: 'zoho',
+    displayName: 'Zoho CRM',
+    shortDescription: 'Leads, contacts, deals, accounts, events and more.',
+    category: 'CRM',
+    icon: ZOHO_ICON,
+    auth: {
+        type: 'oauth2',
+        tokenField: 'zohoToken',
+        provider: {
+            slug: 'zoho',
+            env: { clientId: 'ZOHO_CLIENT_ID', clientSecret: 'ZOHO_CLIENT_SECRET' },
+            authorizeUrl: 'https://accounts.zoho.com/oauth/v2/auth',
+            tokenUrl: 'https://accounts.zoho.com/oauth/v2/token',
+            scopes: [
+                'ZohoCRM.modules.ALL',
+                'ZohoCRM.users.READ',
+                'ZohoCRM.settings.fields.READ',
+                'ZohoCRM.settings.related_lists.READ',
+                'ZohoCRM.settings.modules.READ',
+                'ZohoCRM.settings.tags.CREATE',
+                'ZohoCRM.settings.emails.READ',
+                'ZohoSearch.securesearch.READ',
+            ],
+            scopeSeparator: ',',
+            exchangeStyle: 'form',
+            extraAuthParams: { access_type: 'offline', prompt: 'consent' },
+            connectDescription: 'Connect Zoho CRM to manage leads, contacts, deals, accounts and activities. Requires Zoho CRM account with API access.',
+            callbackPath: '/api/auth/zoho/callback',
+            stateCookie: 'zoho_oauth_state',
+        },
+    },
+    allowedHosts: [
+        'www.zohoapis.com',
+        'www.zohoapis.eu',
+        'www.zohoapis.in',
+        'www.zohoapis.com.au',
+        'www.zohoapis.jp',
+        'zohoapis.com',
+        'accounts.zoho.com',
+    ],
+    tools: zohoTools.map((entry) => defineTool({
+        name: entry.name,
+        description: entry.description,
+        tool: entry.tool,
+        requiredAuth: entry.requiredAuth,
+        scope: entry.scope,
+    })),
+    meta: { since: '0.0.1' },
+});
+//# sourceMappingURL=manifest.js.map

package/dist/toolkits/zoho/tools/convert-zoho-lead.d.ts

@@ -0,0 +1,11 @@
+export declare const ZohoConvertZohoLead: import("ai").Tool<{
+    zohoToken: string;
+    lead_id: string;
+    account_id?: string | undefined;
+    contact_id?: string | undefined;
+    overwrite?: boolean | undefined;
+    assign_to?: string | undefined;
+    notify_lead_owner?: boolean | undefined;
+    notify_new_entity_owner?: boolean | undefined;
+}, any>;
+//# sourceMappingURL=convert-zoho-lead.d.ts.map

package/dist/toolkits/zoho/tools/convert-zoho-lead.js

@@ -0,0 +1,47 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { zohoFetch } from './utils.js';
+export const ZohoConvertZohoLead = tool({
+    description: 'Converts a lead into a contact, account, and optionally a deal in Zoho CRM.',
+    inputSchema: z.object({
+        zohoToken: z.string().describe('Zoho OAuth access token (Zoho-oauthtoken).'),
+        lead_id: z.string().describe('The unique ID of the lead to convert.'),
+        assign_to: z.string().optional().describe('User ID to assign as the owner of the new contact/account.'),
+        overwrite: z.boolean().optional().describe('Whether to overwrite the account name in the contact if it already exists and the company names mismatch.'),
+        account_id: z.string().optional().describe('ID of an existing account to associate with the converted lead.'),
+        contact_id: z.string().optional().describe('ID of an existing contact to associate with the converted lead.'),
+        notify_lead_owner: z.boolean().optional().describe('Notify the lead owner about the conversion via email.'),
+        notify_new_entity_owner: z.boolean().optional().describe('Notify the new owner of the contact/account via email.'),
+    }),
+    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 = `/Leads/${p.lead_id}/actions/convert`;
+            const body = {};
+            if (p.assignTo)
+                body.assign_to = p.assignTo;
+            if (p.overwrite !== undefined)
+                body.overwrite = p.overwrite;
+            if (p.account_id)
+                body.account_id = p.account_id;
+            if (p.contact_id)
+                body.contact_id = p.contact_id;
+            if (p.notifyLeadOwner !== undefined)
+                body.notify_lead_owner = p.notifyLeadOwner;
+            if (p.notifyNewEntityOwner !== undefined)
+                body.notify_new_entity_owner = p.notifyNewEntityOwner;
+            const res = await zohoFetch(path, { zohoToken, method: 'POST', body: { data: [body] } });
+            if (!res.ok)
+                return { error: 'Failed to convert lead', details: res.data };
+            return res.data;
+        }
+        catch (e) {
+            return { error: 'Error in ZohoConvertZohoLead', message: e instanceof Error ? e.message : 'Unknown error' };
+        }
+    },
+});
+//# sourceMappingURL=convert-zoho-lead.js.map

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

@@ -0,0 +1,36 @@
+export declare const ZohoCreateContact: import("ai").Tool<{
+    zohoToken: string;
+    last_name: string;
+    description?: string | undefined;
+    title?: string | undefined;
+    email?: string | undefined;
+    owner?: Record<string, any> | undefined;
+    mobile?: string | undefined;
+    fax?: string | undefined;
+    phone?: string | undefined;
+    twitter?: string | undefined;
+    skype_id?: string | undefined;
+    assistant?: string | undefined;
+    other_zip?: string | undefined;
+    asst_phone?: string | undefined;
+    department?: string | undefined;
+    first_name?: string | undefined;
+    home_phone?: string | undefined;
+    other_city?: string | undefined;
+    lead_source?: string | undefined;
+    mailing_zip?: string | undefined;
+    other_phone?: string | undefined;
+    other_state?: string | undefined;
+    vendor_name?: string | undefined;
+    account_name?: string | undefined;
+    mailing_city?: string | undefined;
+    other_street?: string | undefined;
+    reporting_to?: Record<string, any> | undefined;
+    date_of_birth?: string | undefined;
+    mailing_state?: string | undefined;
+    other_country?: string | undefined;
+    mailing_street?: string | undefined;
+    mailing_country?: string | undefined;
+    secondary_email?: string | undefined;
+}, any>;
+//# sourceMappingURL=create-contact.d.ts.map

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

@@ -0,0 +1,58 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { zohoFetch } from './utils.js';
+export const ZohoCreateContact = tool({
+    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-empty value.',
+    inputSchema: z.object({
+        zohoToken: z.string().describe('Zoho OAuth access token (Zoho-oauthtoken).'),
+        fax: z.string().optional().describe('Fax number of the contact'),
+        email: z.string().optional().describe('Email address of the contact'),
+        owner: z.record(z.any()).optional().describe('Reference to another contact or user in Zoho CRM.'),
+        phone: z.string().optional().describe('Phone number of the contact'),
+        title: z.string().optional().describe('Job title of the contact'),
+        mobile: z.string().optional().describe('Mobile phone number of the contact'),
+        twitter: z.string().optional().describe('Twitter handle of the contact'),
+        skype_id: z.string().optional().describe('Skype ID of the contact'),
+        assistant: z.string().optional().describe('Name of the contact\'s assistant'),
+        last_name: z.string().describe('Last name of the contact (required field, must be non-empty)'),
+        other_zip: z.string().optional().describe('ZIP code for other address'),
+        asst_phone: z.string().optional().describe('Phone number of the contact\'s assistant'),
+        department: z.string().optional().describe('Department where the contact works'),
+        first_name: z.string().optional().describe('First name of the contact'),
+        home_phone: z.string().optional().describe('Home phone number of the contact'),
+        other_city: z.string().optional().describe('City for other address'),
+        description: z.string().optional().describe('Description or notes about the contact'),
+        lead_source: z.string().optional().describe('Source from which the contact was acquired'),
+        mailing_zip: z.string().optional().describe('ZIP code for mailing address'),
+        other_phone: z.string().optional().describe('Alternative phone number of the contact'),
+        other_state: z.string().optional().describe('State for other address'),
+        vendor_name: z.string().optional().describe('Name of the vendor associated with this contact'),
+        account_name: z.string().optional().describe('Name of the account associated with this contact'),
+        mailing_city: z.string().optional().describe('City for mailing address'),
+        other_street: z.string().optional().describe('Street address for other address'),
+        reporting_to: z.record(z.any()).optional().describe('Reference to another contact or user in Zoho CRM.'),
+        date_of_birth: z.string().optional().describe('Date of birth of the contact in YYYY-MM-DD format'),
+        mailing_state: z.string().optional().describe('State for mailing address'),
+        other_country: z.string().optional().describe('Country for other address'),
+        mailing_street: z.string().optional().describe('Street address for mailing'),
+        mailing_country: z.string().optional().describe('Country for mailing address'),
+        secondary_email: z.string().optional().describe('Secondary email address of the contact'),
+    }),
+    execute: async (params) => {
+        const { zohoToken, ...rest } = params;
+        if (!zohoToken)
+            return { error: 'Zoho token is required. Connect Zoho CRM first.' };
+        try {
+            const body = { data: [rest] };
+            const res = await zohoFetch('/Contacts', { zohoToken, method: 'POST', body });
+            if (!res.ok)
+                return { error: 'Failed to create contacts', details: res.data };
+            return res.data;
+        }
+        catch (e) {
+            return { error: 'Error in ZohoCreateContact', message: e instanceof Error ? e.message : 'Unknown error' };
+        }
+    },
+});
+//# sourceMappingURL=create-contact.js.map

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

@@ -0,0 +1,17 @@
+export declare const ZohoCreateDeal: import("ai").Tool<{
+    zohoToken: string;
+    Stage: string;
+    Deal_Name: string;
+    Owner?: Record<string, any> | undefined;
+    Amount?: number | undefined;
+    Pipeline?: string | undefined;
+    Next_Step?: string | undefined;
+    Description?: string | undefined;
+    Lead_Source?: string | undefined;
+    Probability?: number | undefined;
+    Account_Name?: Record<string, any> | undefined;
+    Closing_Date?: string | undefined;
+    Contact_Name?: Record<string, any> | undefined;
+    Campaign_Source?: Record<string, any> | undefined;
+}, any>;
+//# sourceMappingURL=create-deal.d.ts.map

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

@@ -0,0 +1,39 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { zohoFetch } from './utils.js';
+export const ZohoCreateDeal = tool({
+    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 in Zoho CRM. Required fields are Deal_Name and Stage; all other fields are optional. The deal will be assigned to the a',
+    inputSchema: z.object({
+        zohoToken: z.string().describe('Zoho OAuth access token (Zoho-oauthtoken).'),
+        Owner: z.record(z.any()).optional().describe('Owner of the deal.'),
+        Stage: z.string().describe('The current stage of the deal in the sales pipeline. This is a required field. Common stages include: \'Qualification\', \'Needs Analysis\', \'Value Proposition\', \'Proposal/Price Quote\', \'Negotiat'),
+        Amount: z.number().optional().describe('The monetary value of the deal in the account\'s currency. Use decimal format for fractional amounts.'),
+        Pipeline: z.string().optional().describe('The sales pipeline this deal belongs to. Required when multiple pipelines are enabled in your Zoho CRM org. Use the exact pipeline name as configured in Zoho CRM.'),
+        Deal_Name: z.string().describe('The name of the deal. This is a required field and must be a non-empty string.'),
+        Next_Step: z.string().optional().describe('The next action or step planned for moving this deal forward in the sales process.'),
+        Description: z.string().optional().describe('A detailed description or notes about the deal, including context, requirements, or special considerations.'),
+        Lead_Source: z.string().optional().describe('The source or channel from which this deal originated.'),
+        Probability: z.number().int().min(0).max(100).optional().describe('The probability of closing this deal, expressed as a percentage between 0 and 100.'),
+        Account_Name: z.record(z.any()).optional().describe('Account associated with the deal.'),
+        Closing_Date: z.string().optional().describe('The expected or actual closing date of the deal in YYYY-MM-DD format (ISO 8601 date format).'),
+        Contact_Name: z.record(z.any()).optional().describe('Contact associated with the deal.'),
+        Campaign_Source: z.record(z.any()).optional().describe('Campaign associated with the deal.'),
+    }),
+    execute: async (params) => {
+        const { zohoToken, ...rest } = params;
+        if (!zohoToken)
+            return { error: 'Zoho token is required. Connect Zoho CRM first.' };
+        try {
+            const body = { data: [rest] };
+            const res = await zohoFetch('/Deals', { zohoToken, method: 'POST', body });
+            if (!res.ok)
+                return { error: 'Failed to create deals', details: res.data };
+            return res.data;
+        }
+        catch (e) {
+            return { error: 'Error in ZohoCreateDeal', message: e instanceof Error ? e.message : 'Unknown error' };
+        }
+    },
+});
+//# sourceMappingURL=create-deal.js.map

package/dist/toolkits/zoho/tools/create-email-draft.d.ts

@@ -0,0 +1,7 @@
+export declare const ZohoCreateEmailDraft: import("ai").Tool<{
+    zohoToken: string;
+    record_id: string;
+    __email_drafts: Record<string, any>[];
+    module_api_name: string;
+}, any>;
+//# sourceMappingURL=create-email-draft.d.ts.map

package/dist/toolkits/zoho/tools/create-email-draft.js

@@ -0,0 +1,30 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { zohoFetch } from './utils.js';
+export const ZohoCreateEmailDraft = tool({
+    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 prepare email communications associated with CRM records (Leads, Contacts, Deals, etc.) that will be reviewed and sent later. ',
+    inputSchema: z.object({
+        zohoToken: z.string().describe('Zoho OAuth access token (Zoho-oauthtoken).'),
+        record_id: z.string().describe('Unique identifier of the record for which to create the email draft'),
+        __email_drafts: z.array(z.record(z.any())).describe('List of email drafts to create (maximum 100 drafts per API call). Each draft must include \'from\' and \'rich_text\' fields. Use this action when you need to create draft emails associated with a CRM '),
+        module_api_name: z.string().describe('The API name of the module containing the record for which to create the email draft. Standard modules include \'Leads\', \'Contacts\', \'Accounts\', \'Deals\', \'Quotes\', \'Sales_Orders\', \'Purchas'),
+    }),
+    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}/__email_drafts`;
+            const res = await zohoFetch(path, { zohoToken, method: 'POST', body: p });
+            if (!res.ok)
+                return { error: 'Failed', details: res.data };
+            return res.data;
+        }
+        catch (e) {
+            return { error: 'Error in ZohoCreateEmailDraft', message: e instanceof Error ? e.message : 'Unknown error' };
+        }
+    },
+});
+//# sourceMappingURL=create-email-draft.js.map

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

@@ -0,0 +1,18 @@
+export declare const ZohoCreateEvent: import("ai").Tool<{
+    zohoToken: string;
+    Event_Title: string;
+    End_DateTime: string;
+    Start_DateTime: string;
+    Owner?: Record<string, any> | undefined;
+    Description?: string | undefined;
+    Venue?: string | undefined;
+    Who_Id?: Record<string, any> | undefined;
+    All_day?: boolean | undefined;
+    What_Id?: Record<string, any> | undefined;
+    trigger?: string[] | undefined;
+    Remind_At?: Record<string, any>[] | undefined;
+    Participants?: Record<string, any>[] | undefined;
+    Check_In_Status?: string | undefined;
+    Recurring_Activity?: Record<string, any> | undefined;
+}, any>;
+//# sourceMappingURL=create-event.d.ts.map

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

@@ -0,0 +1,40 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { zohoFetch } from './utils.js';
+export const ZohoCreateEvent = tool({
+    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 meeting in the CRM system. All events require an event title, start time, and end time at minimum.',
+    inputSchema: z.object({
+        zohoToken: z.string().describe('Zoho OAuth access token (Zoho-oauthtoken).'),
+        Owner: z.record(z.any()).optional().describe('Reference to another record in the CRM.'),
+        Venue: z.string().optional().describe('Location or venue of the event'),
+        Who_Id: z.record(z.any()).optional().describe('Reference to another record in the CRM.'),
+        All_day: z.boolean().optional().describe('Indicates whether the event spans an entire day or multiple days'),
+        What_Id: z.record(z.any()).optional().describe('Reference to another record in the CRM.'),
+        trigger: z.array(z.string()).optional().describe('List of triggers to invoke (e.g., [\'workflow\', \'blueprint\']). Use cautiously as triggers can cause side effects like sending emails'),
+        Remind_At: z.array(z.record(z.any())).optional().describe('List of reminder configurations for the event. Each reminder specifies when to alert before the event starts'),
+        Description: z.string().optional().describe('Detailed description of the event'),
+        Event_Title: z.string().describe('Name of the event. Required field that accepts alphanumeric and special characters'),
+        End_DateTime: z.string().describe('Event end date and time in ISO8601 format (e.g., \'2024-07-03T14:30:00+05:30\')'),
+        Participants: z.array(z.record(z.any())).optional().describe('List of event participants (leads, contacts, users, or email addresses)'),
+        Start_DateTime: z.string().describe('Event start date and time in ISO8601 format (e.g., \'2024-07-03T12:30:00+05:30\')'),
+        Check_In_Status: z.string().optional().describe('Check-in status for the event'),
+        Recurring_Activity: z.record(z.any()).optional().describe('Recurrence rule for the event in RRULE format.'),
+    }),
+    execute: async (params) => {
+        const { zohoToken, ...rest } = params;
+        if (!zohoToken)
+            return { error: 'Zoho token is required. Connect Zoho CRM first.' };
+        try {
+            const body = { data: [rest] };
+            const res = await zohoFetch('/Events', { zohoToken, method: 'POST', body });
+            if (!res.ok)
+                return { error: 'Failed to create events', details: res.data };
+            return res.data;
+        }
+        catch (e) {
+            return { error: 'Error in ZohoCreateEvent', message: e instanceof Error ? e.message : 'Unknown error' };
+        }
+    },
+});
+//# sourceMappingURL=create-event.js.map

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

@@ -0,0 +1,31 @@
+export declare const ZohoCreateLead: import("ai").Tool<{
+    zohoToken: string;
+    Last_Name: string;
+    State?: string | undefined;
+    Description?: string | undefined;
+    Lead_Source?: string | undefined;
+    trigger?: string[] | undefined;
+    Fax?: string | undefined;
+    City?: string | undefined;
+    Email?: string | undefined;
+    Phone?: string | undefined;
+    Mobile?: string | undefined;
+    Rating?: string | undefined;
+    Street?: string | undefined;
+    lar_id?: string | undefined;
+    Company?: string | undefined;
+    Country?: string | undefined;
+    Twitter?: string | undefined;
+    Website?: string | undefined;
+    Industry?: string | undefined;
+    Skype_ID?: string | undefined;
+    Zip_Code?: string | undefined;
+    First_Name?: string | undefined;
+    Salutation?: string | undefined;
+    Designation?: string | undefined;
+    Lead_Status?: string | undefined;
+    Annual_Revenue?: number | undefined;
+    No_of_Employees?: number | undefined;
+    Secondary_Email?: string | undefined;
+}, any>;
+//# sourceMappingURL=create-lead.d.ts.map

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

@@ -0,0 +1,53 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { zohoFetch } from './utils.js';
+export const ZohoCreateLead = tool({
+    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 lead to Zoho CRM, typically after capturing lead information from a web form, email, or other lead generation source. Th',
+    inputSchema: z.object({
+        zohoToken: z.string().describe('Zoho OAuth access token (Zoho-oauthtoken).'),
+        Fax: z.string().optional().describe('Fax number of the lead'),
+        City: z.string().optional().describe('City of the lead\'s address'),
+        Email: z.string().optional().describe('Email address of the lead'),
+        Phone: z.string().optional().describe('Phone number of the lead (up to 30 characters)'),
+        State: z.string().optional().describe('State or province of the lead\'s address'),
+        Mobile: z.string().optional().describe('Mobile phone number of the lead'),
+        Rating: z.string().optional().describe('Rating of the lead (e.g., Acquired, Active, Market Failed, Project Cancelled, Shutdown)'),
+        Street: z.string().optional().describe('Street address of the lead'),
+        lar_id: z.string().optional().describe('Lead assignment rule ID to apply when creating the lead. This determines which user the lead will be assigned to based on predefined rules'),
+        Company: z.string().optional().describe('Company name associated with the lead'),
+        Country: z.string().optional().describe('Country of the lead\'s address'),
+        Twitter: z.string().optional().describe('Twitter handle of the lead'),
+        Website: z.string().optional().describe('Website URL of the lead\'s company'),
+        trigger: z.array(z.string()).optional().describe('List of workflow triggers to execute during lead creation (e.g., [\'workflow\', \'approval\', \'blueprint\']). Use this only when you explicitly need to trigger workflows, approvals, or blueprints, as'),
+        Industry: z.string().optional().describe('Industry sector of the lead\'s company'),
+        Skype_ID: z.string().optional().describe('Skype ID of the lead'),
+        Zip_Code: z.string().optional().describe('Postal or ZIP code of the lead\'s address'),
+        Last_Name: z.string().describe('Last name of the lead - this is a mandatory field in Zoho CRM'),
+        First_Name: z.string().optional().describe('First name of the lead'),
+        Salutation: z.string().optional().describe('Salutation or title for the lead (e.g., Mr., Ms., Dr., Prof.)'),
+        Description: z.string().optional().describe('Additional notes or description about the lead'),
+        Designation: z.string().optional().describe('Job title or designation of the lead'),
+        Lead_Source: z.string().optional().describe('Source from which the lead was acquired (e.g., Advertisement, Cold Call, Employee Referral, External Referral, Online Store, Partner, Public Relations, Sales Email Alias, Seminar Partner, Internal Sem'),
+        Lead_Status: z.string().optional().describe('Current status of the lead (e.g., Attempted to Contact, Contact in Future, Contacted, Junk Lead, Lost Lead, Not Contacted, Pre-Qualified, Not Qualified)'),
+        Annual_Revenue: z.number().optional().describe('Annual revenue of the lead\'s company'),
+        No_of_Employees: z.number().int().optional().describe('Number of employees in the lead\'s company'),
+        Secondary_Email: z.string().optional().describe('Secondary email address of the lead'),
+    }),
+    execute: async (params) => {
+        const { zohoToken, ...rest } = params;
+        if (!zohoToken)
+            return { error: 'Zoho token is required. Connect Zoho CRM first.' };
+        try {
+            const body = { data: [rest] };
+            const res = await zohoFetch('/Leads', { zohoToken, method: 'POST', body });
+            if (!res.ok)
+                return { error: 'Failed to create leads', details: res.data };
+            return res.data;
+        }
+        catch (e) {
+            return { error: 'Error in ZohoCreateLead', message: e instanceof Error ? e.message : 'Unknown error' };
+        }
+    },
+});
+//# sourceMappingURL=create-lead.js.map

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

@@ -0,0 +1,8 @@
+export declare const ZohoCreateNote: import("ai").Tool<{
+    zohoToken: string;
+    record_id: string;
+    module_api_name: string;
+    Note_Content: string;
+    Note_Title?: string | undefined;
+}, any>;
+//# sourceMappingURL=create-note.d.ts.map

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

@@ -0,0 +1,31 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { zohoFetch } from './utils.js';
+export const ZohoCreateNote = tool({
+    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 add notes, comments, or text-based documentation to a record in Zoho CRM. The note will be visible in the record\'s Not',
+    inputSchema: z.object({
+        zohoToken: z.string().describe('Zoho OAuth access token (Zoho-oauthtoken).'),
+        record_id: z.string().describe('The unique identifier of the parent record to attach the note to. This is the ID of the record in the specified module.'),
+        Note_Title: z.string().optional().describe('Optional title for the note'),
+        Note_Content: z.string().describe('The content/text of the note (required)'),
+        module_api_name: z.string().describe('The API name of the parent module containing the record. 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 = `/${p.module_api_name}/${p.record_id}/Notes`;
+            const res = await zohoFetch(path, { zohoToken, method: 'POST', body: p });
+            if (!res.ok)
+                return { error: 'Failed', details: res.data };
+            return res.data;
+        }
+        catch (e) {
+            return { error: 'Error in ZohoCreateNote', message: e instanceof Error ? e.message : 'Unknown error' };
+        }
+    },
+});
+//# sourceMappingURL=create-note.js.map

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

@@ -0,0 +1,8 @@
+export declare const ZohoCreateZohoRecord: import("ai").Tool<{
+    data: Record<string, any>[];
+    zohoToken: string;
+    module_api_name: string;
+    trigger?: string[] | undefined;
+    lar_id?: string | undefined;
+}, any>;
+//# sourceMappingURL=create-zoho-record.d.ts.map