n8n-nodes-crawl4ai-plus 2.0.9 → 3.0.0

package/dist/nodes/Crawl4aiPlusBasicCrawler/actions/crawlSingleUrl.operation.js

@@ -54,7 +54,7 @@ exports.description = [
                     },
                 ],
                 default: 'chromium',
-                description: 'Which browser engine to use for crawling',
+                description: 'Which browser engine to use for crawling. Default: Chromium (if not specified).',
             },
             {
                 displayName: 'Enable JavaScript',
@@ -70,6 +70,32 @@ exports.description = [
                 default: false,
                 description: 'Whether to enable stealth mode to bypass basic bot detection (hides webdriver properties and modifies browser fingerprints)',
             },
+            {
+                displayName: 'Extra Browser Arguments',
+                name: 'extraArgs',
+                type: 'fixedCollection',
+                typeOptions: {
+                    multipleValues: true,
+                },
+                default: {},
+                description: 'Additional command-line arguments to pass to the browser (advanced users only)',
+                options: [
+                    {
+                        name: 'args',
+                        displayName: 'Arguments',
+                        values: [
+                            {
+                                displayName: 'Argument',
+                                name: 'value',
+                                type: 'string',
+                                default: '',
+                                placeholder: '--disable-blink-features=AutomationControlled',
+                                description: 'Browser command-line argument (e.g., --disable-blink-features=AutomationControlled)',
+                            },
+                        ],
+                    },
+                ],
+            },
             {
                 displayName: 'Headless Mode',
                 name: 'headless',
@@ -108,6 +134,71 @@ exports.description = [
             },
         ],
     },
+    {
+        displayName: 'Session & Authentication',
+        name: 'sessionOptions',
+        type: 'collection',
+        placeholder: 'Add Option',
+        default: {},
+        displayOptions: {
+            show: {
+                operation: ['crawlSingleUrl'],
+            },
+        },
+        options: [
+            {
+                displayName: 'Cookies',
+                name: 'cookies',
+                type: 'json',
+                default: '',
+                placeholder: '[{"name": "session_id", "value": "abc123", "domain": ".example.com", "path": "/"}]',
+                description: 'Array of cookie objects to inject. Alternative to storage state for simple cookie-based auth.',
+            },
+            {
+                displayName: 'Storage State (JSON)',
+                name: 'storageState',
+                type: 'string',
+                typeOptions: {
+                    rows: 6,
+                },
+                default: '',
+                placeholder: '{"cookies": [...], "origins": [...]}',
+                description: 'Browser storage state as JSON (cookies, localStorage, sessionStorage). Captures authenticated session state. Works in all n8n environments.',
+            },
+            {
+                displayName: 'Use Managed Browser',
+                name: 'useManagedBrowser',
+                type: 'boolean',
+                default: false,
+                description: 'Whether to use managed browser mode (required for persistent contexts). Advanced option.',
+                displayOptions: {
+                    show: {
+                        usePersistentContext: [true],
+                    },
+                },
+            },
+            {
+                displayName: 'Use Persistent Browser Context',
+                name: 'usePersistentContext',
+                type: 'boolean',
+                default: false,
+                description: 'Whether to use a persistent browser context (requires user data directory). Only use in self-hosted environments with persistent storage.',
+            },
+            {
+                displayName: 'User Data Directory',
+                name: 'userDataDir',
+                type: 'string',
+                default: '',
+                placeholder: '/data/browser-profiles/profile1',
+                description: 'Path to browser profile directory for persistent sessions. Advanced: Only works in self-hosted n8n with persistent volumes. Use Storage State for cloud deployments.',
+                displayOptions: {
+                    show: {
+                        usePersistentContext: [true],
+                    },
+                },
+            },
+        ],
+    },
     {
         displayName: 'Crawler Options',
         name: 'crawlerOptions',
@@ -249,8 +340,8 @@ exports.description = [
         ],
     },
     {
-        displayName: 'Options',
-        name: 'options',
+        displayName: 'Output Options',
+        name: 'outputOptions',
         type: 'collection',
         placeholder: 'Add Option',
         default: {},
@@ -260,12 +351,71 @@ exports.description = [
             },
         },
         options: [
+            {
+                displayName: 'Capture Screenshot',
+                name: 'screenshot',
+                type: 'boolean',
+                default: false,
+                description: 'Whether to capture a screenshot of the page (returned as base64)',
+            },
+            {
+                displayName: 'Fetch SSL Certificate',
+                name: 'fetchSslCertificate',
+                type: 'boolean',
+                default: false,
+                description: 'Whether to retrieve SSL certificate information from the server',
+            },
+            {
+                displayName: 'Generate PDF',
+                name: 'pdf',
+                type: 'boolean',
+                default: false,
+                description: 'Whether to generate a PDF of the page (returned as base64 or binary)',
+            },
+            {
+                displayName: 'Include Links',
+                name: 'includeLinks',
+                type: 'boolean',
+                default: true,
+                description: 'Whether to include structured internal/external links data in output',
+            },
             {
                 displayName: 'Include Media Data',
                 name: 'includeMedia',
                 type: 'boolean',
                 default: false,
-                description: 'Whether to include media data in output (images, videos)',
+                description: 'Whether to include media data in output (images, videos, audios)',
+            },
+            {
+                displayName: 'Include Tables',
+                name: 'includeTables',
+                type: 'boolean',
+                default: true,
+                description: 'Whether to include extracted tables in the output (if table extraction is enabled)',
+            },
+            {
+                displayName: 'Markdown Output',
+                name: 'markdownOutput',
+                type: 'options',
+                options: [
+                    {
+                        name: 'Raw Markdown',
+                        value: 'raw',
+                        description: 'Return raw markdown (default, full content)',
+                    },
+                    {
+                        name: 'Filtered Markdown',
+                        value: 'fit',
+                        description: 'Return content-filtered markdown (cleaner, main content only)',
+                    },
+                    {
+                        name: 'Both',
+                        value: 'both',
+                        description: 'Return both raw and filtered markdown variants',
+                    },
+                ],
+                default: 'raw',
+                description: 'Which markdown variant(s) to return in the output',
             },
             {
                 displayName: 'Verbose Response',
@@ -276,30 +426,586 @@ exports.description = [
             },
         ],
     },
+    {
+        displayName: 'Content Filter',
+        name: 'contentFilter',
+        type: 'collection',
+        placeholder: 'Add Filter',
+        default: {},
+        displayOptions: {
+            show: {
+                operation: ['crawlSingleUrl'],
+            },
+        },
+        options: [
+            {
+                displayName: 'BM25 Threshold',
+                name: 'bm25Threshold',
+                type: 'number',
+                default: 1.0,
+                displayOptions: {
+                    show: {
+                        filterType: ['bm25'],
+                    },
+                },
+                description: 'Minimum BM25 score threshold for content inclusion (default: 1.0)',
+            },
+            {
+                displayName: 'Chunk Token Threshold',
+                name: 'chunkTokenThreshold',
+                type: 'number',
+                displayOptions: {
+                    show: {
+                        filterType: ['llm'],
+                    },
+                },
+                default: 8192,
+                description: 'Maximum tokens per chunk for LLM processing (default: 8192, recommended: 4096-16384)',
+            },
+            {
+                displayName: 'Filter Type',
+                name: 'filterType',
+                type: 'options',
+                options: [
+                    {
+                        name: 'None',
+                        value: 'none',
+                        description: 'No content filtering (return all content)',
+                    },
+                    {
+                        name: 'Pruning Filter',
+                        value: 'pruning',
+                        description: 'Remove low-value content using relevance thresholds',
+                    },
+                    {
+                        name: 'BM25 Filter',
+                        value: 'bm25',
+                        description: 'Filter content based on query relevance using BM25 algorithm',
+                    },
+                    {
+                        name: 'LLM Filter',
+                        value: 'llm',
+                        description: 'Intelligent content filtering using LLM (requires LLM credentials)',
+                    },
+                ],
+                default: 'none',
+                description: 'Type of content filtering to apply',
+            },
+            {
+                displayName: 'Ignore Cache',
+                name: 'ignoreCache',
+                type: 'boolean',
+                displayOptions: {
+                    show: {
+                        filterType: ['llm'],
+                    },
+                },
+                default: false,
+                description: 'Whether to skip cache and always generate fresh filtered content',
+            },
+            {
+                displayName: 'Ignore Links',
+                name: 'ignoreLinks',
+                type: 'boolean',
+                default: false,
+                description: 'Whether to exclude links from markdown output',
+            },
+            {
+                displayName: 'LLM Instruction',
+                name: 'llmInstruction',
+                type: 'string',
+                typeOptions: {
+                    rows: 8,
+                },
+                displayOptions: {
+                    show: {
+                        filterType: ['llm'],
+                    },
+                },
+                default: `Extract the main content while preserving its original wording and substance completely.
+Remove only clearly irrelevant elements like:
+- Navigation menus
+- Advertisement sections
+- Cookie notices
+- Footers with site information
+- Sidebars with external links
+- Any UI elements that don't contribute to the content
+
+Keep all valuable educational or informational content intact.`,
+                description: 'Instructions for the LLM on how to filter and clean the content',
+                required: true,
+            },
+            {
+                displayName: 'LLM Verbose',
+                name: 'llmVerbose',
+                type: 'boolean',
+                displayOptions: {
+                    show: {
+                        filterType: ['llm'],
+                    },
+                },
+                default: false,
+                description: 'Whether to enable verbose logging for LLM content filtering',
+            },
+            {
+                displayName: 'Min Word Threshold',
+                name: 'minWordThreshold',
+                type: 'number',
+                default: 0,
+                displayOptions: {
+                    show: {
+                        filterType: ['pruning'],
+                    },
+                },
+                description: 'Minimum word count for content blocks to be considered (0 = no minimum)',
+            },
+            {
+                displayName: 'Threshold',
+                name: 'threshold',
+                type: 'number',
+                default: 0.48,
+                displayOptions: {
+                    show: {
+                        filterType: ['pruning'],
+                    },
+                },
+                description: 'Relevance threshold for pruning (0.0-1.0, default: 0.48). Higher values = more aggressive filtering.',
+            },
+            {
+                displayName: 'Threshold Type',
+                name: 'thresholdType',
+                type: 'options',
+                options: [
+                    {
+                        name: 'Fixed',
+                        value: 'fixed',
+                        description: 'Use fixed threshold value',
+                    },
+                    {
+                        name: 'Dynamic',
+                        value: 'dynamic',
+                        description: 'Calculate threshold dynamically based on content',
+                    },
+                ],
+                default: 'fixed',
+                displayOptions: {
+                    show: {
+                        filterType: ['pruning'],
+                    },
+                },
+                description: 'How to apply the pruning threshold',
+            },
+            {
+                displayName: 'User Query',
+                name: 'userQuery',
+                type: 'string',
+                default: '',
+                placeholder: 'main content topics keywords',
+                displayOptions: {
+                    show: {
+                        filterType: ['bm25'],
+                    },
+                },
+                description: 'Query string to filter relevant content (BM25 will rank content by relevance to this query)',
+            },
+        ],
+    },
+    {
+        displayName: 'Advanced Options',
+        name: 'advancedOptions',
+        type: 'collection',
+        placeholder: 'Add Option',
+        default: {},
+        displayOptions: {
+            show: {
+                operation: ['crawlSingleUrl'],
+            },
+        },
+        options: [
+            {
+                displayName: 'Anti-Bot Features',
+                name: 'antiBotFeatures',
+                type: 'fixedCollection',
+                default: {},
+                options: [
+                    {
+                        name: 'features',
+                        displayName: 'Features',
+                        values: [
+                            {
+                                displayName: 'Magic Mode',
+                                name: 'magic',
+                                type: 'boolean',
+                                default: false,
+                                description: 'Whether to enable anti-detection techniques (stealth++)',
+                            },
+                            {
+                                displayName: 'Simulate User Behavior',
+                                name: 'simulateUser',
+                                type: 'boolean',
+                                default: false,
+                                description: 'Whether to simulate human-like browsing behavior',
+                            },
+                            {
+                                displayName: 'Override Navigator',
+                                name: 'overrideNavigator',
+                                type: 'boolean',
+                                default: false,
+                                description: 'Whether to override navigator properties to avoid detection',
+                            },
+                        ],
+                    },
+                ],
+            },
+            {
+                displayName: 'Delay Before Return (Ms)',
+                name: 'delayBeforeReturnHtml',
+                type: 'number',
+                default: 0,
+                description: 'Milliseconds to wait before returning HTML (useful for dynamic content)',
+            },
+            {
+                displayName: 'Exclude External Images',
+                name: 'excludeExternalImages',
+                type: 'boolean',
+                default: false,
+                description: 'Whether to exclude images hosted on external domains',
+            },
+            {
+                displayName: 'Exclude Social Media Links',
+                name: 'excludeSocialMediaLinks',
+                type: 'boolean',
+                default: false,
+                description: 'Whether to exclude links to social media platforms',
+            },
+            {
+                displayName: 'Verbose Mode',
+                name: 'verbose',
+                type: 'boolean',
+                default: false,
+                description: 'Whether to enable verbose logging (debug mode)',
+            },
+            {
+                displayName: 'Wait Until',
+                name: 'waitUntil',
+                type: 'options',
+                options: [
+                    {
+                        name: 'Load',
+                        value: 'load',
+                        description: 'Wait for the load event',
+                    },
+                    {
+                        name: 'DOM Content Loaded',
+                        value: 'domcontentloaded',
+                        description: 'Wait for DOMContentLoaded event',
+                    },
+                    {
+                        name: 'Network Idle',
+                        value: 'networkidle',
+                        description: 'Wait for network to be idle (no requests for 500ms)',
+                    },
+                    {
+                        name: 'Network Idle 2',
+                        value: 'networkidle2',
+                        description: 'Wait for network to be idle (no more than 2 requests for 500ms)',
+                    },
+                ],
+                default: 'load',
+                description: 'When to consider page load complete',
+            },
+        ],
+    },
+    {
+        displayName: 'Table Extraction',
+        name: 'tableExtraction',
+        type: 'collection',
+        placeholder: 'Add Option',
+        default: {},
+        displayOptions: {
+            show: {
+                operation: ['crawlSingleUrl'],
+            },
+        },
+        options: [
+            {
+                displayName: 'Chunk Token Threshold',
+                name: 'chunkTokenThreshold',
+                type: 'number',
+                displayOptions: {
+                    show: {
+                        strategyType: ['llm'],
+                        enableChunking: [true],
+                    },
+                },
+                default: 10000,
+                description: 'Maximum tokens per chunk when processing large tables (default: 10000)',
+            },
+            {
+                displayName: 'CSS Selector',
+                name: 'cssSelector',
+                type: 'string',
+                displayOptions: {
+                    show: {
+                        strategyType: ['llm'],
+                    },
+                },
+                default: '',
+                placeholder: '.main-content',
+                description: 'CSS selector to focus table extraction on specific page area (optional)',
+            },
+            {
+                displayName: 'Enable Chunking',
+                name: 'enableChunking',
+                type: 'boolean',
+                displayOptions: {
+                    show: {
+                        strategyType: ['llm'],
+                    },
+                },
+                default: false,
+                description: 'Whether to enable chunking for large tables (recommended for tables with 100+ rows)',
+            },
+            {
+                displayName: 'Max Parallel Chunks',
+                name: 'maxParallelChunks',
+                type: 'number',
+                displayOptions: {
+                    show: {
+                        strategyType: ['llm'],
+                        enableChunking: [true],
+                    },
+                },
+                default: 5,
+                description: 'Maximum number of chunks to process in parallel (default: 5)',
+            },
+            {
+                displayName: 'Max Tries',
+                name: 'maxTries',
+                type: 'number',
+                displayOptions: {
+                    show: {
+                        strategyType: ['llm'],
+                    },
+                },
+                default: 3,
+                description: 'Maximum number of retry attempts for LLM extraction (default: 3)',
+            },
+            {
+                displayName: 'Min Rows Per Chunk',
+                name: 'minRowsPerChunk',
+                type: 'number',
+                displayOptions: {
+                    show: {
+                        strategyType: ['llm'],
+                        enableChunking: [true],
+                    },
+                },
+                default: 20,
+                description: 'Minimum number of rows per chunk (default: 20)',
+            },
+            {
+                displayName: 'Strategy Type',
+                name: 'strategyType',
+                type: 'options',
+                options: [
+                    {
+                        name: 'None',
+                        value: 'none',
+                        description: 'No table extraction',
+                    },
+                    {
+                        name: 'LLM Table Extraction',
+                        value: 'llm',
+                        description: 'Extract tables using LLM (handles complex tables with rowspan/colspan)',
+                    },
+                    {
+                        name: 'Default Table Extraction',
+                        value: 'default',
+                        description: 'Extract tables using heuristics (faster, simpler tables only)',
+                    },
+                ],
+                default: 'none',
+                description: 'Table extraction strategy to use',
+            },
+            {
+                displayName: 'Table Score Threshold',
+                name: 'tableScoreThreshold',
+                type: 'number',
+                displayOptions: {
+                    show: {
+                        strategyType: ['default'],
+                    },
+                },
+                default: 5,
+                description: 'Minimum score for table to be included in results (default: 5, range: 0-10)',
+            },
+            {
+                displayName: 'Verbose',
+                name: 'verbose',
+                type: 'boolean',
+                displayOptions: {
+                    show: {
+                        strategyType: ['llm', 'default'],
+                    },
+                },
+                default: false,
+                description: 'Whether to enable verbose logging for table extraction',
+            },
+        ],
+    },
 ];
 async function execute(items, nodeOptions) {
-    var _a;
+    var _a, _b;
     const allResults = [];
     for (let i = 0; i < items.length; i++) {
         try {
             const url = this.getNodeParameter('url', i, '');
             const browserOptions = this.getNodeParameter('browserOptions', i, {});
+            const sessionOptions = this.getNodeParameter('sessionOptions', i, {});
             const crawlerOptions = this.getNodeParameter('crawlerOptions', i, {});
-            const options = this.getNodeParameter('options', i, {});
+            const outputOptions = this.getNodeParameter('outputOptions', i, {});
+            const contentFilter = this.getNodeParameter('contentFilter', i, {});
+            const advancedOptions = this.getNodeParameter('advancedOptions', i, {});
+            let mergedBrowserOptions = { ...browserOptions, ...sessionOptions };
+            if (browserOptions.extraArgs && typeof browserOptions.extraArgs === 'object') {
+                const extraArgsCollection = browserOptions.extraArgs;
+                if (extraArgsCollection.args && Array.isArray(extraArgsCollection.args)) {
+                    mergedBrowserOptions.extraArgs = extraArgsCollection.args.map((arg) => arg.value).filter((v) => v);
+                }
+            }
             if (!url) {
                 throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'URL cannot be empty.', { itemIndex: i });
             }
             if (!(0, utils_1.isValidUrl)(url)) {
                 throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Invalid URL: ${url}`, { itemIndex: i });
             }
-            const browserConfig = (0, utils_1.createBrowserConfig)(browserOptions);
+            const browserConfig = (0, utils_1.createBrowserConfig)(mergedBrowserOptions);
+            const antiBotFeatures = ((_a = advancedOptions.antiBotFeatures) === null || _a === void 0 ? void 0 : _a.features) || {};
             const crawlerConfig = (0, utils_1.createCrawlerRunConfig)({
                 ...crawlerOptions,
                 ...browserConfig,
+                screenshot: outputOptions.screenshot,
+                pdf: outputOptions.pdf,
+                fetchSslCertificate: outputOptions.fetchSslCertificate,
+                magic: antiBotFeatures.magic,
+                simulateUser: antiBotFeatures.simulateUser,
+                overrideNavigator: antiBotFeatures.overrideNavigator,
+                excludeSocialMediaLinks: advancedOptions.excludeSocialMediaLinks,
+                excludeExternalImages: advancedOptions.excludeExternalImages,
+                delayBeforeReturnHtml: advancedOptions.delayBeforeReturnHtml,
+                waitUntil: advancedOptions.waitUntil,
+                verbose: advancedOptions.verbose,
             });
+            if (contentFilter.filterType && contentFilter.filterType !== 'none') {
+                const enrichedFilterConfig = { ...contentFilter };
+                if (contentFilter.filterType === 'llm') {
+                    const credentials = await this.getCredentials('crawl4aiPlusApi');
+                    if (!credentials.enableLlm) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'LLM features must be enabled in Crawl4AI credentials to use LLM content filtering.', { itemIndex: i });
+                    }
+                    let provider = 'openai/gpt-4o';
+                    let apiKey = '';
+                    if (credentials.llmProvider === 'openai') {
+                        const model = credentials.llmModel || 'gpt-4o';
+                        provider = `openai/${model}`;
+                        apiKey = credentials.apiKey || '';
+                    }
+                    else if (credentials.llmProvider === 'anthropic') {
+                        const model = credentials.llmModel || 'claude-3-haiku-20240307';
+                        provider = `anthropic/${model}`;
+                        apiKey = credentials.apiKey || '';
+                    }
+                    else if (credentials.llmProvider === 'groq') {
+                        const model = credentials.llmModel || 'llama3-70b-8192';
+                        provider = `groq/${model}`;
+                        apiKey = credentials.apiKey || '';
+                    }
+                    else if (credentials.llmProvider === 'ollama') {
+                        const model = credentials.ollamaModel || 'llama3';
+                        provider = `ollama/${model}`;
+                    }
+                    else if (credentials.llmProvider === 'other') {
+                        provider = credentials.customProvider || 'custom/model';
+                        apiKey = credentials.customApiKey || '';
+                    }
+                    if (!apiKey && credentials.llmProvider !== 'ollama') {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `API key is required for ${credentials.llmProvider} provider. Please configure it in the Crawl4AI credentials.`, { itemIndex: i });
+                    }
+                    enrichedFilterConfig.llmConfig = {
+                        type: 'LLMConfig',
+                        params: {
+                            provider,
+                            api_token: apiKey,
+                            ...(credentials.llmProvider === 'other' && credentials.customBaseUrl ?
+                                { api_base: credentials.customBaseUrl } : {}),
+                            ...(credentials.llmProvider === 'ollama' && credentials.ollamaUrl ?
+                                { api_base: credentials.ollamaUrl } : {})
+                        }
+                    };
+                }
+                crawlerConfig.markdownGenerator = (0, utils_1.createMarkdownGenerator)(enrichedFilterConfig);
+            }
+            const tableExtractionConfig = this.getNodeParameter('tableExtraction', i, {});
+            if (tableExtractionConfig.strategyType && tableExtractionConfig.strategyType !== 'none') {
+                const enrichedTableConfig = { ...tableExtractionConfig };
+                if (tableExtractionConfig.strategyType === 'llm') {
+                    const credentials = await this.getCredentials('crawl4aiPlusApi');
+                    if (!credentials.enableLlm) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'LLM features must be enabled in Crawl4AI credentials to use LLM table extraction.', { itemIndex: i });
+                    }
+                    let provider = 'openai/gpt-4o';
+                    let apiKey = '';
+                    if (credentials.llmProvider === 'openai') {
+                        const model = credentials.llmModel || 'gpt-4o';
+                        provider = `openai/${model}`;
+                        apiKey = credentials.apiKey || '';
+                    }
+                    else if (credentials.llmProvider === 'anthropic') {
+                        const model = credentials.llmModel || 'claude-3-haiku-20240307';
+                        provider = `anthropic/${model}`;
+                        apiKey = credentials.apiKey || '';
+                    }
+                    else if (credentials.llmProvider === 'groq') {
+                        const model = credentials.llmModel || 'llama3-70b-8192';
+                        provider = `groq/${model}`;
+                        apiKey = credentials.apiKey || '';
+                    }
+                    else if (credentials.llmProvider === 'ollama') {
+                        const model = credentials.ollamaModel || 'llama3';
+                        provider = `ollama/${model}`;
+                    }
+                    else if (credentials.llmProvider === 'other') {
+                        provider = credentials.customProvider || 'custom/model';
+                        apiKey = credentials.customApiKey || '';
+                    }
+                    if (!apiKey && credentials.llmProvider !== 'ollama') {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `API key is required for ${credentials.llmProvider} provider. Please configure it in the Crawl4AI credentials.`, { itemIndex: i });
+                    }
+                    enrichedTableConfig.llmConfig = {
+                        type: 'LLMConfig',
+                        params: {
+                            provider,
+                            api_token: apiKey,
+                            ...(credentials.llmProvider === 'other' && credentials.customBaseUrl ?
+                                { api_base: credentials.customBaseUrl } : {}),
+                            ...(credentials.llmProvider === 'ollama' && credentials.ollamaUrl ?
+                                { api_base: credentials.ollamaUrl } : {})
+                        }
+                    };
+                }
+                crawlerConfig.tableExtraction = (0, utils_1.createTableExtractionStrategy)(enrichedTableConfig);
+            }
             const crawler = await (0, utils_1.getCrawl4aiClient)(this);
             const result = await crawler.crawlUrl(url, crawlerConfig);
-            const formattedResult = (0, formatters_1.formatCrawlResult)(result, options.includeMedia, options.verboseResponse);
+            const formattedResult = (0, formatters_1.formatCrawlResult)(result, outputOptions.includeMedia, outputOptions.verboseResponse, {
+                markdownOutput: outputOptions.markdownOutput,
+                includeLinks: outputOptions.includeLinks,
+                includeScreenshot: outputOptions.screenshot,
+                includePdf: outputOptions.pdf,
+                includeSslCertificate: outputOptions.fetchSslCertificate,
+                includeTables: outputOptions.includeTables,
+            });
             allResults.push({
                 json: formattedResult,
                 pairedItem: { item: i },
@@ -308,7 +1014,7 @@ async function execute(items, nodeOptions) {
         catch (error) {
             if (this.continueOnFail()) {
                 const node = this.getNode();
-                const errorItemIndex = (_a = error.itemIndex) !== null && _a !== void 0 ? _a : i;
+                const errorItemIndex = (_b = error.itemIndex) !== null && _b !== void 0 ? _b : i;
                 allResults.push({
                     json: items[i].json,
                     error: new n8n_workflow_1.NodeOperationError(node, error.message, { itemIndex: errorItemIndex }),