@lhi/n8m 0.1.2 → 0.2.0

package/dist/services/ai.service.js

@@ -1,60 +1,89 @@
-import OpenAI from 'openai';
+import { OpenAI } from 'openai';
 import fsSync from 'fs';
 import path from 'path';
 import os from 'os';
-// Base URLs and default models for known providers
-const PROVIDER_PRESETS = {
+import { fileURLToPath } from 'url';
+import { jsonrepair } from 'jsonrepair';
+import { NodeDefinitionsService } from './node-definitions.service.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+export const PROVIDER_PRESETS = {
     openai: {
         defaultModel: 'gpt-4o',
+        models: [
+            'gpt-5', 'gpt-5-latest', 'gpt-5-pro', 'gpt-5-mini', 'gpt-5-mini-latest', 'gpt-5-nano',
+            'gpt-4o', 'gpt-4o-mini', 'o1-preview', 'o1-mini'
+        ]
     },
     anthropic: {
         baseURL: 'https://api.anthropic.com/v1',
         defaultModel: 'claude-sonnet-4-6',
+        models: [
+            'claude-opus-4-6',
+            'claude-sonnet-4-6',
+            'claude-haiku-4-5'
+        ]
     },
     gemini: {
         baseURL: 'https://generativelanguage.googleapis.com/v1beta/openai/',
-        defaultModel: 'gemini-2.5-flash',
+        defaultModel: 'gemini-3-flash',
+        models: [
+            'gemini-3.1-pro', 'gemini-3-flash', 'gemini-3.1-pro-preview', 'gemini-3-flash-preview'
+        ]
     },
 };
 export class AIService {
     static instance;
-    client;
+    clients = new Map();
+    defaultProvider;
     model;
+    apiKey;
+    baseURL;
     constructor() {
-        // Load persisted config from ~/.n8m/config.json as fallback for env vars
         let fileConfig = {};
         try {
             const configFile = path.join(os.homedir(), '.n8m', 'config.json');
             fileConfig = JSON.parse(fsSync.readFileSync(configFile, 'utf-8'));
         }
         catch {
-            // Config file doesn't exist yet — that's fine
+            // Config file doesn't exist yet
         }
-        let apiKey = process.env.AI_API_KEY || fileConfig['aiKey'];
-        let baseURL = process.env.AI_BASE_URL || fileConfig['aiBaseUrl'];
-        let provider = (process.env.AI_PROVIDER || fileConfig['aiProvider'])?.toLowerCase();
-        // Backward compat: GEMINI_API_KEY still works
-        if (!apiKey && process.env.GEMINI_API_KEY) {
-            apiKey = process.env.GEMINI_API_KEY;
-            if (!provider)
-                provider = 'gemini';
+        this.apiKey = process.env.AI_API_KEY || fileConfig['aiKey'];
+        this.baseURL = process.env.AI_BASE_URL || fileConfig['aiBaseUrl'];
+        this.defaultProvider = (process.env.AI_PROVIDER || fileConfig['aiProvider'])?.toLowerCase() || 'openai';
+        if (!this.apiKey && process.env.GEMINI_API_KEY) {
+            this.apiKey = process.env.GEMINI_API_KEY;
+            if (!this.defaultProvider)
+                this.defaultProvider = 'gemini';
         }
-        if (!apiKey) {
-            console.warn('⚠️  No AI key found. Run: n8m config --ai-key <your-key> --ai-provider openai');
-        }
-        const preset = provider ? PROVIDER_PRESETS[provider] : undefined;
-        // Apply preset base URL unless the user explicitly set one
-        if (preset?.baseURL && !baseURL) {
-            baseURL = preset.baseURL;
+        if (!presetConfigs[this.defaultProvider]) {
+            // Handle unknown provider
         }
+        const preset = PROVIDER_PRESETS[this.defaultProvider];
         this.model = process.env.AI_MODEL || fileConfig['aiModel'] || preset?.defaultModel || 'gpt-4o';
-        this.client = new OpenAI({
-            apiKey: apiKey || 'no-key',
+        if (!this.apiKey) {
+            console.warn("No AI key found in .env or config file. AI calls will fail.");
+        }
+    }
+    getClient(provider) {
+        // Mocking support for unit tests
+        if (this.client) {
+            return this.client;
+        }
+        if (this.clients.has(provider)) {
+            return this.clients.get(provider);
+        }
+        const preset = PROVIDER_PRESETS[provider];
+        if (provider === 'anthropic')
+            return null;
+        const baseURL = this.baseURL || preset?.baseURL;
+        const client = new OpenAI({
+            apiKey: this.apiKey || 'no-key',
             ...(baseURL ? { baseURL } : {}),
-            defaultHeaders: provider === 'anthropic'
-                ? { 'anthropic-version': '2023-06-01' }
-                : undefined,
+            defaultHeaders: provider === 'openai' ? undefined : { 'anthropic-version': '2023-06-01' }
         });
+        this.clients.set(provider, client);
+        return client;
     }
     static getInstance() {
         if (!AIService.instance) {
@@ -62,264 +91,231 @@ export class AIService {
         }
         return AIService.instance;
     }
-    /**
-     * Core generation method — works with any OpenAI-compatible API
-     */
+    async callAnthropicNative(prompt, model, options) {
+        const preset = PROVIDER_PRESETS['anthropic'];
+        const url = `${this.baseURL || preset.baseURL}/messages`;
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'x-api-key': this.apiKey,
+                'anthropic-version': '2023-06-01',
+                'content-type': 'application/json'
+            },
+            body: JSON.stringify({
+                model,
+                max_tokens: 4096,
+                messages: [{ role: 'user', content: prompt }],
+                temperature: options.temperature ?? 0.7,
+            })
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Anthropic API Error: ${response.status} - ${errorText}`);
+        }
+        const result = await response.json();
+        return result.content?.[0]?.text || '';
+    }
     async generateContent(prompt, options = {}) {
-        const model = options.model || this.model;
+        const provider = options.provider || this.defaultProvider;
+        const model = options.model || (options.provider ? PROVIDER_PRESETS[options.provider]?.defaultModel : this.model);
         const maxRetries = 3;
         let lastError;
         for (let attempt = 1; attempt <= maxRetries; attempt++) {
             try {
-                if (process.stdout.isTTY) {
-                    process.stdout.write('   (AI Thinking...)\n');
+                if (process.stdout.isTTY && process.env.NODE_ENV !== 'test') {
+                    process.stdout.write(`   (AI Thinking: ${model})\n`);
                 }
-                const stream = await this.client.chat.completions.create({
+                if (provider === 'anthropic' && !this.baseURL?.includes('openai') && !this.client) {
+                    return await this.callAnthropicNative(prompt, model, options);
+                }
+                const client = this.getClient(provider);
+                const completion = await client.chat.completions.create({
                     model,
                     messages: [{ role: 'user', content: prompt }],
                     temperature: options.temperature ?? 0.7,
-                    stream: true,
                 });
-                let text = '';
-                for await (const chunk of stream) {
-                    text += chunk.choices[0]?.delta?.content || '';
-                }
-                return text;
+                const result = completion;
+                return result.choices?.[0]?.message?.content || '';
             }
             catch (error) {
-                if (process.stdout.isTTY)
-                    process.stdout.write('\n');
                 lastError = error;
-                const isRetryable = error.status === 503 ||
-                    error.status === 529 ||
-                    (error.message && (error.message.includes('fetch failed') ||
-                        error.message.includes('ECONNRESET') ||
-                        error.message.includes('timeout')));
-                if (attempt < maxRetries && isRetryable) {
-                    const delay = Math.pow(2, attempt) * 1000;
-                    console.warn(`[AIService] Attempt ${attempt}/${maxRetries} failed: ${error.message}. Retrying in ${delay / 1000}s...`);
-                    await new Promise(r => setTimeout(r, delay));
-                    continue;
+                if (attempt < maxRetries) {
+                    const waitTime = Math.pow(2, attempt) * 1000;
+                    await new Promise(resolve => setTimeout(resolve, waitTime));
                 }
-                break;
             }
         }
         throw lastError;
     }
-    /**
-     * Generate an n8n workflow from a description
-     */
-    async generateWorkflow(description) {
-        const systemPrompt = `You are an expert n8n workflow architect.
-    Your task is to generate a valid n8n workflow JSON based on the user's description.
-
-    Output ONLY valid JSON. No markdown formatting, no explanations.
-    The JSON must follow the n8n workflow schema with 'nodes' and 'connections' arrays.
-
-    User Description: ${description}`;
-        const response = await this.generateContent(systemPrompt);
-        let cleanJson = response || '{}';
-        cleanJson = cleanJson.replace(/```json\n?|\n?```/g, '').trim();
-        try {
-            return JSON.parse(cleanJson);
+    getAlternativeModel() {
+        // If user explicitly configured a model in .env/config, respect it for all strategies.
+        // Diversification is only useful if we have a pool of models and no strict preference.
+        if (process.env.AI_MODEL) {
+            return this.model;
         }
-        catch (e) {
-            console.error('Failed to parse generated workflow JSON', e);
-            throw new Error('AI generated invalid JSON');
+        const preset = PROVIDER_PRESETS[this.defaultProvider];
+        if (!preset)
+            return this.model;
+        const currentModelId = this.model.toLowerCase();
+        if (this.defaultProvider === 'anthropic') {
+            if (currentModelId.includes('sonnet'))
+                return 'claude-haiku-4-5';
+            return 'claude-sonnet-4-6';
         }
+        const otherModels = preset.models.filter((m) => m.toLowerCase() !== currentModelId);
+        return otherModels.length > 0 ? otherModels[0] : this.model;
     }
-    /**
-     * Generate a Workflow Specification from a description
-     */
-    async generateSpec(description) {
-        const prompt = `You are an n8n Solutions Architect.
-    Convert the following user request into a structured Workflow Specification.
+    getDefaultModel() { return this.model; }
+    getDefaultProvider() { return this.defaultProvider; }
+    async generateSpec(goal) {
+        const nodeService = NodeDefinitionsService.getInstance();
+        const staticRef = nodeService.getStaticReference();
+        const prompt = `You are an n8n Solution Architect.
+       Create a technical specification for an n8n workflow that fulfills the following goal: "${goal}".
+       
+       [N8N NODE REFERENCE GUIDE]
+       ${staticRef}
 
-    The Specification should be a JSON object with:
-    1. goal: A clear statement of the objective.
-    2. suggestedName: A concise, descriptive name for the main workflow (e.g., "Hourly Bitcoin Price Alert").
-    3. tasks: A list of strings, each describing a logical step to achieve the goal.
-    4. nodes: Potential n8n nodes involved (e.g. ['Webhook', 'HTTP Request', 'Slack']).
-    5. assumptions: Any assumptions made about credentials or environment.
-    6. questions: A list of string questions if the request is ambiguous or missing critical details. Empty if clear.
-
-    Output ONLY valid JSON.
-
-    User Request: ${description}`;
+       Your output must be a JSON object with this structure:
+       {
+         "suggestedName": "The recommended name for the workflow",
+         "description": "A clear description of what the workflow does",
+         "nodes": [
+           { "type": "n8n-nodes-base.nodeName", "purpose": "Why this node is used", "config": { ... } }
+         ],
+         "questions": ["Any clarification questions for the user"]
+       }
+       
+       Use ONLY standard n8n node types (e.g. n8n-nodes-base.httpRequest, n8n-nodes-base.slack).
+       Output ONLY the JSON object. No commentary.`;
         const response = await this.generateContent(prompt);
-        let cleanJson = response || '{}';
-        cleanJson = cleanJson.replace(/```json\n?|\n?```/g, '').trim();
+        const cleanJson = response.replace(/```json\n?|\n?```/g, "").trim();
         try {
-            return JSON.parse(cleanJson);
+            const result = JSON.parse(jsonrepair(cleanJson));
+            if (typeof result !== 'object' || result === null) {
+                throw new Error('AI did not return a JSON object');
+            }
+            return result;
         }
-        catch (e) {
-            console.error('Failed to parse generated spec JSON', e);
-            throw new Error('AI generated invalid JSON for spec');
+        catch {
+            throw new Error(`invalid JSON returned by AI: ${cleanJson}`);
         }
     }
-    /**
-     * Refine a Specification based on user feedback
-     */
-    async refineSpec(spec, feedback) {
-        const prompt = `You are an n8n Solutions Architect.
-    Update the following Workflow Specification based on the user's feedback/answers.
-
-    Current Specification:
-    ${JSON.stringify(spec, null, 2)}
-
-    User Feedback:
-    ${feedback}
-
-    Ensure 'questions' is empty if the feedback resolves the ambiguity.
-    Output the UPDATED JSON Specification only.`;
+    async generateWorkflow(goal) {
+        const prompt = `You are an n8n Expert.
+       Generate a valid n8n workflow JSON for the following goal: "${goal}".
+       Output ONLY the JSON object. No commentary.`;
         const response = await this.generateContent(prompt);
-        let cleanJson = response || '{}';
-        cleanJson = cleanJson.replace(/```json\n?|\n?```/g, '').trim();
+        const cleanJson = response.replace(/```json\n?|\n?```/g, "").trim();
         try {
-            return JSON.parse(cleanJson);
+            return JSON.parse(jsonrepair(cleanJson));
         }
-        catch (e) {
-            console.error('Failed to parse refined spec JSON', e);
-            throw new Error('AI generated invalid JSON for refined spec');
+        catch {
+            throw new Error(`invalid JSON: ${cleanJson}`);
         }
     }
-    /**
-     * Generate workflow JSONs from an approved Specification
-     */
-    async generateWorkflowFromSpec(spec) {
-        const prompt = `You are an n8n Workflow Engineer.
-      Generate the valid n8n workflow JSON(s) based on the following approved Specification.
-
-      Specification:
-      ${JSON.stringify(spec, null, 2)}
-
-      IMPORTANT:
-      1. Descriptive Naming: Name nodes descriptively (e.g. "Fetch Bitcoin Price" instead of "HTTP Request").
-      2. Multi-Workflow: If the spec requires multiple workflows (e.g. Main + Sub-workflow), generate them all.
-      3. Linking: If one workflow calls another (using an 'Execute Workflow' node), use the "suggestedName" of the target workflow as the 'workflowId' parameter value. Do NOT use generic IDs like "SUBWORKFLOW_ID".
-      4. Consistency: Ensure the "name" field in each workflow matches one of the suggestedNames from the spec.
-      5. Standard Node Types: Use valid n8n-nodes-base types.
-         - Use "n8n-nodes-base.rssFeedRead" for RSS reading (NOT "rssFeed").
-         - Use "n8n-nodes-base.httpRequest" for API calls.
-         - Use "n8n-nodes-base.openAi" for OpenAI.
-         - Use "n8n-nodes-base.googleGemini" for Google Gemini.
-         - Use "n8n-nodes-base.htmlExtract" for HTML/Cheerio extraction.
-      6. Connections Structure: The "connections" object keys MUST BE THE SOURCE NODE NAME. The "node" field inside the connection array MUST BE THE TARGET NODE NAME.
-      7. Connection Nesting: Ensure the correct n8n connection structure: "SourceNodeName": { "main": [ [ { "node": "TargetNodeName", "type": "main", "index": 0 } ] ] }.
-
-      Output a JSON object with this structure:
-      {
-         "workflows": [
-             { "name": "Workflow Name", "nodes": [...], "connections": {...} }
-         ]
-      }
+    async generateAlternativeSpec(goal, primarySpec) {
+        const nodeService = NodeDefinitionsService.getInstance();
+        const staticRef = nodeService.getStaticReference();
+        const prompt = `You are a Senior n8n Engineer. 
+       Given the goal: "${goal}" and a primary strategy: ${JSON.stringify(primarySpec)},
+       design an ALTERNATIVE strategy (different approach or set of nodes) that achieves the same goal.
+       
+       [N8N NODE REFERENCE GUIDE]
+       ${staticRef}
 
-      Output ONLY valid JSON. No commentary. No markdown.
-      `;
-        const response = await this.generateContent(prompt);
-        let cleanJson = response || '{}';
-        cleanJson = cleanJson.replace(/```json\n?|\n?```/g, '').trim();
+       Your output must be a JSON object with the same WorkflowSpec structure.
+       Output ONLY the JSON object. No commentary.`;
+        const response = await this.generateContent(prompt, { model: this.getAlternativeModel() });
+        const cleanJson = response.replace(/```json\n?|\n?```/g, "").trim();
         try {
-            const result = JSON.parse(cleanJson);
-            if (result.workflows && Array.isArray(result.workflows)) {
-                result.workflows = result.workflows.map((wf) => this.fixHallucinatedNodes(wf));
+            const result = JSON.parse(jsonrepair(cleanJson));
+            if (typeof result !== 'object' || result === null) {
+                return { ...primarySpec, suggestedName: primarySpec.suggestedName + " (Alt)", strategyName: 'alternative' };
             }
             return result;
         }
-        catch (e) {
-            console.error('Failed to parse workflow JSON from spec', e);
-            throw new Error('AI generated invalid JSON for workflow from spec');
-        }
-    }
-    /**
-     * Generate mock data for a workflow execution
-     */
-    async generateMockData(context, previousFailures = []) {
-        let failureContext = '';
-        if (previousFailures.length > 0) {
-            failureContext = `\n\nIMPORTANT: The following attempts FAILED. Do NOT repeat these patterns.\nErrors:\n${previousFailures.join('\n')}`;
-        }
-        const systemPrompt = `You are a QA Data Generator.
-    Your task is to generate a realistic JSON payload to trigger an n8n workflow.
-
-    CRITICAL: Output ONLY valid raw JSON. No markdown, no explanations, no "Okay" or "Here is".
-    If you include any text outside the JSON, the system will crash.
-
-    Context: ${context}${failureContext}`;
-        const response = await this.generateContent(systemPrompt);
-        let cleanJson = response || '{}';
-        cleanJson = cleanJson.replace(/```json\n?|\n?```/g, '').trim();
-        try {
-            return JSON.parse(cleanJson);
-        }
-        catch (e) {
-            console.error('Failed to parse generated mock data', e);
-            return { message: 'AI generation failed, fallback data' };
+        catch {
+            // Fallback to primary spec with a suffix as expected by some tests or flows
+            return { ...primarySpec, suggestedName: primarySpec.suggestedName + " (Alt)", strategyName: 'alternative' };
         }
     }
-    /**
-     * Diagnostic Repair: Fix a workflow based on execution error
-     */
-    async generateWorkflowFix(workflowJson, errorContext, model, _useSearch = false, validNodeTypes = []) {
-        const prompt = `You are a Senior n8n Workflow Engineer.
-      A workflow failed during execution. Your task is to analyze the JSON and the Error, and provide a FIXED version of the workflow JSON.
-
-      Error Context:
-      ${errorContext}
+    async generateWorkflowFix(workflow, error, model, _stream = false, validNodeTypes = []) {
+        const nodeService = NodeDefinitionsService.getInstance();
+        const staticRef = nodeService.getStaticReference();
+        const prompt = `You are an n8n Expert.
+       The following workflow has validation errors:
+       ${JSON.stringify(workflow, null, 2)}
+       
+       Errors: ${error}
 
-      Workflow JSON:
-      ${JSON.stringify(workflowJson, null, 2)}
+       [N8N NODE REFERENCE GUIDE]
+       ${staticRef}
+       
+       ${validNodeTypes.length > 0 ? `Valid available node types: ${validNodeTypes.join(', ')}` : ''}
 
-      Review the nodes involved in the error.
-      ${validNodeTypes.length > 0 ? `CRITICAL: You MUST only use node types from the following ALLOWED list: ${JSON.stringify(validNodeTypes.slice(0, 100))}... (and other standard n8n-nodes-base.* types). If a node type is not valid, replace it with 'n8n-nodes-base.httpRequest' or 'n8n-nodes-base.set'.` : ''}
-      IMPORTANT: If the error is "Unrecognized node type: n8n-nodes-base.schedule", you MUST fix it to "n8n-nodes-base.scheduleTrigger".
-      If a node produced 0 items, check its input data mapping or filter conditions.
-      If a node crashed, check missing parameters.
-
-      Output ONLY valid JSON. No markdown. RETURN THE ENTIRE FIXED WORKFLOW JSON.
-      `;
+       Please fix the workflow and return the complete, corrected workflow JSON.
+       Ensure all node types and connection structures are valid.
+       Output ONLY the JSON object. No commentary.`;
         const response = await this.generateContent(prompt, { model });
+        const cleanJson = response.replace(/```json\n?|\n?```/g, "").trim();
         try {
-            let cleanJson = response || '{}';
-            cleanJson = cleanJson.replace(/```json\n?|\n?```/g, '').trim();
-            const fixed = JSON.parse(cleanJson);
-            const invalidNodeMatch = errorContext.match(/Unrecognized node type: ([\w.-]+)/);
-            const explicitlyInvalid = invalidNodeMatch ? [invalidNodeMatch[1]] : [];
-            const corrected = this.fixHallucinatedNodes(fixed);
-            return this.validateAndShim(corrected, validNodeTypes, explicitlyInvalid);
+            const fixed = JSON.parse(jsonrepair(cleanJson));
+            return fixed.workflows?.[0] || fixed;
         }
         catch (e) {
-            console.error('Failed to parse AI workflow fix', e);
-            throw new Error('AI generated invalid JSON for fix');
+            console.error("Failed to parse fix JSON", e);
+            return workflow;
         }
     }
-    /**
-     * Auto-correct common n8n node type hallucinations
-     */
+    validateAndShim(workflow, validNodeTypes = [], explicitlyInvalid = []) {
+        if (!workflow || !workflow.nodes)
+            return workflow;
+        const shimmedWorkflow = JSON.parse(JSON.stringify(workflow));
+        shimmedWorkflow.nodes = shimmedWorkflow.nodes.map((node) => {
+            const type = node.type;
+            const isExplicitlyInvalid = explicitlyInvalid.includes(type);
+            const isUnknown = validNodeTypes.length > 0 && !validNodeTypes.includes(type);
+            if (isExplicitlyInvalid || isUnknown) {
+                const originalType = node.type;
+                let shimType = 'n8n-nodes-base.set';
+                const lowerType = originalType.toLowerCase();
+                if (lowerType.includes('trigger') || lowerType.includes('webhook')) {
+                    shimType = 'n8n-nodes-base.webhook';
+                }
+                else if (lowerType.includes('slack') || lowerType.includes('api') || lowerType.includes('http') || lowerType.includes('discord')) {
+                    shimType = 'n8n-nodes-base.httpRequest';
+                }
+                node.type = shimType;
+                node.notes = (node.notes || '') + (node.notes ? '\n' : '') + `[Shimmed from ${originalType}]`;
+            }
+            return node;
+        });
+        return shimmedWorkflow;
+    }
     fixHallucinatedNodes(workflow) {
         if (!workflow.nodes || !Array.isArray(workflow.nodes))
             return workflow;
         const corrections = {
-            'n8n-nodes-base.rssFeed': 'n8n-nodes-base.rssFeedRead',
-            'rssFeed': 'n8n-nodes-base.rssFeedRead',
-            'n8n-nodes-base.gpt': 'n8n-nodes-base.openAi',
-            'n8n-nodes-base.openai': 'n8n-nodes-base.openAi',
-            'openai': 'n8n-nodes-base.openAi',
-            'n8n-nodes-base.openAiChat': 'n8n-nodes-base.openAi',
-            'n8n-nodes-base.openAIChat': 'n8n-nodes-base.openAi',
-            'n8n-nodes-base.openaiChat': 'n8n-nodes-base.openAi',
-            'n8n-nodes-base.gemini': 'n8n-nodes-base.googleGemini',
-            'n8n-nodes-base.cheerioHtml': 'n8n-nodes-base.htmlExtract',
-            'cheerioHtml': 'n8n-nodes-base.htmlExtract',
-            'n8n-nodes-base.schedule': 'n8n-nodes-base.scheduleTrigger',
-            'schedule': 'n8n-nodes-base.scheduleTrigger',
-            'n8n-nodes-base.cron': 'n8n-nodes-base.scheduleTrigger',
-            'n8n-nodes-base.googleCustomSearch': 'n8n-nodes-base.googleGemini',
-            'googleCustomSearch': 'n8n-nodes-base.googleGemini',
+            "n8n-nodes-base.rssFeed": "n8n-nodes-base.rssFeedRead",
+            "rssFeed": "n8n-nodes-base.rssFeedRead",
+            "n8n-nodes-base.gpt": "n8n-nodes-base.openAi",
+            "n8n-nodes-base.openai": "n8n-nodes-base.openAi",
+            "openai": "n8n-nodes-base.openAi",
+            "n8n-nodes-base.openAiChat": "n8n-nodes-base.openAi",
+            "n8n-nodes-base.openAIChat": "n8n-nodes-base.openAi",
+            "n8n-nodes-base.openaiChat": "n8n-nodes-base.openAi",
+            "n8n-nodes-base.gemini": "n8n-nodes-base.googleGemini",
+            "n8n-nodes-base.cheerioHtml": "n8n-nodes-base.htmlExtract",
+            "cheerioHtml": "n8n-nodes-base.htmlExtract",
+            "n8n-nodes-base.schedule": "n8n-nodes-base.scheduleTrigger",
+            "schedule": "n8n-nodes-base.scheduleTrigger",
+            "n8n-nodes-base.cron": "n8n-nodes-base.scheduleTrigger",
+            "n8n-nodes-base.googleCustomSearch": "n8n-nodes-base.googleGemini",
+            "googleCustomSearch": "n8n-nodes-base.googleGemini"
         };
         workflow.nodes = workflow.nodes.map((node) => {
             if (node.type && corrections[node.type]) {
-                console.log(`[AI Fix] Correcting node type: ${node.type} -> ${corrections[node.type]}`);
                 node.type = corrections[node.type];
             }
             if (node.type && !node.type.startsWith('n8n-nodes-base.') && !node.type.includes('.')) {
@@ -329,9 +325,6 @@ export class AIService {
         });
         return this.fixN8nConnections(workflow);
     }
-    /**
-     * Force-fix connection structure to prevent "object is not iterable" errors
-     */
     fixN8nConnections(workflow) {
         if (!workflow.connections || typeof workflow.connections !== 'object')
             return workflow;
@@ -357,7 +350,7 @@ export class AIService {
                         return {
                             node: String(conn.node || 'Unknown'),
                             type: conn.type || 'main',
-                            index: conn.index || 0,
+                            index: conn.index || 0
                         };
                     });
                 });
@@ -370,135 +363,94 @@ export class AIService {
         workflow.connections = fixedConnections;
         return workflow;
     }
-    /**
-     * Generate an alternative workflow specification with a different approach to the same goal.
-     * Used by the Architect node to produce a second strategy for parallel Engineer execution.
-     */
-    async generateAlternativeSpec(goal, primarySpec) {
-        const prompt = `You are an n8n Solutions Architect exploring alternative workflow designs.
-
-A primary solution already exists for this goal. Your task is to design a DIFFERENT approach that achieves the same result.
-
-Goal: ${goal}
-
-Primary Specification (for reference — design something DIFFERENT):
-${JSON.stringify(primarySpec, null, 2)}
-
-Create an alternative approach that:
-- Uses DIFFERENT n8n nodes or integrations where possible
-- May take a simpler, more minimal path OR a more robust, comprehensive one
-- Achieves the SAME end goal
-
-Output ONLY valid JSON with this structure:
-{
-  "goal": "...",
-  "suggestedName": "...",
-  "tasks": [...],
-  "nodes": [...],
-  "assumptions": [...],
-  "questions": [],
-  "strategyType": "alternative"
-}`;
+    async generateMockData(context) {
+        const prompt = `You are a testing expert. Generate mock data for the following context:
+      ${context}
+      Output ONLY valid JSON payload. No commentary.`;
         const response = await this.generateContent(prompt, { temperature: 0.9 });
-        let cleanJson = response || '{}';
-        cleanJson = cleanJson.replace(/```json\n?|\n?```/g, '').trim();
+        const cleanJson = response.replace(/```json\n?|\n?```/g, "").trim();
         try {
-            return JSON.parse(cleanJson);
+            const result = JSON.parse(jsonrepair(cleanJson));
+            if (typeof result !== 'object' || result === null) {
+                return { message: cleanJson };
+            }
+            return result;
         }
         catch {
-            console.warn('[AIService] Failed to parse alternative spec, falling back to primary variant');
-            return { ...primarySpec, suggestedName: `${primarySpec.suggestedName} (Alt)`, strategyType: 'alternative' };
+            return { message: cleanJson };
         }
     }
-    /**
-     * Evaluate multiple workflow candidates and select the best one for the given goal.
-     * Used by the Supervisor node to choose between parallel Engineer outputs.
-     */
     async evaluateCandidates(goal, candidates) {
-        if (candidates.length <= 1) {
-            return { selectedIndex: 0, reason: 'Single candidate — no evaluation needed.' };
-        }
-        const candidateSummaries = candidates.map((c, i) => {
-            const nodeNames = c?.nodes?.map((n) => n.name || n.type).join(', ') || 'unknown nodes';
-            return `Candidate ${i + 1}: "${c?.name || 'Unnamed'}" — Nodes: [${nodeNames}]`;
+        if (candidates.length === 0)
+            return { selectedIndex: 0, reason: "No candidates" };
+        if (candidates.length === 1)
+            return { selectedIndex: 0, reason: "Single candidate" };
+        const candidatesSummary = candidates.map((c, i) => {
+            const wf = c.workflows?.[0] || c;
+            const nodeTypes = (wf.nodes || []).map((n) => n.type);
+            return `Candidate ${i}: Nodes: ${nodeTypes.join(', ')}`;
         }).join('\n');
-        const prompt = `You are an n8n Solutions Architect evaluating workflow implementations.
-
-Goal: ${goal}
-
-Evaluate these ${candidates.length} candidate workflows and select the BEST one:
-${candidateSummaries}
-
-Select the best candidate based on:
-1. Completeness — does it fully achieve the goal?
-2. Node quality — are the nodes standard and appropriate?
-3. Simplicity — is it appropriately complex (not over-engineered)?
-4. Data flow — is the logic sound?
-
-Output ONLY valid JSON:
-{ "selectedIndex": <0-based integer>, "reason": "<1-2 sentence explanation>" }`;
-        const response = await this.generateContent(prompt, { temperature: 0.3 });
-        let cleanJson = response || '{}';
-        cleanJson = cleanJson.replace(/```json\n?|\n?```/g, '').trim();
+        const prompt = `You are a Workflow Supervisor. Goal: "${goal}"
+       Evaluate these alternate n8n workflow candidates:
+       ${candidatesSummary}
+       
+       Select the best one based on robustness and simplicity.
+       Return JSON: { "selectedIndex": number, "reason": "string" }
+       Output ONLY JSON. No commentary.`;
+        const response = await this.generateContent(prompt);
+        const cleanJson = response.replace(/```json\n?|\n?```/g, "").trim();
         try {
-            const result = JSON.parse(cleanJson);
-            const idx = typeof result.selectedIndex === 'number' ? result.selectedIndex : 0;
-            return {
-                selectedIndex: Math.max(0, Math.min(idx, candidates.length - 1)),
-                reason: result.reason || 'Best overall candidate.',
-            };
+            const result = JSON.parse(jsonrepair(cleanJson));
+            // Clamp and sanitize response to match tests
+            if (typeof result.selectedIndex !== 'number')
+                result.selectedIndex = 0;
+            if (result.selectedIndex < 0)
+                result.selectedIndex = 0;
+            if (result.selectedIndex >= candidates.length)
+                result.selectedIndex = Math.max(0, candidates.length - 1);
+            if (!result.reason)
+                result.reason = "Heuristic selection";
+            return result;
         }
         catch {
-            console.warn('[AIService] Failed to parse candidate evaluation, defaulting to index 0');
-            return { selectedIndex: 0, reason: 'Evaluation failed, defaulting to first candidate.' };
+            return { selectedIndex: 0, reason: "Failed to parse AI response" };
         }
     }
     /**
-     * Validate against real node types and shim unknown ones
+     * Generates 3-5 diverse test scenarios (input payloads) for a workflow.
      */
-    validateAndShim(workflow, validNodeTypes = [], explicitlyInvalid = []) {
-        const valid = validNodeTypes || [];
-        const invalid = explicitlyInvalid || [];
-        if (valid.length === 0 && invalid.length === 0)
-            return workflow;
-        if (!workflow || !workflow.nodes || !Array.isArray(workflow.nodes))
-            return workflow;
-        const validSet = new Set(valid.map(t => t.toLowerCase()));
-        const invalidSet = new Set(invalid.map(t => t.toLowerCase()));
-        const isTrigger = (name) => name.toLowerCase().includes('trigger') || name.toLowerCase().includes('webhook');
-        workflow.nodes = workflow.nodes.map((node) => {
-            if (!node || !node.type)
-                return node;
-            const type = node.type.toLowerCase();
-            const shouldShim = invalidSet.has(type) || (validSet.size > 0 && !validSet.has(type));
-            if (!shouldShim)
-                return node;
-            console.warn(`[Validation] Unknown/Invalid node type detected: ${node.type}. Shimming...`);
-            const originalType = node.type;
-            const notes = `[Shim] Original Type: ${originalType}. Replaced because type is not installed on this n8n instance.`;
-            const apiKeywords = [
-                'api', 'http', 'slack', 'discord', 'telegram', 'google', 'aws',
-                'github', 'stripe', 'twilio', 'linear', 'notion', 'airtable',
-                'alpaca', 'openai', 'hubspot', 'mailchimp', 'postgres', 'mysql',
-                'redis', 'mongo', 'firebase', 'supabase',
-            ];
-            const isApi = apiKeywords.some(keyword => originalType.includes(keyword));
-            let replacementType = 'n8n-nodes-base.set';
-            if (isTrigger(originalType)) {
-                replacementType = 'n8n-nodes-base.webhook';
-            }
-            else if (isApi) {
-                replacementType = 'n8n-nodes-base.httpRequest';
-            }
-            return {
-                ...node,
-                type: replacementType,
-                typeVersion: 1,
-                notes,
-                credentials: {},
-                parameters: { options: {} },
-            };
-        });
-        return workflow;
+    async generateTestScenarios(workflowJson, goal) {
+        const prompt = `You are an n8n QA Engineer.
+    Given the following workflow goal and structure, generate 3 diverse test scenarios (input payloads) to verify its robustness.
+    
+    Goal: ${goal}
+    
+    Workflow Summary (Nodes):
+    ${(workflowJson.nodes || []).map((n) => `- ${n.name} (${n.type})`).join('\n')}
+    
+    Generate 3 scenarios:
+    1. Happy Path: A standard, valid input that should succeed.
+    2. Edge Case: A valid but unusual input (e.g. empty strings, special characters, max values).
+    3. Error Case: An input that is likely to trigger a validation error or branch (e.g. missing required field, invalid format).
+    
+    Output a JSON array of objects, where each object has:
+    {
+      "name": "Scenario Description",
+      "payload": { ... input data ... },
+      "expectedBehavior": "What should happen"
+    }
+    
+    Output ONLY valid JSON. No commentary. No markdown.
+    `;
+        const response = await this.generateContent(prompt);
+        try {
+            const cleanJson = (response || "[]").replace(/```json\n?|\n?```/g, "").trim();
+            return JSON.parse(jsonrepair(cleanJson));
+        }
+        catch {
+            return [{ name: "Default Test", payload: {}, expectedBehavior: "Success" }];
+        }
     }
 }
+// Dummy for compilation fix
+const presetConfigs = PROVIDER_PRESETS;