feat: add n8n_generate_workflow tool for hosted workflow generation

Add new MCP tool that enables AI-powered workflow generation from natural
language descriptions. Uses handler delegation pattern — hosting environments
inject a GenerateWorkflowHandler via EngineOptions, self-hosted instances
receive a hosted-only informational response.

Handler flows through N8NMCPEngine → SingleSessionHTTPServer →
N8NDocumentationMCPServer with helpers for createWorkflow, validateWorkflow,
autofixWorkflow, and getWorkflow.

Includes full tool documentation, tests, and corrected tools overview count.

Conceived by Romuald Członkowski - https://www.aiadvisors.pl/en

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

tests/unit/mcp/generate-workflow-tool.test.ts

@@ -0,0 +1,90 @@
+import { describe, it, expect, vi } from 'vitest';
+import { n8nManagementTools } from '@/mcp/tools-n8n-manager';
+import type {
+  GenerateWorkflowHandler,
+  GenerateWorkflowArgs,
+  GenerateWorkflowResult,
+  GenerateWorkflowHelpers,
+} from '@/types/generate-workflow';
+
+describe('n8n_generate_workflow', () => {
+  describe('tool definition', () => {
+    const tool = n8nManagementTools.find((t) => t.name === 'n8n_generate_workflow');
+
+    it('exists in n8nManagementTools', () => {
+      expect(tool).toBeDefined();
+    });
+
+    it('has correct input schema', () => {
+      expect(tool!.inputSchema.properties).toHaveProperty('description');
+      expect(tool!.inputSchema.properties).toHaveProperty('skip_cache');
+      expect(tool!.inputSchema.required).toEqual(['description']);
+    });
+
+    it('has correct annotations', () => {
+      expect(tool!.annotations).toEqual({
+        title: 'Generate Workflow',
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: true,
+      });
+    });
+  });
+
+  describe('types', () => {
+    it('GenerateWorkflowHandler accepts correct signature', () => {
+      const handler: GenerateWorkflowHandler = async (args, context, helpers) => {
+        return {
+          success: true,
+          source: 'generated',
+          workflow_id: '123',
+          workflow_name: 'Test',
+          message: 'Done',
+        };
+      };
+      expect(handler).toBeDefined();
+    });
+
+    it('GenerateWorkflowHelpers has required methods', () => {
+      const helpers: GenerateWorkflowHelpers = {
+        createWorkflow: vi.fn(),
+        validateWorkflow: vi.fn(),
+        autofixWorkflow: vi.fn(),
+        getWorkflow: vi.fn(),
+      };
+      expect(helpers.createWorkflow).toBeDefined();
+      expect(helpers.validateWorkflow).toBeDefined();
+      expect(helpers.autofixWorkflow).toBeDefined();
+      expect(helpers.getWorkflow).toBeDefined();
+    });
+
+    it('GenerateWorkflowResult supports both success and failure', () => {
+      const success: GenerateWorkflowResult = {
+        success: true,
+        source: 'cache',
+        workflow_id: 'abc',
+        workflow_name: 'Test',
+        workflow_url: 'https://example.com/workflow/abc',
+        node_summary: 'Trigger → HTTP Request → Slack',
+      };
+      expect(success.success).toBe(true);
+
+      const failure: GenerateWorkflowResult = {
+        success: false,
+        error: 'Generation failed',
+        message: 'Try again',
+      };
+      expect(failure.success).toBe(false);
+    });
+
+    it('GenerateWorkflowArgs has description and optional skip_cache', () => {
+      const minimal: GenerateWorkflowArgs = { description: 'test' };
+      expect(minimal.description).toBe('test');
+      expect(minimal.skip_cache).toBeUndefined();
+
+      const withSkip: GenerateWorkflowArgs = { description: 'test', skip_cache: true };
+      expect(withSkip.skip_cache).toBe(true);
+    });
+  });
+});