n8n-nodes-linq 4.0.2 → 4.1.0

package/README.md

@@ -1,6 +1,6 @@
 # n8n-nodes-linq
 
-Community node for the Linq Partner API v3 in n8n. Use this node to manage chats, messages, attachments, phone numbers, webhooks, and contacts from your workflows.
+Community node for the Linq Partner API v3 in n8n. The current implementation covers chats, messages, attachments, phone numbers, webhook subscriptions, and Linq webhooks from your workflows.
 
 **Ownership:** The Linq Partner API is owned and operated by Linq (https://linqapp.com/). This repository is community-maintained by Everyday Workflows.
 
@@ -12,14 +12,15 @@ Community node for the Linq Partner API v3 in n8n. Use this node to manage chats
 
 - Usage guide: [docs/usage.md](docs/usage.md)
 - API reference (v3): [docs/api-reference.md](docs/api-reference.md)
-- OpenAPI spec: [V3.yaml](V3.yaml)
+- Official Linq docs: https://apidocs.linqapp.com/documentation/api-reference
+- Cached OpenAPI snapshot: [V3.yaml](V3.yaml)
 - Contributing: [CONTRIBUTING.md](CONTRIBUTING.md)
 - License: [LICENSE.md](LICENSE.md)
 
 ## Requirements
 
 - Node.js >= 20.15
-- n8n compatible with `n8n-workflow` ^1.120.7
+- n8n compatible with `n8n-workflow` ^1.120.10
 
 ## Installation (in n8n)
 
@@ -54,66 +55,72 @@ Add the **Linq** node to your workflow. Operations map to Linq Partner API v3 en
 
 **Chat**
 
-- Get Many → `GET /v3/chats` (requires `from`, supports cursor/limit)
+- Get Many → `GET /v3/chats` (supports optional `from`, `to`, cursor, and limit)
 - Get One → `GET /v3/chats/{chatId}`
-- Find → `GET /v3/chats` (with `from` + `phone_numbers[]`)
+- Find (legacy helper) → `GET /v3/chats` using `to` plus the older `phone_numbers[]` fallback when multiple handles are supplied
 - Create → `POST /v3/chats`
+- Leave → `POST /v3/chats/{chatId}/leave`
 - Share Contact → `POST /v3/chats/{chatId}/share_contact_card`
+- Start Typing → `POST /v3/chats/{chatId}/typing`
+- Stop Typing → `DELETE /v3/chats/{chatId}/typing`
+- Mark as Read → `POST /v3/chats/{chatId}/read`
+- Send Voice Memo → `POST /v3/chats/{chatId}/voicememo`
+
+Create and send operations support:
+
+- text parts
+- direct media URLs
+- pre-uploaded `attachment_id` values
+- rich link URLs
+- threaded replies (`reply_to`)
+- iMessage effects
+- preferred service selection
+- idempotency keys
 
 **Chat Message**
 
 - Get Many → `GET /v3/chats/{chatId}/messages`
 - Get One → `GET /v3/messages/{messageId}`
 - Create → `POST /v3/chats/{chatId}/messages`
+- Edit → `PATCH /v3/messages/{messageId}`
 - Delete → `DELETE /v3/messages/{messageId}`
 - React → `POST /v3/messages/{messageId}/reactions`
+- Get Thread → `GET /v3/messages/{messageId}/thread`
 
 **Phone Number**
 
-- Get Many → `GET /v3/phonenumbers`
-- Update → `PUT /v3/phonenumbers/{phoneNumberId}`
+- Get Many → `GET /v3/phone_numbers`
 
 **Webhook Subscription**
 
+- Get Events → `GET /v3/webhook-events`
 - Get Many → `GET /v3/webhook-subscriptions`
 - Get One → `GET /v3/webhook-subscriptions/{subscriptionId}`
 - Create → `POST /v3/webhook-subscriptions`
 - Update → `PUT /v3/webhook-subscriptions/{subscriptionId}`
 - Delete → `DELETE /v3/webhook-subscriptions/{subscriptionId}`
 
-**Contact (extension)**
-
-- Create → `POST /v3/contacts`
-- Get One → `GET /v3/contacts/{contactId}`
-- Update → `PUT /v3/contacts/{contactId}`
-- Delete → `DELETE /v3/contacts/{contactId}`
-
-**Chat Message (extension)**
-
-- Edit → `POST /v3/messages/{messageId}/edit`
-- Get Reaction → `GET /v3/chat_message_reactions/{reactionId}`
-
-> **Note:** The “extension” endpoints above are currently implemented in the node but are not present in `V3.yaml`. They will be aligned once the spec is updated.
-
 ## Linq Trigger Node
 
 Add the **Linq Trigger** node to start workflows when Linq events occur. The trigger automatically registers a webhook with Linq when the workflow is activated.
 
 **Supported Events**
 
-- `message.sent`
-- `message.received`
-- `message.read`
-- `call.completed`
-- `contact.created`
-- `contact.updated`
-- `contact.deleted`
+The trigger supports the current documented webhook event families, including:
+
+- `message.*`
+- `participant.*`
+- `reaction.*`
+- `chat.*`
+- `phone_number.status_updated`
+- `call.*`
 
 **Security**
 
 - The trigger verifies Linq webhooks using HMAC-SHA256
 - Uses `X-Webhook-Timestamp` + raw request body for the signature payload: `{timestamp}.{payload}`
 - Requires the **Webhook Signing Secret** from credentials
+- Accepts both the current documented webhook envelope (`event_type` + `data`) and the older legacy envelope (`event` + `payload`)
 
 ## Examples
 

package/dist/credentials/LinqApi.credentials.js

@@ -4,7 +4,7 @@ exports.LinqApi = void 0;
 class LinqApi {
     name = 'linqApi';
     displayName = 'Linq API';
-    documentationUrl = 'https://apidocs.linqapp.com/reference/';
+    documentationUrl = 'https://apidocs.linqapp.com/documentation/getting-started';
     properties = [
         {
             displayName: 'API Token',
@@ -38,7 +38,7 @@ class LinqApi {
     test = {
         request: {
             baseURL: 'https://api.linqapp.com/api/partner',
-            url: '/v3/phonenumbers',
+            url: '/v3/phone_numbers',
             method: 'GET',
         },
     };

package/dist/nodes/Linq/Linq.node.js

@@ -7,6 +7,86 @@ function formatPhoneNumber(phoneNumber) {
     // Only remove space characters; do not modify digits/symbols or add prefixes
     return phoneNumber.trim().replaceAll(' ', '');
 }
+function splitCommaSeparated(value) {
+    return value
+        .split(',')
+        .map(item => item.trim())
+        .filter(Boolean);
+}
+function parseHandles(value) {
+    return splitCommaSeparated(value).map(formatPhoneNumber);
+}
+function buildMessageParts(text, attachmentUrlsString, attachmentIdsString, linkUrl) {
+    const attachmentUrls = splitCommaSeparated(attachmentUrlsString).map(url => {
+        if (!isValidUrl(url)) {
+            throw new n8n_workflow_1.ApplicationError(`Invalid attachment URL: "${url}". URLs must be valid HTTP/HTTPS URLs.`);
+        }
+        return url;
+    });
+    const attachmentIds = splitCommaSeparated(attachmentIdsString);
+    const trimmedLinkUrl = linkUrl.trim();
+    if (trimmedLinkUrl) {
+        if (!isValidUrl(trimmedLinkUrl)) {
+            throw new n8n_workflow_1.ApplicationError(`Invalid link URL: "${trimmedLinkUrl}". URLs must be valid HTTP/HTTPS URLs.`);
+        }
+        if (text || attachmentUrls.length > 0 || attachmentIds.length > 0) {
+            throw new n8n_workflow_1.ApplicationError('Link URL must be the only message part. Remove text, attachment URLs, and attachment IDs before sending a rich link.');
+        }
+        return [{ type: 'link', value: trimmedLinkUrl }];
+    }
+    const parts = [];
+    if (text) {
+        parts.push({ type: 'text', value: text });
+    }
+    attachmentUrls.forEach(url => {
+        parts.push({ type: 'media', url });
+    });
+    attachmentIds.forEach(attachmentId => {
+        parts.push({ type: 'media', attachment_id: attachmentId });
+    });
+    if (!parts.length) {
+        throw new n8n_workflow_1.ApplicationError('A message requires text, attachment URLs, attachment IDs, or a link URL.');
+    }
+    return parts;
+}
+function buildMessageContent(context, i) {
+    const messageText = context.getNodeParameter('messageText', i, '');
+    const attachmentUrls = context.getNodeParameter('attachmentUrls', i, '');
+    const attachmentIds = context.getNodeParameter('attachmentIds', i, '');
+    const linkUrl = context.getNodeParameter('linkUrl', i, '');
+    const idempotencyKey = context.getNodeParameter('idempotencyKey', i, '');
+    const preferredService = context.getNodeParameter('preferredService', i, '');
+    const effectType = context.getNodeParameter('effectType', i, '');
+    const effectName = context.getNodeParameter('effectName', i, '');
+    const replyToMessageId = context.getNodeParameter('replyToMessageId', i, '');
+    const replyToPartIndex = context.getNodeParameter('replyToPartIndex', i, 0);
+    const content = {
+        parts: buildMessageParts(messageText, attachmentUrls, attachmentIds, linkUrl),
+    };
+    if (idempotencyKey) {
+        content.idempotency_key = idempotencyKey;
+    }
+    if (preferredService) {
+        content.preferred_service = preferredService;
+    }
+    if (effectType || effectName) {
+        if (!effectType || !effectName) {
+            throw new n8n_workflow_1.ApplicationError('Both Effect Type and Effect Name are required when sending a message effect.');
+        }
+        content.effect = {
+            type: effectType,
+            name: effectName,
+        };
+    }
+    if (replyToMessageId) {
+        const replyTo = { message_id: replyToMessageId };
+        if (replyToPartIndex > 0) {
+            replyTo.part_index = replyToPartIndex;
+        }
+        content.reply_to = replyTo;
+    }
+    return content;
+}
 class Linq {
     description = {
         displayName: 'Linq',
@@ -84,6 +164,11 @@ class Linq {
                         value: 'getOne',
                         action: 'Get one chat',
                     },
+                    {
+                        name: 'Leave',
+                        value: 'leave',
+                        action: 'Leave a group chat',
+                    },
                     {
                         name: 'Mark as Read',
                         value: 'markAsRead',
@@ -141,15 +226,20 @@ class Linq {
                         action: 'Delete a chat message',
                     },
                     {
-                        name: 'Get',
-                        value: 'get',
-                        action: 'Get a chat message',
+                        name: 'Edit',
+                        value: 'edit',
+                        action: 'Edit a chat message',
                     },
                     {
                         name: 'Get Many',
                         value: 'getAll',
                         action: 'Get many chat messages',
                     },
+                    {
+                        name: 'Get One',
+                        value: 'get',
+                        action: 'Get a chat message',
+                    },
                     {
                         name: 'Get Thread',
                         value: 'getThread',
@@ -197,6 +287,11 @@ class Linq {
                         value: 'delete',
                         action: 'Delete a webhook subscription',
                     },
+                    {
+                        name: 'Get Events',
+                        value: 'getEvents',
+                        action: 'Get available webhook events',
+                    },
                     {
                         name: 'Get Many',
                         value: 'getAll',
@@ -251,6 +346,7 @@ class Linq {
                         resource: ['chat'],
                         operation: [
                             'getOne',
+                            'leave',
                             'shareContact',
                             'update',
                             'addParticipant',
@@ -271,7 +367,15 @@ class Linq {
                 type: 'string',
                 displayOptions: { show: { resource: ['chat'], operation: ['getAll'] } },
                 default: '',
-                description: 'Required: your Linq phone number (from)',
+                description: 'Optional: filter chats by one of your Linq phone numbers (from)',
+            },
+            {
+                displayName: 'Participant Handle',
+                name: 'participantHandle',
+                type: 'string',
+                displayOptions: { show: { resource: ['chat'], operation: ['getAll'] } },
+                default: '',
+                description: 'Optional: filter chats by a participant phone number or email address',
             },
             {
                 displayName: 'From Phone Number',
@@ -293,7 +397,9 @@ class Linq {
                 displayName: 'Cursor',
                 name: 'cursor',
                 type: 'string',
-                displayOptions: { show: { resource: ['chat', 'chatMessage'], operation: ['getAll'] } },
+                displayOptions: {
+                    show: { resource: ['chat', 'chatMessage'], operation: ['getAll', 'getThread'] },
+                },
                 default: '',
                 description: 'Cursor for pagination',
             },
@@ -304,7 +410,9 @@ class Linq {
                 typeOptions: {
                     minValue: 1,
                 },
-                displayOptions: { show: { resource: ['chat', 'chatMessage'], operation: ['getAll'] } },
+                displayOptions: {
+                    show: { resource: ['chat', 'chatMessage'], operation: ['getAll', 'getThread'] },
+                },
                 default: 50,
                 description: 'Max number of results to return',
             },
@@ -355,7 +463,89 @@ class Linq {
                 type: 'string',
                 displayOptions: { show: { resource: ['chat'], operation: ['create'] } },
                 default: '',
-                description: 'Comma-separated list of attachment URLs',
+                description: 'Comma-separated list of attachment URLs to send directly as media parts',
+            },
+            {
+                displayName: 'Attachment IDs',
+                name: 'attachmentIds',
+                type: 'string',
+                displayOptions: {
+                    show: { resource: ['chat', 'chatMessage'], operation: ['create'] },
+                },
+                default: '',
+                description: 'Comma-separated list of pre-uploaded Linq attachment IDs to send as media parts',
+            },
+            {
+                displayName: 'Link URL',
+                name: 'linkUrl',
+                type: 'string',
+                displayOptions: {
+                    show: { resource: ['chat', 'chatMessage'], operation: ['create'] },
+                },
+                default: '',
+                description: 'Optional rich link preview URL. Must be the only message part when provided.',
+            },
+            {
+                displayName: 'Preferred Service',
+                name: 'preferredService',
+                type: 'options',
+                displayOptions: {
+                    show: { resource: ['chat', 'chatMessage'], operation: ['create'] },
+                },
+                options: [
+                    { name: 'Default', value: '' },
+                    { name: 'iMessage', value: 'iMessage' },
+                    { name: 'RCS', value: 'RCS' },
+                    { name: 'SMS', value: 'SMS' },
+                ],
+                default: '',
+                description: 'Optional preferred messaging service for the message',
+            },
+            {
+                displayName: 'Effect Type',
+                name: 'effectType',
+                type: 'options',
+                displayOptions: {
+                    show: { resource: ['chat', 'chatMessage'], operation: ['create'] },
+                },
+                options: [
+                    { name: 'None', value: '' },
+                    { name: 'Screen', value: 'screen' },
+                    { name: 'Bubble', value: 'bubble' },
+                ],
+                default: '',
+                description: 'Optional iMessage effect type',
+            },
+            {
+                displayName: 'Effect Name',
+                name: 'effectName',
+                type: 'string',
+                displayOptions: {
+                    show: { resource: ['chat', 'chatMessage'], operation: ['create'] },
+                },
+                default: '',
+                description: 'Optional effect name such as confetti, fireworks, slam, loud, gentle, or invisible',
+            },
+            {
+                displayName: 'Reply To Message ID',
+                name: 'replyToMessageId',
+                type: 'string',
+                displayOptions: {
+                    show: { resource: ['chat', 'chatMessage'], operation: ['create'] },
+                },
+                default: '',
+                description: 'Optional message ID to reply to',
+            },
+            {
+                displayName: 'Reply To Part Index',
+                name: 'replyToPartIndex',
+                type: 'number',
+                typeOptions: { minValue: 0 },
+                displayOptions: {
+                    show: { resource: ['chat', 'chatMessage'], operation: ['create'] },
+                },
+                default: 0,
+                description: 'Optional part index to reply to when sending a threaded reply',
             },
             // Update Chat parameters
             {
@@ -394,6 +584,14 @@ class Linq {
                 default: '',
                 description: 'The URL of the voice memo to send',
             },
+            {
+                displayName: 'Voice Memo Attachment ID',
+                name: 'voiceMemoAttachmentId',
+                type: 'string',
+                displayOptions: { show: { resource: ['chat'], operation: ['sendVoiceMemo'] } },
+                default: '',
+                description: 'Optional pre-uploaded Linq attachment ID for the voice memo',
+            },
             // Chat Message parameters
             {
                 displayName: 'Chat Message ID',
@@ -402,7 +600,7 @@ class Linq {
                 displayOptions: {
                     show: {
                         resource: ['chatMessage'],
-                        operation: ['getOne', 'delete', 'react', 'getThread'],
+                        operation: ['get', 'edit', 'delete', 'react', 'getThread'],
                     },
                 },
                 default: '',
@@ -438,17 +636,70 @@ class Linq {
                 displayName: 'Idempotency Key',
                 name: 'idempotencyKey',
                 type: 'string',
-                displayOptions: { show: { resource: ['chatMessage'], operation: ['create'] } },
+                displayOptions: {
+                    show: { resource: ['chat', 'chatMessage'], operation: ['create'] },
+                },
                 default: '',
                 description: 'Optional idempotency key for message creation',
             },
             {
-                displayName: 'Reaction',
+                displayName: 'Edit Text',
+                name: 'editText',
+                type: 'string',
+                displayOptions: { show: { resource: ['chatMessage'], operation: ['edit'] } },
+                default: '',
+                description: 'The new text to apply to the selected message part',
+            },
+            {
+                displayName: 'Reaction Type',
                 name: 'reaction',
                 type: 'string',
                 displayOptions: { show: { resource: ['chatMessage'], operation: ['react'] } },
                 default: '',
-                description: 'The reaction to add',
+                description: 'The reaction type to add or remove (for example love, like, custom)',
+            },
+            {
+                displayName: 'Reaction Operation',
+                name: 'reactionOperation',
+                type: 'options',
+                displayOptions: { show: { resource: ['chatMessage'], operation: ['react'] } },
+                options: [
+                    { name: 'Add', value: 'add' },
+                    { name: 'Remove', value: 'remove' },
+                ],
+                default: 'add',
+                description: 'Whether to add or remove the reaction',
+            },
+            {
+                displayName: 'Custom Emoji',
+                name: 'customEmoji',
+                type: 'string',
+                displayOptions: { show: { resource: ['chatMessage'], operation: ['react'] } },
+                default: '',
+                description: 'Optional custom emoji value when reaction type is custom',
+            },
+            {
+                displayName: 'Message Part Index',
+                name: 'messagePartIndex',
+                type: 'number',
+                typeOptions: { minValue: 0 },
+                displayOptions: {
+                    show: { resource: ['chatMessage'], operation: ['edit', 'react'] },
+                },
+                default: 0,
+                description: 'Optional message part index for editing or reacting to a specific part',
+            },
+            {
+                displayName: 'Order',
+                name: 'threadOrder',
+                type: 'options',
+                displayOptions: { show: { resource: ['chatMessage'], operation: ['getThread'] } },
+                options: [
+                    { name: 'Ascending', value: 'asc' },
+                    { name: 'Descending', value: 'desc' },
+                ],
+                default: 'asc',
+                description: 'Sort order for thread messages',
             },
             // Webhook Subscription parameters
             {
@@ -481,15 +732,35 @@ class Linq {
                 default: '',
                 description: 'Comma-separated list of events',
             },
+            {
+                displayName: 'Phone Numbers',
+                name: 'webhookPhoneNumbers',
+                type: 'string',
+                displayOptions: {
+                    show: { resource: ['webhookSubscription'], operation: ['create', 'update'] },
+                },
+                default: '',
+                description: 'Optional comma-separated list of phone numbers to filter webhook deliveries for',
+            },
             {
                 displayName: 'Active',
                 name: 'active',
                 type: 'boolean',
                 displayOptions: {
-                    show: { resource: ['webhookSubscription'], operation: ['create', 'update'] },
+                    show: { resource: ['webhookSubscription'], operation: ['update'] },
                 },
                 default: true,
-                description: 'Whether the webhook is active',
+                description: 'Whether the webhook subscription is active',
+            },
+            {
+                displayName: 'Clear Phone Number Filter',
+                name: 'clearWebhookPhoneNumbers',
+                type: 'boolean',
+                displayOptions: {
+                    show: { resource: ['webhookSubscription'], operation: ['update'] },
+                },
+                default: false,
+                description: 'Whether to remove any existing phone number filter on the subscription',
             },
             // Attachment parameters
             {
@@ -530,7 +801,7 @@ class Linq {
                 type: 'string',
                 displayOptions: { show: { resource: ['attachment'], operation: ['updateStatus'] } },
                 default: '',
-                description: 'The status of the attachment (e.g., uploaded, failed)',
+                description: 'The status of the attachment (pending, complete, or failed)',
             },
         ],
     };
@@ -577,35 +848,6 @@ class Linq {
     }
 }
 exports.Linq = Linq;
-async function uploadAttachment(context, url) {
-    const response = await context.helpers.httpRequest({
-        method: 'GET',
-        url,
-        encoding: 'arraybuffer',
-    });
-    const buffer = Buffer.from(response);
-    const contentType = 'application/octet-stream';
-    const uploadConfig = await context.helpers.httpRequestWithAuthentication.call(context, 'linqApi', {
-        method: 'POST',
-        url: 'https://api.linqapp.com/api/partner/v3/attachments',
-        headers: {
-            'Content-Type': 'application/json',
-            Accept: 'application/json',
-        },
-        body: {
-            content_type: contentType,
-        },
-    });
-    await context.helpers.httpRequest({
-        method: 'PUT',
-        url: uploadConfig.upload_url,
-        headers: {
-            'Content-Type': contentType,
-        },
-        body: buffer,
-    });
-    return uploadConfig.id;
-}
 function isValidUrl(urlString) {
     try {
         const url = new URL(urlString);
@@ -615,44 +857,16 @@ function isValidUrl(urlString) {
         return false;
     }
 }
-async function createParts(context, text, attachmentUrlsString) {
-    const parts = [];
-    if (text) {
-        parts.push({ type: 'text', value: text });
-    }
-    if (attachmentUrlsString) {
-        const urls = attachmentUrlsString
-            .split(',')
-            .map(u => u.trim())
-            .filter(Boolean)
-            .filter(u => {
-            if (!isValidUrl(u)) {
-                throw new n8n_workflow_1.ApplicationError(`Invalid attachment URL: "${u}". URLs must be valid HTTP/HTTPS URLs.`);
-            }
-            return true;
-        });
-        // Upload attachments in batches to limit concurrency and avoid OOM
-        const CONCURRENCY_LIMIT = 3;
-        const attachmentIds = [];
-        for (let i = 0; i < urls.length; i += CONCURRENCY_LIMIT) {
-            const chunk = urls.slice(i, i + CONCURRENCY_LIMIT);
-            const chunkResults = await Promise.all(chunk.map(url => uploadAttachment(context, url)));
-            attachmentIds.push(...chunkResults);
-        }
-        attachmentIds.forEach(id => {
-            parts.push({ type: 'media', attachment_id: id });
-        });
-    }
-    return parts;
-}
 async function chatGetAll(context, i) {
     const phoneNumber = context.getNodeParameter('phoneNumber', i, '');
+    const participantHandle = context.getNodeParameter('participantHandle', i, '');
     const cursor = context.getNodeParameter('cursor', i, '');
     const limit = context.getNodeParameter('limit', i);
-    if (!phoneNumber) {
-        throw new n8n_workflow_1.ApplicationError('phone_number is required by Linq API');
-    }
-    const qs = { from: formatPhoneNumber(phoneNumber) };
+    const qs = {};
+    if (phoneNumber)
+        qs.from = formatPhoneNumber(phoneNumber);
+    if (participantHandle)
+        qs.to = formatPhoneNumber(participantHandle);
     if (cursor)
         qs.cursor = cursor;
     if (limit && limit !== 50)
@@ -673,12 +887,19 @@ async function chatGetOne(context, i) {
 async function chatFind(context, i) {
     const fromPhoneNumber = context.getNodeParameter('fromPhoneNumber', i, '');
     const phoneNumbers = context.getNodeParameter('phoneNumbers', i, '');
-    if (!fromPhoneNumber) {
-        throw new n8n_workflow_1.ApplicationError('phone_number is required when finding chats');
+    const handles = parseHandles(phoneNumbers);
+    if (!fromPhoneNumber && handles.length === 0) {
+        throw new n8n_workflow_1.ApplicationError('Provide a from phone number or at least one participant handle');
+    }
+    const qs = {};
+    if (fromPhoneNumber) {
+        qs.from = formatPhoneNumber(fromPhoneNumber);
+    }
+    if (handles.length === 1) {
+        qs.to = handles[0];
     }
-    const qs = { from: formatPhoneNumber(fromPhoneNumber) };
-    if (phoneNumbers) {
-        qs['phone_numbers[]'] = phoneNumbers.split(',').map(p => formatPhoneNumber(p.trim()));
+    else if (handles.length > 1) {
+        qs['phone_numbers[]'] = handles;
     }
     return context.helpers.httpRequestWithAuthentication.call(context, 'linqApi', {
         method: 'GET',
@@ -690,27 +911,44 @@ async function chatCreate(context, i) {
     const sendFrom = context.getNodeParameter('sendFrom', i);
     const displayName = context.getNodeParameter('displayName', i);
     const phoneNumbers = context.getNodeParameter('phoneNumbers', i);
-    const messageText = context.getNodeParameter('messageText', i);
-    const attachmentUrls = context.getNodeParameter('attachmentUrls', i, '');
     if (!sendFrom) {
         throw new n8n_workflow_1.ApplicationError('send_from is required by Linq when creating chats');
     }
-    const parts = await createParts(context, messageText, attachmentUrls);
+    const recipients = parseHandles(phoneNumbers);
+    if (!recipients.length) {
+        throw new n8n_workflow_1.ApplicationError('At least one recipient phone number or email address is required');
+    }
     const body = {
         from: formatPhoneNumber(sendFrom),
-        to: phoneNumbers.split(',').map(p => formatPhoneNumber(p.trim())),
-        message: { parts },
+        to: recipients,
+        message: buildMessageContent(context, i),
     };
-    if (displayName)
-        body.display_name = displayName;
-    return context.helpers.httpRequestWithAuthentication.call(context, 'linqApi', {
+    const response = (await context.helpers.httpRequestWithAuthentication.call(context, 'linqApi', {
         method: 'POST',
         url: 'https://api.linqapp.com/api/partner/v3/chats',
         headers: {
             'Content-Type': 'application/json',
         },
         body,
-    });
+    }));
+    if (displayName) {
+        const createdChat = response.chat;
+        const createdChatId = createdChat?.id;
+        if (!createdChatId) {
+            throw new n8n_workflow_1.ApplicationError('Linq created the chat but did not return a chat ID for the follow-up display name update.');
+        }
+        await context.helpers.httpRequestWithAuthentication.call(context, 'linqApi', {
+            method: 'PUT',
+            url: `https://api.linqapp.com/api/partner/v3/chats/${createdChatId}`,
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: {
+                display_name: displayName,
+            },
+        });
+    }
+    return response;
 }
 async function chatShareContact(context, i) {
     const chatId = context.getNodeParameter('chatId', i);
@@ -747,6 +985,16 @@ async function chatUpdate(context, i) {
         json: true,
     });
 }
+async function chatLeave(context, i) {
+    const chatId = context.getNodeParameter('chatId', i);
+    if (!chatId) {
+        throw new n8n_workflow_1.ApplicationError('chatId is required to leave a chat');
+    }
+    return context.helpers.httpRequestWithAuthentication.call(context, 'linqApi', {
+        method: 'POST',
+        url: `https://api.linqapp.com/api/partner/v3/chats/${chatId}/leave`,
+    });
+}
 async function chatAddParticipant(context, i) {
     const chatId = context.getNodeParameter('chatId', i);
     const handle = context.getNodeParameter('handle', i);
@@ -817,12 +1065,26 @@ async function chatMarkAsRead(context, i) {
 }
 async function chatSendVoiceMemo(context, i) {
     const chatId = context.getNodeParameter('chatId', i);
-    const voiceMemoUrl = context.getNodeParameter('voiceMemoUrl', i);
+    const voiceMemoUrl = context.getNodeParameter('voiceMemoUrl', i, '');
+    const voiceMemoAttachmentId = context.getNodeParameter('voiceMemoAttachmentId', i, '');
     if (!chatId) {
         throw new n8n_workflow_1.ApplicationError('chatId is required to send a voice memo');
     }
-    if (!voiceMemoUrl) {
-        throw new n8n_workflow_1.ApplicationError('voiceMemoUrl is required to send a voice memo');
+    if (!voiceMemoUrl && !voiceMemoAttachmentId) {
+        throw new n8n_workflow_1.ApplicationError('Either Voice Memo URL or Voice Memo Attachment ID is required to send a voice memo');
+    }
+    if (voiceMemoUrl && voiceMemoAttachmentId) {
+        throw new n8n_workflow_1.ApplicationError('Provide either Voice Memo URL or Voice Memo Attachment ID, but not both.');
+    }
+    const body = {};
+    if (voiceMemoUrl) {
+        if (!isValidUrl(voiceMemoUrl)) {
+            throw new n8n_workflow_1.ApplicationError('Voice Memo URL must be a valid HTTP/HTTPS URL');
+        }
+        body.voice_memo_url = voiceMemoUrl;
+    }
+    if (voiceMemoAttachmentId) {
+        body.attachment_id = voiceMemoAttachmentId;
     }
     return context.helpers.httpRequestWithAuthentication.call(context, 'linqApi', {
         method: 'POST',
@@ -830,7 +1092,7 @@ async function chatSendVoiceMemo(context, i) {
         headers: {
             'Content-Type': 'application/json',
         },
-        body: { voice_memo_url: voiceMemoUrl },
+        body,
         json: true,
     });
 }
@@ -864,8 +1126,8 @@ async function attachmentRequestUpload(context, i) {
             'Content-Type': 'application/json',
         },
         body: {
-            file_name: fileName,
-            file_size: fileSize,
+            filename: fileName,
+            size_bytes: fileSize,
             content_type: contentType,
         },
         json: true,
@@ -904,6 +1166,8 @@ async function handleChatOperation(context, i, operation) {
             return chatShareContact(context, i);
         case 'update':
             return chatUpdate(context, i);
+        case 'leave':
+            return chatLeave(context, i);
         case 'addParticipant':
             return chatAddParticipant(context, i);
         case 'removeParticipant':
@@ -947,17 +1211,10 @@ async function chatMessageGetOne(context, i) {
 }
 async function chatMessageCreate(context, i) {
     const chatId = context.getNodeParameter('chatId', i);
-    const messageText = context.getNodeParameter('messageText', i);
-    const attachmentUrls = context.getNodeParameter('attachmentUrls', i, '');
-    const idempotencyKey = context.getNodeParameter('idempotencyKey', i, '');
     if (!chatId) {
         throw new n8n_workflow_1.ApplicationError('chatId is required to create a chat message');
     }
-    const parts = await createParts(context, messageText, attachmentUrls);
-    const body = { message: { parts } };
-    if (idempotencyKey) {
-        body.message.idempotency_key = idempotencyKey;
-    }
+    const body = { message: buildMessageContent(context, i) };
     return context.helpers.httpRequestWithAuthentication.call(context, 'linqApi', {
         method: 'POST',
         url: `https://api.linqapp.com/api/partner/v3/chats/${chatId}/messages`,
@@ -989,40 +1246,85 @@ async function chatMessageDelete(context, i) {
 async function chatMessageReact(context, i) {
     const chatMessageId = context.getNodeParameter('chatMessageId', i);
     const reaction = context.getNodeParameter('reaction', i);
+    const reactionOperation = context.getNodeParameter('reactionOperation', i, 'add');
+    const customEmoji = context.getNodeParameter('customEmoji', i, '');
+    const messagePartIndex = context.getNodeParameter('messagePartIndex', i, 0);
     if (!chatMessageId) {
         throw new n8n_workflow_1.ApplicationError('chatMessageId is required to react to a message');
     }
     if (!reaction) {
         throw new n8n_workflow_1.ApplicationError('reaction is required to react to a message');
     }
+    const body = { operation: reactionOperation, type: reaction };
+    if (customEmoji) {
+        body.custom_emoji = customEmoji;
+    }
+    if (messagePartIndex > 0) {
+        body.part_index = messagePartIndex;
+    }
     return context.helpers.httpRequestWithAuthentication.call(context, 'linqApi', {
         method: 'POST',
         url: `https://api.linqapp.com/api/partner/v3/messages/${chatMessageId}/reactions`,
         headers: {
             'Content-Type': 'application/json',
         },
-        body: { operation: 'add', type: reaction },
+        body,
+        json: true,
+    });
+}
+async function chatMessageEdit(context, i) {
+    const chatMessageId = context.getNodeParameter('chatMessageId', i);
+    const editText = context.getNodeParameter('editText', i);
+    const messagePartIndex = context.getNodeParameter('messagePartIndex', i, 0);
+    if (!chatMessageId) {
+        throw new n8n_workflow_1.ApplicationError('chatMessageId is required to edit a message');
+    }
+    if (!editText) {
+        throw new n8n_workflow_1.ApplicationError('editText is required to edit a message');
+    }
+    return context.helpers.httpRequestWithAuthentication.call(context, 'linqApi', {
+        method: 'PATCH',
+        url: `https://api.linqapp.com/api/partner/v3/messages/${chatMessageId}`,
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        body: {
+            part_index: messagePartIndex,
+            text: editText,
+        },
         json: true,
     });
 }
 async function chatMessageGetThread(context, i) {
     const chatMessageId = context.getNodeParameter('chatMessageId', i);
+    const cursor = context.getNodeParameter('cursor', i, '');
+    const limit = context.getNodeParameter('limit', i, 50);
+    const threadOrder = context.getNodeParameter('threadOrder', i, 'asc');
     if (!chatMessageId) {
         throw new n8n_workflow_1.ApplicationError('chatMessageId is required to get message thread');
     }
+    const qs = { order: threadOrder };
+    if (cursor)
+        qs.cursor = cursor;
+    if (limit && limit !== 50)
+        qs.limit = limit;
     return context.helpers.httpRequestWithAuthentication.call(context, 'linqApi', {
         method: 'GET',
         url: `https://api.linqapp.com/api/partner/v3/messages/${chatMessageId}/thread`,
+        qs,
     });
 }
 async function handleChatMessageOperation(context, i, operation) {
     switch (operation) {
         case 'getAll':
             return chatMessageGetAll(context, i);
+        case 'getOne':
         case 'get':
             return chatMessageGetOne(context, i);
         case 'create':
             return chatMessageCreate(context, i);
+        case 'edit':
+            return chatMessageEdit(context, i);
         case 'delete':
             return chatMessageDelete(context, i);
         case 'react':
@@ -1036,7 +1338,7 @@ async function handleChatMessageOperation(context, i, operation) {
 async function phoneNumberGetAll(context) {
     return context.helpers.httpRequestWithAuthentication.call(context, 'linqApi', {
         method: 'GET',
-        url: 'https://api.linqapp.com/api/partner/v3/phonenumbers',
+        url: 'https://api.linqapp.com/api/partner/v3/phone_numbers',
     });
 }
 async function handlePhoneNumberOperation(context, _i, operation) {
@@ -1053,6 +1355,12 @@ async function webhookSubscriptionGetAll(context) {
         url: 'https://api.linqapp.com/api/partner/v3/webhook-subscriptions',
     });
 }
+async function webhookSubscriptionGetEvents(context) {
+    return context.helpers.httpRequestWithAuthentication.call(context, 'linqApi', {
+        method: 'GET',
+        url: 'https://api.linqapp.com/api/partner/v3/webhook-events',
+    });
+}
 async function webhookSubscriptionGetOne(context, i) {
     const webhookSubscriptionId = context.getNodeParameter('webhookSubscriptionId', i);
     return context.helpers.httpRequestWithAuthentication.call(context, 'linqApi', {
@@ -1063,13 +1371,17 @@ async function webhookSubscriptionGetOne(context, i) {
 async function webhookSubscriptionCreate(context, i) {
     const webhookUrl = context.getNodeParameter('webhookUrl', i);
     const events = context.getNodeParameter('events', i);
-    const active = context.getNodeParameter('active', i);
+    const phoneNumbers = parseHandles(context.getNodeParameter('webhookPhoneNumbers', i, ''));
+    const subscribedEvents = splitCommaSeparated(events);
+    if (!subscribedEvents.length) {
+        throw new n8n_workflow_1.ApplicationError('At least one webhook event is required when creating a subscription');
+    }
     const body = {
         target_url: webhookUrl,
-        active: active,
+        subscribed_events: subscribedEvents,
     };
-    if (events) {
-        body.subscribed_events = events.split(',').map(e => e.trim());
+    if (phoneNumbers.length) {
+        body.phone_numbers = phoneNumbers;
     }
     return context.helpers.httpRequestWithAuthentication.call(context, 'linqApi', {
         method: 'POST',
@@ -1083,13 +1395,21 @@ async function webhookSubscriptionCreate(context, i) {
 async function webhookSubscriptionUpdate(context, i) {
     const webhookSubscriptionId = context.getNodeParameter('webhookSubscriptionId', i);
     const webhookUrl = context.getNodeParameter('webhookUrl', i);
-    const events = context.getNodeParameter('events', i);
+    const events = context.getNodeParameter('events', i, '');
     const active = context.getNodeParameter('active', i);
-    const body = { active };
+    const clearWebhookPhoneNumbers = context.getNodeParameter('clearWebhookPhoneNumbers', i, false);
+    const phoneNumbers = parseHandles(context.getNodeParameter('webhookPhoneNumbers', i, ''));
+    const body = { is_active: active };
     if (webhookUrl)
         body.target_url = webhookUrl;
     if (events) {
-        body.subscribed_events = events.split(',').map(e => e.trim());
+        body.subscribed_events = splitCommaSeparated(events);
+    }
+    if (clearWebhookPhoneNumbers) {
+        body.phone_numbers = [];
+    }
+    else if (phoneNumbers.length) {
+        body.phone_numbers = phoneNumbers;
     }
     return context.helpers.httpRequestWithAuthentication.call(context, 'linqApi', {
         method: 'PUT',
@@ -1109,6 +1429,8 @@ async function webhookSubscriptionDelete(context, i) {
 }
 async function handleWebhookSubscriptionOperation(context, i, operation) {
     switch (operation) {
+        case 'getEvents':
+            return webhookSubscriptionGetEvents(context);
         case 'getAll':
             return webhookSubscriptionGetAll(context);
         case 'getOne':

package/dist/nodes/LinqTrigger/LinqTrigger.node.d.ts

@@ -1,4 +1,7 @@
-import { IWebhookFunctions, INodeType, INodeTypeDescription, IWebhookResponseData } from 'n8n-workflow';
+import { IWebhookFunctions, INodeType, INodeTypeDescription, IWebhookResponseData, IDataObject } from 'n8n-workflow';
+export declare function extractSignatureHex(signatureHeader: string): string;
+export declare function extractIncomingEvent(bodyData: IDataObject, headers: IDataObject): string | undefined;
+export declare function extractWebhookPayload(bodyData: IDataObject): IDataObject;
 export declare class LinqTrigger implements INodeType {
     description: INodeTypeDescription;
     webhook(this: IWebhookFunctions): Promise<IWebhookResponseData>;

package/dist/nodes/LinqTrigger/LinqTrigger.node.js

@@ -34,8 +34,32 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LinqTrigger = void 0;
+exports.extractSignatureHex = extractSignatureHex;
+exports.extractIncomingEvent = extractIncomingEvent;
+exports.extractWebhookPayload = extractWebhookPayload;
 const n8n_workflow_1 = require("n8n-workflow");
 const crypto = __importStar(require("node:crypto"));
+function extractSignatureHex(signatureHeader) {
+    const trimmedSignature = signatureHeader.trim();
+    const [, prefixedValue] = trimmedSignature.split('=', 2);
+    const hexValue = prefixedValue ?? trimmedSignature;
+    if (!/^[a-fA-F0-9]+$/.test(hexValue)) {
+        throw new n8n_workflow_1.ApplicationError('Invalid signature format');
+    }
+    return hexValue;
+}
+function extractIncomingEvent(bodyData, headers) {
+    return (bodyData.event_type ??
+        bodyData.event ??
+        headers['x-webhook-event']);
+}
+function extractWebhookPayload(bodyData) {
+    const nestedPayload = (bodyData.data ?? bodyData.payload);
+    if (nestedPayload && typeof nestedPayload === 'object' && !Array.isArray(nestedPayload)) {
+        return nestedPayload;
+    }
+    return bodyData;
+}
 class LinqTrigger {
     description = {
         displayName: 'Linq Trigger',
@@ -71,6 +95,38 @@ class LinqTrigger {
                 name: 'events',
                 type: 'multiOptions',
                 options: [
+                    {
+                        name: 'Call Answered',
+                        value: 'call.answered',
+                    },
+                    {
+                        name: 'Call Declined',
+                        value: 'call.declined',
+                    },
+                    {
+                        name: 'Call Ended',
+                        value: 'call.ended',
+                    },
+                    {
+                        name: 'Call Failed',
+                        value: 'call.failed',
+                    },
+                    {
+                        name: 'Call Initiated',
+                        value: 'call.initiated',
+                    },
+                    {
+                        name: 'Call No Answer',
+                        value: 'call.no_answer',
+                    },
+                    {
+                        name: 'Call Ringing',
+                        value: 'call.ringing',
+                    },
+                    {
+                        name: 'Chat Created',
+                        value: 'chat.created',
+                    },
                     {
                         name: 'Chat Group Icon Update Failed',
                         value: 'chat.group_icon_update_failed',
@@ -87,10 +143,22 @@ class LinqTrigger {
                         name: 'Chat Group Name Updated',
                         value: 'chat.group_name_updated',
                     },
+                    {
+                        name: 'Chat Typing Indicator Started',
+                        value: 'chat.typing_indicator.started',
+                    },
+                    {
+                        name: 'Chat Typing Indicator Stopped',
+                        value: 'chat.typing_indicator.stopped',
+                    },
                     {
                         name: 'Message Delivered',
                         value: 'message.delivered',
                     },
+                    {
+                        name: 'Message Edited',
+                        value: 'message.edited',
+                    },
                     {
                         name: 'Message Failed',
                         value: 'message.failed',
@@ -115,6 +183,10 @@ class LinqTrigger {
                         name: 'Participant Removed',
                         value: 'participant.removed',
                     },
+                    {
+                        name: 'Phone Number Status Updated',
+                        value: 'phone_number.status_updated',
+                    },
                     {
                         name: 'Reaction Added',
                         value: 'reaction.added',
@@ -148,10 +220,7 @@ class LinqTrigger {
         if (Math.abs(now - timestamp) > 300) {
             throw new n8n_workflow_1.ApplicationError('Request timestamp is too old');
         }
-        const [scheme, signature] = signatureHeader.split('=');
-        if (scheme !== 'sha256' || !signature) {
-            throw new n8n_workflow_1.ApplicationError('Invalid signature format');
-        }
+        const signature = extractSignatureHex(signatureHeader);
         // 2. Verify HMAC Signature
         const credentials = await this.getCredentials('linqApi');
         const signingSecret = credentials.webhookSigningSecret;
@@ -176,22 +245,34 @@ class LinqTrigger {
         }
         // 3. Event Filtering
         const events = this.getNodeParameter('events', []);
-        const incomingEvent = bodyData.event;
+        const incomingEvent = extractIncomingEvent(bodyData, headers);
+        if (!incomingEvent) {
+            throw new n8n_workflow_1.ApplicationError('Unable to determine webhook event type');
+        }
         // Filter if events are specified
         if (events.length > 0 && !events.includes(incomingEvent)) {
             return {};
         }
-        // 4. Extract Payload
-        // The V3 structure is { event: string, payload: object }
-        const { payload } = bodyData;
+        // 4. Extract payload from both legacy and current webhook envelopes
+        const payload = extractWebhookPayload(bodyData);
+        const json = {
+            event: incomingEvent,
+            api_version: bodyData.api_version,
+            webhook_version: bodyData.webhook_version,
+            event_id: bodyData.event_id,
+            trace_id: bodyData.trace_id,
+            created_at: bodyData.created_at,
+            partner_id: bodyData.partner_id,
+            payload,
+        };
+        if (payload && typeof payload === 'object' && !Array.isArray(payload)) {
+            Object.assign(json, payload);
+        }
         return {
             workflowData: [
                 [
                     {
-                        json: {
-                            event: incomingEvent,
-                            ...payload,
-                        },
+                        json,
                     },
                 ],
             ],

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "n8n-nodes-linq",
-	"version": "4.0.2",
+	"version": "4.1.0",
 	"description": "Linq API integration for n8n",
 	"keywords": [
 		"n8n-community-node-package",
@@ -45,17 +45,17 @@
 		]
 	},
 	"devDependencies": {
-		"@types/node": "^24.3.3",
-		"@typescript-eslint/parser": "~8.32.0",
-		"eslint": "^8.57.0",
-		"eslint-plugin-n8n-nodes-base": "^1.16.3",
-		"gulp": "^5.0.0",
-		"prettier": "^3.5.3",
-		"typescript": "^5.8.2",
-		"vitest": "^2.1.0"
+		"@types/node": "^24.12.0",
+		"@typescript-eslint/parser": "~8.58.0",
+		"eslint": "^8.57.1",
+		"eslint-plugin-n8n-nodes-base": "^1.16.6",
+		"gulp": "^5.0.1",
+		"prettier": "^3.8.1",
+		"typescript": "^5.9.3",
+		"vitest": "^4.1.2"
 	},
 	"peerDependencies": {
-		"n8n-workflow": "^1.120.7"
+		"n8n-workflow": "^1.120.10"
 	},
 	"overrides": {
 		"form-data": "^4.0.5",