@lhi/n8m 0.1.2 → 0.1.3

package/README.md

@@ -235,6 +235,14 @@ npm run dev
 
 ---
 
+## Sponsors
+
+### Partially Sponsored By
+
+[The Daily Caller](https://dailycaller.com)
+
+---
+
 ## Roadmap
 
 - [x] Agentic graph (Architect → Engineer → QA)

package/bin/dev.js

@@ -1,5 +1,13 @@
 #!/usr/bin/env node --loader ts-node/esm --no-warnings=ExperimentalWarning
 
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { config } from 'dotenv';
+
+// Load .env from the package root regardless of the user's cwd
+const __dirname = dirname(fileURLToPath(import.meta.url));
+config({ path: join(__dirname, '..', '.env') });
+
 import {execute} from '@oclif/core'
 
 await execute({development: true, dir: import.meta.url})

package/bin/run.js

@@ -1,5 +1,11 @@
 #!/usr/bin/env node
-import 'dotenv/config';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { config } from 'dotenv';
+
+// Load .env from the package root regardless of the user's cwd
+const __dirname = dirname(fileURLToPath(import.meta.url));
+config({ path: join(__dirname, '..', '.env') });
 
 import {execute} from '@oclif/core'
 

package/dist/agentic/graph.d.ts

@@ -129,9 +129,21 @@ export declare const graph: import("@langchain/langgraph").CompiledStateGraph<{
     collaborationLog: import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
 }, import("@langchain/langgraph").StateDefinition, {
     architect: {
-        spec: any;
-        strategies: any[];
-        needsClarification: any;
+        spec: import("../services/ai.service.js").WorkflowSpec;
+        strategies: {
+            strategyName: string;
+            aiModel: string;
+            suggestedName: string;
+            description: string;
+            nodes: {
+                type: string;
+                purpose: string;
+                config?: any;
+            }[];
+            questions?: string[];
+            aiProvider?: string;
+        }[];
+        needsClarification: boolean | undefined;
         collaborationLog: string[];
     };
     engineer: {
@@ -141,8 +153,8 @@ export declare const graph: import("@langchain/langgraph").CompiledStateGraph<{
         workflowJson?: undefined;
         candidates?: undefined;
     } | {
-        workflowJson: any;
         candidates: any[];
+        workflowJson?: undefined;
     };
     reviewer: import("@langchain/langgraph").UpdateType<{
         userGoal: {
@@ -318,9 +330,21 @@ export declare const runAgenticWorkflow: (goal: string, initialState?: Partial<t
  */
 export declare const runAgenticWorkflowStream: (goal: string, threadId?: string) => Promise<import("@langchain/core/utils/stream").IterableReadableStream<{
     architect?: {
-        spec: any;
-        strategies: any[];
-        needsClarification: any;
+        spec: import("../services/ai.service.js").WorkflowSpec;
+        strategies: {
+            strategyName: string;
+            aiModel: string;
+            suggestedName: string;
+            description: string;
+            nodes: {
+                type: string;
+                purpose: string;
+                config?: any;
+            }[];
+            questions?: string[];
+            aiProvider?: string;
+        }[];
+        needsClarification: boolean | undefined;
         collaborationLog: string[];
     } | undefined;
     engineer?: {
@@ -330,8 +354,8 @@ export declare const runAgenticWorkflowStream: (goal: string, threadId?: string)
         workflowJson?: undefined;
         candidates?: undefined;
     } | {
-        workflowJson: any;
         candidates: any[];
+        workflowJson?: undefined;
     } | undefined;
     reviewer?: import("@langchain/langgraph").UpdateType<{
         userGoal: {

package/dist/agentic/nodes/architect.d.ts

@@ -1,7 +1,19 @@
 import { TeamState } from "../state.js";
 export declare const architectNode: (state: typeof TeamState.State) => Promise<{
-    spec: any;
-    strategies: any[];
-    needsClarification: any;
+    spec: import("../../services/ai.service.js").WorkflowSpec;
+    strategies: {
+        strategyName: string;
+        aiModel: string;
+        suggestedName: string;
+        description: string;
+        nodes: {
+            type: string;
+            purpose: string;
+            config?: any;
+        }[];
+        questions?: string[];
+        aiProvider?: string;
+    }[];
+    needsClarification: boolean | undefined;
     collaborationLog: string[];
 }>;

package/dist/agentic/nodes/architect.js

@@ -33,9 +33,18 @@ export const architectNode = async (state) => {
         // Multi-agent collaboration: generate an alternative strategy in parallel with the primary.
         // Both are handed off to separate Engineer agents that run concurrently.
         const alternativeSpec = await aiService.generateAlternativeSpec(state.userGoal, spec);
+        const alternativeModel = aiService.getAlternativeModel();
         const strategies = [
-            { ...spec, strategyName: "Primary Strategy" },
-            { ...alternativeSpec, strategyName: "Alternative Strategy" },
+            {
+                ...spec,
+                strategyName: "Primary Strategy",
+                aiModel: aiService.getDefaultModel()
+            },
+            {
+                ...alternativeSpec,
+                strategyName: "Alternative Strategy",
+                aiModel: alternativeModel
+            },
         ];
         const logEntry = `Architect: Generated 2 strategies — "${strategies[0].suggestedName}" (primary) and "${strategies[1].suggestedName}" (alternative)`;
         console.log(`[Architect] ${logEntry}`);

package/dist/agentic/nodes/engineer.d.ts

@@ -6,6 +6,6 @@ export declare const engineerNode: (state: typeof TeamState.State) => Promise<{
     workflowJson?: undefined;
     candidates?: undefined;
 } | {
-    workflowJson: any;
     candidates: any[];
+    workflowJson?: undefined;
 }>;

package/dist/agentic/nodes/engineer.js

@@ -1,5 +1,6 @@
 import { AIService } from "../../services/ai.service.js";
 import { NodeDefinitionsService } from "../../services/node-definitions.service.js";
+import { jsonrepair } from "jsonrepair";
 export const engineerNode = async (state) => {
     const aiService = AIService.getInstance();
     // RAG: Load and Search Node Definitions
@@ -9,8 +10,9 @@ export const engineerNode = async (state) => {
     const queryText = (state.userGoal + (state.spec ? ` ${state.spec.suggestedName} ${state.spec.description}` : "")).replace(/\n/g, " ");
     // Search for relevant nodes (limit 8 to save context)
     const relevantDefs = nodeService.search(queryText, 8);
-    const ragContext = relevantDefs.length > 0
-        ? `\n\n[AVAILABLE NODE SCHEMAS - USE THESE EXACT PARAMETERS]\n${nodeService.formatForLLM(relevantDefs)}`
+    const staticRef = nodeService.getStaticReference();
+    const ragContext = (relevantDefs.length > 0 || staticRef)
+        ? `\n\n[N8N NODE REFERENCE GUIDE]\n${staticRef}\n\n[AVAILABLE NODE SCHEMAS - USE THESE EXACT PARAMETERS]\n${nodeService.formatForLLM(relevantDefs)}`
         : "";
     if (relevantDefs.length > 0) {
         console.log(`[Engineer] RAG: Found ${relevantDefs.length} relevant node schemas.`);
@@ -22,7 +24,8 @@ export const engineerNode = async (state) => {
             // We pass the entire list of errors as context
             const errorContext = state.validationErrors.join('\n');
             // Use the robust fix logic from AIService
-            const fixedWorkflow = await aiService.generateWorkflowFix(state.workflowJson, errorContext, undefined, false, state.availableNodeTypes || []);
+            const fixedWorkflow = await aiService.generateWorkflowFix(state.workflowJson, errorContext, state.spec?.aiModel, // Pass model if available
+            false, state.availableNodeTypes || []);
             return {
                 workflowJson: fixedWorkflow,
                 // validationErrors will be overwritten by next QA run
@@ -74,23 +77,27 @@ export const engineerNode = async (state) => {
        Output ONLY valid JSON. No commentary. No markdown.
        `;
         // Using AIService just for the LLM call to keep auth logic dry
-        const response = await aiService.generateContent(prompt);
+        const response = await aiService.generateContent(prompt, {
+            provider: state.spec.aiProvider,
+            model: state.spec.aiModel
+        });
         let cleanJson = response || "{}";
         cleanJson = cleanJson.replace(/```json\n?|\n?```/g, "").trim();
         let result;
         try {
-            result = JSON.parse(cleanJson);
+            result = JSON.parse(jsonrepair(cleanJson));
         }
-        catch (e) {
-            console.error("Failed to parse workflow JSON from spec", e);
+        catch (e2) {
+            console.error("Failed to parse workflow JSON from spec", e2);
             throw new Error("AI generated invalid JSON for workflow from spec");
         }
         if (result.workflows && Array.isArray(result.workflows)) {
             result.workflows = result.workflows.map((wf) => fixHallucinatedNodes(wf));
         }
         return {
-            workflowJson: result,
-            // For parallel execution, push to candidates
+            // Only push to candidates — the Supervisor sets workflowJson after fan-in.
+            // Writing workflowJson here would cause a LastValue conflict when two
+            // Engineers run in parallel via Send().
             candidates: [result],
         };
     }

package/dist/agentic/nodes/qa.js

@@ -10,8 +10,9 @@ export const qaNode = async (state) => {
     }
     // 1. Load Credentials
     const config = await ConfigManager.load();
-    const n8nUrl = config.n8nUrl || process.env.N8N_API_URL;
-    const n8nKey = config.n8nKey || process.env.N8N_API_KEY;
+    // Env vars take priority over stored config so a fresh key in .env is always used
+    const n8nUrl = process.env.N8N_API_URL || config.n8nUrl;
+    const n8nKey = process.env.N8N_API_KEY || config.n8nKey;
     if (!n8nUrl || !n8nKey) {
         throw new Error('Credentials missing. Configure environment via \'n8m config\'.');
     }
@@ -28,10 +29,21 @@ export const qaNode = async (state) => {
             targetWorkflow = workflowJson.workflows[0];
         }
         const workflowName = targetWorkflow.name || 'Agentic_Test_Workflow';
+        // Drop timezone — sanitizeSettings in N8nClient strips it unconditionally
+        const rawSettings = { ...(targetWorkflow.settings || {}) };
+        delete rawSettings.timezone;
+        // Strip credentials from all nodes — n8n 2.x refuses to activate ("publish")
+        // a workflow that references credentials that don't exist on the instance.
+        // Structural validation can still run; only live execution of credentialed
+        // nodes will be skipped/fail, which is expected for an ephemeral test.
+        const strippedNodes = targetWorkflow.nodes.map((node) => {
+            const { credentials: _creds, ...rest } = node;
+            return rest;
+        });
         const rootPayload = {
-            nodes: targetWorkflow.nodes,
+            nodes: strippedNodes,
             connections: targetWorkflow.connections,
-            settings: targetWorkflow.settings || {},
+            settings: rawSettings,
             staticData: targetWorkflow.staticData || {},
             name: `[n8m:test] ${workflowName}`,
         };

package/dist/agentic/nodes/reviewer.js

@@ -66,6 +66,8 @@ export const reviewerNode = async (state) => {
     // Triggers usually have no input.
     // We use a broader check: any node with "trigger" or "webhook" in the name, plus generic start types.
     const isTrigger = (type) => {
+        if (!type)
+            return false;
         const lower = type.toLowerCase();
         return lower.includes('trigger') ||
             lower.includes('webhook') ||
@@ -79,9 +81,9 @@ export const reviewerNode = async (state) => {
             // Sticky notes and Merge nodes can be tricky, but generally Merge needs input.
             if (!node.type.includes('StickyNote')) {
                 // Double check for "On Execution" (custom trigger name sometimes used)
-                if (!node.name.toLowerCase().includes('trigger') && !node.name.toLowerCase().includes('webhook')) {
-                    console.log(theme.warn(`[Reviewer] Validated disconnection: Node "${node.name}" has no incoming connections.`));
-                    validationErrors.push(`Node "${node.name}" (${node.type}) is disconnected (orphaned). Connect it or remove it.`);
+                if (!node.name || (!node.name.toLowerCase().includes('trigger') && !node.name.toLowerCase().includes('webhook'))) {
+                    console.log(theme.warn(`[Reviewer] Validated disconnection: Node "${node.name || 'Unnamed'}" has no incoming connections.`));
+                    validationErrors.push(`Node "${node.name || 'Unnamed'}" (${node.type || 'unknown type'}) is disconnected (orphaned). Connect it or remove it.`);
                 }
             }
         }

package/dist/resources/node-definitions-fallback.json

@@ -0,0 +1,213 @@
+[
+  {
+    "name": "n8n-nodes-base.start",
+    "displayName": "Manual Trigger",
+    "description": "The starting point for manual execution.",
+    "properties": []
+  },
+  {
+    "name": "n8n-nodes-base.httpRequest",
+    "displayName": "HTTP Request",
+    "description": "Send HTTP requests to any API",
+    "properties": [
+      {
+        "name": "method",
+        "displayName": "Method",
+        "type": "options",
+        "default": "GET",
+        "options": [
+          { "name": "GET", "value": "GET" },
+          { "name": "POST", "value": "POST" },
+          { "name": "PUT", "value": "PUT" },
+          { "name": "DELETE", "value": "DELETE" }
+        ]
+      },
+      {
+        "name": "url",
+        "displayName": "URL",
+        "type": "string",
+        "default": "",
+        "description": "The URL to send the request to"
+      },
+      {
+        "name": "authentication",
+        "displayName": "Authentication",
+        "type": "options",
+        "default": "none",
+        "options": [
+          { "name": "None", "value": "none" },
+          { "name": "Predefined Credential Type", "value": "predefinedCredentialType" }
+        ]
+      },
+      {
+        "name": "sendBody",
+        "displayName": "Send Body",
+        "type": "boolean",
+        "default": false
+      },
+      {
+        "name": "body",
+        "displayName": "Body",
+        "type": "json",
+        "default": ""
+      }
+    ]
+  },
+  {
+    "name": "n8n-nodes-base.slack",
+    "displayName": "Slack",
+    "description": "Interact with Slack",
+    "properties": [
+      {
+        "name": "resource",
+        "displayName": "Resource",
+        "type": "options",
+        "default": "message",
+        "options": [
+          { "name": "Message", "value": "message" },
+          { "name": "Channel", "value": "channel" }
+        ]
+      },
+      {
+        "name": "operation",
+        "displayName": "Operation",
+        "type": "options",
+        "default": "post",
+        "options": [
+          { "name": "Post", "value": "post" },
+          { "name": "Update", "value": "update" }
+        ]
+      },
+      {
+        "name": "channel",
+        "displayName": "Channel",
+        "type": "string",
+        "default": ""
+      },
+      {
+        "name": "text",
+        "displayName": "Text",
+        "type": "string",
+        "default": ""
+      }
+    ]
+  },
+  {
+    "name": "n8n-nodes-base.googleSheets",
+    "displayName": "Google Sheets",
+    "description": "Interact with Google Sheets",
+    "properties": [
+      {
+        "name": "resource",
+        "displayName": "Resource",
+        "type": "options",
+        "default": "sheet",
+        "options": [
+          { "name": "Sheet", "value": "sheet" }
+        ]
+      },
+      {
+        "name": "operation",
+        "displayName": "Operation",
+        "type": "options",
+        "default": "append",
+        "options": [
+          { "name": "Append", "value": "append" },
+          { "name": "Read", "value": "read" },
+          { "name": "Update", "value": "update" }
+        ]
+      },
+      {
+        "name": "sheetId",
+        "displayName": "Sheet ID",
+        "type": "string",
+        "default": ""
+      },
+      {
+        "name": "range",
+        "displayName": "Range",
+        "type": "string",
+        "default": "Sheet1!A:Z"
+      }
+    ]
+  },
+  {
+    "name": "n8n-nodes-base.if",
+    "displayName": "IF",
+    "description": "Conditional logic: True/False",
+    "properties": [
+      {
+        "name": "conditions",
+        "displayName": "Conditions",
+        "type": "json",
+        "default": {}
+      }
+    ]
+  },
+  {
+    "name": "n8n-nodes-base.set",
+    "displayName": "Set",
+    "description": "Set variables or values",
+    "properties": [
+      {
+        "name": "values",
+        "displayName": "Values",
+        "type": "fixedCollection",
+        "default": {}
+      }
+    ]
+  },
+  {
+    "name": "n8n-nodes-base.webhook",
+    "displayName": "Webhook",
+    "description": "Receive HTTP requests",
+    "properties": [
+      {
+        "name": "httpMethod",
+        "displayName": "HTTP Method",
+        "type": "options",
+        "default": "GET",
+        "options": [
+          { "name": "GET", "value": "GET" },
+          { "name": "POST", "value": "POST" }
+        ]
+      },
+      {
+        "name": "path",
+        "displayName": "Path",
+        "type": "string",
+        "default": ""
+      }
+    ]
+  },
+  {
+    "name": "n8n-nodes-base.code",
+    "displayName": "Code",
+    "description": "Run JavaScript/TypeScript",
+    "properties": [
+      {
+        "name": "jsCode",
+        "displayName": "JS Code",
+        "type": "string",
+        "default": "// Your code here\nreturn items;"
+      }
+    ]
+  },
+  {
+    "name": "n8n-nodes-base.merge",
+    "displayName": "Merge",
+    "description": "Merge data from multiple inputs",
+    "properties": [
+      {
+        "name": "mode",
+        "displayName": "Mode",
+        "type": "options",
+        "default": "append",
+        "options": [
+          { "name": "Append", "value": "append" },
+          { "name": "Merge by Index", "value": "mergeByIndex" }
+        ]
+      }
+    ]
+  }
+]

package/dist/services/ai.service.d.ts

@@ -1,64 +1,47 @@
 export interface GenerateOptions {
     model?: string;
+    provider?: string;
     temperature?: number;
 }
+export interface WorkflowSpec {
+    suggestedName: string;
+    description: string;
+    nodes: {
+        type: string;
+        purpose: string;
+        config?: any;
+    }[];
+    questions?: string[];
+    strategyName?: string;
+    aiModel?: string;
+    aiProvider?: string;
+}
+export declare const PROVIDER_PRESETS: Record<string, {
+    baseURL?: string;
+    defaultModel: string;
+    models: string[];
+}>;
 export declare class AIService {
     private static instance;
-    private client;
-    private model;
+    private clients;
+    private defaultProvider;
+    private defaultModel;
+    private apiKey;
+    private baseURL?;
     private constructor();
+    private getClient;
     static getInstance(): AIService;
-    /**
-     * Core generation method — works with any OpenAI-compatible API
-     */
+    private callAnthropicNative;
     generateContent(prompt: string, options?: GenerateOptions): Promise<string>;
-    /**
-     * Generate an n8n workflow from a description
-     */
-    generateWorkflow(description: string): Promise<any>;
-    /**
-     * Generate a Workflow Specification from a description
-     */
-    generateSpec(description: string): Promise<any>;
-    /**
-     * Refine a Specification based on user feedback
-     */
-    refineSpec(spec: any, feedback: string): Promise<any>;
-    /**
-     * Generate workflow JSONs from an approved Specification
-     */
-    generateWorkflowFromSpec(spec: any): Promise<any>;
-    /**
-     * Generate mock data for a workflow execution
-     */
-    generateMockData(context: string, previousFailures?: string[]): Promise<any>;
-    /**
-     * Diagnostic Repair: Fix a workflow based on execution error
-     */
-    generateWorkflowFix(workflowJson: any, errorContext: string, model?: string, _useSearch?: boolean, validNodeTypes?: string[]): Promise<any>;
-    /**
-     * Auto-correct common n8n node type hallucinations
-     */
-    private fixHallucinatedNodes;
-    /**
-     * Force-fix connection structure to prevent "object is not iterable" errors
-     */
-    private fixN8nConnections;
-    /**
-     * 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.
-     */
-    generateAlternativeSpec(goal: string, primarySpec: any): Promise<any>;
-    /**
-     * Evaluate multiple workflow candidates and select the best one for the given goal.
-     * Used by the Supervisor node to choose between parallel Engineer outputs.
-     */
+    getAlternativeModel(): string;
+    getDefaultModel(): string;
+    getDefaultProvider(): string;
+    generateSpec(goal: string): Promise<WorkflowSpec>;
+    generateAlternativeSpec(goal: string, primarySpec: WorkflowSpec): Promise<WorkflowSpec>;
+    generateWorkflowFix(workflow: any, error: string, model?: string, stream?: boolean, validNodeTypes?: string[]): Promise<any>;
+    generateMockData(context: string): Promise<any>;
     evaluateCandidates(goal: string, candidates: any[]): Promise<{
         selectedIndex: number;
         reason: string;
     }>;
-    /**
-     * Validate against real node types and shim unknown ones
-     */
-    validateAndShim(workflow: any, validNodeTypes?: string[], explicitlyInvalid?: string[]): any;
 }