n8n-nodes-firecrawl-latest 1.0.0

package/dist/nodes/Firecrawl/resources/deepResearch/deepResearch.methods.js

@@ -0,0 +1,171 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deepResearchMethods = void 0;
+const firecrawl_js_1 = __importDefault(require("@mendable/firecrawl-js"));
+const n8n_workflow_1 = require("n8n-workflow");
+exports.deepResearchMethods = {
+    async execute() {
+        const items = this.getInputData();
+        const returnData = [];
+        // Get credentials
+        const credentials = await this.getCredentials('firecrawlApi');
+        const apiKey = credentials.apiKey;
+        // Initialize Firecrawl app
+        const firecrawl = new firecrawl_js_1.default({ apiKey });
+        // Process each item
+        for (let i = 0; i < items.length; i++) {
+            try {
+                // Get operation mode
+                const operationMode = this.getNodeParameter('operationMode', i);
+                if (operationMode === 'new') {
+                    // Start a new research task
+                    const query = this.getNodeParameter('query', i);
+                    const maxDepth = this.getNodeParameter('maxDepth', i, 7);
+                    const timeLimit = this.getNodeParameter('timeLimit', i, 270);
+                    const maxUrls = this.getNodeParameter('maxUrls', i, 20);
+                    const systemPrompt = this.getNodeParameter('systemPrompt', i, '');
+                    const analysisPrompt = this.getNodeParameter('analysisPrompt', i, '');
+                    const jsonOutput = this.getNodeParameter('jsonOutput', i, false);
+                    const waitForCompletion = this.getNodeParameter('waitForCompletion', i, true);
+                    const trackActivity = this.getNodeParameter('trackActivity', i, false);
+                    // Prepare research parameters
+                    const params = {
+                        maxDepth,
+                        timeLimit,
+                        maxUrls,
+                    };
+                    // Add optional parameters if provided
+                    if (systemPrompt)
+                        params.systemPrompt = systemPrompt;
+                    if (analysisPrompt)
+                        params.analysisPrompt = analysisPrompt;
+                    // Add JSON output settings if enabled
+                    if (jsonOutput) {
+                        params.formats = ['json'];
+                        const jsonSchema = this.getNodeParameter('jsonSchema', i, '{}');
+                        params.jsonOptions = {
+                            schema: JSON.parse(jsonSchema),
+                        };
+                    }
+                    // Handle different operation modes
+                    if (waitForCompletion) {
+                        // Start research with optional activity tracking
+                        let results;
+                        if (trackActivity) {
+                            // Initialize an array to store activities
+                            const activities = [];
+                            // Define activity callback
+                            const onActivity = (activity) => {
+                                activities.push(activity);
+                            };
+                            // Run research with activity tracking
+                            results = await firecrawl.deepResearch(query, params, onActivity);
+                            // Add activities to results if not an error
+                            if (results.success && !('error' in results)) {
+                                results.activities = activities;
+                            }
+                        }
+                        else {
+                            // Run research without activity tracking
+                            results = await firecrawl.deepResearch(query, params);
+                        }
+                        if (!results.success && 'error' in results) {
+                            returnData.push({
+                                json: {
+                                    success: false,
+                                    status: 'error',
+                                    error: results.error,
+                                },
+                            });
+                        }
+                        else {
+                            const resultData = results;
+                            returnData.push({
+                                json: {
+                                    success: true,
+                                    status: resultData.status || 'completed',
+                                    data: resultData.data,
+                                    currentDepth: resultData.currentDepth,
+                                    maxDepth: resultData.maxDepth,
+                                    expiresAt: resultData.expiresAt,
+                                    activities: resultData.activities,
+                                },
+                            });
+                        }
+                    }
+                    else {
+                        // Start a new research job asynchronously
+                        const job = await firecrawl.asyncDeepResearch(query, params);
+                        if (!job.success && 'error' in job) {
+                            returnData.push({
+                                json: {
+                                    success: false,
+                                    status: 'error',
+                                    error: job.error,
+                                },
+                            });
+                        }
+                        else {
+                            returnData.push({
+                                json: {
+                                    success: true,
+                                    status: 'started',
+                                    jobId: 'jobId' in job ? job.jobId : undefined,
+                                    message: 'Deep research started successfully. Use the job ID to check status.',
+                                },
+                            });
+                        }
+                    }
+                }
+                else {
+                    // Check the status of an existing job
+                    const jobId = this.getNodeParameter('jobId', i);
+                    const status = await firecrawl.checkDeepResearchStatus(jobId);
+                    if (!status.success && 'error' in status) {
+                        returnData.push({
+                            json: {
+                                success: false,
+                                status: 'error',
+                                error: status.error,
+                                jobId,
+                            },
+                        });
+                    }
+                    else {
+                        returnData.push({
+                            json: {
+                                success: true,
+                                status: 'status' in status ? status.status : 'unknown',
+                                jobId,
+                                currentDepth: 'currentDepth' in status ? status.currentDepth : undefined,
+                                maxDepth: 'maxDepth' in status ? status.maxDepth : undefined,
+                                data: 'data' in status ? status.data : undefined,
+                                expiresAt: 'expiresAt' in status ? status.expiresAt : undefined,
+                            },
+                        });
+                    }
+                }
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                console.error('Deep Research error:', errorMessage);
+                if (this.continueOnFail()) {
+                    returnData.push({
+                        json: {
+                            success: false,
+                            error: errorMessage,
+                        },
+                    });
+                    continue;
+                }
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), error, {
+                    itemIndex: i,
+                });
+            }
+        }
+        return [returnData];
+    },
+};

package/dist/nodes/Firecrawl/resources/deepResearch/deepResearch.properties.js

@@ -0,0 +1,200 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deepResearchProperties = void 0;
+// Fields for the Deep Research resource
+const deepResearchFields = [
+    {
+        displayName: 'Query',
+        name: 'query',
+        type: 'string',
+        displayOptions: {
+            show: {
+                resource: ['deepResearch'],
+            },
+        },
+        default: '',
+        required: true,
+        description: 'The research topic or question you want to investigate',
+        placeholder: 'What are the latest developments in quantum computing?',
+    },
+    {
+        displayName: 'Operation Mode',
+        name: 'operationMode',
+        type: 'options',
+        displayOptions: {
+            show: {
+                resource: ['deepResearch'],
+            },
+        },
+        options: [
+            {
+                name: 'Start New Research',
+                value: 'new',
+                description: 'Start a new deep research task',
+            },
+            {
+                name: 'Check Status',
+                value: 'status',
+                description: 'Check the status of an existing research task',
+            },
+        ],
+        default: 'new',
+        description: 'Whether to start a new research task or check an existing one',
+    },
+    {
+        displayName: 'Job ID',
+        name: 'jobId',
+        type: 'string',
+        displayOptions: {
+            show: {
+                resource: ['deepResearch'],
+                operationMode: ['status'],
+            },
+        },
+        default: '',
+        required: true,
+        description: 'The ID of the research job to check',
+    },
+    {
+        displayName: 'Maximum Depth',
+        name: 'maxDepth',
+        type: 'number',
+        typeOptions: {
+            minValue: 1,
+            maxValue: 10,
+        },
+        displayOptions: {
+            show: {
+                resource: ['deepResearch'],
+                operationMode: ['new'],
+            },
+        },
+        default: 7,
+        description: 'Maximum number of research iterations (1-10)',
+    },
+    {
+        displayName: 'Time Limit (Seconds)',
+        name: 'timeLimit',
+        type: 'number',
+        typeOptions: {
+            minValue: 30,
+            maxValue: 300,
+        },
+        displayOptions: {
+            show: {
+                resource: ['deepResearch'],
+                operationMode: ['new'],
+            },
+        },
+        default: 270,
+        description: 'Time limit in seconds (30-300)',
+    },
+    {
+        displayName: 'Maximum URLs',
+        name: 'maxUrls',
+        type: 'number',
+        typeOptions: {
+            minValue: 1,
+            maxValue: 1000,
+        },
+        displayOptions: {
+            show: {
+                resource: ['deepResearch'],
+                operationMode: ['new'],
+            },
+        },
+        default: 20,
+        description: 'Maximum number of URLs to analyze (1-1000)',
+    },
+    {
+        displayName: 'System Prompt',
+        name: 'systemPrompt',
+        type: 'string',
+        typeOptions: {
+            rows: 4,
+        },
+        displayOptions: {
+            show: {
+                resource: ['deepResearch'],
+                operationMode: ['new'],
+            },
+        },
+        default: '',
+        description: 'Optional system prompt to guide the research process',
+    },
+    {
+        displayName: 'Analysis Prompt',
+        name: 'analysisPrompt',
+        type: 'string',
+        typeOptions: {
+            rows: 4,
+        },
+        displayOptions: {
+            show: {
+                resource: ['deepResearch'],
+                operationMode: ['new'],
+            },
+        },
+        default: '',
+        description: 'Optional prompt for customizing the final analysis',
+    },
+    {
+        displayName: 'JSON Output',
+        name: 'jsonOutput',
+        type: 'boolean',
+        displayOptions: {
+            show: {
+                resource: ['deepResearch'],
+                operationMode: ['new'],
+            },
+        },
+        default: false,
+        description: 'Whether to output the research results in structured JSON format',
+    },
+    {
+        displayName: 'JSON Schema',
+        name: 'jsonSchema',
+        type: 'json',
+        typeOptions: {
+            alwaysOpenEditWindow: true,
+            rows: 10,
+        },
+        displayOptions: {
+            show: {
+                resource: ['deepResearch'],
+                operationMode: ['new'],
+                jsonOutput: [true],
+            },
+        },
+        default: '{\n  "type": "object",\n  "properties": {\n    "keyFindings": {\n      "type": "array",\n      "items": {\n        "type": "string"\n      }\n    },\n    "relevantCompanies": {\n      "type": "array",\n      "items": {\n        "type": "object",\n        "properties": {\n          "name": {\n            "type": "string"\n          },\n          "relevance": {\n            "type": "string"\n          }\n        }\n      }\n    }\n  }\n}',
+        description: 'Schema for structured JSON output (if JSON Output is enabled)',
+    },
+    {
+        displayName: 'Real-Time Updates',
+        name: 'trackActivity',
+        type: 'boolean',
+        displayOptions: {
+            show: {
+                resource: ['deepResearch'],
+                operationMode: ['new'],
+            },
+        },
+        default: false,
+        description: 'Whether to track research activities in real-time (not recommended for n8n)',
+    },
+    {
+        displayName: 'Wait for Completion',
+        name: 'waitForCompletion',
+        type: 'boolean',
+        displayOptions: {
+            show: {
+                resource: ['deepResearch'],
+                operationMode: ['new'],
+            },
+        },
+        default: true,
+        description: 'Whether to wait for the research to complete before returning',
+    },
+];
+// Export all properties for the Deep Research resource
+exports.deepResearchProperties = [...deepResearchFields];