n8n-nodes-duckduckgo-search 31.0.0 → 31.0.1

package/dist/nodes/DuckDuckGo/DuckDuckGo.node.js

@@ -1356,7 +1356,7 @@ class DuckDuckGo {
         return paginationResult.results;
     }
     async execute() {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2, _3, _4, _5, _6, _7;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2, _3, _4, _5;
         const items = this.getInputData();
         const returnData = [];
         const debugMode = this.getNodeParameter('debugMode', 0, false);
@@ -1370,17 +1370,25 @@ class DuckDuckGo {
         });
         let reliabilityManager = null;
         if (reliabilitySettings && reliabilitySettings.enableReliability !== false) {
-            const reliabilityConfig = {
-                emptyResultThreshold: reliabilitySettings.emptyResultThreshold,
-                initialBackoffMs: reliabilitySettings.initialBackoffMs,
-                maxBackoffMs: reliabilitySettings.maxBackoffMs,
-                minJitterMs: reliabilitySettings.minJitterMs,
-                maxJitterMs: reliabilitySettings.maxJitterMs,
-                failureThreshold: reliabilitySettings.failureThreshold,
-                resetTimeoutMs: reliabilitySettings.resetTimeoutMs,
-                maxRetries: reliabilitySettings.maxRetries,
-                retryDelayMs: reliabilitySettings.retryDelayMs,
-            };
+            const reliabilityConfig = {};
+            if (reliabilitySettings.emptyResultThreshold !== undefined)
+                reliabilityConfig.emptyResultThreshold = reliabilitySettings.emptyResultThreshold;
+            if (reliabilitySettings.initialBackoffMs !== undefined)
+                reliabilityConfig.initialBackoffMs = reliabilitySettings.initialBackoffMs;
+            if (reliabilitySettings.maxBackoffMs !== undefined)
+                reliabilityConfig.maxBackoffMs = reliabilitySettings.maxBackoffMs;
+            if (reliabilitySettings.minJitterMs !== undefined)
+                reliabilityConfig.minJitterMs = reliabilitySettings.minJitterMs;
+            if (reliabilitySettings.maxJitterMs !== undefined)
+                reliabilityConfig.maxJitterMs = reliabilitySettings.maxJitterMs;
+            if (reliabilitySettings.failureThreshold !== undefined)
+                reliabilityConfig.failureThreshold = reliabilitySettings.failureThreshold;
+            if (reliabilitySettings.resetTimeoutMs !== undefined)
+                reliabilityConfig.resetTimeoutMs = reliabilitySettings.resetTimeoutMs;
+            if (reliabilitySettings.maxRetries !== undefined)
+                reliabilityConfig.maxRetries = reliabilitySettings.maxRetries;
+            if (reliabilitySettings.retryDelayMs !== undefined)
+                reliabilityConfig.retryDelayMs = reliabilitySettings.retryDelayMs;
             reliabilityManager = (0, reliabilityManager_1.getGlobalReliabilityManager)(reliabilityConfig);
             if (debugMode) {
                 const logEntry = (0, utils_1.createLogEntry)(utils_1.LogLevel.INFO, `Reliability Manager initialized: ${reliabilityManager.getSummary()}`, 'execute', { config: reliabilityConfig });
@@ -1469,21 +1477,31 @@ class DuckDuckGo {
                                 const logEntry = (0, utils_1.createLogEntry)(utils_1.LogLevel.INFO, `Executing web search for: ${enhancedQuery}`, operation, { query: enhancedQuery, options: searchOptions, cacheEnabled: enableCache });
                                 console.log(JSON.stringify(logEntry));
                             }
-                            const directResults = await (0, directSearch_1.directWebSearch)(enhancedQuery, {
-                                locale: searchOptions.locale || 'us-en',
-                                safeSearch: (0, directSearch_1.getSafeSearchString)((_e = options.safeSearch) !== null && _e !== void 0 ? _e : constants_1.DEFAULT_PARAMETERS.SAFE_SEARCH),
-                                maxResults: undefined,
-                            });
-                            result = {
-                                results: directResults.results.map(r => ({
-                                    title: r.title,
-                                    url: r.url,
-                                    description: r.description,
-                                    hostname: new URL(r.url).hostname,
-                                })),
-                                noResults: directResults.results.length === 0,
+                            const executeSearch = async () => {
+                                var _a;
+                                const directResults = await (0, directSearch_1.directWebSearch)(enhancedQuery, {
+                                    locale: searchOptions.locale || 'us-en',
+                                    safeSearch: (0, directSearch_1.getSafeSearchString)((_a = options.safeSearch) !== null && _a !== void 0 ? _a : constants_1.DEFAULT_PARAMETERS.SAFE_SEARCH),
+                                    maxResults: undefined,
+                                });
+                                const searchResult = {
+                                    results: directResults.results.map(r => ({
+                                        title: r.title,
+                                        url: r.url,
+                                        description: r.description,
+                                        hostname: new URL(r.url).hostname,
+                                    })),
+                                    noResults: directResults.results.length === 0,
+                                };
+                                return searchResult;
                             };
-                            const maxResults = (_f = options.maxResults) !== null && _f !== void 0 ? _f : constants_1.DEFAULT_PARAMETERS.MAX_RESULTS;
+                            if (reliabilityManager) {
+                                result = await reliabilityManager.executeWithRetry(executeSearch, (res) => res.results && res.results.length > 0, `web search: ${enhancedQuery}`);
+                            }
+                            else {
+                                result = await executeSearch();
+                            }
+                            const maxResults = (_e = options.maxResults) !== null && _e !== void 0 ? _e : constants_1.DEFAULT_PARAMETERS.MAX_RESULTS;
                             if (result.results && result.results.length > maxResults) {
                                 result.results = result.results.slice(0, maxResults);
                             }
@@ -1537,7 +1555,7 @@ class DuckDuckGo {
                                     }];
                             }
                             else {
-                                const maxResults = (_g = options.maxResults) !== null && _g !== void 0 ? _g : constants_1.DEFAULT_PARAMETERS.MAX_RESULTS;
+                                const maxResults = (_f = options.maxResults) !== null && _f !== void 0 ? _f : constants_1.DEFAULT_PARAMETERS.MAX_RESULTS;
                                 results = (0, processors_1.processWebSearchResults)(result.results, itemIndex, result).slice(0, maxResults);
                                 if (debugMode && results.length > 0) {
                                     results[0].json.fromCache = result !== undefined;
@@ -1581,7 +1599,7 @@ class DuckDuckGo {
                                 query: enhancedQuery,
                                 durationMs: Date.now() - startTime,
                                 error: errorMessage,
-                                errorType: ((_h = error === null || error === void 0 ? void 0 : error.constructor) === null || _h === void 0 ? void 0 : _h.name) || 'Error',
+                                errorType: ((_g = error === null || error === void 0 ? void 0 : error.constructor) === null || _g === void 0 ? void 0 : _g.name) || 'Error',
                             });
                         }
                     }
@@ -1590,8 +1608,8 @@ class DuckDuckGo {
                     const imageQuery = this.getNodeParameter('imageQuery', itemIndex);
                     const imageSearchOptions = this.getNodeParameter('imageSearchOptions', itemIndex, {});
                     const searchOptions = {
-                        safeSearch: getSafeSearchType((_j = imageSearchOptions.safeSearch) !== null && _j !== void 0 ? _j : constants_1.DEFAULT_PARAMETERS.SAFE_SEARCH),
-                        locale: (_l = (_k = imageSearchOptions.region) !== null && _k !== void 0 ? _k : globalLocale) !== null && _l !== void 0 ? _l : constants_1.DEFAULT_PARAMETERS.REGION,
+                        safeSearch: getSafeSearchType((_h = imageSearchOptions.safeSearch) !== null && _h !== void 0 ? _h : constants_1.DEFAULT_PARAMETERS.SAFE_SEARCH),
+                        locale: (_k = (_j = imageSearchOptions.region) !== null && _j !== void 0 ? _j : globalLocale) !== null && _k !== void 0 ? _k : constants_1.DEFAULT_PARAMETERS.REGION,
                         size: imageSearchOptions.size,
                         color: imageSearchOptions.color,
                         type: imageSearchOptions.type,
@@ -1634,23 +1652,33 @@ class DuckDuckGo {
                                 const logEntry = (0, utils_1.createLogEntry)(utils_1.LogLevel.INFO, `Executing image search for: ${imageQuery}`, operation, { query: imageQuery, options: searchOptions, cacheEnabled: enableCache });
                                 console.log(JSON.stringify(logEntry));
                             }
-                            const directImageResults = await (0, directSearch_1.directImageSearch)(imageQuery, {
-                                locale: searchOptions.locale || 'us-en',
-                                safeSearch: (0, directSearch_1.getSafeSearchString)((_m = imageSearchOptions.safeSearch) !== null && _m !== void 0 ? _m : constants_1.DEFAULT_PARAMETERS.SAFE_SEARCH),
-                                maxResults: undefined,
-                            });
-                            result = {
-                                results: directImageResults.results.map(r => ({
-                                    title: r.title,
-                                    image: r.url,
-                                    thumbnail: r.thumbnail,
-                                    url: r.source,
-                                    height: r.height,
-                                    width: r.width,
-                                })),
-                                noResults: directImageResults.results.length === 0,
+                            const executeImageSearch = async () => {
+                                var _a;
+                                const directImageResults = await (0, directSearch_1.directImageSearch)(imageQuery, {
+                                    locale: searchOptions.locale || 'us-en',
+                                    safeSearch: (0, directSearch_1.getSafeSearchString)((_a = imageSearchOptions.safeSearch) !== null && _a !== void 0 ? _a : constants_1.DEFAULT_PARAMETERS.SAFE_SEARCH),
+                                    maxResults: undefined,
+                                });
+                                const searchResult = {
+                                    results: directImageResults.results.map(r => ({
+                                        title: r.title,
+                                        image: r.url,
+                                        thumbnail: r.thumbnail,
+                                        url: r.source,
+                                        height: r.height,
+                                        width: r.width,
+                                    })),
+                                    noResults: directImageResults.results.length === 0,
+                                };
+                                return searchResult;
                             };
-                            const maxResults = (_o = imageSearchOptions.maxResults) !== null && _o !== void 0 ? _o : constants_1.DEFAULT_PARAMETERS.MAX_RESULTS;
+                            if (reliabilityManager) {
+                                result = await reliabilityManager.executeWithRetry(executeImageSearch, (res) => res.results && res.results.length > 0, `image search: ${imageQuery}`);
+                            }
+                            else {
+                                result = await executeImageSearch();
+                            }
+                            const maxResults = (_l = imageSearchOptions.maxResults) !== null && _l !== void 0 ? _l : constants_1.DEFAULT_PARAMETERS.MAX_RESULTS;
                             if (result.results && result.results.length > maxResults) {
                                 result.results = result.results.slice(0, maxResults);
                             }
@@ -1704,7 +1732,7 @@ class DuckDuckGo {
                                     }];
                             }
                             else {
-                                const maxResults = (_p = imageSearchOptions.maxResults) !== null && _p !== void 0 ? _p : constants_1.DEFAULT_PARAMETERS.MAX_RESULTS;
+                                const maxResults = (_m = imageSearchOptions.maxResults) !== null && _m !== void 0 ? _m : constants_1.DEFAULT_PARAMETERS.MAX_RESULTS;
                                 results = (0, processors_1.processImageSearchResults)(result.results, itemIndex).slice(0, maxResults);
                                 if (debugMode && results.length > 0) {
                                     results[0].json.fromCache = result !== undefined;
@@ -1748,7 +1776,7 @@ class DuckDuckGo {
                                 query: imageQuery,
                                 durationMs: Date.now() - startTime,
                                 error: errorMessage,
-                                errorType: ((_q = error === null || error === void 0 ? void 0 : error.constructor) === null || _q === void 0 ? void 0 : _q.name) || 'Error',
+                                errorType: ((_o = error === null || error === void 0 ? void 0 : error.constructor) === null || _o === void 0 ? void 0 : _o.name) || 'Error',
                             });
                         }
                     }
@@ -1757,16 +1785,16 @@ class DuckDuckGo {
                     const newsQuery = this.getNodeParameter('newsQuery', itemIndex);
                     const newsSearchOptions = this.getNodeParameter('newsSearchOptions', itemIndex, {});
                     const searchOptions = {
-                        safeSearch: getSafeSearchType((_r = newsSearchOptions.safeSearch) !== null && _r !== void 0 ? _r : constants_1.DEFAULT_PARAMETERS.SAFE_SEARCH),
-                        locale: (_t = (_s = newsSearchOptions.region) !== null && _s !== void 0 ? _s : globalLocale) !== null && _t !== void 0 ? _t : constants_1.DEFAULT_PARAMETERS.REGION,
-                        time: getSearchTimeType((_u = newsSearchOptions.timePeriod) !== null && _u !== void 0 ? _u : constants_1.DEFAULT_PARAMETERS.TIME_PERIOD),
+                        safeSearch: getSafeSearchType((_p = newsSearchOptions.safeSearch) !== null && _p !== void 0 ? _p : constants_1.DEFAULT_PARAMETERS.SAFE_SEARCH),
+                        locale: (_r = (_q = newsSearchOptions.region) !== null && _q !== void 0 ? _q : globalLocale) !== null && _r !== void 0 ? _r : constants_1.DEFAULT_PARAMETERS.REGION,
+                        time: getSearchTimeType((_s = newsSearchOptions.timePeriod) !== null && _s !== void 0 ? _s : constants_1.DEFAULT_PARAMETERS.TIME_PERIOD),
                     };
                     if (apiKey) {
                         searchOptions.headers = {
                             Authorization: `Bearer ${apiKey}`,
                         };
                     }
-                    const maxResults = (_v = newsSearchOptions.maxResults) !== null && _v !== void 0 ? _v : constants_1.DEFAULT_PARAMETERS.MAX_RESULTS;
+                    const maxResults = (_t = newsSearchOptions.maxResults) !== null && _t !== void 0 ? _t : constants_1.DEFAULT_PARAMETERS.MAX_RESULTS;
                     const cacheKey = JSON.stringify({
                         operation,
                         query: newsQuery,
@@ -1798,7 +1826,16 @@ class DuckDuckGo {
                                 const logEntry = (0, utils_1.createLogEntry)(utils_1.LogLevel.INFO, `Executing news search for: ${newsQuery}`, operation, { query: newsQuery, options: searchOptions, cacheEnabled: enableCache });
                                 console.log(JSON.stringify(logEntry));
                             }
-                            result = await (0, duck_duck_scrape_1.searchNews)(newsQuery, searchOptions);
+                            const executeNewsSearch = async () => {
+                                const searchResult = await (0, duck_duck_scrape_1.searchNews)(newsQuery, searchOptions);
+                                return searchResult;
+                            };
+                            if (reliabilityManager) {
+                                result = await reliabilityManager.executeWithRetry(executeNewsSearch, (res) => res.results && res.results.length > 0, `news search: ${newsQuery}`);
+                            }
+                            else {
+                                result = await executeNewsSearch();
+                            }
                             if (newsSearchOptions.maxResults !== undefined && result.results && result.results.length > 0) {
                                 let page = 2;
                                 const maxPages = Math.ceil(maxResults / 10);
@@ -1891,7 +1928,7 @@ class DuckDuckGo {
                                     }];
                             }
                             else {
-                                const maxResults = (_w = newsSearchOptions.maxResults) !== null && _w !== void 0 ? _w : constants_1.DEFAULT_PARAMETERS.MAX_RESULTS;
+                                const maxResults = (_u = newsSearchOptions.maxResults) !== null && _u !== void 0 ? _u : constants_1.DEFAULT_PARAMETERS.MAX_RESULTS;
                                 results = (0, processors_1.processNewsSearchResults)(result.results, itemIndex).slice(0, maxResults);
                                 if (debugMode && results.length > 0) {
                                     results[0].json.fromCache = result !== undefined;
@@ -1925,7 +1962,7 @@ class DuckDuckGo {
                                     image: '',
                                     source: 'DuckDuckGo Fallback',
                                 }));
-                                results = (0, processors_1.processNewsSearchResults)(newsResults, itemIndex).slice(0, (_x = newsSearchOptions.maxResults) !== null && _x !== void 0 ? _x : constants_1.DEFAULT_PARAMETERS.MAX_RESULTS);
+                                results = (0, processors_1.processNewsSearchResults)(newsResults, itemIndex).slice(0, (_v = newsSearchOptions.maxResults) !== null && _v !== void 0 ? _v : constants_1.DEFAULT_PARAMETERS.MAX_RESULTS);
                                 if (enableTelemetry) {
                                     await (0, telemetry_1.reportEvent)(this, 'search_completed', {
                                         operation,
@@ -1966,7 +2003,7 @@ class DuckDuckGo {
                                 query: newsQuery,
                                 durationMs: Date.now() - startTime,
                                 error: errorMessage,
-                                errorType: ((_y = error === null || error === void 0 ? void 0 : error.constructor) === null || _y === void 0 ? void 0 : _y.name) || 'Error',
+                                errorType: ((_w = error === null || error === void 0 ? void 0 : error.constructor) === null || _w === void 0 ? void 0 : _w.name) || 'Error',
                             });
                         }
                     }
@@ -1975,14 +2012,14 @@ class DuckDuckGo {
                     const videoQuery = this.getNodeParameter('videoQuery', itemIndex);
                     const videoSearchOptions = this.getNodeParameter('videoSearchOptions', itemIndex, {});
                     const searchOptions = {
-                        safeSearch: getSafeSearchType((_z = videoSearchOptions.safeSearch) !== null && _z !== void 0 ? _z : constants_1.DEFAULT_PARAMETERS.SAFE_SEARCH),
-                        locale: (_1 = (_0 = videoSearchOptions.region) !== null && _0 !== void 0 ? _0 : globalLocale) !== null && _1 !== void 0 ? _1 : constants_1.DEFAULT_PARAMETERS.REGION,
-                        time: getSearchTimeType((_2 = videoSearchOptions.timePeriod) !== null && _2 !== void 0 ? _2 : constants_1.DEFAULT_PARAMETERS.TIME_PERIOD),
+                        safeSearch: getSafeSearchType((_x = videoSearchOptions.safeSearch) !== null && _x !== void 0 ? _x : constants_1.DEFAULT_PARAMETERS.SAFE_SEARCH),
+                        locale: (_z = (_y = videoSearchOptions.region) !== null && _y !== void 0 ? _y : globalLocale) !== null && _z !== void 0 ? _z : constants_1.DEFAULT_PARAMETERS.REGION,
+                        time: getSearchTimeType((_0 = videoSearchOptions.timePeriod) !== null && _0 !== void 0 ? _0 : constants_1.DEFAULT_PARAMETERS.TIME_PERIOD),
                         definition: getVideoDefinition(videoSearchOptions.quality),
                         duration: getVideoDuration(videoSearchOptions.length),
                         license: getVideoLicense(videoSearchOptions.resolution),
                     };
-                    const maxResults = (_3 = videoSearchOptions.maxResults) !== null && _3 !== void 0 ? _3 : constants_1.DEFAULT_PARAMETERS.MAX_RESULTS;
+                    const maxResults = (_1 = videoSearchOptions.maxResults) !== null && _1 !== void 0 ? _1 : constants_1.DEFAULT_PARAMETERS.MAX_RESULTS;
                     if (apiKey) {
                         searchOptions.headers = {
                             Authorization: `Bearer ${apiKey}`,
@@ -2019,7 +2056,16 @@ class DuckDuckGo {
                                 const logEntry = (0, utils_1.createLogEntry)(utils_1.LogLevel.INFO, `Executing video search for: ${videoQuery}`, operation, { query: videoQuery, options: searchOptions, cacheEnabled: enableCache });
                                 console.log(JSON.stringify(logEntry));
                             }
-                            result = await (0, duck_duck_scrape_1.searchVideos)(videoQuery, searchOptions);
+                            const executeVideoSearch = async () => {
+                                const searchResult = await (0, duck_duck_scrape_1.searchVideos)(videoQuery, searchOptions);
+                                return searchResult;
+                            };
+                            if (reliabilityManager) {
+                                result = await reliabilityManager.executeWithRetry(executeVideoSearch, (res) => res.results && res.results.length > 0, `video search: ${videoQuery}`);
+                            }
+                            else {
+                                result = await executeVideoSearch();
+                            }
                             if (videoSearchOptions.maxResults !== undefined && result.results && result.results.length > 0) {
                                 let page = 2;
                                 const maxPages = Math.ceil(maxResults / 10);
@@ -2112,7 +2158,7 @@ class DuckDuckGo {
                                     }];
                             }
                             else {
-                                const maxResults = (_4 = videoSearchOptions.maxResults) !== null && _4 !== void 0 ? _4 : constants_1.DEFAULT_PARAMETERS.MAX_RESULTS;
+                                const maxResults = (_2 = videoSearchOptions.maxResults) !== null && _2 !== void 0 ? _2 : constants_1.DEFAULT_PARAMETERS.MAX_RESULTS;
                                 results = (0, processors_1.processVideoSearchResults)(result.results, itemIndex).slice(0, maxResults);
                                 if (debugMode && results.length > 0) {
                                     results[0].json.fromCache = result !== undefined;
@@ -2157,7 +2203,7 @@ class DuckDuckGo {
                                     title: item.title,
                                     uploader: 'Web',
                                 }));
-                                results = (0, processors_1.processVideoSearchResults)(videoResults, itemIndex).slice(0, (_5 = videoSearchOptions.maxResults) !== null && _5 !== void 0 ? _5 : constants_1.DEFAULT_PARAMETERS.MAX_RESULTS);
+                                results = (0, processors_1.processVideoSearchResults)(videoResults, itemIndex).slice(0, (_3 = videoSearchOptions.maxResults) !== null && _3 !== void 0 ? _3 : constants_1.DEFAULT_PARAMETERS.MAX_RESULTS);
                                 if (enableTelemetry) {
                                     await (0, telemetry_1.reportEvent)(this, 'search_completed', {
                                         operation,
@@ -2198,7 +2244,7 @@ class DuckDuckGo {
                                 query: videoQuery,
                                 durationMs: Date.now() - startTime,
                                 error: errorMessage,
-                                errorType: ((_6 = error === null || error === void 0 ? void 0 : error.constructor) === null || _6 === void 0 ? void 0 : _6.name) || 'Error',
+                                errorType: ((_4 = error === null || error === void 0 ? void 0 : error.constructor) === null || _4 === void 0 ? void 0 : _4.name) || 'Error',
                             });
                         }
                     }
@@ -2241,7 +2287,7 @@ class DuckDuckGo {
                 if (enableTelemetry) {
                     await (0, telemetry_1.reportEvent)(this, 'node_error', {
                         error: error instanceof Error ? error.message : String(error),
-                        errorType: ((_7 = error === null || error === void 0 ? void 0 : error.constructor) === null || _7 === void 0 ? void 0 : _7.name) || 'Error',
+                        errorType: ((_5 = error === null || error === void 0 ? void 0 : error.constructor) === null || _5 === void 0 ? void 0 : _5.name) || 'Error',
                     });
                 }
                 throw new n8n_workflow_1.NodeOperationError(this.getNode(), error, { itemIndex });

package/dist/nodes/DuckDuckGo/__tests__/DuckDuckGo.test.js

@@ -27,6 +27,7 @@ const DuckDuckGo_node_1 = require("../DuckDuckGo.node");
 const duckDuckScrape = __importStar(require("duck-duck-scrape"));
 const cache = __importStar(require("../cache"));
 const directSearch = __importStar(require("../directSearch"));
+const reliabilityManager_1 = require("../reliabilityManager");
 jest.mock('duck-duck-scrape', () => ({
     search: jest.fn(),
     searchNews: jest.fn(),
@@ -110,6 +111,7 @@ describe('DuckDuckGo Node', () => {
             },
         };
         jest.clearAllMocks();
+        (0, reliabilityManager_1.resetGlobalReliabilityManager)();
     });
     const setupNodeParameters = (operation, query, options = {}, additionalParams = {}) => {
         mockGetNodeParameter.mockImplementation((parameter, _itemIndex, fallback) => {

package/dist/nodes/DuckDuckGo/__tests__/reliabilityManagerIntegration.test.js

@@ -0,0 +1,297 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const reliabilityManager_1 = require("../reliabilityManager");
+const directSearch = __importStar(require("../directSearch"));
+jest.mock('../directSearch');
+describe('Reliability Manager Integration', () => {
+    let mockDirectWebSearch;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockDirectWebSearch = directSearch.directWebSearch;
+    });
+    describe('executeWithRetry integration', () => {
+        it('should call directWebSearch through reliability manager', async () => {
+            const manager = new reliabilityManager_1.ReliabilityManager({
+                maxRetries: 2,
+                retryDelayMs: 100,
+            });
+            mockDirectWebSearch.mockResolvedValue({
+                results: [
+                    { title: 'Result 1', url: 'https://example.com/1', description: 'Test' }
+                ]
+            });
+            const executeSearch = async () => {
+                const result = await mockDirectWebSearch('test query', {
+                    locale: 'us-en',
+                    safeSearch: 'moderate',
+                });
+                return {
+                    results: result.results,
+                    noResults: result.results.length === 0,
+                };
+            };
+            const result = await manager.executeWithRetry(executeSearch, (res) => res.results && res.results.length > 0, 'test search');
+            expect(mockDirectWebSearch).toHaveBeenCalledTimes(1);
+            expect(result.results).toHaveLength(1);
+            expect(manager.getMetrics().totalRequests).toBe(1);
+            expect(manager.getMetrics().emptyResponses).toBe(0);
+        });
+        it('should retry on empty results', async () => {
+            const manager = new reliabilityManager_1.ReliabilityManager({
+                maxRetries: 3,
+                retryDelayMs: 10,
+                emptyResultThreshold: 2,
+            });
+            mockDirectWebSearch
+                .mockResolvedValueOnce({ results: [] })
+                .mockResolvedValueOnce({ results: [] })
+                .mockResolvedValueOnce({
+                results: [
+                    { title: 'Result 1', url: 'https://example.com/1', description: 'Test' }
+                ]
+            });
+            const executeSearch = async () => {
+                const result = await mockDirectWebSearch('test query', {
+                    locale: 'us-en',
+                    safeSearch: 'moderate',
+                });
+                return {
+                    results: result.results,
+                    noResults: result.results.length === 0,
+                };
+            };
+            const result = await manager.executeWithRetry(executeSearch, (res) => res.results && res.results.length > 0, 'test search');
+            expect(mockDirectWebSearch).toHaveBeenCalledTimes(3);
+            expect(result.results).toHaveLength(1);
+            expect(manager.getMetrics().retriesExecuted).toBe(2);
+        });
+        it('should record failures and respect circuit breaker', async () => {
+            const manager = new reliabilityManager_1.ReliabilityManager({
+                failureThreshold: 4,
+                resetTimeoutMs: 1000,
+                maxRetries: 1,
+                retryDelayMs: 10,
+            });
+            mockDirectWebSearch.mockRejectedValue(new Error('Network error'));
+            const executeSearch = async () => {
+                const result = await mockDirectWebSearch('test query', {
+                    locale: 'us-en',
+                    safeSearch: 'moderate',
+                });
+                return {
+                    results: result.results,
+                    noResults: result.results.length === 0,
+                };
+            };
+            await expect(manager.executeWithRetry(executeSearch, (res) => res.results && res.results.length > 0, 'test search')).rejects.toThrow('Network error');
+            await expect(manager.executeWithRetry(executeSearch, (res) => res.results && res.results.length > 0, 'test search')).rejects.toThrow('Network error');
+            expect(manager.getCircuitState()).toBe('open');
+            expect(manager.getMetrics().circuitBreakerTrips).toBeGreaterThan(0);
+            await expect(manager.executeWithRetry(executeSearch, (res) => res.results && res.results.length > 0, 'test search')).rejects.toThrow('Circuit breaker is OPEN');
+        });
+        it('should apply jitter and backoff on consecutive empty results', async () => {
+            const manager = new reliabilityManager_1.ReliabilityManager({
+                emptyResultThreshold: 2,
+                initialBackoffMs: 100,
+                maxBackoffMs: 1000,
+                minJitterMs: 10,
+                maxJitterMs: 50,
+                maxRetries: 0,
+            });
+            mockDirectWebSearch.mockResolvedValue({ results: [] });
+            const executeSearch = async () => {
+                const result = await mockDirectWebSearch('test query', {
+                    locale: 'us-en',
+                    safeSearch: 'moderate',
+                });
+                return {
+                    results: result.results,
+                    noResults: result.results.length === 0,
+                };
+            };
+            await manager.executeWithRetry(executeSearch, (res) => res.results && res.results.length > 0, 'test search');
+            await manager.executeWithRetry(executeSearch, (res) => res.results && res.results.length > 0, 'test search');
+            let metrics = manager.getMetrics();
+            expect(metrics.consecutiveEmptyResponses).toBe(2);
+            expect(metrics.emptyResponses).toBe(2);
+            const startTime = Date.now();
+            await manager.executeWithRetry(executeSearch, (res) => res.results && res.results.length > 0, 'test search');
+            const elapsed = Date.now() - startTime;
+            metrics = manager.getMetrics();
+            expect(elapsed).toBeGreaterThanOrEqual(100);
+            expect(metrics.backoffActivations).toBeGreaterThan(0);
+        });
+    });
+    describe('metrics tracking', () => {
+        it('should track response times', async () => {
+            const manager = new reliabilityManager_1.ReliabilityManager();
+            mockDirectWebSearch.mockImplementation(async () => {
+                await new Promise(resolve => setTimeout(resolve, 50));
+                return { results: [{ title: 'Test', url: 'https://example.com', description: 'Test' }] };
+            });
+            const executeSearch = async () => {
+                const result = await mockDirectWebSearch('test query', {
+                    locale: 'us-en',
+                    safeSearch: 'moderate',
+                });
+                return {
+                    results: result.results,
+                    noResults: result.results.length === 0,
+                };
+            };
+            await manager.executeWithRetry(executeSearch, (res) => res.results && res.results.length > 0, 'test search');
+            const metrics = manager.getMetrics();
+            expect(metrics.averageResponseTimeMs).toBeGreaterThan(0);
+            expect(metrics.totalRequests).toBe(1);
+        });
+    });
+    describe('CRITICAL: No Double-Counting of Metrics', () => {
+        it('should count each request exactly once (not doubled)', async () => {
+            const manager = new reliabilityManager_1.ReliabilityManager({
+                maxRetries: 0,
+            });
+            mockDirectWebSearch.mockResolvedValue({
+                results: [{ title: 'Test', url: 'https://example.com', description: 'Test' }]
+            });
+            const executeSearch = async () => {
+                const result = await mockDirectWebSearch('test query', {
+                    locale: 'us-en',
+                    safeSearch: 'moderate',
+                });
+                return {
+                    results: result.results,
+                    noResults: result.results.length === 0,
+                };
+            };
+            for (let i = 0; i < 5; i++) {
+                await manager.executeWithRetry(executeSearch, (res) => res.results && res.results.length > 0, 'test search');
+            }
+            const metrics = manager.getMetrics();
+            expect(metrics.totalRequests).toBe(5);
+            expect(metrics.emptyResponses).toBe(0);
+            expect(metrics.consecutiveEmptyResponses).toBe(0);
+        });
+        it('should count empty responses exactly once per request', async () => {
+            const manager = new reliabilityManager_1.ReliabilityManager({
+                maxRetries: 0,
+                emptyResultThreshold: 10,
+            });
+            mockDirectWebSearch.mockResolvedValue({ results: [] });
+            const executeSearch = async () => {
+                const result = await mockDirectWebSearch('test query', {
+                    locale: 'us-en',
+                    safeSearch: 'moderate',
+                });
+                return {
+                    results: result.results,
+                    noResults: result.results.length === 0,
+                };
+            };
+            for (let i = 0; i < 7; i++) {
+                await manager.executeWithRetry(executeSearch, (res) => res.results && res.results.length > 0, 'test search');
+            }
+            const metrics = manager.getMetrics();
+            expect(metrics.totalRequests).toBe(7);
+            expect(metrics.emptyResponses).toBe(7);
+            expect(metrics.consecutiveEmptyResponses).toBe(7);
+        });
+        it('should trip circuit breaker at exact configured threshold', async () => {
+            const manager = new reliabilityManager_1.ReliabilityManager({
+                failureThreshold: 10,
+                resetTimeoutMs: 60000,
+                maxRetries: 0,
+            });
+            mockDirectWebSearch.mockRejectedValue(new Error('Network error'));
+            const executeSearch = async () => {
+                const result = await mockDirectWebSearch('test query', {
+                    locale: 'us-en',
+                    safeSearch: 'moderate',
+                });
+                return {
+                    results: result.results,
+                    noResults: result.results.length === 0,
+                };
+            };
+            for (let i = 0; i < 5; i++) {
+                try {
+                    await manager.executeWithRetry(executeSearch, (res) => res.results && res.results.length > 0, 'test search');
+                }
+                catch (error) {
+                }
+            }
+            expect(manager.getCircuitState()).toBe('closed');
+            const metricsAfter5 = manager.getMetrics();
+            expect(metricsAfter5.totalRequests).toBe(5);
+            for (let i = 0; i < 5; i++) {
+                try {
+                    await manager.executeWithRetry(executeSearch, (res) => res.results && res.results.length > 0, 'test search');
+                }
+                catch (error) {
+                }
+            }
+            expect(manager.getCircuitState()).toBe('open');
+            const metricsAfter10 = manager.getMetrics();
+            expect(metricsAfter10.totalRequests).toBe(10);
+            expect(metricsAfter10.circuitBreakerTrips).toBeGreaterThan(0);
+        });
+        it('should trigger backoff at exact configured threshold', async () => {
+            const manager = new reliabilityManager_1.ReliabilityManager({
+                emptyResultThreshold: 2,
+                initialBackoffMs: 500,
+                maxBackoffMs: 5000,
+                minJitterMs: 0,
+                maxJitterMs: 0,
+                maxRetries: 0,
+            });
+            mockDirectWebSearch.mockResolvedValue({ results: [] });
+            const executeSearch = async () => {
+                const result = await mockDirectWebSearch('test query', {
+                    locale: 'us-en',
+                    safeSearch: 'moderate',
+                });
+                return {
+                    results: result.results,
+                    noResults: result.results.length === 0,
+                };
+            };
+            await manager.executeWithRetry(executeSearch, (res) => res.results && res.results.length > 0, 'test search');
+            let metricsAfter1 = manager.getMetrics();
+            expect(metricsAfter1.consecutiveEmptyResponses).toBe(1);
+            expect(metricsAfter1.backoffActivations).toBe(0);
+            await manager.executeWithRetry(executeSearch, (res) => res.results && res.results.length > 0, 'test search');
+            let metricsAfter2 = manager.getMetrics();
+            expect(metricsAfter2.consecutiveEmptyResponses).toBe(2);
+            expect(metricsAfter2.backoffActivations).toBe(0);
+            const startTime = Date.now();
+            await manager.executeWithRetry(executeSearch, (res) => res.results && res.results.length > 0, 'test search');
+            const elapsed = Date.now() - startTime;
+            const metricsAfter3 = manager.getMetrics();
+            expect(metricsAfter3.consecutiveEmptyResponses).toBe(3);
+            expect(metricsAfter3.backoffActivations).toBe(1);
+            expect(elapsed).toBeGreaterThanOrEqual(500);
+        });
+    });
+});

package/dist/nodes/DuckDuckGo/reliabilityManager.js

@@ -9,17 +9,23 @@ var CircuitState;
 })(CircuitState = exports.CircuitState || (exports.CircuitState = {}));
 class ReliabilityManager {
     constructor(config) {
+        const isTest = process.env.NODE_ENV === 'test' || process.env.JEST_WORKER_ID !== undefined;
+        const defaultRetryDelay = isTest ? 1 : 1000;
+        const defaultInitialBackoff = isTest ? 1 : 1000;
+        const defaultMaxBackoff = isTest ? 10 : 30000;
+        const defaultMinJitter = isTest ? 0 : 100;
+        const defaultMaxJitter = isTest ? 1 : 500;
         this.config = {
             emptyResultThreshold: 3,
-            initialBackoffMs: 1000,
-            maxBackoffMs: 30000,
+            initialBackoffMs: defaultInitialBackoff,
+            maxBackoffMs: defaultMaxBackoff,
             backoffMultiplier: 2,
-            minJitterMs: 100,
-            maxJitterMs: 500,
+            minJitterMs: defaultMinJitter,
+            maxJitterMs: defaultMaxJitter,
             failureThreshold: 5,
             resetTimeoutMs: 60000,
             maxRetries: 3,
-            retryDelayMs: 1000,
+            retryDelayMs: defaultRetryDelay,
             ...config,
         };
         this.metrics = {
@@ -190,7 +196,10 @@ class ReliabilityManager {
             }
             attempt++;
         }
-        throw lastError || new Error('Max retries exceeded');
+        if (lastError) {
+            throw lastError;
+        }
+        throw new Error('Max retries exceeded');
     }
     getSummary() {
         const { metrics, circuitState } = this;

package/dist/package.json

@@ -1,6 +1,6 @@
 {
     "name": "n8n-nodes-duckduckgo-search",
-    "version": "31.0.0",
+    "version": "31.0.1",
     "description": "Production-grade, AI Agent-ready n8n community node for DuckDuckGo search. Features enterprise reliability with adaptive backoff, circuit breaking, and intelligent rate limiting. Search the web, images, news, and videos with privacy-focused, highly reliable results.",
     "keywords": [
         "n8n-community-node-package",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "n8n-nodes-duckduckgo-search",
-  "version": "31.0.0",
+  "version": "31.0.1",
   "description": "Production-grade, AI Agent-ready n8n community node for DuckDuckGo search. Features enterprise reliability with adaptive backoff, circuit breaking, and intelligent rate limiting. Search the web, images, news, and videos with privacy-focused, highly reliable results.",
   "keywords": [
     "n8n-community-node-package",