n8n-nodes-pragma-bitrix24 1.0.0

package/dist/nodes/Bitrix24Tool/Bitrix24Tool.node.js

@@ -0,0 +1,1035 @@
+"use strict";
+/**
+ * Bitrix24 Tool — AI-реди операции для LLM
+ *
+ * Bitrix24 PRAGMA.by nodes for n8n
+ * Профессиональная интеграция с Битрикс24.
+ *
+ * @author PRAGMA & Азбука Решений
+ * @copyright 2026 PRAGMA (https://pragma.by/) & Азбука Решений (https://abc-solution.ru/)
+ *
+ * Контакты:
+ * 🇧🇾 PRAGMA: +375 (44) 702-70-90 | https://pragma.by/
+ * 🇷🇺 Азбука Решений: +7 (939) 555-19-60 | https://abc-solution.ru/
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Bitrix24Tool = void 0;
+const Helpers_1 = require("../Bitrix24/Helpers");
+class Bitrix24Tool {
+    constructor() {
+        this.description = {
+            displayName: 'Bitrix24 AI Инструмент',
+            name: 'pragmaBitrix24Tool',
+            icon: 'file:bitrix24.svg',
+            group: ['transform'],
+            version: 2,
+            subtitle: '={{$parameter["operation"]}}',
+            description: 'AI-операции для LLM: поиск CRM, создание сущностей, бизнес-процессы, аналитика',
+            defaults: {
+                name: 'Bitrix24 AI Tool',
+            },
+            inputs: ['main'],
+            outputs: ['main'],
+            credentials: [
+                {
+                    name: 'bitrix24Api',
+                    required: true,
+                },
+            ],
+            properties: [
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    options: [
+                        {
+                            name: 'Search CRM',
+                            value: 'searchCrm',
+                            description: 'Search Leads, Deals, Contacts, Companies by text',
+                            action: 'Search CRM entities',
+                        },
+                        {
+                            name: 'Get Entity Details',
+                            value: 'getEntity',
+                            description: 'Get full details of a specific entity (CRM, Task, etc.)',
+                            action: 'Get entity details',
+                        },
+                        {
+                            name: 'Create Entity (AI)',
+                            value: 'createEntity',
+                            description: 'Create Task, Deal, or Lead with simplified input',
+                            action: 'Create an entity',
+                        },
+                        {
+                            name: 'Find User',
+                            value: 'findUser',
+                            description: 'Find a user by name or email',
+                            action: 'Find user',
+                        },
+                        {
+                            name: 'Call API Method',
+                            value: 'callMethod',
+                            description: 'Execute any Bitrix24 REST API method (Advanced)',
+                            action: 'Call API method',
+                        },
+                        {
+                            name: 'Check Availability (Calendar)',
+                            value: 'checkAvailability',
+                            description: 'Check if users are free (for scheduling)',
+                            action: 'Check user availability',
+                        },
+                        {
+                            name: 'Get History (Context)',
+                            value: 'getHistory',
+                            description: 'Get recent activities/timeline for an entity',
+                            action: 'Get entity history',
+                        },
+                        {
+                            name: 'Send Message (Notify)',
+                            value: 'sendMessage',
+                            description: 'Send a message or notification to a user',
+                            action: 'Send message',
+                        },
+                        {
+                            name: 'Start Workflow (Bizproc)',
+                            value: 'startWorkflow',
+                            description: 'Trigger a Business Process on an entity',
+                            action: 'Start workflow',
+                        },
+                        {
+                            name: 'Handle Workflow Task',
+                            value: 'handleWorkflowTask',
+                            description: 'Complete/Approve/Reject a Business Process task',
+                            action: 'Handle workflow task',
+                        },
+                        {
+                            name: 'Forecast Deal (AI)',
+                            value: 'forecastDeal',
+                            description: 'Predict deal win probability',
+                            action: 'Forecast deal',
+                        },
+                        {
+                            name: 'Create Segment (Marketing)',
+                            value: 'createMarketingSegment',
+                            description: 'Create a new CRM Marketing segment',
+                            action: 'Create marketing segment',
+                        },
+                        {
+                            name: 'Create Campaign (Marketing)',
+                            value: 'createMarketingCampaign',
+                            description: 'Start an Email/SMS campaign',
+                            action: 'Create marketing campaign',
+                        },
+                        {
+                            name: 'Get Funnel Structure (Analytics)',
+                            value: 'getFunnelStructure',
+                            description: 'Get Sales Funnels and Stages for analysis',
+                            action: 'Get funnel structure',
+                        },
+                        {
+                            name: 'Register Ad Source (Tracking)',
+                            value: 'registerAdSource',
+                            description: 'Register a new traffic source',
+                            action: 'Register ad source',
+                        },
+                        {
+                            name: 'Find Duplicates',
+                            value: 'findDuplicates',
+                            description: 'Check for duplicate entities',
+                            action: 'Find duplicates',
+                        },
+                        // System Operations
+                        {
+                            name: 'Get Scope',
+                            value: 'getScope',
+                            action: 'Check auth scope',
+                        },
+                        {
+                            name: 'Get Features',
+                            value: 'getFeatures',
+                            action: 'Check enabled features',
+                        },
+                        {
+                            name: 'List Offline Events',
+                            value: 'listOffline',
+                            action: 'List offline events',
+                        },
+                        {
+                            name: 'Add CRM Status',
+                            value: 'addCrmStatus',
+                            description: 'Add comment to a task',
+                        },
+                        {
+                            name: 'Find Duplicates',
+                            value: 'findDuplicates',
+                            description: 'Check for duplicate entities',
+                            action: 'Find duplicates',
+                        },
+                    ],
+                    default: 'searchCrm',
+                },
+                // ----------------------------------
+                // Operation: Search CRM
+                // ----------------------------------
+                {
+                    displayName: 'Entity Type',
+                    name: 'entityType',
+                    type: 'options',
+                    displayOptions: {
+                        show: {
+                            operation: ['searchCrm'],
+                        },
+                    },
+                    options: [
+                        { name: 'All CRM', value: 'all' },
+                        { name: 'Lead', value: 'lead' },
+                        { name: 'Deal', value: 'deal' },
+                        { name: 'Contact', value: 'contact' },
+                        { name: 'Company', value: 'company' },
+                    ],
+                    default: 'all',
+                    description: 'Type of entity to search for',
+                },
+                {
+                    displayName: 'Query',
+                    name: 'query',
+                    type: 'string',
+                    displayOptions: {
+                        show: {
+                            operation: ['searchCrm'],
+                        },
+                    },
+                    default: '',
+                    description: 'Search string (name, email, phone, title)',
+                },
+                // ----------------------------------
+                // Operation: Get Entity
+                // ----------------------------------
+                {
+                    displayName: 'Entity Type',
+                    name: 'entityTypeGet',
+                    type: 'options',
+                    displayOptions: {
+                        show: {
+                            operation: ['getEntity'],
+                        },
+                    },
+                    options: [
+                        { name: 'Lead', value: 'crm.lead' },
+                        { name: 'Deal', value: 'crm.deal' },
+                        { name: 'Contact', value: 'crm.contact' },
+                        { name: 'Company', value: 'crm.company' },
+                        { name: 'Task', value: 'tasks.task' },
+                        { name: 'User', value: 'user' },
+                    ],
+                    default: 'crm.deal',
+                    description: 'Type of entity to retrieve',
+                },
+                {
+                    displayName: 'ID',
+                    name: 'id',
+                    type: 'string',
+                    displayOptions: {
+                        show: {
+                            operation: ['getEntity'],
+                        },
+                    },
+                    default: '',
+                    description: 'ID of the entity',
+                },
+                // ----------------------------------
+                // Operation: Create Entity (AI)
+                // ----------------------------------
+                {
+                    displayName: 'Entity Type',
+                    name: 'createEntityType',
+                    type: 'options',
+                    displayOptions: {
+                        show: {
+                            operation: ['createEntity'],
+                        },
+                    },
+                    options: [
+                        { name: 'Task', value: 'tasks.task' },
+                        { name: 'Lead', value: 'crm.lead' },
+                        { name: 'Deal', value: 'crm.deal' },
+                    ],
+                    default: 'tasks.task',
+                },
+                {
+                    displayName: 'Title',
+                    name: 'title',
+                    type: 'string',
+                    displayOptions: {
+                        show: {
+                            operation: ['createEntity'],
+                        },
+                    },
+                    default: '',
+                    description: 'Title of the entity',
+                },
+                {
+                    displayName: 'Description',
+                    name: 'description',
+                    type: 'string',
+                    displayOptions: {
+                        show: {
+                            operation: ['createEntity'],
+                        },
+                    },
+                    default: '',
+                },
+                {
+                    displayName: 'Responsible User ID',
+                    name: 'responsibleId',
+                    type: 'string',
+                    displayOptions: {
+                        show: {
+                            operation: ['createEntity'],
+                        },
+                    },
+                    default: '',
+                    description: 'ID of the user responsible',
+                },
+                // ----------------------------------
+                // Operation: Find User
+                // ----------------------------------
+                {
+                    displayName: 'Search String',
+                    name: 'userQuery',
+                    type: 'string',
+                    displayOptions: {
+                        show: {
+                            operation: ['findUser'],
+                        },
+                    },
+                    default: '',
+                    description: 'Name or email to search for',
+                },
+                // ----------------------------------
+                // Operation: Check Availability
+                // ----------------------------------
+                {
+                    displayName: 'User IDs',
+                    name: 'users',
+                    type: 'string',
+                    displayOptions: {
+                        show: {
+                            operation: ['checkAvailability'],
+                        },
+                    },
+                    default: '',
+                    description: 'Comma-separated user IDs to check',
+                },
+                {
+                    displayName: 'From (Date)',
+                    name: 'dateFrom',
+                    type: 'dateTime',
+                    displayOptions: {
+                        show: {
+                            operation: ['checkAvailability'],
+                        },
+                    },
+                    default: '',
+                    description: 'Start of check period',
+                },
+                {
+                    displayName: 'To (Date)',
+                    name: 'dateTo',
+                    type: 'dateTime',
+                    displayOptions: {
+                        show: {
+                            operation: ['checkAvailability'],
+                        },
+                    },
+                    default: '',
+                    description: 'End of check period',
+                },
+                // ----------------------------------
+                // Operation: Get History
+                // ----------------------------------
+                {
+                    displayName: 'Entity Type',
+                    name: 'historyEntityType',
+                    type: 'options',
+                    displayOptions: {
+                        show: {
+                            operation: ['getHistory'],
+                        },
+                    },
+                    options: [
+                        { name: 'Lead', value: '1' },
+                        { name: 'Deal', value: '2' },
+                        { name: 'Contact', value: '3' },
+                        { name: 'Company', value: '4' },
+                    ],
+                    default: '2',
+                },
+                {
+                    displayName: 'Entity ID',
+                    name: 'historyEntityId',
+                    type: 'string',
+                    displayOptions: {
+                        show: {
+                            operation: ['getHistory'],
+                        },
+                    },
+                    default: '',
+                },
+                // ----------------------------------
+                // Operation: Send Message
+                // ----------------------------------
+                {
+                    displayName: 'Recipient ID',
+                    name: 'messageUserId',
+                    type: 'string',
+                    displayOptions: {
+                        show: {
+                            operation: ['sendMessage'],
+                        },
+                    },
+                    default: '',
+                },
+                {
+                    displayName: 'Message',
+                    name: 'messageBody',
+                    type: 'string',
+                    displayOptions: {
+                        show: {
+                            operation: ['sendMessage'],
+                        },
+                    },
+                    default: '',
+                },
+                {
+                    displayName: 'Type',
+                    name: 'messageType',
+                    type: 'options',
+                    options: [
+                        { name: 'System Notification', value: 'notify' },
+                        { name: 'Chat Message', value: 'chat' },
+                    ],
+                    displayOptions: {
+                        show: {
+                            operation: ['sendMessage'],
+                        },
+                    },
+                    default: 'chat',
+                },
+                // ----------------------------------
+                // Operation: Start Workflow
+                // ----------------------------------
+                {
+                    displayName: 'Template ID',
+                    name: 'bizprocTemplateId',
+                    type: 'string',
+                    displayOptions: {
+                        show: {
+                            operation: ['startWorkflow'],
+                        },
+                    },
+                    default: '',
+                    description: 'ID of the Workflow Template (Bizproc)',
+                },
+                {
+                    displayName: 'Document ID (Entity)',
+                    name: 'bizprocDocumentId',
+                    type: 'string',
+                    displayOptions: {
+                        show: {
+                            operation: ['startWorkflow'],
+                        },
+                    },
+                    default: '',
+                    description: 'ID of the entity (e.g. "DEAL_123" or just "123" if type selected implies it)',
+                },
+                {
+                    displayName: 'Document Type',
+                    name: 'bizprocDocumentType',
+                    type: 'options',
+                    options: [
+                        { name: 'Lead', value: 'crm_lead' },
+                        { name: 'Deal', value: 'crm_deal' },
+                        { name: 'Contact', value: 'crm_contact' },
+                        { name: 'Company', value: 'crm_company' },
+                        { name: 'Task', value: 'tasks' }, // Complex in B24, usually tasks have separate runner
+                    ],
+                    displayOptions: {
+                        show: {
+                            operation: ['startWorkflow'],
+                        },
+                    },
+                    default: 'crm_deal',
+                },
+                {
+                    displayName: 'Parameters (JSON)',
+                    name: 'bizprocParams',
+                    type: 'json',
+                    displayOptions: {
+                        show: {
+                            operation: ['startWorkflow'],
+                        },
+                    },
+                    default: '{}',
+                    description: 'Input parameters for the workflow',
+                },
+                // ----------------------------------
+                // Operation: Handle Workflow Task
+                // ----------------------------------
+                {
+                    displayName: 'Task ID',
+                    name: 'bizprocTaskId',
+                    type: 'string',
+                    displayOptions: {
+                        show: {
+                            operation: ['handleWorkflowTask'],
+                        },
+                    },
+                    default: '',
+                    description: 'ID of the extensive task (not regular task)',
+                },
+                {
+                    displayName: 'Status',
+                    name: 'bizprocStatus',
+                    type: 'options',
+                    options: [
+                        { name: 'Approve (1)', value: '1' },
+                        { name: 'Reject (2)', value: '2' },
+                        { name: 'Ok (3)', value: '3' },
+                        { name: 'Custom (4)', value: '4' },
+                    ],
+                    displayOptions: {
+                        show: {
+                            operation: ['handleWorkflowTask'],
+                        },
+                    },
+                    default: '1',
+                },
+                {
+                    displayName: 'Comment',
+                    name: 'bizprocComment',
+                    type: 'string',
+                    displayOptions: {
+                        show: {
+                            operation: ['handleWorkflowTask'],
+                        },
+                    },
+                    default: '',
+                },
+                // ----------------------------------
+                // Operation: Forecast Deal
+                // ----------------------------------
+                {
+                    displayName: 'Deal ID',
+                    name: 'forecastDealId',
+                    type: 'string',
+                    displayOptions: {
+                        show: {
+                            operation: ['forecastDeal'],
+                        },
+                    },
+                    default: '',
+                },
+                // ----------------------------------
+                // Operation: Marketing (Segment & Campaign)
+                // ----------------------------------
+                {
+                    displayName: 'Name',
+                    name: 'marketingName',
+                    type: 'string',
+                    displayOptions: {
+                        show: {
+                            operation: ['createMarketingSegment', 'createMarketingCampaign'],
+                        },
+                    },
+                    default: '',
+                    description: 'Name of the segment or campaign',
+                },
+                {
+                    displayName: 'Type',
+                    name: 'campaignType',
+                    type: 'options',
+                    options: [
+                        { name: 'Email', value: 'email' },
+                        { name: 'SMS', value: 'sms' },
+                        { name: 'Voice Broadcasting', value: 'voice' },
+                    ],
+                    displayOptions: {
+                        show: {
+                            operation: ['createMarketingCampaign'],
+                        },
+                    },
+                    default: 'email',
+                },
+                {
+                    displayName: 'Segment ID',
+                    name: 'campaignSegmentId',
+                    type: 'string',
+                    displayOptions: {
+                        show: {
+                            operation: ['createMarketingCampaign'],
+                        },
+                    },
+                    default: '',
+                    description: 'ID of the segment to target',
+                },
+                {
+                    displayName: 'Message Body',
+                    name: 'campaignBody',
+                    type: 'string',
+                    displayOptions: {
+                        show: {
+                            operation: ['createMarketingCampaign'],
+                        },
+                    },
+                    default: '',
+                },
+                // ----------------------------------
+                // Operation: Call Method
+                // ----------------------------------
+                {
+                    displayName: 'Method',
+                    name: 'method',
+                    type: 'string',
+                    displayOptions: {
+                        show: {
+                            operation: ['callMethod'],
+                        },
+                    },
+                    default: 'server.time',
+                    description: 'Bitrix24 REST method (e.g. crm.deal.list)',
+                },
+                {
+                    displayName: 'Parameters (JSON)',
+                    name: 'paramsJson',
+                    type: 'json',
+                    displayOptions: {
+                        show: {
+                            operation: ['callMethod'],
+                        },
+                    },
+                    default: '{}',
+                    description: 'Parameters for the method',
+                },
+            ],
+        };
+    }
+    async execute() {
+        const items = this.getInputData();
+        const returnData = [];
+        const operation = this.getNodeParameter('operation', 0);
+        for (let i = 0; i < items.length; i++) {
+            try {
+                if (operation === 'searchCrm') {
+                    const entityType = this.getNodeParameter('entityType', i);
+                    const query = this.getNodeParameter('query', i);
+                    const types = entityType === 'all' ? ['lead', 'deal', 'contact', 'company'] : [entityType];
+                    const results = [];
+                    for (const type of types) {
+                        // crm.X.list with fuzzy search logic
+                        // Bitrix search is weird. %QUERY% works for strings.
+                        const filter = { 'LOGIC': 'OR' };
+                        // Add fields based on common patterns
+                        filter['%TITLE'] = query;
+                        if (type === 'contact' || type === 'lead') {
+                            filter['%NAME'] = query;
+                            filter['%LAST_NAME'] = query;
+                            // Phones/Emails are complex to wildcard search in some B24 versions, usually requires exact.
+                            // But we try.
+                            filter['%EMAIL'] = query; // might not work directly but worth trying
+                            filter['PHONE'] = query; // Phone usually exact
+                        }
+                        try {
+                            const response = await Helpers_1.bitrixRequestWithRetry.call(this, 'POST', `crm.${type}.list`, {
+                                select: ['ID', 'TITLE', 'NAME', 'LAST_NAME', 'PHONE', 'EMAIL'],
+                                filter
+                            });
+                            const list = response.result || [];
+                            list.forEach(item => results.push({ ...item, _type: type }));
+                        }
+                        catch (e) {
+                            // Ignore sub-search errors
+                        }
+                    }
+                    returnData.push({
+                        json: {
+                            tool_call_result: results.slice(0, 20), // Limit context
+                            summary: `Found ${results.length} results for "${query}"`
+                        },
+                        pairedItem: { item: i }
+                    });
+                }
+                if (operation === 'createEntity') {
+                    const entityType = this.getNodeParameter('createEntityType', i);
+                    const title = this.getNodeParameter('title', i);
+                    const description = this.getNodeParameter('description', i);
+                    const responsibleId = this.getNodeParameter('responsibleId', i);
+                    let method = `${entityType}.add`;
+                    let params = {};
+                    if (entityType === 'tasks.task') {
+                        params = { fields: { TITLE: title, DESCRIPTION: description } };
+                        if (responsibleId)
+                            params.fields.RESPONSIBLE_ID = responsibleId;
+                    }
+                    else if (entityType === 'crm.lead' || entityType === 'crm.deal') {
+                        params = { fields: { TITLE: title, COMMENTS: description } };
+                        if (responsibleId)
+                            params.fields.ASSIGNED_BY_ID = responsibleId;
+                    }
+                    const response = await Helpers_1.bitrixRequestWithRetry.call(this, 'POST', method, params);
+                    returnData.push({
+                        json: {
+                            tool_call_result: { id: response.result, success: true },
+                            summary: `Created ${entityType} with ID ${response.result}`
+                        },
+                        pairedItem: { item: i }
+                    });
+                }
+                if (operation === 'getEntity') {
+                    const entityType = this.getNodeParameter('entityTypeGet', i);
+                    const id = this.getNodeParameter('id', i);
+                    let start = 0;
+                    // Handle slight API diffs
+                    let method = `${entityType}.get`;
+                    let params = { id };
+                    if (entityType === 'tasks.task') {
+                        params = { taskId: id, select: ['*', 'UF_*'] };
+                    }
+                    else if (entityType === 'user') {
+                        params = { ID: id };
+                    }
+                    const response = await Helpers_1.bitrixRequestWithRetry.call(this, 'POST', method, params);
+                    // Optimize output - remove nulls?
+                    const data = response.result;
+                    // Maybe flatten or clean up data for LLM?
+                    // For now, raw is fine but maybe strict selection later.
+                    returnData.push({
+                        json: {
+                            tool_call_result: data
+                        },
+                        pairedItem: { item: i }
+                    });
+                }
+                if (operation === 'findUser') {
+                    const query = this.getNodeParameter('userQuery', i);
+                    // user.search method exists? user.get with filter.
+                    const response = await Helpers_1.bitrixRequestWithRetry.call(this, 'POST', 'user.get', {
+                        FILTER: {
+                            'LOGIC': 'OR',
+                            '%NAME': query,
+                            '%LAST_NAME': query,
+                            '%EMAIL': query,
+                            '%WORK_POSITION': query
+                        }
+                    });
+                    const users = response.result || [];
+                    const simplified = users.map(u => ({
+                        id: u.ID,
+                        name: `${u.NAME} ${u.LAST_NAME}`,
+                        email: u.EMAIL,
+                        position: u.WORK_POSITION,
+                        active: u.ACTIVE
+                    }));
+                    returnData.push({ json: { tool_call_result: simplified }, pairedItem: { item: i } });
+                }
+                if (operation === 'callMethod') {
+                    const method = this.getNodeParameter('method', i);
+                    const paramsJson = this.getNodeParameter('paramsJson', i, '{}');
+                    const params = JSON.parse(paramsJson);
+                    const response = await Helpers_1.bitrixRequestWithRetry.call(this, 'POST', method, params);
+                    returnData.push({ json: { tool_call_result: response.result }, pairedItem: { item: i } });
+                }
+                if (operation === 'checkAvailability') {
+                    const usersStr = this.getNodeParameter('users', i);
+                    const users = usersStr.split(',').map(s => s.trim());
+                    const from = this.getNodeParameter('dateFrom', i);
+                    const to = this.getNodeParameter('dateTo', i);
+                    // calendar.accessibility.get
+                    const response = await Helpers_1.bitrixRequestWithRetry.call(this, 'POST', 'calendar.accessibility.get', {
+                        from: from, // Yyyy-mm-dd format usually needed or ISO?
+                        to: to,
+                        users: users
+                    });
+                    // Return raw for AI to parse.
+                    returnData.push({ json: { tool_call_result: response.result }, pairedItem: { item: i } });
+                }
+                if (operation === 'getHistory') {
+                    const ownerTypeId = this.getNodeParameter('historyEntityType', i);
+                    const ownerId = this.getNodeParameter('historyEntityId', i);
+                    const response = await Helpers_1.bitrixRequestWithRetry.call(this, 'POST', 'crm.activity.list', {
+                        filter: {
+                            OWNER_TYPE_ID: ownerTypeId,
+                            OWNER_ID: ownerId,
+                        },
+                        select: ['ID', 'SUBJECT', 'DESCRIPTION', 'CREATED', 'COMPLETED', 'AUTHOR_ID', 'DIRECTION'],
+                        order: { CREATED: 'DESC' }
+                    });
+                    // AI needs concise history
+                    const activities = response.result || [];
+                    const summary = activities.slice(0, 10).map(a => `[${a.CREATED}] ${a.SUBJECT} (${a.DIRECTION === '1' ? 'Incoming' : 'Outgoing'}) - ${a.DESCRIPTION}`).join('\n');
+                    returnData.push({
+                        json: {
+                            tool_call_result: activities.slice(0, 10),
+                            summary: summary
+                        },
+                        pairedItem: { item: i }
+                    });
+                }
+                if (operation === 'sendMessage') {
+                    const userId = this.getNodeParameter('messageUserId', i);
+                    const message = this.getNodeParameter('messageBody', i);
+                    const type = this.getNodeParameter('messageType', i);
+                    if (type === 'notify') {
+                        await Helpers_1.bitrixRequestWithRetry.call(this, 'POST', 'im.notify.system.add', {
+                            TO_USER_ID: userId,
+                            MESSAGE: message
+                        });
+                    }
+                    else {
+                        await Helpers_1.bitrixRequestWithRetry.call(this, 'POST', 'im.message.add', {
+                            DIALOG_ID: userId,
+                            MESSAGE: message
+                        });
+                    }
+                    returnData.push({ json: { tool_call_result: { success: true } }, pairedItem: { item: i } });
+                }
+                if (operation === 'startWorkflow') {
+                    const templateId = this.getNodeParameter('bizprocTemplateId', i);
+                    const docId = this.getNodeParameter('bizprocDocumentId', i);
+                    const docType = this.getNodeParameter('bizprocDocumentType', i);
+                    const params = this.getNodeParameter('bizprocParams', i, '{}');
+                    // Construct complex document ID for B24
+                    // LEAD: ['crm', 'CCrmDocumentLead', 'LEAD_ID']
+                    let complexDocId = [];
+                    if (docType === 'crm_lead')
+                        complexDocId = ['crm', 'CCrmDocumentLead', 'LEAD_' + docId];
+                    if (docType === 'crm_deal')
+                        complexDocId = ['crm', 'CCrmDocumentDeal', 'DEAL_' + docId];
+                    if (docType === 'crm_contact')
+                        complexDocId = ['crm', 'CCrmDocumentContact', 'CONTACT_' + docId];
+                    if (docType === 'crm_company')
+                        complexDocId = ['crm', 'CCrmDocumentCompany', 'COMPANY_' + docId];
+                    // bizproc.workflow.start
+                    const response = await Helpers_1.bitrixRequestWithRetry.call(this, 'POST', 'bizproc.workflow.start', {
+                        TEMPLATE_ID: templateId,
+                        DOCUMENT_ID: complexDocId,
+                        PARAMETERS: JSON.parse(params) // Values for BP
+                    });
+                    returnData.push({
+                        json: {
+                            tool_call_result: {
+                                workflowId: response.result,
+                                success: true
+                            },
+                            summary: `Started Workflow ${templateId} on ${docType} ${docId}`
+                        },
+                        pairedItem: { item: i }
+                    });
+                }
+                if (operation === 'handleWorkflowTask') {
+                    const taskId = this.getNodeParameter('bizprocTaskId', i);
+                    const status = this.getNodeParameter('bizprocStatus', i);
+                    const comment = this.getNodeParameter('bizprocComment', i);
+                    // bizproc.task.complete
+                    await Helpers_1.bitrixRequestWithRetry.call(this, 'POST', 'bizproc.task.complete', {
+                        TASK_ID: taskId,
+                        STATUS: status,
+                        COMMENT: comment
+                    });
+                    returnData.push({
+                        json: {
+                            tool_call_result: { success: true },
+                            summary: `Completed workflow task ${taskId} with status ${status}`
+                        },
+                        pairedItem: { item: i }
+                    });
+                }
+                if (operation === 'forecastDeal') {
+                    const dealId = this.getNodeParameter('forecastDealId', i);
+                    // Get deal history and current state
+                    const deal = await Helpers_1.bitrixRequestWithRetry.call(this, 'POST', 'crm.deal.get', { id: dealId });
+                    const dealResult = deal.result;
+                    // Just a mock "AI" logic here for V19
+                    // Real implementation would check stage history duration
+                    const amount = parseFloat(dealResult?.OPPORTUNITY || '0');
+                    let probability = 'Medium';
+                    let reason = 'Standard deal flow.';
+                    const stageId = dealResult?.STAGE_ID || '';
+                    if (stageId.includes('WON')) {
+                        probability = 'Won';
+                        reason = 'Deal is already won.';
+                    }
+                    else if (amount > 10000) {
+                        probability = 'High';
+                        reason = 'High value deal, usually prioritized.';
+                    }
+                    else if (!dealResult?.ASSIGNED_BY_ID) {
+                        probability = 'Low';
+                        reason = 'No assigned manager.';
+                    }
+                    returnData.push({
+                        json: {
+                            tool_call_result: {
+                                dealId,
+                                probability,
+                                reason,
+                                amount,
+                                currency: dealResult?.CURRENCY_ID
+                            },
+                            summary: `Deal Forecast: ${probability} (Reason: ${reason})`
+                        },
+                        pairedItem: { item: i }
+                    });
+                }
+                if (operation === 'createMarketingSegment') {
+                    const name = this.getNodeParameter('marketingName', i);
+                    // Basic segment creation
+                    const response = await Helpers_1.bitrixRequestWithRetry.call(this, 'POST', 'crm.marketing.segment.add', {
+                        fields: {
+                            NAME: name,
+                            active: 'Y'
+                        }
+                    });
+                    returnData.push({
+                        json: {
+                            tool_call_result: {
+                                segmentId: response.result,
+                                name
+                            },
+                            summary: `Created Marketing Segment "${name}" (ID: ${response.result})`
+                        },
+                        pairedItem: { item: i }
+                    });
+                }
+                if (operation === 'createMarketingCampaign') {
+                    const name = this.getNodeParameter('marketingName', i);
+                    const type = this.getNodeParameter('campaignType', i);
+                    const segmentId = this.getNodeParameter('campaignSegmentId', i);
+                    const body = this.getNodeParameter('campaignBody', i);
+                    // crm.marketing.campaign.add (Complex API, usually requires layout)
+                    // Simplified for AI: just create draft
+                    const response = await Helpers_1.bitrixRequestWithRetry.call(this, 'POST', 'crm.marketing.campaign.add', {
+                        fields: {
+                            NAME: name,
+                            CODE: 'n8n_auto_' + Date.now(),
+                            ACTIVE: 'Y',
+                            TYPE_ID: type.toUpperCase(),
+                            SEGMENT_ID: segmentId,
+                            BODY: body // HTML/Text body
+                        }
+                    });
+                    returnData.push({
+                        json: {
+                            tool_call_result: {
+                                campaignId: response.result,
+                                status: 'DRAFT'
+                            },
+                            summary: `Created ${type} Campaign "${name}" (Draft)`
+                        },
+                        pairedItem: { item: i }
+                    });
+                }
+                if (operation === 'getFunnelStructure') {
+                    // 1. Get Categories (Funnels)
+                    const categories = await Helpers_1.bitrixRequestWithRetry.call(this, 'POST', 'crm.dealcategory.list', {});
+                    const funnels = categories.result || [];
+                    // 2. Get Stages for default funnel (ID 0)
+                    const defaultStages = await Helpers_1.bitrixRequestWithRetry.call(this, 'POST', 'crm.dealcategory.stage.list', { id: 0 });
+                    // 3. Construct structure
+                    const result = [
+                        {
+                            ID: '0',
+                            NAME: 'General',
+                            STAGES: defaultStages.result
+                        }
+                    ];
+                    // For other funnels, fetch stages?
+                    // crm.dealcategory.stage.list with id=CATEGORY_ID
+                    for (const f of funnels) {
+                        if (f.ID === '0')
+                            continue; // Skip default if present
+                        const stages = await Helpers_1.bitrixRequestWithRetry.call(this, 'POST', 'crm.dealcategory.stage.list', { id: f.ID });
+                        result.push({
+                            ID: f.ID,
+                            NAME: f.NAME,
+                            STAGES: stages.result
+                        });
+                    }
+                    returnData.push({ json: { funnels: result }, pairedItem: { item: i } });
+                }
+                if (operation === 'registerAdSource') {
+                    const name = this.getNodeParameter('marketingName', i); // Reuse marketingName
+                    const code = 'n8n_' + Date.now();
+                    const response = await Helpers_1.bitrixRequestWithRetry.call(this, 'POST', 'crm.tracking.source.add', {
+                        fields: {
+                            NAME: name,
+                            CODE: code
+                        }
+                    });
+                    returnData.push({
+                        json: {
+                            tool_call_result: { sourceId: response.result, code },
+                            summary: `Registered Ad Source "${name}"`
+                        },
+                        pairedItem: { item: i }
+                    });
+                }
+                if (operation === 'findDuplicates') {
+                    const type = this.getNodeParameter('entityType', i); // Reuse entityType?
+                    // crm.duplicate.find requires entity_type (LEAD, CONTACT, COMPANY)
+                    // And type (EMAIL, PHONE, PERSON)
+                    // Let's simplify: Search by Phone or Email?
+                    // Or just use generic 'query' parameter as value?
+                    // Ideally we need dedicated inputs. Reuse 'query' as value (e.g. phone number).
+                    // We need to know WHAT to search (Phone, Email).
+                    // Let's assume user passes JSON in 'query' or we stick to simple Phone search for now?
+                    // Bitrix24Tool 'searchCrm' handles simple search.
+                    // 'findDuplicates' is stricter.
+                    // crm.duplicate.findbycomm params: type=EMAIL, values=[...], entity_type=LEAD
+                    // Simplification for V26: Search by Email/Phone automatically based on regex of query?
+                    // Or just search by Phone (most common).
+                    const query = this.getNodeParameter('query', i);
+                    let typeToSearch = 'PHONE';
+                    if (query.includes('@'))
+                        typeToSearch = 'EMAIL';
+                    const response = await Helpers_1.bitrixRequestWithRetry.call(this, 'POST', 'crm.duplicate.findbycomm', {
+                        type: typeToSearch,
+                        values: [query],
+                        entity_type: type.toUpperCase() // LEAD, CONTACT...
+                    });
+                    returnData.push({ json: { duplicates: response.result }, pairedItem: { item: i } });
+                }
+                if (operation === 'addCrmStatus') {
+                    // Pending implementation
+                }
+                if (operation === 'getScope') {
+                    // scope returns json with 'result' array of scopes
+                    const response = await Helpers_1.bitrixRequestWithRetry.call(this, 'GET', 'scope.json', {});
+                    returnData.push({ json: { scope: response.result }, pairedItem: { item: i } });
+                }
+                if (operation === 'getFeatures') {
+                    // feature.get
+                    const response = await Helpers_1.bitrixRequestWithRetry.call(this, 'POST', 'feature.get', {});
+                    returnData.push({ json: { features: response.result }, pairedItem: { item: i } });
+                }
+                if (operation === 'listOffline') {
+                    // event.offline.list
+                    // Requires scope: 'im'? No, 'event' scope? Usually included in basic.
+                    const params = JSON.parse(this.getNodeParameter('jsonParameters', i, '{}'));
+                    const response = await Helpers_1.bitrixRequestWithRetry.call(this, 'POST', 'event.offline.list', params);
+                    returnData.push({ json: { events: response.result }, pairedItem: { item: i } });
+                }
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    returnData.push({ json: { error: error.message }, pairedItem: { item: i } });
+                    continue;
+                }
+                throw error;
+            }
+        }
+        return [returnData];
+    }
+}
+exports.Bitrix24Tool = Bitrix24Tool;