fix: add QEMU setup for multi-arch Docker builds

Add docker/setup-qemu-action@v3 before Buildx setup to enable
proper QEMU emulation for linux/arm64 builds on GitHub Actions.

Fixes CI Docker build failure with "execve: No such file or directory"

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

.claude/agents/code-reviewer.md

@@ -1,6 +1,7 @@
 ---
 name: code-reviewer
 description: Use this agent when you need to review recently written or modified code for quality, security, and maintainability. This agent should be invoked immediately after code changes are made to ensure high standards are maintained. Examples:\n\n<example>\nContext: The user has created a code-review agent that should be called after writing code.\nuser: "Please write a function that validates email addresses"\nassistant: "I'll create an email validation function for you:"\n<function implementation>\nassistant: "Now let me use the code-reviewer agent to review this code for quality and security"\n<commentary>\nSince new code was just written, the code-reviewer agent should be invoked to ensure it meets quality standards.\n</commentary>\n</example>\n\n<example>\nContext: The user has modified existing code and wants it reviewed.\nuser: "I've updated the authentication logic, can you check if it's secure?"\nassistant: "I'll use the code-reviewer agent to analyze your authentication changes for security and best practices"\n<commentary>\nThe user has made changes to security-critical code, so the code-reviewer agent is the appropriate tool to ensure the modifications are secure and well-implemented.\n</commentary>\n</example>
+model: inherit
 ---
 
 You are a senior code reviewer with extensive experience in software engineering, security, and best practices. Your role is to ensure code quality, security, and maintainability through thorough and constructive reviews.

.claude/agents/n8n-mcp-tester.md

@@ -1,7 +1,7 @@
 ---
 name: n8n-mcp-tester
 description: Use this agent when you need to test n8n-mcp functionality after implementing fixes or new features. This agent should be invoked proactively after code changes to validate that the MCP tools work correctly with real n8n workflows. The agent tests the actual MCP server tools, not just unit tests. Examples:\n\n<example>\nContext: Developer has just fixed a validation bug in the n8n-mcp server\nuser: "I've fixed the validation issue for HTTP Request nodes"\nassistant: "I've completed the fix. Now let me build the project and then test it."\n<builds project>\nassistant: "Project built successfully. Please reload the MCP server in Claude Desktop to apply the changes."\nuser: "Reloaded"\nassistant: "Great! Now let me invoke the n8n-mcp-tester agent to verify the fix works correctly."\n<commentary>\nSince a fix has been implemented and the MCP server reloaded, use the n8n-mcp-tester agent to validate the fix works in real-world usage.\n</commentary>\n</example>\n\n<example>\nContext: Developer has added a new MCP tool for workflow validation\nuser: "I've implemented the new workflow validation tool"\nassistant: "Implementation complete. Let me build and prepare for testing."\n<builds project>\nassistant: "Build successful. Please reload the MCP server to load the new tool."\nuser: "Done"\nassistant: "Perfect! I'll now use the n8n-mcp-tester agent to test the new workflow validation tool."\n<commentary>\nAfter implementing new MCP functionality and reloading the server, invoke n8n-mcp-tester to verify it works correctly.\n</commentary>\n</example>
-tools: Glob, Grep, LS, Read, WebFetch, TodoWrite, WebSearch, mcp__puppeteer__puppeteer_navigate, mcp__puppeteer__puppeteer_screenshot, mcp__puppeteer__puppeteer_click, mcp__puppeteer__puppeteer_fill, mcp__puppeteer__puppeteer_select, mcp__puppeteer__puppeteer_hover, mcp__puppeteer__puppeteer_evaluate, ListMcpResourcesTool, ReadMcpResourceTool, mcp__supabase__list_organizations, mcp__supabase__get_organization, mcp__supabase__list_projects, mcp__supabase__get_project, mcp__supabase__get_cost, mcp__supabase__confirm_cost, mcp__supabase__create_project, mcp__supabase__pause_project, mcp__supabase__restore_project, mcp__supabase__create_branch, mcp__supabase__list_branches, mcp__supabase__delete_branch, mcp__supabase__merge_branch, mcp__supabase__reset_branch, mcp__supabase__rebase_branch, mcp__supabase__list_tables, mcp__supabase__list_extensions, mcp__supabase__list_migrations, mcp__supabase__apply_migration, mcp__supabase__execute_sql, mcp__supabase__get_logs, mcp__supabase__get_advisors, mcp__supabase__get_project_url, mcp__supabase__get_anon_key, mcp__supabase__generate_typescript_types, mcp__supabase__search_docs, mcp__supabase__list_edge_functions, mcp__supabase__deploy_edge_function, mcp__n8n-mcp__tools_documentation, mcp__n8n-mcp__list_nodes, mcp__n8n-mcp__get_node_info, mcp__n8n-mcp__search_nodes, mcp__n8n-mcp__list_ai_tools, mcp__n8n-mcp__get_node_documentation, mcp__n8n-mcp__get_database_statistics, mcp__n8n-mcp__get_node_essentials, mcp__n8n-mcp__search_node_properties, mcp__n8n-mcp__get_node_for_task, mcp__n8n-mcp__list_tasks, mcp__n8n-mcp__validate_node_operation, mcp__n8n-mcp__validate_node_minimal, mcp__n8n-mcp__get_property_dependencies, mcp__n8n-mcp__get_node_as_tool_info, mcp__n8n-mcp__list_node_templates, mcp__n8n-mcp__get_template, mcp__n8n-mcp__search_templates, mcp__n8n-mcp__get_templates_for_task, mcp__n8n-mcp__validate_workflow, mcp__n8n-mcp__validate_workflow_connections, mcp__n8n-mcp__validate_workflow_expressions, mcp__n8n-mcp__n8n_create_workflow, mcp__n8n-mcp__n8n_get_workflow, mcp__n8n-mcp__n8n_get_workflow_details, mcp__n8n-mcp__n8n_get_workflow_structure, mcp__n8n-mcp__n8n_get_workflow_minimal, mcp__n8n-mcp__n8n_update_full_workflow, mcp__n8n-mcp__n8n_update_partial_workflow, mcp__n8n-mcp__n8n_delete_workflow, mcp__n8n-mcp__n8n_list_workflows, mcp__n8n-mcp__n8n_validate_workflow, mcp__n8n-mcp__n8n_trigger_webhook_workflow, mcp__n8n-mcp__n8n_get_execution, mcp__n8n-mcp__n8n_list_executions, mcp__n8n-mcp__n8n_delete_execution, mcp__n8n-mcp__n8n_health_check, mcp__n8n-mcp__n8n_list_available_tools, mcp__n8n-mcp__n8n_diagnostic
+tools: Glob, Grep, Read, WebFetch, TodoWrite, WebSearch, mcp__supabase__create_branch, mcp__supabase__list_branches, mcp__supabase__delete_branch, mcp__supabase__merge_branch, mcp__supabase__reset_branch, mcp__supabase__rebase_branch, mcp__supabase__list_tables, mcp__supabase__list_extensions, mcp__supabase__list_migrations, mcp__supabase__apply_migration, mcp__supabase__execute_sql, mcp__supabase__get_logs, mcp__supabase__get_advisors, mcp__supabase__get_project_url, mcp__supabase__generate_typescript_types, mcp__supabase__search_docs, mcp__supabase__list_edge_functions, mcp__supabase__deploy_edge_function, mcp__n8n-mcp__tools_documentation, mcp__n8n-mcp__search_nodes, mcp__n8n-mcp__get_template, mcp__n8n-mcp__search_templates, mcp__n8n-mcp__validate_workflow, mcp__n8n-mcp__n8n_create_workflow, mcp__n8n-mcp__n8n_get_workflow, mcp__n8n-mcp__n8n_update_full_workflow, mcp__n8n-mcp__n8n_update_partial_workflow, mcp__n8n-mcp__n8n_delete_workflow, mcp__n8n-mcp__n8n_list_workflows, mcp__n8n-mcp__n8n_validate_workflow, mcp__n8n-mcp__n8n_trigger_webhook_workflow, mcp__n8n-mcp__n8n_health_check, mcp__brightdata-mcp__search_engine, mcp__brightdata-mcp__scrape_as_markdown, mcp__brightdata-mcp__search_engine_batch, mcp__brightdata-mcp__scrape_batch, mcp__supabase__get_publishable_keys, mcp__supabase__get_edge_function, mcp__n8n-mcp__get_node, mcp__n8n-mcp__validate_node, mcp__n8n-mcp__n8n_autofix_workflow, mcp__n8n-mcp__n8n_executions, mcp__n8n-mcp__n8n_workflow_versions, mcp__n8n-mcp__n8n_deploy_template, mcp__ide__getDiagnostics, mcp__ide__executeCode
 model: sonnet
 ---
 

.github/workflows/dependency-check.yml

@@ -0,0 +1,222 @@
+name: Dependency Compatibility Check
+
+# This workflow verifies that when users install n8n-mcp via npm (without lockfile),
+# they get compatible dependency versions. This catches issues like #440, #444, #446, #447, #450
+# where npm resolution gave users incompatible SDK/Zod versions.
+
+on:
+  push:
+    branches: [main]
+    paths:
+      - 'package.json'
+      - 'package-lock.json'
+      - '.github/workflows/dependency-check.yml'
+  pull_request:
+    branches: [main]
+    paths:
+      - 'package.json'
+      - 'package-lock.json'
+      - '.github/workflows/dependency-check.yml'
+  # Allow manual trigger for debugging
+  workflow_dispatch:
+  # Run weekly to catch upstream dependency changes
+  schedule:
+    - cron: '0 6 * * 1'  # Every Monday at 6 AM UTC
+
+permissions:
+  contents: read
+
+jobs:
+  fresh-install-check:
+    name: Fresh Install Dependency Check
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: 20
+
+      - name: Build package
+        run: |
+          npm ci
+          npm run build
+
+      - name: Pack package for testing
+        run: npm pack
+
+      - name: Create fresh install test directory
+        run: |
+          mkdir -p /tmp/fresh-install-test
+          cp n8n-mcp-*.tgz /tmp/fresh-install-test/
+
+      - name: Install package fresh (simulating user install)
+        working-directory: /tmp/fresh-install-test
+        run: |
+          npm init -y
+          # Install from tarball WITHOUT lockfile (simulates npm install n8n-mcp)
+          npm install ./n8n-mcp-*.tgz
+
+      - name: Verify critical dependency versions
+        working-directory: /tmp/fresh-install-test
+        run: |
+          echo "=== Dependency Version Check ==="
+          echo ""
+
+          # Get actual resolved versions
+          SDK_VERSION=$(npm list @modelcontextprotocol/sdk --json 2>/dev/null | jq -r '.dependencies["n8n-mcp"].dependencies["@modelcontextprotocol/sdk"].version // .dependencies["@modelcontextprotocol/sdk"].version // "not found"')
+          ZOD_VERSION=$(npm list zod --json 2>/dev/null | jq -r '.dependencies["n8n-mcp"].dependencies.zod.version // .dependencies.zod.version // "not found"')
+
+          echo "MCP SDK version: $SDK_VERSION"
+          echo "Zod version: $ZOD_VERSION"
+          echo ""
+
+          # Check MCP SDK version - must be exactly 1.20.1
+          if [[ "$SDK_VERSION" == "not found" ]]; then
+            echo "❌ FAILED: Could not determine MCP SDK version!"
+            echo "   The dependency may not have been installed correctly."
+            exit 1
+          fi
+          if [[ "$SDK_VERSION" != "1.20.1" ]]; then
+            echo "❌ FAILED: MCP SDK version mismatch!"
+            echo "   Expected: 1.20.1"
+            echo "   Got: $SDK_VERSION"
+            echo ""
+            echo "This can cause runtime errors. See issues #440, #444, #446, #447, #450"
+            exit 1
+          fi
+          echo "✅ MCP SDK version is correct: $SDK_VERSION"
+
+          # Check Zod version - must be 3.x (not 4.x, including pre-releases)
+          if [[ "$ZOD_VERSION" == "not found" ]]; then
+            echo "❌ FAILED: Could not determine Zod version!"
+            echo "   The dependency may not have been installed correctly."
+            exit 1
+          fi
+          if [[ "$ZOD_VERSION" =~ ^4\. ]]; then
+            echo "❌ FAILED: Zod v4 detected - incompatible with MCP SDK 1.20.1!"
+            echo "   Expected: 3.x"
+            echo "   Got: $ZOD_VERSION"
+            echo ""
+            echo "Zod v4 causes '_zod' property errors. See issues #440, #444, #446, #447, #450"
+            exit 1
+          fi
+          echo "✅ Zod version is compatible: $ZOD_VERSION"
+
+          echo ""
+          echo "=== All dependency checks passed ==="
+
+      - name: Test basic functionality
+        working-directory: /tmp/fresh-install-test
+        run: |
+          echo "=== Basic Functionality Test ==="
+
+          # Create a simple test script
+          cat > test-import.mjs << 'EOF'
+          import { spawn } from 'child_process';
+          import path from 'path';
+          import { fileURLToPath } from 'url';
+
+          const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+          // Test that the package can be required and basic tools work
+          async function test() {
+            console.log('Testing n8n-mcp package import...');
+
+            // Start the MCP server briefly to verify it initializes
+            const serverPath = path.join(__dirname, 'node_modules/n8n-mcp/dist/mcp/index.js');
+
+            const proc = spawn('node', [serverPath], {
+              env: { ...process.env, MCP_MODE: 'stdio' },
+              stdio: ['pipe', 'pipe', 'pipe']
+            });
+
+            // Send initialize request
+            const initRequest = JSON.stringify({
+              jsonrpc: '2.0',
+              id: 1,
+              method: 'initialize',
+              params: {
+                protocolVersion: '2024-11-05',
+                capabilities: {},
+                clientInfo: { name: 'test', version: '1.0.0' }
+              }
+            });
+
+            proc.stdin.write(initRequest + '\n');
+
+            // Wait for response or timeout
+            let output = '';
+            let stderrOutput = '';
+            proc.stdout.on('data', (data) => {
+              output += data.toString();
+            });
+
+            proc.stderr.on('data', (data) => {
+              stderrOutput += data.toString();
+              console.error('stderr:', data.toString());
+            });
+
+            // Give it 5 seconds to respond
+            await new Promise((resolve) => setTimeout(resolve, 5000));
+
+            proc.kill();
+
+            // Check for Zod v4 compatibility errors (the bug we're testing for)
+            const allOutput = output + stderrOutput;
+            if (allOutput.includes('_zod') || allOutput.includes('Cannot read properties of undefined')) {
+              console.error('❌ FAILED: Zod compatibility error detected!');
+              console.error('This indicates the SDK/Zod version fix is not working.');
+              console.error('See issues #440, #444, #446, #447, #450');
+              process.exit(1);
+            }
+
+            if (output.includes('"result"')) {
+              console.log('✅ MCP server initialized successfully');
+              return true;
+            } else {
+              console.log('Output received:', output.substring(0, 500));
+              // Server might not respond in stdio mode without proper framing
+              // But if we got here without crashing, that's still good
+              console.log('✅ MCP server started without errors');
+              return true;
+            }
+          }
+
+          test()
+            .then(() => {
+              console.log('=== Basic functionality test passed ===');
+              process.exit(0);
+            })
+            .catch((err) => {
+              console.error('❌ Test failed:', err.message);
+              process.exit(1);
+            });
+          EOF
+
+          node test-import.mjs
+
+      - name: Generate dependency report
+        if: always()
+        working-directory: /tmp/fresh-install-test
+        run: |
+          echo "=== Full Dependency Tree ===" > dependency-report.txt
+          npm list --all >> dependency-report.txt 2>&1 || true
+
+          echo "" >> dependency-report.txt
+          echo "=== Critical Dependencies ===" >> dependency-report.txt
+          npm list @modelcontextprotocol/sdk zod zod-to-json-schema >> dependency-report.txt 2>&1 || true
+
+          cat dependency-report.txt
+
+      - name: Upload dependency report
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: dependency-report-${{ github.run_number }}
+          path: /tmp/fresh-install-test/dependency-report.txt
+          retention-days: 30

.github/workflows/docker-build-n8n.yml

@@ -52,6 +52,9 @@ jobs:
       - name: Checkout repository
         uses: actions/checkout@v4
 
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+
       - name: Set up Docker Buildx
         uses: docker/setup-buildx-action@v3
 

CHANGELOG.md

@@ -7,6 +7,959 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.28.4] - 2025-12-05
+
+### Features
+
+**Configurable MAX_SESSIONS Limit (#468)**
+
+The `MAX_SESSIONS` limit is now configurable via the `N8N_MCP_MAX_SESSIONS` environment variable, addressing scalability issues for multi-tenant SaaS deployments.
+
+- **Problem**: Hardcoded limit of 100 concurrent sessions caused "Session limit reached" errors during peak usage
+- **Solution**: `MAX_SESSIONS` now reads from `N8N_MCP_MAX_SESSIONS` env var (default: 100)
+- **Usage**: Set `N8N_MCP_MAX_SESSIONS=1000` for higher capacity deployments
+- **Safety**: Includes `Math.max(1, ...)` floor to prevent invalid configurations
+- **Files**: `src/http-server-single-session.ts:44`
+
+```bash
+# Example: Allow up to 1000 concurrent sessions
+N8N_MCP_MAX_SESSIONS=1000
+```
+
+## [2.28.3] - 2025-12-02
+
+### Changed
+
+**Dependencies**
+- Updated n8n from 1.121.2 to 1.122.4
+- Updated n8n-core from 1.120.1 to 1.121.1
+- Updated n8n-workflow from 1.118.1 to 1.119.1
+- Updated @n8n/n8n-nodes-langchain from 1.120.1 to 1.121.1
+- Rebuilt node database with 544 nodes (438 from n8n-nodes-base, 106 from @n8n/n8n-nodes-langchain)
+
+### Removed
+
+**Templates**
+- Removed 7 templates from creator "ludwig" at author's request
+  - Template IDs: 2795, 2816, 2825, 2850, 2869, 2939, 3847
+
+**Conceived by Romuald Członkowski - [AiAdvisors](https://www.aiadvisors.pl/en)**
+
+## [2.28.2] - 2025-12-01
+
+### Bug Fixes
+
+**n8n_test_workflow: webhookId Resolution**
+
+Fixed critical bug where trigger handlers used `node.id` instead of `node.webhookId` for building webhook URLs. This caused chat/form/webhook triggers to fail with 404 errors when nodes had custom IDs.
+
+- **Root Cause**: `extractWebhookPath()` in `trigger-detector.ts` fell back to `node.id` instead of checking `node.webhookId` first
+- **Fix**: Added `webhookId` to `WorkflowNode` type and updated priority: `params.path` > `webhookId` > `node.id`
+- **Files**: `src/triggers/trigger-detector.ts`, `src/types/n8n-api.ts`
+
+**n8n_test_workflow: Chat Trigger URL Pattern**
+
+Fixed chat triggers using wrong URL pattern. n8n chat triggers require `/webhook/<id>/chat` suffix.
+
+- **Root Cause**: `buildTriggerUrl()` used same pattern for webhooks and chat triggers
+- **Fix**: Chat triggers now correctly use `/webhook/<webhookId>/chat` endpoint
+- **Files**: `src/triggers/trigger-detector.ts:284-289`
+
+**n8n_test_workflow: Form Trigger Content-Type**
+
+Fixed form triggers failing with "Expected multipart/form-data" error.
+
+- **Root Cause**: Form handler sent `application/json` but n8n requires `multipart/form-data`
+- **Fix**: Switched to `form-data` library for proper multipart encoding
+- **Files**: `src/triggers/handlers/form-handler.ts`
+
+### Enhancements
+
+**Form Handler: Complete Field Type Support**
+
+Enhanced form handler to support all n8n form field types with intelligent handling:
+
+- **Supported Types**: text, textarea, email, number, password, date, dropdown, checkbox, file, hidden, html
+- **Checkbox Arrays**: Automatically converts arrays to `field[]` format required by n8n
+- **File Uploads**: Supports base64 content or sends empty placeholder for required files
+- **Helpful Warnings**: Reports missing required fields with field names and labels
+- **Error Hints**: On failure, provides complete field structure with usage examples
+
+```javascript
+// Example with all field types
+n8n_test_workflow({
+  workflowId: "abc123",
+  data: {
+    "field-0": "text value",
+    "field-1": ["checkbox1", "checkbox2"],  // Array for checkboxes
+    "field-2": "dropdown_option",
+    "field-3": "2025-01-15",                // Date format
+    "field-4": "user@example.com",
+    "field-5": 42,                          // Number
+    "field-6": "password123"
+  }
+})
+```
+
+**Conceived by Romuald Członkowski - [AiAdvisors](https://www.aiadvisors.pl/en)**
+
+## [2.28.1] - 2025-12-01
+
+### 🐛 Bug Fixes
+
+**Issue #458: AI Connection Type Propagation**
+
+Fixed `addConnection` operation in workflow diff engine defaulting `targetInput` to "main" instead of preserving the source output type. This caused AI tool connections to be created with incorrect type.
+
+- **Root Cause**: `targetInput` defaulted to `'main'` regardless of `sourceOutput` type
+- **Fix**: Changed default to `sourceOutput` to preserve connection type (ai_tool, ai_memory, ai_languageModel)
+- **Files**: `src/services/workflow-diff-engine.ts:760`
+
+**AI Agent Validation False Positive**
+
+Fixed false positive "AI Agent has no tools connected" warning when tools were properly connected.
+
+- **Root Cause**: Validation checked connections FROM agent instead of TO agent
+- **Fix**: Search all connections where target node is the agent
+- **Files**: `src/services/workflow-validator.ts:1148-1163`
+
+### ✨ Enhancements
+
+**get_node: expectedFormat for resourceLocator Properties**
+
+Added `expectedFormat` field to resourceLocator properties in `get_node` output. This helps AI models understand the correct format for these complex property types.
+
+```json
+{
+  "name": "model",
+  "type": "resourceLocator",
+  "expectedFormat": {
+    "structure": { "mode": "string", "value": "string" },
+    "modes": ["list", "id"],
+    "example": { "mode": "id", "value": "gpt-4o-mini" }
+  }
+}
+```
+
+**get_node: versionNotice Field**
+
+Added `versionNotice` field to make typeVersion more prominent in get_node output, reducing the chance of AI models using outdated versions.
+
+```json
+{
+  "version": "1.3",
+  "versionNotice": "⚠️ Use typeVersion: 1.3 when creating this node"
+}
+```
+
+**Conceived by Romuald Członkowski - [AiAdvisors](https://www.aiadvisors.pl/en)**
+
+## [2.28.0] - 2025-12-01
+
+### ✨ Features
+
+**n8n_test_workflow: Unified Workflow Trigger Tool**
+
+Replaced `n8n_trigger_webhook_workflow` with a new unified `n8n_test_workflow` tool that supports multiple trigger types with auto-detection.
+
+#### Key Features
+
+1. **Auto-Detection of Trigger Type**
+   - Automatically analyzes workflow to detect trigger type (webhook, form, or chat)
+   - No need to specify triggerType unless you want to override detection
+
+2. **Multi-Trigger Support**
+   - **Webhook**: HTTP-based triggers (GET/POST/PUT/DELETE) with custom headers and data
+   - **Form**: Form submission triggers with form field data
+   - **Chat**: AI chat triggers with message and session continuity
+
+3. **SSRF Protection**
+   - All trigger handlers include SSRF URL validation
+   - Blocks requests to private networks, cloud metadata endpoints
+   - Configurable security modes (strict/moderate/permissive)
+
+4. **Extensible Handler Architecture**
+   - Plugin-based trigger handler system
+   - Registry pattern for easy extension
+   - Clean separation of concerns
+
+#### Usage
+
+```javascript
+// Auto-detect trigger type (recommended)
+n8n_test_workflow({workflowId: "123"})
+
+// Webhook with data
+n8n_test_workflow({
+  workflowId: "123",
+  triggerType: "webhook",
+  httpMethod: "POST",
+  data: {name: "John", email: "john@example.com"}
+})
+
+// Chat trigger
+n8n_test_workflow({
+  workflowId: "123",
+  triggerType: "chat",
+  message: "Hello AI assistant",
+  sessionId: "conversation-123"
+})
+
+// Form submission
+n8n_test_workflow({
+  workflowId: "123",
+  triggerType: "form",
+  data: {email: "test@example.com", name: "Test User"}
+})
+```
+
+#### Breaking Changes
+
+- **Removed**: `n8n_trigger_webhook_workflow` tool
+- **Replaced by**: `n8n_test_workflow` with enhanced capabilities
+- **Migration**: Change tool name and add `workflowId` parameter (previously `webhookUrl`)
+
+#### Technical Details
+
+**New Files:**
+- `src/triggers/` - Complete trigger system module
+  - `types.ts` - Type definitions for all trigger types
+  - `trigger-detector.ts` - Auto-detection logic
+  - `trigger-registry.ts` - Handler registration
+  - `handlers/` - Individual handler implementations
+
+**Modified Files:**
+- `src/mcp/handlers-n8n-manager.ts` - New `handleTestWorkflow` function
+- `src/mcp/tools-n8n-manager.ts` - Updated tool definition
+- `src/mcp/tool-docs/workflow_management/` - New documentation
+
+**Test Coverage:**
+- 32 unit tests for trigger detection and registry
+- 30 unit tests for SSRF protection
+- All parameter validation tests updated
+
+**Conceived by Romuald Członkowski - [AiAdvisors](https://www.aiadvisors.pl/en)**
+
+## [2.27.2] - 2025-11-29
+
+### ✨ Enhanced Features
+
+**n8n_deploy_template: Deploy-First with Auto-Fix**
+
+Improved the template deployment tool to deploy first, then automatically fix common issues. This change dramatically improves deployment success rates for templates with expression format issues.
+
+#### Key Changes
+
+1. **Deploy-First Behavior**
+   - Templates are now deployed first without pre-validation
+   - Auto-fix runs automatically after deployment (configurable via `autoFix` parameter)
+   - Returns `fixesApplied` array showing all corrections made
+
+2. **Fixed Expression Validator False Positive**
+   - Fixed "nested expressions" detection that incorrectly flagged valid patterns
+   - Multiple expressions in one string like `={{ $a }} text {{ $b }}` now correctly pass validation
+   - Only truly nested patterns like `{{ {{ $json }} }}` are flagged as errors
+
+3. **Fixed Zod Schema Validation**
+   - Added missing `typeversion-upgrade` and `version-migration` fix types to autofix schema
+   - Prevents silent validation failures when autofix runs
+
+#### Usage
+
+```javascript
+// Deploy with auto-fix (default behavior)
+n8n_deploy_template({
+  templateId: 2776,
+  name: "My Workflow"
+})
+
+// Deploy without auto-fix (not recommended)
+n8n_deploy_template({
+  templateId: 2776,
+  autoFix: false
+})
+```
+
+#### Response
+
+```json
+{
+  "workflowId": "abc123",
+  "name": "My Workflow",
+  "fixesApplied": [
+    {
+      "node": "HTTP Request",
+      "field": "url",
+      "type": "expression-format",
+      "before": "https://api.com/{{ $json.id }}",
+      "after": "=https://api.com/{{ $json.id }}",
+      "confidence": "high"
+    }
+  ]
+}
+```
+
+#### Testing Results
+
+- 87% deployment success rate across 15 diverse templates
+- Auto-fix correctly adds `=` prefix to expressions missing it
+- Auto-fix correctly upgrades outdated typeVersions
+- Failed deployments are legitimate issues (missing community nodes, incomplete templates)
+
+**Conceived by Romuald Członkowski - [AiAdvisors](https://www.aiadvisors.pl/en)**
+
+## [2.27.1] - 2025-11-29
+
+### 🐛 Bug Fixes
+
+**Issue #454: Docker Image Missing Zod Fix from #450**
+
+Fixed Docker image build that was missing the pinned MCP SDK version, causing `n8n_create_workflow` Zod validation errors to persist in the 2.27.0 Docker image.
+
+#### Root Cause
+
+Two files were not updated when #450 pinned the SDK version in `package.json`:
+- `package.runtime.json` had `"@modelcontextprotocol/sdk": "^1.13.2"` instead of `"1.20.1"`
+- `Dockerfile` builder stage had `@modelcontextprotocol/sdk@^1.12.1` hardcoded
+
+The Docker runtime stage uses `package.runtime.json` (not `package.json`), and the builder stage has hardcoded dependency versions.
+
+#### Changes
+
+- **package.runtime.json**: Updated SDK to pinned version `"1.20.1"` (no caret)
+- **Dockerfile**: Updated builder stage SDK to `@1.20.1` and pinned `zod@3.24.1`
+
+#### Impact
+
+- Docker images now include the correct MCP SDK version with Zod fix
+- `n8n_create_workflow` and other workflow tools work correctly in Docker deployments
+- No changes to functionality - this is a build configuration fix
+
+Fixes #454
+
+**Conceived by Romuald Członkowski - [AiAdvisors](https://www.aiadvisors.pl/en)**
+
+## [2.27.0] - 2025-11-28
+
+### ✨ Features
+
+**n8n_deploy_template Tool**
+
+Added new tool for one-click deployment of n8n.io workflow templates directly to your n8n instance.
+
+#### Key Features
+
+- Fetches templates from n8n.io by ID
+- Automatically upgrades node typeVersions to latest supported
+- Validates workflow before deployment
+- Lists required credentials for configuration
+- Strips credential references (user configures in n8n UI)
+
+#### Usage
+
+```javascript
+n8n_deploy_template({
+  templateId: 2639,           // Required: template ID from n8n.io
+  name: "My Custom Name",     // Optional: custom workflow name
+  autoUpgradeVersions: true,  // Default: upgrade node versions
+  validate: true,             // Default: validate before deploy
+  stripCredentials: true      // Default: remove credential refs
+})
+```
+
+**Conceived by Romuald Członkowski - [AiAdvisors](https://www.aiadvisors.pl/en)**
+
+## [2.26.5] - 2025-11-27
+
+### 🔧 Fixed
+
+- **Tools Documentation: Runtime Token Optimization**
+  - Removed historical migration information from tool descriptions (e.g., "Replaces X, Y, Z...")
+  - Removed version-specific references (v2.21.1, issue #357) that are not needed at runtime
+  - Cleaned up consolidation comments in index.ts
+  - Documentation now starts directly with functional content for better AI agent efficiency
+  - Estimated savings: ~128 tokens per full documentation request
+  - Affected tools: `get_node`, `validate_node`, `search_templates`, `n8n_executions`, `n8n_get_workflow`, `n8n_update_partial_workflow`
+
+**Conceived by Romuald Członkowski - [AiAdvisors](https://www.aiadvisors.pl/en)**
+
+## [2.26.4] - 2025-11-26
+
+### 🔧 Fixed
+
+- **n8n 1.121 Compatibility**: Added support for new workflow settings introduced in n8n 1.121
+  - Added `availableInMCP` (boolean) to settings whitelist - controls "Available in MCP" toggle
+  - Added `callerPolicy` to settings whitelist - was already in schema but missing from sanitization
+  - Both settings are now preserved during workflow updates instead of being silently stripped
+  - Settings can be toggled via `updateSettings` operation: `{type: "updateSettings", settings: {availableInMCP: true}}`
+
+**Conceived by Romuald Członkowski - [AiAdvisors](https://www.aiadvisors.pl/en)**
+
+## [2.26.3] - 2025-11-26
+
+### 🔧 Fixed
+
+- **Tools Documentation Gaps**: Addressed remaining documentation issues after v2.26.2 tool consolidation
+  - Added missing `n8n_workflow_versions` documentation with all 6 modes (list, get, rollback, delete, prune, truncate)
+  - Removed non-existent tools (`n8n_diagnostic`, `n8n_list_available_tools`) from documentation exports
+  - Fixed 10+ outdated tool name references:
+    - `get_node_essentials` → `get_node({detail: "standard"})`
+    - `validate_node_operation` → `validate_node()`
+    - `get_minimal` → `n8n_get_workflow({mode: "minimal"})`
+  - Added missing `mode` and `verbose` parameters to `n8n_health_check` documentation
+  - Added missing `mode` parameter to `get_template` documentation (nodes_only, structure, full)
+  - Updated template count from "399+" to "2,700+" in `get_template`
+  - Updated node count from "525" to "500+" in `search_nodes`
+  - Fixed `relatedTools` arrays to remove references to non-existent tools
+
+**Conceived by Romuald Członkowski - [AiAdvisors](https://www.aiadvisors.pl/en)**
+
+## [2.26.2] - 2025-11-25
+
+### 🔧 Fixed
+
+- **Tool Documentation Cleanup**: Synchronized `tool-docs/` with v2.26.0 tool consolidation
+  - Deleted 23 obsolete documentation files for removed tools (get_node_info, get_node_essentials, validate_node_operation, etc.)
+  - Created consolidated documentation for `get_node` (covers all modes: info, docs, search_properties, versions, compare, breaking, migrations)
+  - Created consolidated documentation for `validate_node` (covers modes: full, minimal; profiles: minimal, runtime, ai-friendly, strict)
+  - Created consolidated documentation for `n8n_executions` (covers actions: get, list, delete)
+  - Updated `search_templates` documentation with all searchModes (keyword, by_nodes, by_task, by_metadata)
+  - Updated `n8n_get_workflow` documentation with all modes (full, details, structure, minimal)
+  - Fixed stale `relatedTools` references pointing to removed tools
+  - Updated `tools-documentation.ts` overview to accurately reflect 19 consolidated tools
+
+## [2.26.1] - 2025-11-25
+
+### 🔄 Updated
+
+- Updated n8n from 1.120.3 to 1.121.2
+- Updated n8n-core from 1.119.2 to 1.120.1
+- Updated n8n-workflow from 1.117.0 to 1.118.1
+- Updated @n8n/n8n-nodes-langchain from 1.119.1 to 1.120.1
+- Rebuilt node database with 545 nodes (439 from n8n-nodes-base, 106 from @n8n/n8n-nodes-langchain)
+- Expanded template database from ~2,598 to 2,768 templates (+170 new templates)
+- Updated README badge with new n8n version
+
+## [2.26.0] - 2025-01-25
+
+### ✨ Features
+
+**Tool Consolidation - Reduced Tool Count by 38%**
+
+Major consolidation of MCP tools from 31 tools to 19 tools, using mode-based parameters for better AI agent ergonomics. This reduces cognitive load for AI agents while maintaining full functionality.
+
+#### Consolidated Tools
+
+**1. Node Tools - `get_node` Enhanced**
+
+The `get_node` tool now supports additional modes:
+- `mode='docs'`: Replaces `get_node_documentation` - returns readable docs with examples
+- `mode='search_properties'`: Replaces `search_node_properties` - search within node properties
+
+```javascript
+// Old: get_node_documentation
+get_node_documentation({nodeType: "nodes-base.slack"})
+// New: mode='docs'
+get_node({nodeType: "nodes-base.slack", mode: "docs"})
+
+// Old: search_node_properties
+search_node_properties({nodeType: "nodes-base.httpRequest", query: "auth"})
+// New: mode='search_properties'
+get_node({nodeType: "nodes-base.httpRequest", mode: "search_properties", propertyQuery: "auth"})
+```
+
+**2. Validation Tools - `validate_node` Unified**
+
+Consolidated `validate_node_operation` and `validate_node_minimal` into single `validate_node`:
+- `mode='full'`: Full validation (replaces `validate_node_operation`)
+- `mode='minimal'`: Quick required fields check (replaces `validate_node_minimal`)
+
+```javascript
+// Old: validate_node_operation
+validate_node_operation({nodeType: "nodes-base.slack", config: {...}})
+// New: mode='full' (default)
+validate_node({nodeType: "nodes-base.slack", config: {...}, mode: "full"})
+
+// Old: validate_node_minimal
+validate_node_minimal({nodeType: "nodes-base.slack", config: {}})
+// New: mode='minimal'
+validate_node({nodeType: "nodes-base.slack", config: {}, mode: "minimal"})
+```
+
+**3. Template Tools - `search_templates` Enhanced**
+
+Consolidated `list_node_templates`, `search_templates_by_metadata`, and `get_templates_for_task`:
+- `searchMode='keyword'`: Search by keywords (default, was `search_templates`)
+- `searchMode='by_nodes'`: Search by node types (was `list_node_templates`)
+- `searchMode='by_metadata'`: Search by AI metadata (was `search_templates_by_metadata`)
+- `searchMode='by_task'`: Search by task type (was `get_templates_for_task`)
+
+```javascript
+// Old: list_node_templates
+list_node_templates({nodeTypes: ["n8n-nodes-base.httpRequest"]})
+// New: searchMode='by_nodes'
+search_templates({searchMode: "by_nodes", nodeTypes: ["n8n-nodes-base.httpRequest"]})
+
+// Old: get_templates_for_task
+get_templates_for_task({task: "webhook_processing"})
+// New: searchMode='by_task'
+search_templates({searchMode: "by_task", task: "webhook_processing"})
+```
+
+**4. Workflow Getters - `n8n_get_workflow` Enhanced**
+
+Consolidated `n8n_get_workflow_details`, `n8n_get_workflow_structure`, `n8n_get_workflow_minimal`:
+- `mode='full'`: Complete workflow data (default)
+- `mode='details'`: Workflow with metadata (was `n8n_get_workflow_details`)
+- `mode='structure'`: Nodes and connections only (was `n8n_get_workflow_structure`)
+- `mode='minimal'`: ID, name, active status (was `n8n_get_workflow_minimal`)
+
+```javascript
+// Old: n8n_get_workflow_details
+n8n_get_workflow_details({id: "123"})
+// New: mode='details'
+n8n_get_workflow({id: "123", mode: "details"})
+
+// Old: n8n_get_workflow_minimal
+n8n_get_workflow_minimal({id: "123"})
+// New: mode='minimal'
+n8n_get_workflow({id: "123", mode: "minimal"})
+```
+
+**5. Execution Tools - `n8n_executions` Unified**
+
+Consolidated `n8n_list_executions`, `n8n_get_execution`, `n8n_delete_execution`:
+- `action='list'`: List executions with filters
+- `action='get'`: Get single execution details
+- `action='delete'`: Delete an execution
+
+```javascript
+// Old: n8n_list_executions
+n8n_list_executions({workflowId: "123", status: "success"})
+// New: action='list'
+n8n_executions({action: "list", workflowId: "123", status: "success"})
+
+// Old: n8n_get_execution
+n8n_get_execution({id: "456"})
+// New: action='get'
+n8n_executions({action: "get", id: "456"})
+
+// Old: n8n_delete_execution
+n8n_delete_execution({id: "456"})
+// New: action='delete'
+n8n_executions({action: "delete", id: "456"})
+```
+
+### 🗑️ Removed Tools
+
+The following tools have been removed (use consolidated equivalents):
+- `get_node_documentation` → `get_node` with `mode='docs'`
+- `search_node_properties` → `get_node` with `mode='search_properties'`
+- `get_property_dependencies` → Removed (use `validate_node` for dependency info)
+- `validate_node_operation` → `validate_node` with `mode='full'`
+- `validate_node_minimal` → `validate_node` with `mode='minimal'`
+- `list_node_templates` → `search_templates` with `searchMode='by_nodes'`
+- `search_templates_by_metadata` → `search_templates` with `searchMode='by_metadata'`
+- `get_templates_for_task` → `search_templates` with `searchMode='by_task'`
+- `n8n_get_workflow_details` → `n8n_get_workflow` with `mode='details'`
+- `n8n_get_workflow_structure` → `n8n_get_workflow` with `mode='structure'`
+- `n8n_get_workflow_minimal` → `n8n_get_workflow` with `mode='minimal'`
+- `n8n_list_executions` → `n8n_executions` with `action='list'`
+- `n8n_get_execution` → `n8n_executions` with `action='get'`
+- `n8n_delete_execution` → `n8n_executions` with `action='delete'`
+
+### 📊 Impact
+
+**Tool Count**: 31 → 19 tools (38% reduction)
+
+**For AI Agents:**
+- Fewer tools to choose from reduces decision complexity
+- Mode-based parameters provide clear action disambiguation
+- Consistent patterns across tool categories
+- Backward-compatible parameter handling
+
+**For Users:**
+- Simpler tool discovery and documentation
+- Consistent API design patterns
+- Reduced token usage in tool descriptions
+
+### 🔧 Technical Details
+
+**Files Modified:**
+- `src/mcp/tools.ts` - Consolidated tool definitions
+- `src/mcp/tools-n8n-manager.ts` - n8n manager tool consolidation
+- `src/mcp/server.ts` - Handler consolidation and mode routing
+- `tests/unit/mcp/parameter-validation.test.ts` - Updated for new tool names
+- `tests/integration/mcp-protocol/tool-invocation.test.ts` - Updated test cases
+- `tests/integration/mcp-protocol/error-handling.test.ts` - Updated error handling tests
+
+**Conceived by Romuald Członkowski - [AiAdvisors](https://www.aiadvisors.pl/en)**
+
+## [2.24.1] - 2025-01-24
+
+### ✨ Features
+
+**Session Persistence API**
+
+Added export/restore functionality for MCP sessions to enable zero-downtime deployments in container environments (Kubernetes, Docker Swarm, etc.).
+
+#### What's New
+
+**1. Export Session State**
+- `exportSessionState()` method in `SingleSessionHTTPServer` and `N8NMCPEngine`
+- Exports all active sessions with metadata and instance context
+- Automatically filters expired sessions
+- Returns serializable `SessionState[]` array
+
+**2. Restore Session State**
+- `restoreSessionState(sessions)` method for session recovery
+- Validates session structure using existing `validateInstanceContext()`
+- Handles null/invalid sessions gracefully with warnings
+- Enforces MAX_SESSIONS limit (default 100, configurable via N8N_MCP_MAX_SESSIONS env var)
+- Skips expired sessions during restore
+
+**3. SessionState Type**
+- New type definition in `src/types/session-state.ts`
+- Fully documented with JSDoc comments
+- Includes metadata (timestamps) and context (credentials)
+- Exported from main package index
+
+**4. Dormant Session Behavior**
+- Restored sessions are "dormant" until first request
+- Transport and server objects recreated on-demand
+- Memory-efficient session recovery
+
+#### Security Considerations
+
+⚠️ **IMPORTANT:** Exported session data contains plaintext n8n API keys. Downstream applications MUST encrypt session data before persisting to disk using AES-256-GCM or equivalent.
+
+#### Use Cases
+- Zero-downtime deployments in container orchestration
+- Session recovery after crashes or restarts
+- Multi-tenant platform session management
+- Rolling updates without user disruption
+
+#### Testing
+- 22 comprehensive unit tests (100% passing)
+- Tests cover export, restore, edge cases, and round-trip cycles
+- Validation of expired session filtering and error handling
+
+#### Implementation Details
+- Only exports sessions with valid `n8nApiUrl` and `n8nApiKey` in context
+- Respects `sessionTimeout` setting (default 30 minutes)
+- Session metadata and context persisted; transport/server recreated on-demand
+- Comprehensive error handling with detailed logging
+
+**Conceived by Romuald Członkowski - [AiAdvisors](https://www.aiadvisors.pl/en)**
+
+## [2.24.0] - 2025-01-24
+
+### ✨ Features
+
+**Unified Node Information Tool**
+
+Introduced `get_node` - a unified tool that consolidates and enhances node information retrieval with multiple detail levels, version history, and type structure metadata.
+
+#### What's New
+
+**1. Progressive Detail Levels**
+- `minimal`: Basic metadata only (~200 tokens) - nodeType, displayName, description, category, version summary
+- `standard`: Essential properties and operations - AI-friendly default (~1000-2000 tokens)
+- `full`: Complete node information including all properties (~3000-8000 tokens)
+
+**2. Version History & Management**
+- `versions` mode: List all versions with breaking changes summary
+- `compare` mode: Compare two versions with property-level changes
+- `breaking` mode: Show only breaking changes between versions
+- `migrations` mode: Show auto-migratable changes
+- Version summary always included in info mode responses
+
+**3. Type Structure Metadata**
+- `includeTypeInfo` parameter exposes type structures from v2.23.0 validation system
+- Includes: type category, JS type, validation rules, structure hints
+- Helps AI agents understand complex types (filter, resourceMapper, resourceLocator, etc.)
+- Adds ~80-120 tokens per property when enabled
+- Works with all detail levels
+
+**4. Real-World Examples**
+- `includeExamples` parameter includes configuration examples from templates
+- Shows popular workflow patterns
+- Includes metadata (views, complexity, use cases)
+
+#### Usage Examples
+
+```javascript
+// Standard detail (recommended for AI agents)
+get_node({nodeType: "nodes-base.httpRequest"})
+
+// Standard with type info
+get_node({nodeType: "nodes-base.httpRequest", includeTypeInfo: true})
+
+// Minimal (quick metadata check)
+get_node({nodeType: "nodes-base.httpRequest", detail: "minimal"})
+
+// Full detail with examples
+get_node({nodeType: "nodes-base.httpRequest", detail: "full", includeExamples: true})
+
+// Version history
+get_node({nodeType: "nodes-base.httpRequest", mode: "versions"})
+
+// Compare versions
+get_node({
+  nodeType: "nodes-base.httpRequest",
+  mode: "compare",
+  fromVersion: "3.0",
+  toVersion: "4.1"
+})
+```
+
+#### Benefits
+
+- ✅ **Single Unified API**: One tool for all node information needs
+- ✅ **Token Efficient**: AI-friendly defaults (standard mode recommended)
+- ✅ **Progressive Disclosure**: minimal → standard → full as needed
+- ✅ **Type Aware**: Exposes v2.23.0 type structures for better configuration
+- ✅ **Version Aware**: Built-in version history and comparison
+- ✅ **Flexible**: Can combine detail levels with type info and examples
+- ✅ **Discoverable**: Version summary always visible in info mode
+
+#### Token Costs
+
+- `minimal`: ~200 tokens
+- `standard`: ~1000-2000 tokens (default)
+- `full`: ~3000-8000 tokens
+- `includeTypeInfo`: +80-120 tokens per property
+- `includeExamples`: +200-400 tokens per example
+- Version modes: ~400-1200 tokens
+
+### 🗑️ Breaking Changes
+
+**Removed Deprecated Tools**
+
+Immediately removed `get_node_info` and `get_node_essentials` in favor of the unified `get_node` tool:
+- `get_node_info` → Use `get_node` with `detail='full'`
+- `get_node_essentials` → Use `get_node` with `detail='standard'` (default)
+
+**Migration:**
+```javascript
+// Old
+get_node_info({nodeType: "nodes-base.httpRequest"})
+// New
+get_node({nodeType: "nodes-base.httpRequest", detail: "full"})
+
+// Old
+get_node_essentials({nodeType: "nodes-base.httpRequest", includeExamples: true})
+// New
+get_node({nodeType: "nodes-base.httpRequest", includeExamples: true})
+// or
+get_node({nodeType: "nodes-base.httpRequest", detail: "standard", includeExamples: true})
+```
+
+### 📊 Impact
+
+**Tool Count**: 40 → 39 tools (-2 deprecated, +1 new unified)
+
+**For AI Agents:**
+- Better understanding of complex n8n types through type metadata
+- Version upgrade planning with breaking change detection
+- Token-efficient defaults reduce costs
+- Progressive disclosure of information as needed
+
+**For Users:**
+- Single tool to learn instead of two separate tools
+- Clear progression from minimal to full detail
+- Version history helps with node upgrades
+- Type-aware configuration assistance
+
+### 🔧 Technical Details
+
+**Files Added:**
+- Enhanced type structure exposure in node information
+
+**Files Modified:**
+- `src/mcp/tools.ts` - Removed get_node_info and get_node_essentials, added get_node
+- `src/mcp/server.ts` - Added unified getNode() implementation with all modes
+- `package.json` - Version bump to 2.24.0
+
+**Implementation:**
+- ~250 lines of new code
+- 7 new private methods for mode handling
+- Version repository methods utilized (previously unused)
+- TypeStructureService integrated for type metadata
+- 100% backward compatible in behavior (just different API)
+
+Conceived by Romuald Członkowski - https://www.aiadvisors.pl/en
+
+## [2.23.0] - 2025-11-21
+
+### ✨ Features
+
+**Type Structure Validation System (Phases 1-4 Complete)**
+
+Implemented comprehensive automatic validation system for complex n8n node configuration structures, ensuring workflows are correct before deployment.
+
+#### Overview
+
+Type Structure Validation is an automatic, zero-configuration validation system that validates complex node configurations (filter, resourceMapper, assignmentCollection, resourceLocator) during node validation. The system operates transparently - no special flags or configuration required.
+
+#### Key Features
+
+**1. Automatic Structure Validation**
+- Validates 4 special n8n types: filter, resourceMapper, assignmentCollection, resourceLocator
+- Zero configuration required - works automatically in all validation tools
+- Integrated in `validate_node_operation` and `validate_node_minimal` tools
+- 100% backward compatible - no breaking changes
+
+**2. Comprehensive Type Coverage**
+- **filter** (FilterValue) - Complex filtering conditions with 40+ operations (equals, contains, regex, etc.)
+- **resourceMapper** (ResourceMapperValue) - Data mapping configuration for format transformation
+- **assignmentCollection** (AssignmentCollectionValue) - Variable assignments for setting multiple values
+- **resourceLocator** (INodeParameterResourceLocator) - Resource selection with multiple lookup modes (ID, name, URL)
+
+**3. Production-Ready Performance**
+- **100% pass rate** on 776 real-world validations (91 templates, 616 nodes)
+- **0.01ms average** validation time (500x faster than 50ms target)
+- **0% false positive rate**
+- Tested against top n8n.io workflow templates
+
+**4. Clear Error Messages**
+- Actionable error messages with property paths
+- Fix suggestions for common issues
+- Context-aware validation with node-specific logic
+- Educational feedback for AI agents
+
+#### Implementation Phases
+
+**Phase 1: Type Structure Definitions** ✅
+- 22 complete type structures defined in `src/constants/type-structures.ts` (741 lines)
+- Type definitions in `src/types/type-structures.ts` (301 lines)
+- Complete coverage of filter, resourceMapper, assignmentCollection, resourceLocator
+- TypeScript interfaces with validation schemas
+
+**Phase 2: Validation Integration** ✅
+- Integrated in `EnhancedConfigValidator` service (427 lines)
+- Automatic validation in all MCP tools (validate_node_operation, validate_node_minimal)
+- Four validation profiles: minimal, runtime, ai-friendly, strict
+- Node-specific validation logic for edge cases
+
+**Phase 3: Real-World Validation** ✅
+- 100% pass rate on 776 validations across 91 templates
+- 616 nodes tested from top n8n.io workflows
+- Type-specific results:
+  - filter: 93/93 passed (100.00%)
+  - resourceMapper: 69/69 passed (100.00%)
+  - assignmentCollection: 213/213 passed (100.00%)
+  - resourceLocator: 401/401 passed (100.00%)
+- Performance: 0.01ms average (500x better than target)
+
+**Phase 4: Documentation & Polish** ✅
+- Comprehensive technical documentation (`docs/TYPE_STRUCTURE_VALIDATION.md`)
+- Updated internal documentation (CLAUDE.md)
+- Progressive discovery maintained (minimal tool documentation changes)
+- Production readiness checklist completed
+
+#### Edge Cases Handled
+
+**1. Credential-Provided Fields**
+- Fields like Google Sheets `sheetId` that come from credentials at runtime
+- No false positives for credential-populated fields
+
+**2. Filter Operations**
+- Universal operations (exists, notExists, isNotEmpty) work across all data types
+- Type-specific operations validated (regex for strings, gt/lt for numbers)
+
+**3. Node-Specific Logic**
+- Custom validation for specific nodes (Google Sheets, Slack, etc.)
+- Context-aware error messages based on node operation
+
+#### Technical Details
+
+**Files Added:**
+- `src/types/type-structures.ts` (301 lines) - Type definitions
+- `src/constants/type-structures.ts` (741 lines) - 22 complete type structures
+- `src/services/type-structure-service.ts` (427 lines) - Validation service
+- `docs/TYPE_STRUCTURE_VALIDATION.md` (239 lines) - Technical documentation
+
+**Files Modified:**
+- `src/services/enhanced-config-validator.ts` - Integrated structure validation
+- `src/mcp/tools-documentation.ts` - Minimal progressive discovery notes
+- `CLAUDE.md` - Updated architecture and Phase 1-3 completion
+
+**Test Coverage:**
+- `tests/unit/types/type-structures.test.ts` (14 tests)
+- `tests/unit/constants/type-structures.test.ts` (39 tests)
+- `tests/unit/services/type-structure-service.test.ts` (64 tests)
+- `tests/unit/services/enhanced-config-validator-type-structures.test.ts` (comprehensive)
+- `tests/integration/validation/real-world-structure-validation.test.ts` (8 tests, 388ms)
+- `scripts/test-structure-validation.ts` - Standalone validation script
+
+#### Usage
+
+No changes required - structure validation works automatically:
+
+```javascript
+// Validation works automatically with structure validation
+validate_node_operation("nodes-base.if", {
+  conditions: {
+    combinator: "and",
+    conditions: [{
+      leftValue: "={{ $json.status }}",
+      rightValue: "active",
+      operator: { type: "string", operation: "equals" }
+    }]
+  }
+})
+
+// Structure errors are caught and reported clearly
+// Invalid operation → Clear error with valid operations list
+// Missing required fields → Actionable fix suggestions
+```
+
+#### Benefits
+
+**For Users:**
+- ✅ Prevents configuration errors before deployment
+- ✅ Clear, actionable error messages
+- ✅ Faster workflow development with immediate feedback
+- ✅ Confidence in workflow correctness
+
+**For AI Agents:**
+- ✅ Better understanding of complex n8n types
+- ✅ Self-correction based on clear error messages
+- ✅ Reduced validation errors and retry loops
+- ✅ Educational feedback for learning n8n patterns
+
+**Technical:**
+- ✅ Zero breaking changes (100% backward compatible)
+- ✅ Automatic integration (no configuration needed)
+- ✅ High performance (0.01ms average)
+- ✅ Production-ready (100% pass rate on real workflows)
+
+#### Documentation
+
+**User Documentation:**
+- `docs/TYPE_STRUCTURE_VALIDATION.md` - Complete technical reference
+- Includes: Overview, supported types, performance metrics, examples, developer guide
+
+**Internal Documentation:**
+- `CLAUDE.md` - Architecture updates and Phase 1-3 results
+- `src/mcp/tools-documentation.ts` - Progressive discovery notes
+
+**Implementation Details:**
+- `docs/local/v3/implementation-plan-final.md` - Complete technical specifications
+- All 4 phases documented with success criteria and results
+
+#### Version History
+
+- **v2.23.0** (2025-11-21): Type structure validation system completed (Phases 1-4)
+  - Phase 1: 22 complete type structures defined
+  - Phase 2: Validation integrated in all MCP tools
+  - Phase 3: 100% pass rate on 776 real-world validations
+  - Phase 4: Documentation and polish completed
+  - Zero false positives, 0.01ms average validation time
+
+Conceived by Romuald Członkowski - https://www.aiadvisors.pl/en
+
 ## [2.22.21] - 2025-11-20
 
 ### 🐛 Bug Fixes

CLAUDE.md

@@ -28,8 +28,15 @@ src/
 │   ├── enhanced-config-validator.ts # Operation-aware validation (NEW in v2.4.2)
 │   ├── node-specific-validators.ts  # Node-specific validation logic (NEW in v2.4.2)
 │   ├── property-dependencies.ts # Dependency analysis (NEW in v2.4)
+│   ├── type-structure-service.ts # Type structure validation (NEW in v2.22.21)
 │   ├── expression-validator.ts # n8n expression syntax validation (NEW in v2.5.0)
 │   └── workflow-validator.ts  # Complete workflow validation (NEW in v2.5.0)
+├── types/
+│   ├── type-structures.ts      # Type structure definitions (NEW in v2.22.21)
+│   ├── instance-context.ts     # Multi-tenant instance configuration
+│   └── session-state.ts        # Session persistence types (NEW in v2.24.1)
+├── constants/
+│   └── type-structures.ts      # 22 complete type structures (NEW in v2.22.21)
 ├── templates/
 │   ├── template-fetcher.ts    # Fetches templates from n8n.io API (NEW in v2.4.1)
 │   ├── template-repository.ts # Template database operations (NEW in v2.4.1)
@@ -40,6 +47,7 @@ src/
 │   ├── test-nodes.ts          # Critical node tests
 │   ├── test-essentials.ts     # Test new essentials tools (NEW in v2.4)
 │   ├── test-enhanced-validation.ts # Test enhanced validation (NEW in v2.4.2)
+│   ├── test-structure-validation.ts # Test type structure validation (NEW in v2.22.21)
 │   ├── test-workflow-validation.ts # Test workflow validation (NEW in v2.5.0)
 │   ├── test-ai-workflow-validation.ts # Test AI workflow validation (NEW in v2.5.1)
 │   ├── test-mcp-tools.ts      # Test MCP tool enhancements (NEW in v2.5.1)
@@ -58,7 +66,9 @@ src/
 │   ├── console-manager.ts     # Console output isolation (NEW in v2.3.1)
 │   └── logger.ts              # Logging utility with HTTP awareness
 ├── http-server-single-session.ts  # Single-session HTTP server (NEW in v2.3.1)
+│                                   # Session persistence API (NEW in v2.24.1)
 ├── mcp-engine.ts              # Clean API for service integration (NEW in v2.3.1)
+│                                # Session persistence wrappers (NEW in v2.24.1)
 └── index.ts                   # Library exports
 ```
 
@@ -76,6 +86,7 @@ npm run test:unit      # Run unit tests only
 npm run test:integration # Run integration tests
 npm run test:coverage  # Run tests with coverage report
 npm run test:watch     # Run tests in watch mode
+npm run test:structure-validation # Test type structure validation (Phase 3)
 
 # Run a single test file
 npm test -- tests/unit/services/property-filter.test.ts
@@ -126,6 +137,7 @@ npm run test:templates   # Test template functionality
 4. **Service Layer** (`services/`)
    - **Property Filter**: Reduces node properties to AI-friendly essentials
    - **Config Validator**: Multi-profile validation system
+   - **Type Structure Service**: Validates complex type structures (filter, resourceMapper, etc.)
    - **Expression Validator**: Validates n8n expression syntax
    - **Workflow Validator**: Complete workflow structure validation
 
@@ -183,6 +195,35 @@ The MCP server exposes tools in several categories:
 ### Development Best Practices
 - Run typecheck and lint after every code change
 
+### Session Persistence Feature (v2.24.1)
+
+**Location:**
+- Types: `src/types/session-state.ts`
+- Implementation: `src/http-server-single-session.ts` (lines 698-702, 1444-1584)
+- Wrapper: `src/mcp-engine.ts` (lines 123-169)
+- Tests: `tests/unit/http-server/session-persistence.test.ts`, `tests/unit/mcp-engine/session-persistence.test.ts`
+
+**Key Features:**
+- **Export/Restore API**: `exportSessionState()` and `restoreSessionState()` methods
+- **Multi-tenant support**: Enables zero-downtime deployments for SaaS platforms
+- **Security-first**: API keys exported as plaintext - downstream MUST encrypt
+- **Dormant sessions**: Restored sessions recreate transports on first request
+- **Automatic expiration**: Respects `sessionTimeout` setting (default 30 min)
+- **MAX_SESSIONS limit**: Caps at 100 concurrent sessions (configurable via N8N_MCP_MAX_SESSIONS env var)
+
+**Important Implementation Notes:**
+- Only exports sessions with valid n8nApiUrl and n8nApiKey in context
+- Skips expired sessions during both export and restore
+- Uses `validateInstanceContext()` for data integrity checks
+- Handles null/invalid session gracefully with warnings
+- Session metadata (timestamps) and context (credentials) are persisted
+- Transport and server objects are NOT persisted (recreated on-demand)
+
+**Testing:**
+- 22 unit tests covering export, restore, edge cases, and round-trip cycles
+- Tests use current timestamps to avoid expiration issues
+- Integration with multi-tenant backends documented in README.md
+
 # important-instruction-reminders
 Do what has been asked; nothing more, nothing less.
 NEVER create files unless they're absolutely necessary for achieving your goal.

Dockerfile

@@ -13,9 +13,9 @@ COPY tsconfig*.json ./
 RUN --mount=type=cache,target=/root/.npm \
     echo '{}' > package.json && \
     npm install --no-save typescript@^5.8.3 @types/node@^22.15.30 @types/express@^5.0.3 \
-        @modelcontextprotocol/sdk@^1.12.1 dotenv@^16.5.0 express@^5.1.0 axios@^1.10.0 \
+        @modelcontextprotocol/sdk@1.20.1 dotenv@^16.5.0 express@^5.1.0 axios@^1.10.0 \
         n8n-workflow@^1.96.0 uuid@^11.0.5 @types/uuid@^10.0.0 \
-        openai@^4.77.0 zod@^3.24.1 lru-cache@^11.2.1 @supabase/supabase-js@^2.57.4
+        openai@^4.77.0 zod@3.24.1 lru-cache@^11.2.1 @supabase/supabase-js@^2.57.4
 
 # Copy source and build
 COPY src ./src

README.md

@@ -5,11 +5,11 @@
 [![npm version](https://img.shields.io/npm/v/n8n-mcp.svg)](https://www.npmjs.com/package/n8n-mcp)
 [![codecov](https://codecov.io/gh/czlonkowski/n8n-mcp/graph/badge.svg?token=YOUR_TOKEN)](https://codecov.io/gh/czlonkowski/n8n-mcp)
 [![Tests](https://img.shields.io/badge/tests-3336%20passing-brightgreen.svg)](https://github.com/czlonkowski/n8n-mcp/actions)
-[![n8n version](https://img.shields.io/badge/n8n-1.120.3-orange.svg)](https://github.com/n8n-io/n8n)
+[![n8n version](https://img.shields.io/badge/n8n-1.122.4-orange.svg)](https://github.com/n8n-io/n8n)
 [![Docker](https://img.shields.io/badge/docker-ghcr.io%2Fczlonkowski%2Fn8n--mcp-green.svg)](https://github.com/czlonkowski/n8n-mcp/pkgs/container/n8n-mcp)
 [![Deploy on Railway](https://railway.com/button.svg)](https://railway.com/deploy/n8n-mcp?referralCode=n8n-mcp)
 
-A Model Context Protocol (MCP) server that provides AI assistants with comprehensive access to n8n node documentation, properties, and operations. Deploy in minutes to give Claude and other AI assistants deep knowledge about n8n's 543 workflow automation nodes.
+A Model Context Protocol (MCP) server that provides AI assistants with comprehensive access to n8n node documentation, properties, and operations. Deploy in minutes to give Claude and other AI assistants deep knowledge about n8n's 545 workflow automation nodes.
 
 ## Overview
 
@@ -36,12 +36,31 @@ AI results can be unpredictable. Protect your work!
 
 ## 🚀 Quick Start
 
-Get n8n-MCP running in 5 minutes:
+### Option 1: Hosted Service (Easiest - No Setup!) ☁️
+
+**The fastest way to try n8n-MCP** - no installation, no configuration:
+
+👉 **[dashboard.n8n-mcp.com](https://dashboard.n8n-mcp.com)**
+
+- ✅ **Free tier**: 100 tool calls/day
+- ✅ **Instant access**: Start building workflows immediately
+- ✅ **Always up-to-date**: Latest n8n nodes and templates
+- ✅ **No infrastructure**: We handle everything
+
+Just sign up, get your API key, and connect your MCP client. 
+
+---
+
+## 🏠 Self-Hosting Options
+
+Prefer to run n8n-MCP yourself? Choose your deployment method:
+
+### Option A: npx (Quick Local Setup) 🚀
+
+Get n8n-MCP running in minutes:
 
 [![n8n-mcp Video Quickstart Guide](./thumbnail.png)](https://youtu.be/5CccjiLLyaY?si=Z62SBGlw9G34IQnQ&t=343)
 
-### Option 1: npx (Fastest - No Installation!) 🚀
-
 **Prerequisites:** [Node.js](https://nodejs.org/) installed on your system
 
 ```bash
@@ -98,7 +117,7 @@ Add to Claude Desktop config:
 
 **Restart Claude Desktop after updating configuration** - That's it! 🎉
 
-### Option 2: Docker (Easy & Isolated) 🐳
+### Option B: Docker (Isolated & Reproducible) 🐳
 
 **Prerequisites:** Docker installed on your system
 
@@ -345,27 +364,6 @@ environment:
   SQLJS_SAVE_INTERVAL_MS: "10000"
 ```
 
-### Memory Leak Fix (v2.20.2)
-
-**Issue #330** identified a critical memory leak in long-running Docker/Kubernetes deployments:
-- **Before:** 100 MB → 2.2 GB over 72 hours (OOM kills)
-- **After:** Stable at 100-200 MB indefinitely
-
-**Fixes Applied:**
-- ✅ Docker images now use better-sqlite3 by default (eliminates leak entirely)
-- ✅ sql.js fallback optimized (98% reduction in save frequency)
-- ✅ Removed unnecessary memory allocations (50% reduction per save)
-- ✅ Configurable save interval via `SQLJS_SAVE_INTERVAL_MS`
-
-For Kubernetes deployments with memory limits:
-```yaml
-resources:
-  requests:
-    memory: 256Mi
-  limits:
-    memory: 512Mi
-```
-
 ## 💖 Support This Project
 
 <div align="center">
@@ -386,7 +384,7 @@ Every sponsorship directly translates to hours invested in making n8n-mcp better
 
 ---
 
-### Option 3: Local Installation (For Development)
+### Option C: Local Installation (For Development)
 
 **Prerequisites:** [Node.js](https://nodejs.org/) installed on your system
 
@@ -444,7 +442,7 @@ Add to Claude Desktop config:
 
 > 💡 Tip: If you’re running n8n locally on the same machine (e.g., via Docker), use http://host.docker.internal:5678 as the N8N_API_URL.
 
-### Option 4: Railway Cloud Deployment (One-Click Deploy) ☁️
+### Option D: Railway Cloud Deployment (One-Click Deploy) ☁️
 
 **Prerequisites:** Railway account (free tier available)
 
@@ -503,6 +501,9 @@ Complete guide for integrating n8n-MCP with Windsurf using project rules.
 ### [Codex](./docs/CODEX_SETUP.md)
 Complete guide for integrating n8n-MCP with Codex.
 
+### [Antigravity](./docs/ANTIGRAVITY_SETUP.md)
+Complete guide for integrating n8n-MCP with Antigravity.
+
 ## 🎓 Add Claude Skills (Optional)
 
 Supercharge your n8n workflow building with specialized skills that teach AI how to build production-ready workflows!
@@ -524,7 +525,7 @@ You are an expert in n8n automation software using n8n-MCP tools. Your role is t
 CRITICAL: Execute tools without commentary. Only respond AFTER all tools complete.
 
 ❌ BAD: "Let me search for Slack nodes... Great! Now let me get details..."
-✅ GOOD: [Execute search_nodes and get_node_essentials in parallel, then respond]
+✅ GOOD: [Execute search_nodes and get_node in parallel, then respond]
 
 ### 2. Parallel Execution
 When operations are independent, execute them in parallel for maximum performance.
@@ -536,7 +537,7 @@ When operations are independent, execute them in parallel for maximum performanc
 ALWAYS check templates before building from scratch (2,709 available).
 
 ### 4. Multi-Level Validation
-Use validate_node_minimal → validate_node_operation → validate_workflow pattern.
+Use validate_node(mode='minimal') → validate_node(mode='full') → validate_workflow pattern.
 
 ### 5. Never Trust Defaults
 ⚠️ CRITICAL: Default parameter values are the #1 source of runtime failures.
@@ -547,10 +548,10 @@ ALWAYS explicitly configure ALL parameters that control node behavior.
 1. **Start**: Call `tools_documentation()` for best practices
 
 2. **Template Discovery Phase** (FIRST - parallel when searching multiple)
-   - `search_templates_by_metadata({complexity: "simple"})` - Smart filtering
-   - `get_templates_for_task('webhook_processing')` - Curated by task
-   - `search_templates('slack notification')` - Text search
-   - `list_node_templates(['n8n-nodes-base.slack'])` - By node type
+   - `search_templates({searchMode: 'by_metadata', complexity: 'simple'})` - Smart filtering
+   - `search_templates({searchMode: 'by_task', task: 'webhook_processing'})` - Curated by task
+   - `search_templates({query: 'slack notification'})` - Text search (default searchMode='keyword')
+   - `search_templates({searchMode: 'by_nodes', nodeTypes: ['n8n-nodes-base.slack']})` - By node type
 
    **Filtering strategies**:
    - Beginners: `complexity: "simple"` + `maxSetupMinutes: 30`
@@ -561,18 +562,20 @@ ALWAYS explicitly configure ALL parameters that control node behavior.
 3. **Node Discovery** (if no suitable template - parallel execution)
    - Think deeply about requirements. Ask clarifying questions if unclear.
    - `search_nodes({query: 'keyword', includeExamples: true})` - Parallel for multiple nodes
-   - `list_nodes({category: 'trigger'})` - Browse by category
-   - `list_ai_tools()` - AI-capable nodes
+   - `search_nodes({query: 'trigger'})` - Browse triggers
+   - `search_nodes({query: 'AI agent langchain'})` - AI-capable nodes
 
 4. **Configuration Phase** (parallel for multiple nodes)
-   - `get_node_essentials(nodeType, {includeExamples: true})` - 10-20 key properties
-   - `search_node_properties(nodeType, 'auth')` - Find specific properties
-   - `get_node_documentation(nodeType)` - Human-readable docs
+   - `get_node({nodeType, detail: 'standard', includeExamples: true})` - Essential properties (default)
+   - `get_node({nodeType, detail: 'minimal'})` - Basic metadata only (~200 tokens)
+   - `get_node({nodeType, detail: 'full'})` - Complete information (~3000-8000 tokens)
+   - `get_node({nodeType, mode: 'search_properties', propertyQuery: 'auth'})` - Find specific properties
+   - `get_node({nodeType, mode: 'docs'})` - Human-readable markdown documentation
    - Show workflow architecture to user for approval before proceeding
 
 5. **Validation Phase** (parallel for multiple nodes)
-   - `validate_node_minimal(nodeType, config)` - Quick required fields check
-   - `validate_node_operation(nodeType, config, 'runtime')` - Full validation with fixes
+   - `validate_node({nodeType, config, mode: 'minimal'})` - Quick required fields check
+   - `validate_node({nodeType, config, mode: 'full', profile: 'runtime'})` - Full validation with fixes
    - Fix ALL errors before proceeding
 
 6. **Building Phase**
@@ -595,7 +598,7 @@ ALWAYS explicitly configure ALL parameters that control node behavior.
    - `n8n_create_workflow(workflow)` - Deploy
    - `n8n_validate_workflow({id})` - Post-deployment check
    - `n8n_update_partial_workflow({id, operations: [...]})` - Batch updates
-   - `n8n_trigger_webhook_workflow()` - Test webhooks
+   - `n8n_test_workflow({workflowId})` - Test workflow execution
 
 ## Critical Warnings
 
@@ -612,15 +615,15 @@ Default values cause runtime failures. Example:
 ### ⚠️ Example Availability
 `includeExamples: true` returns real configurations from workflow templates.
 - Coverage varies by node popularity
-- When no examples available, use `get_node_essentials` + `validate_node_minimal`
+- When no examples available, use `get_node` + `validate_node({mode: 'minimal'})`
 
 ## Validation Strategy
 
 ### Level 1 - Quick Check (before building)
-`validate_node_minimal(nodeType, config)` - Required fields only (<100ms)
+`validate_node({nodeType, config, mode: 'minimal'})` - Required fields only (<100ms)
 
 ### Level 2 - Comprehensive (before building)
-`validate_node_operation(nodeType, config, 'runtime')` - Full validation with fixes
+`validate_node({nodeType, config, mode: 'full', profile: 'runtime'})` - Full validation with fixes
 
 ### Level 3 - Complete (after building)
 `validate_workflow(workflow)` - Connections, expressions, AI tools
@@ -628,7 +631,7 @@ Default values cause runtime failures. Example:
 ### Level 4 - Post-Deployment
 1. `n8n_validate_workflow({id})` - Validate deployed workflow
 2. `n8n_autofix_workflow({id})` - Auto-fix common errors
-3. `n8n_list_executions()` - Monitor execution status
+3. `n8n_executions({action: 'list'})` - Monitor execution status
 
 ## Response Format
 
@@ -774,12 +777,13 @@ Use the same four-parameter format:
 ```
 // STEP 1: Template Discovery (parallel execution)
 [Silent execution]
-search_templates_by_metadata({
+search_templates({
+  searchMode: 'by_metadata',
   requiredService: 'slack',
   complexity: 'simple',
   targetAudience: 'marketers'
 })
-get_templates_for_task('slack_integration')
+search_templates({searchMode: 'by_task', task: 'slack_integration'})
 
 // STEP 2: Use template
 get_template(templateId, {mode: 'full'})
@@ -798,17 +802,17 @@ Validation: ✅ All checks passed"
 // STEP 1: Discovery (parallel execution)
 [Silent execution]
 search_nodes({query: 'slack', includeExamples: true})
-list_nodes({category: 'communication'})
+search_nodes({query: 'communication trigger'})
 
 // STEP 2: Configuration (parallel execution)
 [Silent execution]
-get_node_essentials('n8n-nodes-base.slack', {includeExamples: true})
-get_node_essentials('n8n-nodes-base.webhook', {includeExamples: true})
+get_node({nodeType: 'n8n-nodes-base.slack', detail: 'standard', includeExamples: true})
+get_node({nodeType: 'n8n-nodes-base.webhook', detail: 'standard', includeExamples: true})
 
 // STEP 3: Validation (parallel execution)
 [Silent execution]
-validate_node_minimal('n8n-nodes-base.slack', config)
-validate_node_operation('n8n-nodes-base.slack', fullConfig, 'runtime')
+validate_node({nodeType: 'n8n-nodes-base.slack', config, mode: 'minimal'})
+validate_node({nodeType: 'n8n-nodes-base.slack', config: fullConfig, mode: 'full', profile: 'runtime'})
 
 // STEP 4: Build
 // Construct workflow with validated configs
@@ -860,7 +864,7 @@ n8n_update_partial_workflow({
 - **Only when necessary** - Use code node as last resort
 - **AI tool capability** - ANY node can be an AI tool (not just marked ones)
 
-### Most Popular n8n Nodes (for get_node_essentials):
+### Most Popular n8n Nodes (for get_node):
 
 1. **n8n-nodes-base.code** - JavaScript/Python scripting
 2. **n8n-nodes-base.httpRequest** - HTTP API calls
@@ -924,7 +928,7 @@ When Claude, Anthropic's AI assistant, tested n8n-MCP, the results were transfor
 
 **Without MCP:** "I was basically playing a guessing game. 'Is it `scheduleTrigger` or `schedule`? Does it take `interval` or `rule`?' I'd write what seemed logical, but n8n has its own conventions that you can't just intuit. I made six different configuration errors in a simple HackerNews scraper."
 
-**With MCP:** "Everything just... worked. Instead of guessing, I could ask `get_node_essentials()` and get exactly what I needed - not a 100KB JSON dump, but the actual 5-10 properties that matter. What took 45 minutes now takes 3 minutes."
+**With MCP:** "Everything just... worked. Instead of guessing, I could ask `get_node()` and get exactly what I needed - not a 100KB JSON dump, but the actual properties that matter. What took 45 minutes now takes 3 minutes."
 
 **The Real Value:** "It's about confidence. When you're building automation workflows, uncertainty is expensive. One wrong parameter and your workflow fails at 3 AM. With MCP, I could validate my configuration before deployment. That's not just time saved - that's peace of mind."
 
@@ -934,94 +938,111 @@ When Claude, Anthropic's AI assistant, tested n8n-MCP, the results were transfor
 
 Once connected, Claude can use these powerful tools:
 
-### Core Tools
+### Core Tools (7 tools)
 - **`tools_documentation`** - Get documentation for any MCP tool (START HERE!)
-- **`list_nodes`** - List all n8n nodes with filtering options
-- **`get_node_info`** - Get comprehensive information about a specific node
-- **`get_node_essentials`** - Get only essential properties (10-20 instead of 200+). Use `includeExamples: true` to get top 3 real-world configurations from popular templates
-- **`search_nodes`** - Full-text search across all node documentation. Use `includeExamples: true` to get top 2 real-world configurations per node from templates
-- **`search_node_properties`** - Find specific properties within nodes
-- **`list_ai_tools`** - List all AI-capable nodes (ANY node can be used as AI tool!)
-- **`get_node_as_tool_info`** - Get guidance on using any node as an AI tool
+- **`search_nodes`** - Full-text search across all nodes. Use `includeExamples: true` for real-world configurations
+- **`get_node`** - Unified node information tool with multiple modes (v2.26.0):
+  - **Info mode** (default): `detail: 'minimal'|'standard'|'full'`, `includeExamples: true`
+  - **Docs mode**: `mode: 'docs'` - Human-readable markdown documentation
+  - **Property search**: `mode: 'search_properties'`, `propertyQuery: 'auth'`
+  - **Versions**: `mode: 'versions'|'compare'|'breaking'|'migrations'`
+- **`validate_node`** - Unified node validation (v2.26.0):
+  - `mode: 'minimal'` - Quick required fields check (<100ms)
+  - `mode: 'full'` - Comprehensive validation with profiles (minimal, runtime, ai-friendly, strict)
+- **`validate_workflow`** - Complete workflow validation including AI Agent validation
+- **`search_templates`** - Unified template search (v2.26.0):
+  - `searchMode: 'keyword'` (default) - Text search with `query` parameter
+  - `searchMode: 'by_nodes'` - Find templates using specific `nodeTypes`
+  - `searchMode: 'by_task'` - Curated templates for common `task` types
+  - `searchMode: 'by_metadata'` - Filter by `complexity`, `requiredService`, `targetAudience`
+- **`get_template`** - Get complete workflow JSON (modes: nodes_only, structure, full)
 
-### Template Tools
-- **`list_templates`** - Browse all templates with descriptions and optional metadata (2,709 templates)
-- **`search_templates`** - Text search across template names and descriptions
-- **`search_templates_by_metadata`** - Advanced filtering by complexity, setup time, services, audience
-- **`list_node_templates`** - Find templates using specific nodes
-- **`get_template`** - Get complete workflow JSON for import
-- **`get_templates_for_task`** - Curated templates for common automation tasks
-
-### Validation Tools
-- **`validate_workflow`** - Complete workflow validation including **AI Agent validation** (NEW in v2.17.0!)
-  - Detects missing language model connections
-  - Validates AI tool connections (no false warnings)
-  - Enforces streaming mode constraints
-  - Checks memory and output parser configurations
-- **`validate_workflow_connections`** - Check workflow structure and AI tool connections
-- **`validate_workflow_expressions`** - Validate n8n expressions including $fromAI()
-- **`validate_node_operation`** - Validate node configurations (operation-aware, profiles support)
-- **`validate_node_minimal`** - Quick validation for just required fields
-
-### Advanced Tools
-- **`get_property_dependencies`** - Analyze property visibility conditions
-- **`get_node_documentation`** - Get parsed documentation from n8n-docs
-- **`get_database_statistics`** - View database metrics and coverage
-
-### n8n Management Tools (Optional - Requires API Configuration)
-These powerful tools allow you to manage n8n workflows directly from Claude. They're only available when you provide `N8N_API_URL` and `N8N_API_KEY` in your configuration.
+### n8n Management Tools (13 tools - Requires API Configuration)
+These tools require `N8N_API_URL` and `N8N_API_KEY` in your configuration.
 
 #### Workflow Management
 - **`n8n_create_workflow`** - Create new workflows with nodes and connections
-- **`n8n_get_workflow`** - Get complete workflow by ID
-- **`n8n_get_workflow_details`** - Get workflow with execution statistics
-- **`n8n_get_workflow_structure`** - Get simplified workflow structure
-- **`n8n_get_workflow_minimal`** - Get minimal workflow info (ID, name, active status)
+- **`n8n_get_workflow`** - Unified workflow retrieval (v2.26.0):
+  - `mode: 'full'` (default) - Complete workflow JSON
+  - `mode: 'details'` - Include execution statistics
+  - `mode: 'structure'` - Nodes and connections topology only
+  - `mode: 'minimal'` - Just ID, name, active status
 - **`n8n_update_full_workflow`** - Update entire workflow (complete replacement)
-- **`n8n_update_partial_workflow`** - Update workflow using diff operations (NEW in v2.7.0!)
+- **`n8n_update_partial_workflow`** - Update workflow using diff operations
 - **`n8n_delete_workflow`** - Delete workflows permanently
 - **`n8n_list_workflows`** - List workflows with filtering and pagination
-- **`n8n_validate_workflow`** - Validate workflows already in n8n by ID (NEW in v2.6.3)
-- **`n8n_autofix_workflow`** - Automatically fix common workflow errors (NEW in v2.13.0!)
-- **`n8n_workflow_versions`** - Manage workflow version history and rollback (NEW in v2.22.0!)
+- **`n8n_validate_workflow`** - Validate workflows in n8n by ID
+- **`n8n_autofix_workflow`** - Automatically fix common workflow errors
+- **`n8n_workflow_versions`** - Manage version history and rollback
+- **`n8n_deploy_template`** - Deploy templates from n8n.io directly to your instance with auto-fix
 
 #### Execution Management
-- **`n8n_trigger_webhook_workflow`** - Trigger workflows via webhook URL
-- **`n8n_get_execution`** - Get execution details by ID
-- **`n8n_list_executions`** - List executions with status filtering
-- **`n8n_delete_execution`** - Delete execution records
+- **`n8n_test_workflow`** - Test/trigger workflow execution:
+  - Auto-detects trigger type (webhook, form, chat) from workflow
+  - Supports custom data, headers, and HTTP methods for webhooks
+  - Chat triggers support message and sessionId for conversations
+- **`n8n_executions`** - Unified execution management (v2.26.0):
+  - `action: 'list'` - List executions with status filtering
+  - `action: 'get'` - Get execution details by ID
+  - `action: 'delete'` - Delete execution records
 
 #### System Tools
 - **`n8n_health_check`** - Check n8n API connectivity and features
-- **`n8n_diagnostic`** - Troubleshoot management tools visibility and configuration issues
-- **`n8n_list_available_tools`** - List all available management tools
 
 ### Example Usage
 
 ```typescript
-// Get essentials with real-world examples from templates
-get_node_essentials({
+// Get node info with different detail levels
+get_node({
   nodeType: "nodes-base.httpRequest",
-  includeExamples: true  // Returns top 3 configs from popular templates
+  detail: "standard",        // Default: Essential properties
+  includeExamples: true      // Include real-world examples from templates
+})
+
+// Get documentation
+get_node({
+  nodeType: "nodes-base.slack",
+  mode: "docs"               // Human-readable markdown documentation
+})
+
+// Search for specific properties
+get_node({
+  nodeType: "nodes-base.httpRequest",
+  mode: "search_properties",
+  propertyQuery: "authentication"
+})
+
+// Version history and breaking changes
+get_node({
+  nodeType: "nodes-base.httpRequest",
+  mode: "versions"            // View all versions with summary
 })
 
 // Search nodes with configuration examples
 search_nodes({
   query: "send email gmail",
-  includeExamples: true  // Returns top 2 configs per node
+  includeExamples: true       // Returns top 2 configs per node
 })
 
-// Validate before deployment
-validate_node_operation({
+// Validate node configuration
+validate_node({
   nodeType: "nodes-base.httpRequest",
   config: { method: "POST", url: "..." },
-  profile: "runtime" // or "minimal", "ai-friendly", "strict"
+  mode: "full",
+  profile: "runtime"          // or "minimal", "ai-friendly", "strict"
 })
 
 // Quick required field check
-validate_node_minimal({
+validate_node({
   nodeType: "nodes-base.slack",
-  config: { resource: "message", operation: "send" }
+  config: { resource: "message", operation: "send" },
+  mode: "minimal"
+})
+
+// Search templates by task
+search_templates({
+  searchMode: "by_task",
+  task: "webhook_processing"
 })
 ```
 
@@ -1114,43 +1135,7 @@ Current database coverage (n8n v1.117.2):
 
 ## 🔄 Recent Updates
 
-### v2.22.19 - Critical Bug Fix
-**Fixed:** Stack overflow in session removal (Issue #427)
-- Eliminated infinite recursion in HTTP server session cleanup
-- Transport resources now deleted before closing to prevent circular event handler chain
-- Production logs no longer show "RangeError: Maximum call stack size exceeded"
-- All session cleanup operations now complete successfully without crashes
-
-See [CHANGELOG.md](./docs/CHANGELOG.md) for full version history and recent changes.
-
-## ⚠️ Known Issues
-
-### Claude Desktop Container Management
-
-#### Container Accumulation (Fixed in v2.7.20+)
-Previous versions had an issue where containers would not properly clean up when Claude Desktop sessions ended. This has been fixed in v2.7.20+ with proper signal handling.
-
-**For best container lifecycle management:**
-1. **Use the --init flag** (recommended) - Docker's init system ensures proper signal handling:
-```json
-{
-  "mcpServers": {
-    "n8n-mcp": {
-      "command": "docker",
-      "args": [
-        "run", "-i", "--rm", "--init",
-        "ghcr.io/czlonkowski/n8n-mcp:latest"
-      ]
-    }
-  }
-}
-```
-
-2. **Ensure you're using v2.7.20 or later** - Check your version:
-```bash
-docker run --rm ghcr.io/czlonkowski/n8n-mcp:latest --version
-```
-
+See [CHANGELOG.md](./CHANGELOG.md) for complete version history and recent changes.
 
 ## 🧪 Testing
 

docs/ANTIGRAVITY_SETUP.md

@@ -0,0 +1,433 @@
+# Antigravity Setup
+
+:white_check_mark: This n8n MCP server is compatible with Antigravity (Chat in IDE).
+
+## Preconditions
+
+Assuming you've already deployed the n8n MCP server locally and connected it to the n8n API, and it's available at:
+`http://localhost:5678`
+
+Or if you are using `https://n8n.your.production.url/` then just replace the URLs in the below code.
+
+💡 The deployment process is documented in the [HTTP Deployment Guide](./HTTP_DEPLOYMENT.md).
+
+## Step 1
+
+Add n8n-mcp globally: `npm install -g n8n-mcp`
+
+## Step 2
+
+Add MCP server by clicking three dots `...` on the top right of chat, and click MCP Servers.
+Then click on "Manage MCP Servers" and then click on "View raw config" and `C:\Users\<USER_NAME>\.gemini\antigravity\mcp_config.json` will be opened.
+
+## Step 3
+
+Add the following code to: `C:\Users\<USER_NAME>\.gemini\antigravity\mcp_config.json` and save the file.
+```json
+{
+  "mcpServers": {
+    "n8n-mcp": {
+      "command": "node",
+      "args": [
+        "C:\\Users\\<USER_NAME>\\AppData\\Roaming\\npm\\node_modules\\n8n-mcp\\dist\\mcp\\index.js"
+      ],
+      "env": {
+        "MCP_MODE": "stdio",
+        "LOG_LEVEL": "error",
+        "DISABLE_CONSOLE_OUTPUT": "true",
+        "N8N_API_URL": "http://localhost:5678",
+        "N8N_BASE_URL": "http://localhost:5678",
+        "N8N_API_KEY": ""
+      }
+    }
+  }
+}
+```
+
+## Step 4
+
+Go back to "Manage MCP servers" and click referesh. The n8n-mcp will be enabled with all the tools.
+
+
+## Step 5
+
+For the best results when using n8n-MCP with Antigravity, use these enhanced system instructions (create `AGENTS.md` in the root directory of the project, `AGENTS.md` is the file standard for giving special instructions in Antigravity):
+
+````markdown
+You are an expert in n8n automation software using n8n-MCP tools. Your role is to design, build, and validate n8n workflows with maximum accuracy and efficiency.
+
+## Core Principles
+
+### 1. Silent Execution
+CRITICAL: Execute tools without commentary. Only respond AFTER all tools complete.
+
+❌ BAD: "Let me search for Slack nodes... Great! Now let me get details..."
+✅ GOOD: [Execute search_nodes and get_node in parallel, then respond]
+
+### 2. Parallel Execution
+When operations are independent, execute them in parallel for maximum performance.
+
+✅ GOOD: Call search_nodes, list_nodes, and search_templates simultaneously
+❌ BAD: Sequential tool calls (await each one before the next)
+
+### 3. Templates First
+ALWAYS check templates before building from scratch (2,709 available).
+
+### 4. Multi-Level Validation
+Use validate_node(mode='minimal') → validate_node(mode='full') → validate_workflow pattern.
+
+### 5. Never Trust Defaults
+⚠️ CRITICAL: Default parameter values are the #1 source of runtime failures.
+ALWAYS explicitly configure ALL parameters that control node behavior.
+
+## Workflow Process
+
+1. **Start**: Call `tools_documentation()` for best practices
+
+2. **Template Discovery Phase** (FIRST - parallel when searching multiple)
+   - `search_templates({searchMode: 'by_metadata', complexity: 'simple'})` - Smart filtering
+   - `search_templates({searchMode: 'by_task', task: 'webhook_processing'})` - Curated by task
+   - `search_templates({query: 'slack notification'})` - Text search (default searchMode='keyword')
+   - `search_templates({searchMode: 'by_nodes', nodeTypes: ['n8n-nodes-base.slack']})` - By node type
+
+   **Filtering strategies**:
+   - Beginners: `complexity: "simple"` + `maxSetupMinutes: 30`
+   - By role: `targetAudience: "marketers"` | `"developers"` | `"analysts"`
+   - By time: `maxSetupMinutes: 15` for quick wins
+   - By service: `requiredService: "openai"` for compatibility
+
+3. **Node Discovery** (if no suitable template - parallel execution)
+   - Think deeply about requirements. Ask clarifying questions if unclear.
+   - `search_nodes({query: 'keyword', includeExamples: true})` - Parallel for multiple nodes
+   - `search_nodes({query: 'trigger'})` - Browse triggers
+   - `search_nodes({query: 'AI agent langchain'})` - AI-capable nodes
+
+4. **Configuration Phase** (parallel for multiple nodes)
+   - `get_node({nodeType, detail: 'standard', includeExamples: true})` - Essential properties (default)
+   - `get_node({nodeType, detail: 'minimal'})` - Basic metadata only (~200 tokens)
+   - `get_node({nodeType, detail: 'full'})` - Complete information (~3000-8000 tokens)
+   - `get_node({nodeType, mode: 'search_properties', propertyQuery: 'auth'})` - Find specific properties
+   - `get_node({nodeType, mode: 'docs'})` - Human-readable markdown documentation
+   - Show workflow architecture to user for approval before proceeding
+
+5. **Validation Phase** (parallel for multiple nodes)
+   - `validate_node({nodeType, config, mode: 'minimal'})` - Quick required fields check
+   - `validate_node({nodeType, config, mode: 'full', profile: 'runtime'})` - Full validation with fixes
+   - Fix ALL errors before proceeding
+
+6. **Building Phase**
+   - If using template: `get_template(templateId, {mode: "full"})`
+   - **MANDATORY ATTRIBUTION**: "Based on template by **[author.name]** (@[username]). View at: [url]"
+   - Build from validated configurations
+   - ⚠️ EXPLICITLY set ALL parameters - never rely on defaults
+   - Connect nodes with proper structure
+   - Add error handling
+   - Use n8n expressions: $json, $node["NodeName"].json
+   - Build in artifact (unless deploying to n8n instance)
+
+7. **Workflow Validation** (before deployment)
+   - `validate_workflow(workflow)` - Complete validation
+   - `validate_workflow_connections(workflow)` - Structure check
+   - `validate_workflow_expressions(workflow)` - Expression validation
+   - Fix ALL issues before deployment
+
+8. **Deployment** (if n8n API configured)
+   - `n8n_create_workflow(workflow)` - Deploy
+   - `n8n_validate_workflow({id})` - Post-deployment check
+   - `n8n_update_partial_workflow({id, operations: [...]})` - Batch updates
+   - `n8n_trigger_webhook_workflow()` - Test webhooks
+
+## Critical Warnings
+
+### ⚠️ Never Trust Defaults
+Default values cause runtime failures. Example:
+```json
+// ❌ FAILS at runtime
+{resource: "message", operation: "post", text: "Hello"}
+
+// ✅ WORKS - all parameters explicit
+{resource: "message", operation: "post", select: "channel", channelId: "C123", text: "Hello"}
+```
+
+### ⚠️ Example Availability
+`includeExamples: true` returns real configurations from workflow templates.
+- Coverage varies by node popularity
+- When no examples available, use `get_node` + `validate_node({mode: 'minimal'})`
+
+## Validation Strategy
+
+### Level 1 - Quick Check (before building)
+`validate_node({nodeType, config, mode: 'minimal'})` - Required fields only (<100ms)
+
+### Level 2 - Comprehensive (before building)
+`validate_node({nodeType, config, mode: 'full', profile: 'runtime'})` - Full validation with fixes
+
+### Level 3 - Complete (after building)
+`validate_workflow(workflow)` - Connections, expressions, AI tools
+
+### Level 4 - Post-Deployment
+1. `n8n_validate_workflow({id})` - Validate deployed workflow
+2. `n8n_autofix_workflow({id})` - Auto-fix common errors
+3. `n8n_executions({action: 'list'})` - Monitor execution status
+
+## Response Format
+
+### Initial Creation
+```
+[Silent tool execution in parallel]
+
+Created workflow:
+- Webhook trigger → Slack notification
+- Configured: POST /webhook → #general channel
+
+Validation: ✅ All checks passed
+```
+
+### Modifications
+```
+[Silent tool execution]
+
+Updated workflow:
+- Added error handling to HTTP node
+- Fixed required Slack parameters
+
+Changes validated successfully.
+```
+
+## Batch Operations
+
+Use `n8n_update_partial_workflow` with multiple operations in a single call:
+
+✅ GOOD - Batch multiple operations:
+```json
+n8n_update_partial_workflow({
+  id: "wf-123",
+  operations: [
+    {type: "updateNode", nodeId: "slack-1", changes: {...}},
+    {type: "updateNode", nodeId: "http-1", changes: {...}},
+    {type: "cleanStaleConnections"}
+  ]
+})
+```
+
+❌ BAD - Separate calls:
+```json
+n8n_update_partial_workflow({id: "wf-123", operations: [{...}]})
+n8n_update_partial_workflow({id: "wf-123", operations: [{...}]})
+```
+
+###   CRITICAL: addConnection Syntax
+
+The `addConnection` operation requires **four separate string parameters**. Common mistakes cause misleading errors.
+
+❌ WRONG - Object format (fails with "Expected string, received object"):
+```json
+{
+  "type": "addConnection",
+  "connection": {
+    "source": {"nodeId": "node-1", "outputIndex": 0},
+    "destination": {"nodeId": "node-2", "inputIndex": 0}
+  }
+}
+```
+
+❌ WRONG - Combined string (fails with "Source node not found"):
+```json
+{
+  "type": "addConnection",
+  "source": "node-1:main:0",
+  "target": "node-2:main:0"
+}
+```
+
+✅ CORRECT - Four separate string parameters:
+```json
+{
+  "type": "addConnection",
+  "source": "node-id-string",
+  "target": "target-node-id-string",
+  "sourcePort": "main",
+  "targetPort": "main"
+}
+```
+
+**Reference**: [GitHub Issue #327](https://github.com/czlonkowski/n8n-mcp/issues/327)
+
+### ⚠️ CRITICAL: IF Node Multi-Output Routing
+
+IF nodes have **two outputs** (TRUE and FALSE). Use the **`branch` parameter** to route to the correct output:
+
+✅ CORRECT - Route to TRUE branch (when condition is met):
+```json
+{
+  "type": "addConnection",
+  "source": "if-node-id",
+  "target": "success-handler-id",
+  "sourcePort": "main",
+  "targetPort": "main",
+  "branch": "true"
+}
+```
+
+✅ CORRECT - Route to FALSE branch (when condition is NOT met):
+```json
+{
+  "type": "addConnection",
+  "source": "if-node-id",
+  "target": "failure-handler-id",
+  "sourcePort": "main",
+  "targetPort": "main",
+  "branch": "false"
+}
+```
+
+**Common Pattern** - Complete IF node routing:
+```json
+n8n_update_partial_workflow({
+  id: "workflow-id",
+  operations: [
+    {type: "addConnection", source: "If Node", target: "True Handler", sourcePort: "main", targetPort: "main", branch: "true"},
+    {type: "addConnection", source: "If Node", target: "False Handler", sourcePort: "main", targetPort: "main", branch: "false"}
+  ]
+})
+```
+
+**Note**: Without the `branch` parameter, both connections may end up on the same output, causing logic errors!
+
+### removeConnection Syntax
+
+Use the same four-parameter format:
+```json
+{
+  "type": "removeConnection",
+  "source": "source-node-id",
+  "target": "target-node-id",
+  "sourcePort": "main",
+  "targetPort": "main"
+}
+```
+
+## Example Workflow
+
+### Template-First Approach
+
+```
+// STEP 1: Template Discovery (parallel execution)
+[Silent execution]
+search_templates({
+  searchMode: 'by_metadata',
+  requiredService: 'slack',
+  complexity: 'simple',
+  targetAudience: 'marketers'
+})
+search_templates({searchMode: 'by_task', task: 'slack_integration'})
+
+// STEP 2: Use template
+get_template(templateId, {mode: 'full'})
+validate_workflow(workflow)
+
+// Response after all tools complete:
+"Found template by **David Ashby** (@cfomodz).
+View at: https://n8n.io/workflows/2414
+
+Validation: ✅ All checks passed"
+```
+
+### Building from Scratch (if no template)
+
+```
+// STEP 1: Discovery (parallel execution)
+[Silent execution]
+search_nodes({query: 'slack', includeExamples: true})
+search_nodes({query: 'communication trigger'})
+
+// STEP 2: Configuration (parallel execution)
+[Silent execution]
+get_node({nodeType: 'n8n-nodes-base.slack', detail: 'standard', includeExamples: true})
+get_node({nodeType: 'n8n-nodes-base.webhook', detail: 'standard', includeExamples: true})
+
+// STEP 3: Validation (parallel execution)
+[Silent execution]
+validate_node({nodeType: 'n8n-nodes-base.slack', config, mode: 'minimal'})
+validate_node({nodeType: 'n8n-nodes-base.slack', config: fullConfig, mode: 'full', profile: 'runtime'})
+
+// STEP 4: Build
+// Construct workflow with validated configs
+// ⚠️ Set ALL parameters explicitly
+
+// STEP 5: Validate
+[Silent execution]
+validate_workflow(workflowJson)
+
+// Response after all tools complete:
+"Created workflow: Webhook → Slack
+Validation: ✅ Passed"
+```
+
+### Batch Updates
+
+```json
+// ONE call with multiple operations
+n8n_update_partial_workflow({
+  id: "wf-123",
+  operations: [
+    {type: "updateNode", nodeId: "slack-1", changes: {position: [100, 200]}},
+    {type: "updateNode", nodeId: "http-1", changes: {position: [300, 200]}},
+    {type: "cleanStaleConnections"}
+  ]
+})
+```
+
+## Important Rules
+
+### Core Behavior
+1. **Silent execution** - No commentary between tools
+2. **Parallel by default** - Execute independent operations simultaneously
+3. **Templates first** - Always check before building (2,709 available)
+4. **Multi-level validation** - Quick check → Full validation → Workflow validation
+5. **Never trust defaults** - Explicitly configure ALL parameters
+
+### Attribution & Credits
+- **MANDATORY TEMPLATE ATTRIBUTION**: Share author name, username, and n8n.io link
+- **Template validation** - Always validate before deployment (may need updates)
+
+### Performance
+- **Batch operations** - Use diff operations with multiple changes in one call
+- **Parallel execution** - Search, validate, and configure simultaneously
+- **Template metadata** - Use smart filtering for faster discovery
+
+### Code Node Usage
+- **Avoid when possible** - Prefer standard nodes
+- **Only when necessary** - Use code node as last resort
+- **AI tool capability** - ANY node can be an AI tool (not just marked ones)
+
+### Most Popular n8n Nodes (for get_node):
+
+1. **n8n-nodes-base.code** - JavaScript/Python scripting
+2. **n8n-nodes-base.httpRequest** - HTTP API calls
+3. **n8n-nodes-base.webhook** - Event-driven triggers
+4. **n8n-nodes-base.set** - Data transformation
+5. **n8n-nodes-base.if** - Conditional routing
+6. **n8n-nodes-base.manualTrigger** - Manual workflow execution
+7. **n8n-nodes-base.respondToWebhook** - Webhook responses
+8. **n8n-nodes-base.scheduleTrigger** - Time-based triggers
+9. **@n8n/n8n-nodes-langchain.agent** - AI agents
+10. **n8n-nodes-base.googleSheets** - Spreadsheet integration
+11. **n8n-nodes-base.merge** - Data merging
+12. **n8n-nodes-base.switch** - Multi-branch routing
+13. **n8n-nodes-base.telegram** - Telegram bot integration
+14. **@n8n/n8n-nodes-langchain.lmChatOpenAi** - OpenAI chat models
+15. **n8n-nodes-base.splitInBatches** - Batch processing
+16. **n8n-nodes-base.openAi** - OpenAI legacy node
+17. **n8n-nodes-base.gmail** - Email automation
+18. **n8n-nodes-base.function** - Custom functions
+19. **n8n-nodes-base.stickyNote** - Workflow documentation
+20. **n8n-nodes-base.executeWorkflowTrigger** - Sub-workflow calls
+
+**Note:** LangChain nodes use the `@n8n/n8n-nodes-langchain.` prefix, core nodes use `n8n-nodes-base.`
+
+````
+
+This helps the agent produce higher-quality, well-structured n8n workflows.
+
+🧪 This setup is for windows but for Mac and Linux also, it is similar, just provide the absolute path of the global `n8n-mcp` install! 😄 Stay tuned for updates!

docs/LIBRARY_USAGE.md

@@ -558,7 +558,7 @@ DISABLE_CONSOLE_OUTPUT=false
 
 # Optional: Session configuration
 SESSION_TIMEOUT=1800000  # 30 minutes in milliseconds
-MAX_SESSIONS=100
+N8N_MCP_MAX_SESSIONS=100  # Maximum concurrent sessions (default: 100)
 
 # Optional: Performance
 NODE_ENV=production

docs/SESSION_PERSISTENCE.md

@@ -0,0 +1,758 @@
+# Session Persistence API - Production Guide
+
+## Overview
+
+The Session Persistence API enables zero-downtime container deployments in multi-tenant n8n-mcp environments. It allows you to export active MCP session state before shutdown and restore it after restart, maintaining session continuity across container lifecycle events.
+
+**Version:** 2.24.1+
+**Status:** Production-ready
+**Use Cases:** Multi-tenant SaaS, Kubernetes deployments, container orchestration, rolling updates
+
+## Architecture
+
+### Session State Components
+
+Each persisted session contains:
+
+1. **Session Metadata**
+   - `sessionId`: Unique session identifier (UUID v4)
+   - `createdAt`: ISO 8601 timestamp of session creation
+   - `lastAccess`: ISO 8601 timestamp of last activity
+
+2. **Instance Context**
+   - `n8nApiUrl`: n8n instance API endpoint
+   - `n8nApiKey`: n8n API authentication key (plaintext)
+   - `instanceId`: Optional tenant/instance identifier
+   - `sessionId`: Optional session-specific identifier
+   - `metadata`: Optional custom application data
+
+3. **Dormant Session Pattern**
+   - Transport and MCP server objects are NOT persisted
+   - Recreated automatically on first request after restore
+   - Reduces memory footprint during restore
+
+## API Reference
+
+### N8NMCPEngine.exportSessionState()
+
+Exports all active session state for persistence before shutdown.
+
+```typescript
+exportSessionState(): SessionState[]
+```
+
+**Returns:** Array of session state objects containing metadata and credentials
+
+**Example:**
+```typescript
+const sessions = engine.exportSessionState();
+// sessions = [
+//   {
+//     sessionId: '550e8400-e29b-41d4-a716-446655440000',
+//     metadata: {
+//       createdAt: '2025-11-24T10:30:00.000Z',
+//       lastAccess: '2025-11-24T17:15:32.000Z'
+//     },
+//     context: {
+//       n8nApiUrl: 'https://tenant1.n8n.cloud',
+//       n8nApiKey: 'n8n_api_...',
+//       instanceId: 'tenant-123',
+//       metadata: { userId: 'user-456' }
+//     }
+//   }
+// ]
+```
+
+**Key Behaviors:**
+- Exports only non-expired sessions (within sessionTimeout)
+- Detects and warns about duplicate session IDs
+- Logs security event with session count
+- Returns empty array if no active sessions
+
+### N8NMCPEngine.restoreSessionState()
+
+Restores sessions from previously exported state after container restart.
+
+```typescript
+restoreSessionState(sessions: SessionState[]): number
+```
+
+**Parameters:**
+- `sessions`: Array of session state objects from `exportSessionState()`
+
+**Returns:** Number of sessions successfully restored
+
+**Example:**
+```typescript
+const sessions = await loadFromEncryptedStorage();
+const count = engine.restoreSessionState(sessions);
+console.log(`Restored ${count} sessions`);
+```
+
+**Key Behaviors:**
+- Validates session metadata (timestamps, required fields)
+- Skips expired sessions (age > sessionTimeout)
+- Skips duplicate sessions (idempotent)
+- Respects MAX_SESSIONS limit (default 100, configurable via N8N_MCP_MAX_SESSIONS env var)
+- Recreates transports/servers lazily on first request
+- Logs security events for restore success/failure
+
+## Security Considerations
+
+### Critical: Encrypt Before Storage
+
+**The exported session state contains plaintext n8n API keys.** You MUST encrypt this data before persisting to disk.
+
+```typescript
+// ❌ NEVER DO THIS
+await fs.writeFile('sessions.json', JSON.stringify(sessions));
+
+// ✅ ALWAYS ENCRYPT
+const encrypted = await encryptSessionData(sessions, encryptionKey);
+await saveToSecureStorage(encrypted);
+```
+
+### Recommended Encryption Approach
+
+```typescript
+import crypto from 'crypto';
+
+/**
+ * Encrypt session data using AES-256-GCM
+ */
+async function encryptSessionData(
+  sessions: SessionState[],
+  encryptionKey: Buffer
+): Promise<string> {
+  const iv = crypto.randomBytes(16);
+  const cipher = crypto.createCipheriv('aes-256-gcm', encryptionKey, iv);
+
+  const json = JSON.stringify(sessions);
+  const encrypted = Buffer.concat([
+    cipher.update(json, 'utf8'),
+    cipher.final()
+  ]);
+
+  const authTag = cipher.getAuthTag();
+
+  // Return base64: iv:authTag:encrypted
+  return [
+    iv.toString('base64'),
+    authTag.toString('base64'),
+    encrypted.toString('base64')
+  ].join(':');
+}
+
+/**
+ * Decrypt session data
+ */
+async function decryptSessionData(
+  encryptedData: string,
+  encryptionKey: Buffer
+): Promise<SessionState[]> {
+  const [ivB64, authTagB64, encryptedB64] = encryptedData.split(':');
+
+  const iv = Buffer.from(ivB64, 'base64');
+  const authTag = Buffer.from(authTagB64, 'base64');
+  const encrypted = Buffer.from(encryptedB64, 'base64');
+
+  const decipher = crypto.createDecipheriv('aes-256-gcm', encryptionKey, iv);
+  decipher.setAuthTag(authTag);
+
+  const decrypted = Buffer.concat([
+    decipher.update(encrypted),
+    decipher.final()
+  ]);
+
+  return JSON.parse(decrypted.toString('utf8'));
+}
+```
+
+### Key Management
+
+Store encryption keys securely:
+- **Kubernetes:** Use Kubernetes Secrets with encryption at rest
+- **AWS:** Use AWS Secrets Manager or Parameter Store with KMS
+- **Azure:** Use Azure Key Vault
+- **GCP:** Use Secret Manager
+- **Local Dev:** Use environment variables (NEVER commit to git)
+
+### Security Logging
+
+All session persistence operations are logged with `[SECURITY]` prefix:
+
+```
+[SECURITY] session_export { timestamp, count }
+[SECURITY] session_restore { timestamp, sessionId, instanceId }
+[SECURITY] session_restore_failed { timestamp, sessionId, reason }
+[SECURITY] max_sessions_reached { timestamp, count }
+```
+
+Monitor these logs in production for audit trails and security analysis.
+
+## Implementation Examples
+
+### 1. Express.js Multi-Tenant Backend
+
+```typescript
+import express from 'express';
+import { N8NMCPEngine } from 'n8n-mcp';
+
+const app = express();
+const engine = new N8NMCPEngine({
+  sessionTimeout: 1800000, // 30 minutes
+  logLevel: 'info'
+});
+
+// Startup: Restore sessions from encrypted storage
+async function startup() {
+  try {
+    const encrypted = await redis.get('mcp:sessions');
+    if (encrypted) {
+      const sessions = await decryptSessionData(
+        encrypted,
+        process.env.ENCRYPTION_KEY
+      );
+      const count = engine.restoreSessionState(sessions);
+      console.log(`Restored ${count} sessions`);
+    }
+  } catch (error) {
+    console.error('Failed to restore sessions:', error);
+  }
+}
+
+// Shutdown: Export sessions to encrypted storage
+async function shutdown() {
+  try {
+    const sessions = engine.exportSessionState();
+    const encrypted = await encryptSessionData(
+      sessions,
+      process.env.ENCRYPTION_KEY
+    );
+    await redis.set('mcp:sessions', encrypted, 'EX', 3600); // 1 hour TTL
+    console.log(`Exported ${sessions.length} sessions`);
+  } catch (error) {
+    console.error('Failed to export sessions:', error);
+  }
+
+  await engine.shutdown();
+  process.exit(0);
+}
+
+// Handle graceful shutdown
+process.on('SIGTERM', shutdown);
+process.on('SIGINT', shutdown);
+
+// Start server
+await startup();
+app.listen(3000);
+```
+
+### 2. Kubernetes Deployment with Init Container
+
+**deployment.yaml:**
+```yaml
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: n8n-mcp
+spec:
+  replicas: 3
+  strategy:
+    type: RollingUpdate
+    rollingUpdate:
+      maxUnavailable: 1
+      maxSurge: 1
+  template:
+    spec:
+      initContainers:
+      - name: restore-sessions
+        image: your-app:latest
+        command: ['/app/restore-sessions.sh']
+        env:
+        - name: ENCRYPTION_KEY
+          valueFrom:
+            secretKeyRef:
+              name: mcp-secrets
+              key: encryption-key
+        - name: REDIS_URL
+          valueFrom:
+            secretKeyRef:
+              name: mcp-secrets
+              key: redis-url
+        volumeMounts:
+        - name: sessions
+          mountPath: /sessions
+
+      containers:
+      - name: mcp-server
+        image: your-app:latest
+        lifecycle:
+          preStop:
+            exec:
+              command: ['/app/export-sessions.sh']
+        env:
+        - name: ENCRYPTION_KEY
+          valueFrom:
+            secretKeyRef:
+              name: mcp-secrets
+              key: encryption-key
+        - name: SESSION_TIMEOUT
+          value: "1800000"
+        volumeMounts:
+        - name: sessions
+          mountPath: /sessions
+
+        # Graceful shutdown configuration
+        terminationGracePeriodSeconds: 30
+
+      volumes:
+      - name: sessions
+        emptyDir: {}
+```
+
+**restore-sessions.sh:**
+```bash
+#!/bin/bash
+set -e
+
+echo "Restoring sessions from Redis..."
+
+# Fetch encrypted sessions from Redis
+ENCRYPTED=$(redis-cli -u "$REDIS_URL" GET "mcp:sessions:${HOSTNAME}")
+
+if [ -n "$ENCRYPTED" ]; then
+  echo "$ENCRYPTED" > /sessions/encrypted.txt
+  echo "Sessions fetched, will be restored on startup"
+else
+  echo "No sessions to restore"
+fi
+```
+
+**export-sessions.sh:**
+```bash
+#!/bin/bash
+set -e
+
+echo "Exporting sessions to Redis..."
+
+# Trigger session export via HTTP endpoint
+curl -X POST http://localhost:3000/internal/export-sessions
+
+echo "Sessions exported successfully"
+```
+
+### 3. Docker Compose with Redis
+
+**docker-compose.yml:**
+```yaml
+version: '3.8'
+
+services:
+  n8n-mcp:
+    build: .
+    environment:
+      - ENCRYPTION_KEY=${ENCRYPTION_KEY}
+      - REDIS_URL=redis://redis:6379
+      - SESSION_TIMEOUT=1800000
+    depends_on:
+      - redis
+    volumes:
+      - ./data:/data
+    deploy:
+      replicas: 2
+      update_config:
+        parallelism: 1
+        delay: 10s
+        order: start-first
+    stop_grace_period: 30s
+
+  redis:
+    image: redis:7-alpine
+    volumes:
+      - redis-data:/data
+    command: redis-server --appendonly yes
+
+volumes:
+  redis-data:
+```
+
+**Application code:**
+```typescript
+import { N8NMCPEngine } from 'n8n-mcp';
+import Redis from 'ioredis';
+
+const redis = new Redis(process.env.REDIS_URL);
+const engine = new N8NMCPEngine();
+
+// Export endpoint (called by preStop hook)
+app.post('/internal/export-sessions', async (req, res) => {
+  try {
+    const sessions = engine.exportSessionState();
+    const encrypted = await encryptSessionData(
+      sessions,
+      Buffer.from(process.env.ENCRYPTION_KEY, 'hex')
+    );
+
+    // Store with hostname as key for per-container tracking
+    await redis.set(
+      `mcp:sessions:${os.hostname()}`,
+      encrypted,
+      'EX',
+      3600
+    );
+
+    res.json({ exported: sessions.length });
+  } catch (error) {
+    console.error('Export failed:', error);
+    res.status(500).json({ error: 'Export failed' });
+  }
+});
+
+// Restore on startup
+async function startup() {
+  const encrypted = await redis.get(`mcp:sessions:${os.hostname()}`);
+  if (encrypted) {
+    const sessions = await decryptSessionData(
+      encrypted,
+      Buffer.from(process.env.ENCRYPTION_KEY, 'hex')
+    );
+    const count = engine.restoreSessionState(sessions);
+    console.log(`Restored ${count} sessions`);
+  }
+}
+```
+
+## Best Practices
+
+### 1. Session Timeout Configuration
+
+Choose appropriate timeout based on use case:
+
+```typescript
+const engine = new N8NMCPEngine({
+  sessionTimeout: 1800000  // 30 minutes (recommended default)
+});
+
+// Development: 5 minutes
+sessionTimeout: 300000
+
+// Production SaaS: 30-60 minutes
+sessionTimeout: 1800000 - 3600000
+
+// Long-running workflows: 2-4 hours
+sessionTimeout: 7200000 - 14400000
+```
+
+### 2. Storage Backend Selection
+
+**Redis (Recommended for Production)**
+- Fast read/write for session data
+- TTL support for automatic cleanup
+- Pub/sub for distributed coordination
+- Atomic operations for consistency
+
+**Database (PostgreSQL/MySQL)**
+- JSONB column for session state
+- Good for audit requirements
+- Slower than Redis
+- Requires periodic cleanup
+
+**S3/Cloud Storage**
+- Good for disaster recovery backups
+- Not suitable for hot session restore
+- High latency
+- Good for long-term session archival
+
+### 3. Monitoring and Alerting
+
+Monitor these metrics:
+
+```typescript
+// Session export metrics
+const sessions = engine.exportSessionState();
+metrics.gauge('mcp.sessions.exported', sessions.length);
+metrics.gauge('mcp.sessions.export_size_kb',
+  JSON.stringify(sessions).length / 1024
+);
+
+// Session restore metrics
+const restored = engine.restoreSessionState(sessions);
+metrics.gauge('mcp.sessions.restored', restored);
+metrics.gauge('mcp.sessions.restore_success_rate',
+  restored / sessions.length
+);
+
+// Runtime metrics
+const info = engine.getSessionInfo();
+metrics.gauge('mcp.sessions.active', info.active ? 1 : 0);
+metrics.gauge('mcp.sessions.age_seconds', info.age || 0);
+```
+
+Alert on:
+- Export failures (should be rare)
+- Low restore success rate (<95%)
+- MAX_SESSIONS limit reached
+- High session age (potential leaks)
+
+### 4. Graceful Shutdown Timing
+
+Ensure sufficient time for session export:
+
+```typescript
+// Kubernetes terminationGracePeriodSeconds
+terminationGracePeriodSeconds: 30  // 30 seconds minimum
+
+// Docker stop timeout
+docker run --stop-timeout 30 your-image
+
+// Process signal handling
+process.on('SIGTERM', async () => {
+  console.log('SIGTERM received, starting graceful shutdown...');
+
+  // 1. Stop accepting new requests (5s)
+  await server.close();
+
+  // 2. Wait for in-flight requests (10s)
+  await waitForInFlightRequests(10000);
+
+  // 3. Export sessions (5s)
+  const sessions = engine.exportSessionState();
+  await saveEncryptedSessions(sessions);
+
+  // 4. Cleanup (5s)
+  await engine.shutdown();
+
+  // 5. Exit (5s buffer)
+  process.exit(0);
+});
+```
+
+### 5. Idempotency Handling
+
+Sessions can be restored multiple times safely:
+
+```typescript
+// First restore
+const count1 = engine.restoreSessionState(sessions);
+// count1 = 5
+
+// Second restore (same sessions)
+const count2 = engine.restoreSessionState(sessions);
+// count2 = 0 (all already exist)
+```
+
+This is safe for:
+- Init container retries
+- Manual recovery operations
+- Disaster recovery scenarios
+
+### 6. Multi-Instance Coordination
+
+For multiple container instances:
+
+```typescript
+// Option 1: Per-instance storage (simple)
+const key = `mcp:sessions:${instance.hostname}`;
+
+// Option 2: Centralized with distributed lock (advanced)
+const lock = await acquireLock('mcp:session-export');
+try {
+  const allSessions = await getAllInstanceSessions();
+  await saveToBackup(allSessions);
+} finally {
+  await lock.release();
+}
+```
+
+## Performance Considerations
+
+### Memory Usage
+
+```typescript
+// Each session: ~1-2 KB in memory
+// 100 sessions: ~100-200 KB
+// 1000 sessions: ~1-2 MB
+
+// Export serialized size
+const sessions = engine.exportSessionState();
+const sizeKB = JSON.stringify(sessions).length / 1024;
+console.log(`Export size: ${sizeKB.toFixed(2)} KB`);
+```
+
+### Export/Restore Speed
+
+```typescript
+// Export: O(n) where n = active sessions
+// Typical: 50-100 sessions in <10ms
+
+// Restore: O(n) with validation
+// Typical: 50-100 sessions in 20-50ms
+
+// Factor in encryption:
+// AES-256-GCM: ~1ms per 100 sessions
+```
+
+### MAX_SESSIONS Limit
+
+Default limit: 100 sessions per container (configurable via `N8N_MCP_MAX_SESSIONS` env var)
+
+```typescript
+// Restore respects limit
+const sessions = createSessions(150); // 150 sessions
+const restored = engine.restoreSessionState(sessions);
+// restored = 100 (only first 100 restored, or N8N_MCP_MAX_SESSIONS value)
+```
+
+For higher session limits:
+- Set `N8N_MCP_MAX_SESSIONS=1000` (or desired limit)
+- Monitor memory usage as sessions consume resources
+- Alternatively, deploy multiple containers with session routing/sharding
+
+## Troubleshooting
+
+### Issue: No sessions restored
+
+**Symptoms:**
+```
+Restored 0 sessions
+```
+
+**Causes:**
+1. All sessions expired (age > sessionTimeout)
+2. Invalid date format in metadata
+3. Missing required context fields
+
+**Debug:**
+```typescript
+const sessions = await loadFromEncryptedStorage();
+console.log('Loaded sessions:', sessions.length);
+
+// Check individual sessions
+sessions.forEach((s, i) => {
+  const age = Date.now() - new Date(s.metadata.lastAccess).getTime();
+  console.log(`Session ${i}: age=${age}ms, expired=${age > sessionTimeout}`);
+});
+```
+
+### Issue: Restore fails with "invalid context"
+
+**Symptoms:**
+```
+[SECURITY] session_restore_failed { sessionId: '...', reason: 'invalid context: ...' }
+```
+
+**Causes:**
+1. Missing n8nApiUrl or n8nApiKey
+2. Invalid URL format
+3. Corrupted session data
+
+**Fix:**
+```typescript
+// Validate before restore
+const valid = sessions.filter(s => {
+  if (!s.context?.n8nApiUrl || !s.context?.n8nApiKey) {
+    console.warn(`Invalid session ${s.sessionId}: missing credentials`);
+    return false;
+  }
+  try {
+    new URL(s.context.n8nApiUrl); // Validate URL
+    return true;
+  } catch {
+    console.warn(`Invalid session ${s.sessionId}: malformed URL`);
+    return false;
+  }
+});
+
+const count = engine.restoreSessionState(valid);
+```
+
+### Issue: MAX_SESSIONS limit hit
+
+**Symptoms:**
+```
+Reached MAX_SESSIONS limit (100), skipping remaining sessions
+```
+
+**Solutions:**
+
+1. Increase limit: Set `N8N_MCP_MAX_SESSIONS=1000` (or desired value)
+2. Scale horizontally (more containers)
+3. Implement session sharding
+4. Reduce sessionTimeout
+5. Clean up inactive sessions
+
+```typescript
+// Pre-filter by activity
+const recentSessions = sessions.filter(s => {
+  const age = Date.now() - new Date(s.metadata.lastAccess).getTime();
+  return age < 600000; // Only restore sessions active in last 10 min
+});
+
+const count = engine.restoreSessionState(recentSessions);
+```
+
+### Issue: Duplicate session IDs
+
+**Symptoms:**
+```
+Duplicate sessionId detected during export: 550e8400-...
+```
+
+**Cause:** Bug in session management logic
+
+**Fix:** This is a warning, not an error. The duplicate is automatically skipped. If persistent, investigate session creation logic.
+
+### Issue: High memory usage after restore
+
+**Symptoms:** Container OOM after restoring many sessions
+
+**Cause:** Too many sessions for container resources
+
+**Solution:**
+```typescript
+// Restore in batches
+async function restoreInBatches(sessions: SessionState[], batchSize = 25) {
+  let totalRestored = 0;
+
+  for (let i = 0; i < sessions.length; i += batchSize) {
+    const batch = sessions.slice(i, i + batchSize);
+    const count = engine.restoreSessionState(batch);
+    totalRestored += count;
+
+    // Wait for GC between batches
+    await new Promise(resolve => setTimeout(resolve, 100));
+  }
+
+  return totalRestored;
+}
+```
+
+## Version Compatibility
+
+| Feature | Version | Status |
+|---------|---------|--------|
+| exportSessionState() | 2.3.0+ | Stable |
+| restoreSessionState() | 2.3.0+ | Stable |
+| Security logging | 2.24.1+ | Stable |
+| Duplicate detection | 2.24.1+ | Stable |
+| Race condition fix | 2.24.1+ | Stable |
+| Date validation | 2.24.1+ | Stable |
+| Optional instanceId | 2.24.1+ | Stable |
+
+## Additional Resources
+
+- [HTTP Deployment Guide](./HTTP_DEPLOYMENT.md) - Multi-tenant HTTP server setup
+- [Library Usage Guide](./LIBRARY_USAGE.md) - Embedding n8n-mcp in your app
+- [Docker Guide](./DOCKER_README.md) - Container deployment
+- [Flexible Instance Configuration](./FLEXIBLE_INSTANCE_CONFIGURATION.md) - Multi-tenant patterns
+
+## Support
+
+For issues or questions:
+- GitHub Issues: https://github.com/czlonkowski/n8n-mcp/issues
+- Documentation: https://github.com/czlonkowski/n8n-mcp#readme
+
+---
+
+Conceived by Romuald Członkowski - https://www.aiadvisors.pl/en

docs/TYPE_STRUCTURE_VALIDATION.md

@@ -0,0 +1,239 @@
+# Type Structure Validation
+
+## Overview
+
+Type Structure Validation is an automatic validation system that ensures complex n8n node configurations conform to their expected data structures. Implemented as part of the n8n-mcp validation system, it provides zero-configuration validation for special n8n types that have complex nested structures.
+
+**Status:** Production (v2.22.21+)
+**Performance:** 100% pass rate on 776 real-world validations
+**Speed:** 0.01ms average validation time (500x faster than target)
+
+The system automatically validates node configurations without requiring any additional setup or configuration from users or AI assistants.
+
+## Supported Types
+
+The validation system supports four special n8n types that have complex structures:
+
+### 1. **filter** (FilterValue)
+Complex filtering conditions with boolean operators, comparison operations, and nested logic.
+
+**Structure:**
+- `combinator`: "and" | "or" - How conditions are combined
+- `conditions`: Array of filter conditions
+  - Each condition has: `leftValue`, `operator` (type + operation), `rightValue`
+  - Supports 40+ operations: equals, contains, exists, notExists, gt, lt, regex, etc.
+
+**Example Usage:** IF node, Switch node condition filtering
+
+### 2. **resourceMapper** (ResourceMapperValue)
+Data mapping configuration for transforming data between different formats.
+
+**Structure:**
+- `mappingMode`: "defineBelow" | "autoMapInputData" | "mapManually"
+- `value`: Field mappings or expressions
+- `matchingColumns`: Column matching configuration
+- `schema`: Target schema definition
+
+**Example Usage:** Google Sheets node, Airtable node data mapping
+
+### 3. **assignmentCollection** (AssignmentCollectionValue)
+Variable assignments for setting multiple values at once.
+
+**Structure:**
+- `assignments`: Array of name-value pairs
+  - Each assignment has: `name`, `value`, `type`
+
+**Example Usage:** Set node, Code node variable assignments
+
+### 4. **resourceLocator** (INodeParameterResourceLocator)
+Resource selection with multiple lookup modes (ID, name, URL, etc.).
+
+**Structure:**
+- `mode`: "id" | "list" | "url" | "name"
+- `value`: Resource identifier (string, number, or expression)
+- `cachedResultName`: Optional cached display name
+- `cachedResultUrl`: Optional cached URL
+
+**Example Usage:** Google Sheets spreadsheet selection, Slack channel selection
+
+## Performance & Results
+
+The validation system was tested against real-world n8n.io workflow templates:
+
+| Metric | Result |
+|--------|--------|
+| **Templates Tested** | 91 (top by popularity) |
+| **Nodes Validated** | 616 nodes with special types |
+| **Total Validations** | 776 property validations |
+| **Pass Rate** | 100.00% (776/776) |
+| **False Positive Rate** | 0.00% |
+| **Average Time** | 0.01ms per validation |
+| **Max Time** | 1.00ms per validation |
+| **Performance vs Target** | 500x faster than 50ms target |
+
+### Type-Specific Results
+
+- `filter`: 93/93 passed (100.00%)
+- `resourceMapper`: 69/69 passed (100.00%)
+- `assignmentCollection`: 213/213 passed (100.00%)
+- `resourceLocator`: 401/401 passed (100.00%)
+
+## How It Works
+
+### Automatic Integration
+
+Structure validation is automatically applied during node configuration validation. When you call `validate_node_operation` or `validate_node_minimal`, the system:
+
+1. **Identifies Special Types**: Detects properties that use filter, resourceMapper, assignmentCollection, or resourceLocator types
+2. **Validates Structure**: Checks that the configuration matches the expected structure for that type
+3. **Validates Operations**: For filter types, validates that operations are supported for the data type
+4. **Provides Context**: Returns specific error messages with property paths and fix suggestions
+
+### Validation Flow
+
+```
+User/AI provides node config
+        ↓
+validate_node_operation (MCP tool)
+        ↓
+EnhancedConfigValidator.validateWithMode()
+        ↓
+validateSpecialTypeStructures() ← Automatic structure validation
+        ↓
+TypeStructureService.validateStructure()
+        ↓
+Returns validation result with errors/warnings/suggestions
+```
+
+### Edge Cases Handled
+
+**1. Credential-Provided Fields**
+- Fields like Google Sheets `sheetId` that come from n8n credentials at runtime are excluded from validation
+- No false positives for fields that aren't in the configuration
+
+**2. Filter Operations**
+- Universal operations (`exists`, `notExists`, `isNotEmpty`) work across all data types
+- Type-specific operations validated (e.g., `regex` only for strings, `gt`/`lt` only for numbers)
+
+**3. Node-Specific Logic**
+- Custom validation logic for specific nodes (Google Sheets, Slack, etc.)
+- Context-aware error messages that understand the node's operation
+
+## Example Validation Error
+
+### Invalid Filter Structure
+
+**Configuration:**
+```json
+{
+  "conditions": {
+    "combinator": "and",
+    "conditions": [
+      {
+        "leftValue": "={{ $json.status }}",
+        "rightValue": "active",
+        "operator": {
+          "type": "string",
+          "operation": "invalidOperation"  // ❌ Not a valid operation
+        }
+      }
+    ]
+  }
+}
+```
+
+**Validation Error:**
+```json
+{
+  "valid": false,
+  "errors": [
+    {
+      "type": "invalid_structure",
+      "property": "conditions.conditions[0].operator.operation",
+      "message": "Unsupported operation 'invalidOperation' for type 'string'",
+      "suggestion": "Valid operations for string: equals, notEquals, contains, notContains, startsWith, endsWith, regex, exists, notExists, isNotEmpty"
+    }
+  ]
+}
+```
+
+## Technical Details
+
+### Implementation
+
+- **Type Definitions**: `src/types/type-structures.ts` (301 lines)
+- **Type Structures**: `src/constants/type-structures.ts` (741 lines, 22 complete type structures)
+- **Service Layer**: `src/services/type-structure-service.ts` (427 lines)
+- **Validator Integration**: `src/services/enhanced-config-validator.ts` (line 270)
+- **Node-Specific Logic**: `src/services/node-specific-validators.ts`
+
+### Test Coverage
+
+- **Unit Tests**:
+  - `tests/unit/types/type-structures.test.ts` (14 tests)
+  - `tests/unit/constants/type-structures.test.ts` (39 tests)
+  - `tests/unit/services/type-structure-service.test.ts` (64 tests)
+  - `tests/unit/services/enhanced-config-validator-type-structures.test.ts`
+
+- **Integration Tests**:
+  - `tests/integration/validation/real-world-structure-validation.test.ts` (8 tests, 388ms)
+
+- **Validation Scripts**:
+  - `scripts/test-structure-validation.ts` - Standalone validation against 100 templates
+
+### Documentation
+
+- **Implementation Plan**: `docs/local/v3/implementation-plan-final.md` - Complete technical specifications
+- **Phase Results**: Phases 1-3 completed with 100% success criteria met
+
+## For Developers
+
+### Adding New Type Structures
+
+1. Define the type structure in `src/constants/type-structures.ts`
+2. Add validation logic in `TypeStructureService.validateStructure()`
+3. Add tests in `tests/unit/constants/type-structures.test.ts`
+4. Test against real templates using `scripts/test-structure-validation.ts`
+
+### Testing Structure Validation
+
+**Run Unit Tests:**
+```bash
+npm run test:unit -- tests/unit/services/enhanced-config-validator-type-structures.test.ts
+```
+
+**Run Integration Tests:**
+```bash
+npm run test:integration -- tests/integration/validation/real-world-structure-validation.test.ts
+```
+
+**Run Full Validation:**
+```bash
+npm run test:structure-validation
+```
+
+### Relevant Test Files
+
+- **Type Tests**: `tests/unit/types/type-structures.test.ts`
+- **Structure Tests**: `tests/unit/constants/type-structures.test.ts`
+- **Service Tests**: `tests/unit/services/type-structure-service.test.ts`
+- **Validator Tests**: `tests/unit/services/enhanced-config-validator-type-structures.test.ts`
+- **Integration Tests**: `tests/integration/validation/real-world-structure-validation.test.ts`
+- **Real-World Validation**: `scripts/test-structure-validation.ts`
+
+## Production Readiness
+
+✅ **All Tests Passing**: 100% pass rate on unit and integration tests
+✅ **Performance Validated**: 0.01ms average (500x better than 50ms target)
+✅ **Zero Breaking Changes**: Fully backward compatible
+✅ **Real-World Validation**: 91 templates, 616 nodes, 776 validations
+✅ **Production Deployment**: Successfully deployed in v2.22.21
+✅ **Edge Cases Handled**: Credential fields, filter operations, node-specific logic
+
+## Version History
+
+- **v2.22.21** (2025-11-21): Type structure validation system completed (Phases 1-3)
+  - 22 complete type structures defined
+  - 100% pass rate on real-world validation
+  - 0.01ms average validation time
+  - Zero false positives

package.json

@@ -1,6 +1,6 @@
 {
   "name": "n8n-mcp",
-  "version": "2.22.21",
+  "version": "2.28.4",
   "description": "Integration between n8n workflow automation and Model Context Protocol (MCP)",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -66,6 +66,7 @@
     "test:workflow-diff": "node dist/scripts/test-workflow-diff.js",
     "test:transactional-diff": "node dist/scripts/test-transactional-diff.js",
     "test:tools-documentation": "node dist/scripts/test-tools-documentation.js",
+    "test:structure-validation": "npx tsx scripts/test-structure-validation.ts",
     "test:url-configuration": "npm run build && ts-node scripts/test-url-configuration.ts",
     "test:search-improvements": "node dist/scripts/test-search-improvements.js",
     "test:fts5-search": "node dist/scripts/test-fts5-search.js",
@@ -139,21 +140,22 @@
     "vitest": "^3.2.4"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.20.1",
-    "@n8n/n8n-nodes-langchain": "^1.119.1",
+    "@modelcontextprotocol/sdk": "1.20.1",
+    "@n8n/n8n-nodes-langchain": "^1.121.1",
     "@supabase/supabase-js": "^2.57.4",
     "dotenv": "^16.5.0",
     "express": "^5.1.0",
     "express-rate-limit": "^7.1.5",
+    "form-data": "^4.0.5",
     "lru-cache": "^11.2.1",
-    "n8n": "^1.120.3",
-    "n8n-core": "^1.119.2",
-    "n8n-workflow": "^1.117.0",
+    "n8n": "^1.122.4",
+    "n8n-core": "^1.121.1",
+    "n8n-workflow": "^1.119.1",
     "openai": "^4.77.0",
     "sql.js": "^1.13.0",
     "tslib": "^2.6.2",
     "uuid": "^10.0.0",
-    "zod": "^3.24.1"
+    "zod": "3.24.1"
   },
   "optionalDependencies": {
     "@rollup/rollup-darwin-arm64": "^4.50.0",

package.runtime.json

@@ -1,10 +1,10 @@
 {
   "name": "n8n-mcp-runtime",
-  "version": "2.22.17",
+  "version": "2.28.0",
   "description": "n8n MCP Server Runtime Dependencies Only",
   "private": true,
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.13.2",
+    "@modelcontextprotocol/sdk": "1.20.1",
     "@supabase/supabase-js": "^2.57.4",
     "express": "^5.1.0",
     "express-rate-limit": "^7.1.5",

scripts/test-structure-validation.ts

@@ -0,0 +1,470 @@
+#!/usr/bin/env ts-node
+/**
+ * Phase 3: Real-World Type Structure Validation
+ *
+ * Tests type structure validation against real workflow templates from n8n.io
+ * to ensure production readiness. Validates filter, resourceMapper,
+ * assignmentCollection, and resourceLocator types.
+ *
+ * Usage:
+ *   npm run build && node dist/scripts/test-structure-validation.js
+ *
+ * or with ts-node:
+ *   npx ts-node scripts/test-structure-validation.ts
+ */
+
+import { createDatabaseAdapter } from '../src/database/database-adapter';
+import { EnhancedConfigValidator } from '../src/services/enhanced-config-validator';
+import type { NodePropertyTypes } from 'n8n-workflow';
+import { gunzipSync } from 'zlib';
+
+interface ValidationResult {
+  templateId: number;
+  templateName: string;
+  templateViews: number;
+  nodeId: string;
+  nodeName: string;
+  nodeType: string;
+  propertyName: string;
+  propertyType: NodePropertyTypes;
+  valid: boolean;
+  errors: Array<{ type: string; property?: string; message: string }>;
+  warnings: Array<{ type: string; property?: string; message: string }>;
+  validationTimeMs: number;
+}
+
+interface ValidationStats {
+  totalTemplates: number;
+  totalNodes: number;
+  totalValidations: number;
+  passedValidations: number;
+  failedValidations: number;
+  byType: Record<string, { passed: number; failed: number }>;
+  byError: Record<string, number>;
+  avgValidationTimeMs: number;
+  maxValidationTimeMs: number;
+}
+
+// Special types we want to validate
+const SPECIAL_TYPES: NodePropertyTypes[] = [
+  'filter',
+  'resourceMapper',
+  'assignmentCollection',
+  'resourceLocator',
+];
+
+function decompressWorkflow(compressed: string): any {
+  try {
+    const buffer = Buffer.from(compressed, 'base64');
+    const decompressed = gunzipSync(buffer);
+    return JSON.parse(decompressed.toString('utf-8'));
+  } catch (error: any) {
+    throw new Error(`Failed to decompress workflow: ${error.message}`);
+  }
+}
+
+async function loadTopTemplates(db: any, limit: number = 100) {
+  console.log(`📥 Loading top ${limit} templates by popularity...\n`);
+
+  const stmt = db.prepare(`
+    SELECT
+      id,
+      name,
+      workflow_json_compressed,
+      views
+    FROM templates
+    WHERE workflow_json_compressed IS NOT NULL
+    ORDER BY views DESC
+    LIMIT ?
+  `);
+
+  const templates = stmt.all(limit);
+  console.log(`✓ Loaded ${templates.length} templates\n`);
+
+  return templates;
+}
+
+function extractNodesWithSpecialTypes(workflowJson: any): Array<{
+  nodeId: string;
+  nodeName: string;
+  nodeType: string;
+  properties: Array<{ name: string; type: NodePropertyTypes; value: any }>;
+}> {
+  const results: Array<any> = [];
+
+  if (!workflowJson || !workflowJson.nodes || !Array.isArray(workflowJson.nodes)) {
+    return results;
+  }
+
+  for (const node of workflowJson.nodes) {
+    // Check if node has parameters with special types
+    if (!node.parameters || typeof node.parameters !== 'object') {
+      continue;
+    }
+
+    const specialProperties: Array<{ name: string; type: NodePropertyTypes; value: any }> = [];
+
+    // Check each parameter against our special types
+    for (const [paramName, paramValue] of Object.entries(node.parameters)) {
+      // Try to infer type from structure
+      const inferredType = inferPropertyType(paramValue);
+
+      if (inferredType && SPECIAL_TYPES.includes(inferredType)) {
+        specialProperties.push({
+          name: paramName,
+          type: inferredType,
+          value: paramValue,
+        });
+      }
+    }
+
+    if (specialProperties.length > 0) {
+      results.push({
+        nodeId: node.id,
+        nodeName: node.name,
+        nodeType: node.type,
+        properties: specialProperties,
+      });
+    }
+  }
+
+  return results;
+}
+
+function inferPropertyType(value: any): NodePropertyTypes | null {
+  if (!value || typeof value !== 'object') {
+    return null;
+  }
+
+  // Filter type: has combinator and conditions
+  if (value.combinator && value.conditions) {
+    return 'filter';
+  }
+
+  // ResourceMapper type: has mappingMode
+  if (value.mappingMode) {
+    return 'resourceMapper';
+  }
+
+  // AssignmentCollection type: has assignments array
+  if (value.assignments && Array.isArray(value.assignments)) {
+    return 'assignmentCollection';
+  }
+
+  // ResourceLocator type: has mode and value
+  if (value.mode && value.hasOwnProperty('value')) {
+    return 'resourceLocator';
+  }
+
+  return null;
+}
+
+async function validateTemplate(
+  templateId: number,
+  templateName: string,
+  templateViews: number,
+  workflowJson: any
+): Promise<ValidationResult[]> {
+  const results: ValidationResult[] = [];
+
+  // Extract nodes with special types
+  const nodesWithSpecialTypes = extractNodesWithSpecialTypes(workflowJson);
+
+  for (const node of nodesWithSpecialTypes) {
+    for (const prop of node.properties) {
+      const startTime = Date.now();
+
+      // Create property definition for validation
+      const properties = [
+        {
+          name: prop.name,
+          type: prop.type,
+          required: true,
+          displayName: prop.name,
+          default: {},
+        },
+      ];
+
+      // Create config with just this property
+      const config = {
+        [prop.name]: prop.value,
+      };
+
+      try {
+        // Run validation
+        const validationResult = EnhancedConfigValidator.validateWithMode(
+          node.nodeType,
+          config,
+          properties,
+          'operation',
+          'ai-friendly'
+        );
+
+        const validationTimeMs = Date.now() - startTime;
+
+        results.push({
+          templateId,
+          templateName,
+          templateViews,
+          nodeId: node.nodeId,
+          nodeName: node.nodeName,
+          nodeType: node.nodeType,
+          propertyName: prop.name,
+          propertyType: prop.type,
+          valid: validationResult.valid,
+          errors: validationResult.errors || [],
+          warnings: validationResult.warnings || [],
+          validationTimeMs,
+        });
+      } catch (error: any) {
+        const validationTimeMs = Date.now() - startTime;
+
+        results.push({
+          templateId,
+          templateName,
+          templateViews,
+          nodeId: node.nodeId,
+          nodeName: node.nodeName,
+          nodeType: node.nodeType,
+          propertyName: prop.name,
+          propertyType: prop.type,
+          valid: false,
+          errors: [
+            {
+              type: 'exception',
+              property: prop.name,
+              message: `Validation threw exception: ${error.message}`,
+            },
+          ],
+          warnings: [],
+          validationTimeMs,
+        });
+      }
+    }
+  }
+
+  return results;
+}
+
+function calculateStats(results: ValidationResult[]): ValidationStats {
+  const stats: ValidationStats = {
+    totalTemplates: new Set(results.map(r => r.templateId)).size,
+    totalNodes: new Set(results.map(r => `${r.templateId}-${r.nodeId}`)).size,
+    totalValidations: results.length,
+    passedValidations: results.filter(r => r.valid).length,
+    failedValidations: results.filter(r => !r.valid).length,
+    byType: {},
+    byError: {},
+    avgValidationTimeMs: 0,
+    maxValidationTimeMs: 0,
+  };
+
+  // Stats by type
+  for (const type of SPECIAL_TYPES) {
+    const typeResults = results.filter(r => r.propertyType === type);
+    stats.byType[type] = {
+      passed: typeResults.filter(r => r.valid).length,
+      failed: typeResults.filter(r => !r.valid).length,
+    };
+  }
+
+  // Error frequency
+  for (const result of results.filter(r => !r.valid)) {
+    for (const error of result.errors) {
+      const key = `${error.type}: ${error.message}`;
+      stats.byError[key] = (stats.byError[key] || 0) + 1;
+    }
+  }
+
+  // Performance stats
+  if (results.length > 0) {
+    stats.avgValidationTimeMs =
+      results.reduce((sum, r) => sum + r.validationTimeMs, 0) / results.length;
+    stats.maxValidationTimeMs = Math.max(...results.map(r => r.validationTimeMs));
+  }
+
+  return stats;
+}
+
+function printStats(stats: ValidationStats) {
+  console.log('\n' + '='.repeat(80));
+  console.log('VALIDATION STATISTICS');
+  console.log('='.repeat(80) + '\n');
+
+  console.log(`📊 Total Templates Tested: ${stats.totalTemplates}`);
+  console.log(`📊 Total Nodes with Special Types: ${stats.totalNodes}`);
+  console.log(`📊 Total Property Validations: ${stats.totalValidations}\n`);
+
+  const passRate = (stats.passedValidations / stats.totalValidations * 100).toFixed(2);
+  const failRate = (stats.failedValidations / stats.totalValidations * 100).toFixed(2);
+
+  console.log(`✅ Passed: ${stats.passedValidations} (${passRate}%)`);
+  console.log(`❌ Failed: ${stats.failedValidations} (${failRate}%)\n`);
+
+  console.log('By Property Type:');
+  console.log('-'.repeat(80));
+  for (const [type, counts] of Object.entries(stats.byType)) {
+    const total = counts.passed + counts.failed;
+    if (total === 0) {
+      console.log(`  ${type}: No occurrences found`);
+    } else {
+      const typePassRate = (counts.passed / total * 100).toFixed(2);
+      console.log(`  ${type}: ${counts.passed}/${total} passed (${typePassRate}%)`);
+    }
+  }
+
+  console.log('\n⚡ Performance:');
+  console.log('-'.repeat(80));
+  console.log(`  Average validation time: ${stats.avgValidationTimeMs.toFixed(2)}ms`);
+  console.log(`  Maximum validation time: ${stats.maxValidationTimeMs.toFixed(2)}ms`);
+
+  const meetsTarget = stats.avgValidationTimeMs < 50;
+  console.log(`  Target (<50ms): ${meetsTarget ? '✅ MET' : '❌ NOT MET'}\n`);
+
+  if (Object.keys(stats.byError).length > 0) {
+    console.log('🔍 Most Common Errors:');
+    console.log('-'.repeat(80));
+
+    const sortedErrors = Object.entries(stats.byError)
+      .sort((a, b) => b[1] - a[1])
+      .slice(0, 10);
+
+    for (const [error, count] of sortedErrors) {
+      console.log(`  ${count}x: ${error}`);
+    }
+  }
+}
+
+function printFailures(results: ValidationResult[], maxFailures: number = 20) {
+  const failures = results.filter(r => !r.valid);
+
+  if (failures.length === 0) {
+    console.log('\n✨ No failures! All validations passed.\n');
+    return;
+  }
+
+  console.log('\n' + '='.repeat(80));
+  console.log(`VALIDATION FAILURES (showing first ${Math.min(maxFailures, failures.length)})` );
+  console.log('='.repeat(80) + '\n');
+
+  for (let i = 0; i < Math.min(maxFailures, failures.length); i++) {
+    const failure = failures[i];
+
+    console.log(`Failure ${i + 1}/${failures.length}:`);
+    console.log(`  Template: ${failure.templateName} (ID: ${failure.templateId}, Views: ${failure.templateViews})`);
+    console.log(`  Node: ${failure.nodeName} (${failure.nodeType})`);
+    console.log(`  Property: ${failure.propertyName} (type: ${failure.propertyType})`);
+    console.log(`  Errors:`);
+
+    for (const error of failure.errors) {
+      console.log(`    - [${error.type}] ${error.property}: ${error.message}`);
+    }
+
+    if (failure.warnings.length > 0) {
+      console.log(`  Warnings:`);
+      for (const warning of failure.warnings) {
+        console.log(`    - [${warning.type}] ${warning.property}: ${warning.message}`);
+      }
+    }
+
+    console.log('');
+  }
+
+  if (failures.length > maxFailures) {
+    console.log(`... and ${failures.length - maxFailures} more failures\n`);
+  }
+}
+
+async function main() {
+  console.log('='.repeat(80));
+  console.log('PHASE 3: REAL-WORLD TYPE STRUCTURE VALIDATION');
+  console.log('='.repeat(80) + '\n');
+
+  // Initialize database
+  console.log('🔌 Connecting to database...');
+  const db = await createDatabaseAdapter('./data/nodes.db');
+  console.log('✓ Database connected\n');
+
+  // Load templates
+  const templates = await loadTopTemplates(db, 100);
+
+  // Validate each template
+  console.log('🔍 Validating templates...\n');
+
+  const allResults: ValidationResult[] = [];
+  let processedCount = 0;
+  let nodesFound = 0;
+
+  for (const template of templates) {
+    processedCount++;
+
+    let workflowJson;
+    try {
+      workflowJson = decompressWorkflow(template.workflow_json_compressed);
+    } catch (error) {
+      console.warn(`⚠️  Template ${template.id}: Decompression failed, skipping`);
+      continue;
+    }
+
+    const results = await validateTemplate(
+      template.id,
+      template.name,
+      template.views,
+      workflowJson
+    );
+
+    if (results.length > 0) {
+      nodesFound += new Set(results.map(r => r.nodeId)).size;
+      allResults.push(...results);
+
+      const passedCount = results.filter(r => r.valid).length;
+      const status = passedCount === results.length ? '✓' : '✗';
+      console.log(
+        `${status} Template ${processedCount}/${templates.length}: ` +
+        `"${template.name}" (${results.length} validations, ${passedCount} passed)`
+      );
+    }
+  }
+
+  console.log(`\n✓ Processed ${processedCount} templates`);
+  console.log(`✓ Found ${nodesFound} nodes with special types\n`);
+
+  // Calculate and print statistics
+  const stats = calculateStats(allResults);
+  printStats(stats);
+
+  // Print detailed failures
+  printFailures(allResults);
+
+  // Success criteria check
+  console.log('='.repeat(80));
+  console.log('SUCCESS CRITERIA CHECK');
+  console.log('='.repeat(80) + '\n');
+
+  const passRate = (stats.passedValidations / stats.totalValidations * 100);
+  const falsePositiveRate = (stats.failedValidations / stats.totalValidations * 100);
+  const avgTime = stats.avgValidationTimeMs;
+
+  console.log(`Pass Rate: ${passRate.toFixed(2)}% (target: >95%) ${passRate > 95 ? '✅' : '❌'}`);
+  console.log(`False Positive Rate: ${falsePositiveRate.toFixed(2)}% (target: <5%) ${falsePositiveRate < 5 ? '✅' : '❌'}`);
+  console.log(`Avg Validation Time: ${avgTime.toFixed(2)}ms (target: <50ms) ${avgTime < 50 ? '✅' : '❌'}\n`);
+
+  const allCriteriaMet = passRate > 95 && falsePositiveRate < 5 && avgTime < 50;
+
+  if (allCriteriaMet) {
+    console.log('🎉 ALL SUCCESS CRITERIA MET! Phase 3 validation complete.\n');
+  } else {
+    console.log('⚠️  Some success criteria not met. Iteration required.\n');
+  }
+
+  // Close database
+  db.close();
+
+  process.exit(allCriteriaMet ? 0 : 1);
+}
+
+// Run the script
+main().catch((error) => {
+  console.error('Fatal error:', error);
+  process.exit(1);
+});

src/constants/type-structures.ts

@@ -0,0 +1,741 @@
+/**
+ * Type Structure Constants
+ *
+ * Complete definitions for all n8n NodePropertyTypes.
+ * These structures define the expected data format, JavaScript type,
+ * validation rules, and examples for each property type.
+ *
+ * Based on n8n-workflow v1.120.3 NodePropertyTypes
+ *
+ * @module constants/type-structures
+ * @since 2.23.0
+ */
+
+import type { NodePropertyTypes } from 'n8n-workflow';
+import type { TypeStructure } from '../types/type-structures';
+
+/**
+ * Complete type structure definitions for all 22 NodePropertyTypes
+ *
+ * Each entry defines:
+ * - type: Category (primitive/object/collection/special)
+ * - jsType: Underlying JavaScript type
+ * - description: What this type represents
+ * - structure: Expected data shape (for complex types)
+ * - example: Working example value
+ * - validation: Type-specific validation rules
+ *
+ * @constant
+ */
+export const TYPE_STRUCTURES: Record<NodePropertyTypes, TypeStructure> = {
+	// ============================================================================
+	// PRIMITIVE TYPES - Simple JavaScript values
+	// ============================================================================
+
+	string: {
+		type: 'primitive',
+		jsType: 'string',
+		description: 'A text value that can contain any characters',
+		example: 'Hello World',
+		examples: ['', 'A simple text', '{{ $json.name }}', 'https://example.com'],
+		validation: {
+			allowEmpty: true,
+			allowExpressions: true,
+		},
+		notes: ['Most common property type', 'Supports n8n expressions'],
+	},
+
+	number: {
+		type: 'primitive',
+		jsType: 'number',
+		description: 'A numeric value (integer or decimal)',
+		example: 42,
+		examples: [0, -10, 3.14, 100],
+		validation: {
+			allowEmpty: false,
+			allowExpressions: true,
+		},
+		notes: ['Can be constrained with min/max in typeOptions'],
+	},
+
+	boolean: {
+		type: 'primitive',
+		jsType: 'boolean',
+		description: 'A true/false toggle value',
+		example: true,
+		examples: [true, false],
+		validation: {
+			allowEmpty: false,
+			allowExpressions: false,
+		},
+		notes: ['Rendered as checkbox in n8n UI'],
+	},
+
+	dateTime: {
+		type: 'primitive',
+		jsType: 'string',
+		description: 'A date and time value in ISO 8601 format',
+		example: '2024-01-20T10:30:00Z',
+		examples: [
+			'2024-01-20T10:30:00Z',
+			'2024-01-20',
+			'{{ $now }}',
+		],
+		validation: {
+			allowEmpty: false,
+			allowExpressions: true,
+			pattern: '^\\d{4}-\\d{2}-\\d{2}(T\\d{2}:\\d{2}:\\d{2}(\\.\\d{3})?Z?)?$',
+		},
+		notes: ['Accepts ISO 8601 format', 'Can use n8n date expressions'],
+	},
+
+	color: {
+		type: 'primitive',
+		jsType: 'string',
+		description: 'A color value in hex format',
+		example: '#FF5733',
+		examples: ['#FF5733', '#000000', '#FFFFFF', '{{ $json.color }}'],
+		validation: {
+			allowEmpty: false,
+			allowExpressions: true,
+			pattern: '^#[0-9A-Fa-f]{6}$',
+		},
+		notes: ['Must be 6-digit hex color', 'Rendered with color picker in UI'],
+	},
+
+	json: {
+		type: 'primitive',
+		jsType: 'string',
+		description: 'A JSON string that can be parsed into any structure',
+		example: '{"key": "value", "nested": {"data": 123}}',
+		examples: [
+			'{}',
+			'{"name": "John", "age": 30}',
+			'[1, 2, 3]',
+			'{{ $json }}',
+		],
+		validation: {
+			allowEmpty: false,
+			allowExpressions: true,
+		},
+		notes: ['Must be valid JSON when parsed', 'Often used for custom payloads'],
+	},
+
+	// ============================================================================
+	// OPTION TYPES - Selection from predefined choices
+	// ============================================================================
+
+	options: {
+		type: 'primitive',
+		jsType: 'string',
+		description: 'Single selection from a list of predefined options',
+		example: 'option1',
+		examples: ['GET', 'POST', 'channelMessage', 'update'],
+		validation: {
+			allowEmpty: false,
+			allowExpressions: false,
+		},
+		notes: [
+			'Value must match one of the defined option values',
+			'Rendered as dropdown in UI',
+			'Options defined in property.options array',
+		],
+	},
+
+	multiOptions: {
+		type: 'array',
+		jsType: 'array',
+		description: 'Multiple selections from a list of predefined options',
+		structure: {
+			items: {
+				type: 'string',
+				description: 'Selected option value',
+			},
+		},
+		example: ['option1', 'option2'],
+		examples: [[], ['GET', 'POST'], ['read', 'write', 'delete']],
+		validation: {
+			allowEmpty: true,
+			allowExpressions: false,
+		},
+		notes: [
+			'Array of option values',
+			'Each value must exist in property.options',
+			'Rendered as multi-select dropdown',
+		],
+	},
+
+	// ============================================================================
+	// COLLECTION TYPES - Complex nested structures
+	// ============================================================================
+
+	collection: {
+		type: 'collection',
+		jsType: 'object',
+		description: 'A group of related properties with dynamic values',
+		structure: {
+			properties: {
+				'<propertyName>': {
+					type: 'any',
+					description: 'Any nested property from the collection definition',
+				},
+			},
+			flexible: true,
+		},
+		example: {
+			name: 'John Doe',
+			email: 'john@example.com',
+			age: 30,
+		},
+		examples: [
+			{},
+			{ key1: 'value1', key2: 123 },
+			{ nested: { deep: { value: true } } },
+		],
+		validation: {
+			allowEmpty: true,
+			allowExpressions: true,
+		},
+		notes: [
+			'Properties defined in property.values array',
+			'Each property can be any type',
+			'UI renders as expandable section',
+		],
+	},
+
+	fixedCollection: {
+		type: 'collection',
+		jsType: 'object',
+		description: 'A collection with predefined groups of properties',
+		structure: {
+			properties: {
+				'<collectionName>': {
+					type: 'array',
+					description: 'Array of collection items',
+					items: {
+						type: 'object',
+						description: 'Collection item with defined properties',
+					},
+				},
+			},
+			required: [],
+		},
+		example: {
+			headers: [
+				{ name: 'Content-Type', value: 'application/json' },
+				{ name: 'Authorization', value: 'Bearer token' },
+			],
+		},
+		examples: [
+			{},
+			{ queryParameters: [{ name: 'id', value: '123' }] },
+			{
+				headers: [{ name: 'Accept', value: '*/*' }],
+				queryParameters: [{ name: 'limit', value: '10' }],
+			},
+		],
+		validation: {
+			allowEmpty: true,
+			allowExpressions: true,
+		},
+		notes: [
+			'Each collection has predefined structure',
+			'Often used for headers, parameters, etc.',
+			'Supports multiple values per collection',
+		],
+	},
+
+	// ============================================================================
+	// SPECIAL n8n TYPES - Advanced functionality
+	// ============================================================================
+
+	resourceLocator: {
+		type: 'special',
+		jsType: 'object',
+		description: 'A flexible way to specify a resource by ID, name, URL, or list',
+		structure: {
+			properties: {
+				mode: {
+					type: 'string',
+					description: 'How the resource is specified',
+					enum: ['id', 'url', 'list'],
+					required: true,
+				},
+				value: {
+					type: 'string',
+					description: 'The resource identifier',
+					required: true,
+				},
+			},
+			required: ['mode', 'value'],
+		},
+		example: {
+			mode: 'id',
+			value: 'abc123',
+		},
+		examples: [
+			{ mode: 'url', value: 'https://example.com/resource/123' },
+			{ mode: 'list', value: 'item-from-dropdown' },
+			{ mode: 'id', value: '{{ $json.resourceId }}' },
+		],
+		validation: {
+			allowEmpty: false,
+			allowExpressions: true,
+		},
+		notes: [
+			'Provides flexible resource selection',
+			'Mode determines how value is interpreted',
+			'UI adapts based on selected mode',
+		],
+	},
+
+	resourceMapper: {
+		type: 'special',
+		jsType: 'object',
+		description: 'Maps input data fields to resource fields with transformation options',
+		structure: {
+			properties: {
+				mappingMode: {
+					type: 'string',
+					description: 'How fields are mapped',
+					enum: ['defineBelow', 'autoMapInputData'],
+				},
+				value: {
+					type: 'object',
+					description: 'Field mappings',
+					properties: {
+						'<fieldName>': {
+							type: 'string',
+							description: 'Expression or value for this field',
+						},
+					},
+					flexible: true,
+				},
+			},
+		},
+		example: {
+			mappingMode: 'defineBelow',
+			value: {
+				name: '{{ $json.fullName }}',
+				email: '{{ $json.emailAddress }}',
+				status: 'active',
+			},
+		},
+		examples: [
+			{ mappingMode: 'autoMapInputData', value: {} },
+			{
+				mappingMode: 'defineBelow',
+				value: { id: '{{ $json.userId }}', name: '{{ $json.name }}' },
+			},
+		],
+		validation: {
+			allowEmpty: false,
+			allowExpressions: true,
+		},
+		notes: [
+			'Complex mapping with UI assistance',
+			'Can auto-map or manually define',
+			'Supports field transformations',
+		],
+	},
+
+	filter: {
+		type: 'special',
+		jsType: 'object',
+		description: 'Defines conditions for filtering data with boolean logic',
+		structure: {
+			properties: {
+				conditions: {
+					type: 'array',
+					description: 'Array of filter conditions',
+					items: {
+						type: 'object',
+						properties: {
+							id: {
+								type: 'string',
+								description: 'Unique condition identifier',
+								required: true,
+							},
+							leftValue: {
+								type: 'any',
+								description: 'Left side of comparison',
+							},
+							operator: {
+								type: 'object',
+								description: 'Comparison operator',
+								required: true,
+								properties: {
+									type: {
+										type: 'string',
+										enum: ['string', 'number', 'boolean', 'dateTime', 'array', 'object'],
+										required: true,
+									},
+									operation: {
+										type: 'string',
+										description: 'Operation to perform',
+										required: true,
+									},
+								},
+							},
+							rightValue: {
+								type: 'any',
+								description: 'Right side of comparison',
+							},
+						},
+					},
+					required: true,
+				},
+				combinator: {
+					type: 'string',
+					description: 'How to combine conditions',
+					enum: ['and', 'or'],
+					required: true,
+				},
+			},
+			required: ['conditions', 'combinator'],
+		},
+		example: {
+			conditions: [
+				{
+					id: 'abc-123',
+					leftValue: '{{ $json.status }}',
+					operator: { type: 'string', operation: 'equals' },
+					rightValue: 'active',
+				},
+			],
+			combinator: 'and',
+		},
+		validation: {
+			allowEmpty: false,
+			allowExpressions: true,
+		},
+		notes: [
+			'Advanced filtering UI in n8n',
+			'Supports complex boolean logic',
+			'Operations vary by data type',
+		],
+	},
+
+	assignmentCollection: {
+		type: 'special',
+		jsType: 'object',
+		description: 'Defines variable assignments with expressions',
+		structure: {
+			properties: {
+				assignments: {
+					type: 'array',
+					description: 'Array of variable assignments',
+					items: {
+						type: 'object',
+						properties: {
+							id: {
+								type: 'string',
+								description: 'Unique assignment identifier',
+								required: true,
+							},
+							name: {
+								type: 'string',
+								description: 'Variable name',
+								required: true,
+							},
+							value: {
+								type: 'any',
+								description: 'Value to assign',
+								required: true,
+							},
+							type: {
+								type: 'string',
+								description: 'Data type of the value',
+								enum: ['string', 'number', 'boolean', 'array', 'object'],
+							},
+						},
+					},
+					required: true,
+				},
+			},
+			required: ['assignments'],
+		},
+		example: {
+			assignments: [
+				{
+					id: 'abc-123',
+					name: 'userName',
+					value: '{{ $json.name }}',
+					type: 'string',
+				},
+				{
+					id: 'def-456',
+					name: 'userAge',
+					value: 30,
+					type: 'number',
+				},
+			],
+		},
+		validation: {
+			allowEmpty: false,
+			allowExpressions: true,
+		},
+		notes: [
+			'Used in Set node and similar',
+			'Each assignment can use expressions',
+			'Type helps with validation',
+		],
+	},
+
+	// ============================================================================
+	// CREDENTIAL TYPES - Authentication and credentials
+	// ============================================================================
+
+	credentials: {
+		type: 'special',
+		jsType: 'string',
+		description: 'Reference to credential configuration',
+		example: 'googleSheetsOAuth2Api',
+		examples: ['httpBasicAuth', 'slackOAuth2Api', 'postgresApi'],
+		validation: {
+			allowEmpty: false,
+			allowExpressions: false,
+		},
+		notes: [
+			'References credential type name',
+			'Credential must be configured in n8n',
+			'Type name matches credential definition',
+		],
+	},
+
+	credentialsSelect: {
+		type: 'special',
+		jsType: 'string',
+		description: 'Dropdown to select from available credentials',
+		example: 'credential-id-123',
+		examples: ['cred-abc', 'cred-def', '{{ $credentials.id }}'],
+		validation: {
+			allowEmpty: false,
+			allowExpressions: true,
+		},
+		notes: [
+			'User selects from configured credentials',
+			'Returns credential ID',
+			'Used when multiple credential instances exist',
+		],
+	},
+
+	// ============================================================================
+	// UI-ONLY TYPES - Display elements without data
+	// ============================================================================
+
+	hidden: {
+		type: 'special',
+		jsType: 'string',
+		description: 'Hidden property not shown in UI (used for internal logic)',
+		example: '',
+		validation: {
+			allowEmpty: true,
+			allowExpressions: true,
+		},
+		notes: [
+			'Not rendered in UI',
+			'Can store metadata or computed values',
+			'Often used for version tracking',
+		],
+	},
+
+	button: {
+		type: 'special',
+		jsType: 'string',
+		description: 'Clickable button that triggers an action',
+		example: '',
+		validation: {
+			allowEmpty: true,
+			allowExpressions: false,
+		},
+		notes: [
+			'Triggers action when clicked',
+			'Does not store a value',
+			'Action defined in routing property',
+		],
+	},
+
+	callout: {
+		type: 'special',
+		jsType: 'string',
+		description: 'Informational message box (warning, info, success, error)',
+		example: '',
+		validation: {
+			allowEmpty: true,
+			allowExpressions: false,
+		},
+		notes: [
+			'Display-only, no value stored',
+			'Used for warnings and hints',
+			'Style controlled by typeOptions',
+		],
+	},
+
+	notice: {
+		type: 'special',
+		jsType: 'string',
+		description: 'Notice message displayed to user',
+		example: '',
+		validation: {
+			allowEmpty: true,
+			allowExpressions: false,
+		},
+		notes: ['Similar to callout', 'Display-only element', 'Provides contextual information'],
+	},
+
+	// ============================================================================
+	// UTILITY TYPES - Special-purpose functionality
+	// ============================================================================
+
+	workflowSelector: {
+		type: 'special',
+		jsType: 'string',
+		description: 'Dropdown to select another workflow',
+		example: 'workflow-123',
+		examples: ['wf-abc', '{{ $json.workflowId }}'],
+		validation: {
+			allowEmpty: false,
+			allowExpressions: true,
+		},
+		notes: [
+			'Selects from available workflows',
+			'Returns workflow ID',
+			'Used in Execute Workflow node',
+		],
+	},
+
+	curlImport: {
+		type: 'special',
+		jsType: 'string',
+		description: 'Import configuration from cURL command',
+		example: 'curl -X GET https://api.example.com/data',
+		validation: {
+			allowEmpty: true,
+			allowExpressions: false,
+		},
+		notes: [
+			'Parses cURL command to populate fields',
+			'Used in HTTP Request node',
+			'One-time import feature',
+		],
+	},
+};
+
+/**
+ * Real-world examples for complex types
+ *
+ * These examples come from actual n8n workflows and demonstrate
+ * correct usage patterns for complex property types.
+ *
+ * @constant
+ */
+export const COMPLEX_TYPE_EXAMPLES = {
+	collection: {
+		basic: {
+			name: 'John Doe',
+			email: 'john@example.com',
+		},
+		nested: {
+			user: {
+				firstName: 'Jane',
+				lastName: 'Smith',
+			},
+			preferences: {
+				theme: 'dark',
+				notifications: true,
+			},
+		},
+		withExpressions: {
+			id: '{{ $json.userId }}',
+			timestamp: '{{ $now }}',
+			data: '{{ $json.payload }}',
+		},
+	},
+
+	fixedCollection: {
+		httpHeaders: {
+			headers: [
+				{ name: 'Content-Type', value: 'application/json' },
+				{ name: 'Authorization', value: 'Bearer {{ $credentials.token }}' },
+			],
+		},
+		queryParameters: {
+			queryParameters: [
+				{ name: 'page', value: '1' },
+				{ name: 'limit', value: '100' },
+			],
+		},
+		multipleCollections: {
+			headers: [{ name: 'Accept', value: 'application/json' }],
+			queryParameters: [{ name: 'filter', value: 'active' }],
+		},
+	},
+
+	filter: {
+		simple: {
+			conditions: [
+				{
+					id: '1',
+					leftValue: '{{ $json.status }}',
+					operator: { type: 'string', operation: 'equals' },
+					rightValue: 'active',
+				},
+			],
+			combinator: 'and',
+		},
+		complex: {
+			conditions: [
+				{
+					id: '1',
+					leftValue: '{{ $json.age }}',
+					operator: { type: 'number', operation: 'gt' },
+					rightValue: 18,
+				},
+				{
+					id: '2',
+					leftValue: '{{ $json.country }}',
+					operator: { type: 'string', operation: 'equals' },
+					rightValue: 'US',
+				},
+			],
+			combinator: 'and',
+		},
+	},
+
+	resourceMapper: {
+		autoMap: {
+			mappingMode: 'autoMapInputData',
+			value: {},
+		},
+		manual: {
+			mappingMode: 'defineBelow',
+			value: {
+				firstName: '{{ $json.first_name }}',
+				lastName: '{{ $json.last_name }}',
+				email: '{{ $json.email_address }}',
+				status: 'active',
+			},
+		},
+	},
+
+	assignmentCollection: {
+		basic: {
+			assignments: [
+				{
+					id: '1',
+					name: 'fullName',
+					value: '{{ $json.firstName }} {{ $json.lastName }}',
+					type: 'string',
+				},
+			],
+		},
+		multiple: {
+			assignments: [
+				{ id: '1', name: 'userName', value: '{{ $json.name }}', type: 'string' },
+				{ id: '2', name: 'userAge', value: '{{ $json.age }}', type: 'number' },
+				{ id: '3', name: 'isActive', value: true, type: 'boolean' },
+			],
+		},
+	},
+};

src/http-server-single-session.ts

@@ -25,6 +25,7 @@ import {
   STANDARD_PROTOCOL_VERSION
 } from './utils/protocol-version';
 import { InstanceContext, validateInstanceContext } from './types/instance-context';
+import { SessionState } from './types/session-state';
 
 dotenv.config();
 
@@ -40,7 +41,7 @@ interface MultiTenantHeaders {
 }
 
 // Session management constants
-const MAX_SESSIONS = 100;
+const MAX_SESSIONS = Math.max(1, parseInt(process.env.N8N_MCP_MAX_SESSIONS || '100', 10));
 const SESSION_CLEANUP_INTERVAL = 5 * 60 * 1000; // 5 minutes
 
 interface Session {
@@ -71,6 +72,30 @@ function extractMultiTenantHeaders(req: express.Request): MultiTenantHeaders {
   };
 }
 
+/**
+ * Security logging helper for audit trails
+ * Provides structured logging for security-relevant events
+ */
+function logSecurityEvent(
+  event: 'session_export' | 'session_restore' | 'session_restore_failed' | 'max_sessions_reached',
+  details: {
+    sessionId?: string;
+    reason?: string;
+    count?: number;
+    instanceId?: string;
+  }
+): void {
+  const timestamp = new Date().toISOString();
+  const logEntry = {
+    timestamp,
+    event,
+    ...details
+  };
+
+  // Log to standard logger with [SECURITY] prefix for easy filtering
+  logger.info(`[SECURITY] ${event}`, logEntry);
+}
+
 export class SingleSessionHTTPServer {
   // Map to store transports by session ID (following SDK pattern)
   private transports: { [sessionId: string]: StreamableHTTPServerTransport } = {};
@@ -687,7 +712,20 @@ export class SingleSessionHTTPServer {
     if (!this.session) return true;
     return Date.now() - this.session.lastAccess.getTime() > this.sessionTimeout;
   }
-  
+
+  /**
+   * Check if a specific session is expired based on sessionId
+   * Used for multi-session expiration checks during export/restore
+   *
+   * @param sessionId - The session ID to check
+   * @returns true if session is expired or doesn't exist
+   */
+  private isSessionExpired(sessionId: string): boolean {
+    const metadata = this.sessionMetadata[sessionId];
+    if (!metadata) return true;
+    return Date.now() - metadata.lastAccess.getTime() > this.sessionTimeout;
+  }
+
   /**
    * Start the HTTP server
    */
@@ -1406,6 +1444,197 @@ export class SingleSessionHTTPServer {
       }
     };
   }
+
+  /**
+   * Export all active session state for persistence
+   *
+   * Used by multi-tenant backends to dump sessions before container restart.
+   * This method exports the minimal state needed to restore sessions after
+   * a restart: session metadata (timing) and instance context (credentials).
+   *
+   * Transport and server objects are NOT persisted - they will be recreated
+   * on the first request after restore.
+   *
+   * SECURITY WARNING: The exported data contains plaintext n8n API keys.
+   * The downstream application MUST encrypt this data before persisting to disk.
+   *
+   * @returns Array of session state objects, excluding expired sessions
+   *
+   * @example
+   * // Before shutdown
+   * const sessions = server.exportSessionState();
+   * await saveToEncryptedStorage(sessions);
+   */
+  public exportSessionState(): SessionState[] {
+    const sessions: SessionState[] = [];
+    const seenSessionIds = new Set<string>();
+
+    // Iterate over all sessions with metadata (source of truth for active sessions)
+    for (const sessionId of Object.keys(this.sessionMetadata)) {
+      // Check for duplicates (defensive programming)
+      if (seenSessionIds.has(sessionId)) {
+        logger.warn(`Duplicate sessionId detected during export: ${sessionId}`);
+        continue;
+      }
+
+      // Skip expired sessions - they're not worth persisting
+      if (this.isSessionExpired(sessionId)) {
+        continue;
+      }
+
+      const metadata = this.sessionMetadata[sessionId];
+      const context = this.sessionContexts[sessionId];
+
+      // Skip sessions without context - these can't be restored meaningfully
+      // (Context is required to reconnect to the correct n8n instance)
+      if (!context || !context.n8nApiUrl || !context.n8nApiKey) {
+        logger.debug(`Skipping session ${sessionId} - missing required context`);
+        continue;
+      }
+
+      seenSessionIds.add(sessionId);
+      sessions.push({
+        sessionId,
+        metadata: {
+          createdAt: metadata.createdAt.toISOString(),
+          lastAccess: metadata.lastAccess.toISOString()
+        },
+        context: {
+          n8nApiUrl: context.n8nApiUrl,
+          n8nApiKey: context.n8nApiKey,
+          instanceId: context.instanceId || sessionId, // Use sessionId as fallback
+          sessionId: context.sessionId,
+          metadata: context.metadata
+        }
+      });
+    }
+
+    logger.info(`Exported ${sessions.length} session(s) for persistence`);
+    logSecurityEvent('session_export', { count: sessions.length });
+    return sessions;
+  }
+
+  /**
+   * Restore session state from previously exported data
+   *
+   * Used by multi-tenant backends to restore sessions after container restart.
+   * This method restores only the session metadata and instance context.
+   * Transport and server objects will be recreated on the first request.
+   *
+   * Restored sessions are "dormant" until a client makes a request, at which
+   * point the transport and server will be initialized normally.
+   *
+   * @param sessions - Array of session state objects from exportSessionState()
+   * @returns Number of sessions successfully restored
+   *
+   * @example
+   * // After startup
+   * const sessions = await loadFromEncryptedStorage();
+   * const count = server.restoreSessionState(sessions);
+   * console.log(`Restored ${count} sessions`);
+   */
+  public restoreSessionState(sessions: SessionState[]): number {
+    let restoredCount = 0;
+
+    for (const sessionState of sessions) {
+      try {
+        // Skip null or invalid session objects
+        if (!sessionState || typeof sessionState !== 'object' || !sessionState.sessionId) {
+          logger.warn('Skipping invalid session state object');
+          continue;
+        }
+
+        // Check if we've hit the MAX_SESSIONS limit (check real-time count)
+        if (Object.keys(this.sessionMetadata).length >= MAX_SESSIONS) {
+          logger.warn(
+            `Reached MAX_SESSIONS limit (${MAX_SESSIONS}), skipping remaining sessions`
+          );
+          logSecurityEvent('max_sessions_reached', { count: MAX_SESSIONS });
+          break;
+        }
+
+        // Skip if session already exists (duplicate sessionId)
+        if (this.sessionMetadata[sessionState.sessionId]) {
+          logger.debug(`Skipping session ${sessionState.sessionId} - already exists`);
+          continue;
+        }
+
+        // Parse and validate dates first
+        const createdAt = new Date(sessionState.metadata.createdAt);
+        const lastAccess = new Date(sessionState.metadata.lastAccess);
+
+        if (isNaN(createdAt.getTime()) || isNaN(lastAccess.getTime())) {
+          logger.warn(
+            `Skipping session ${sessionState.sessionId} - invalid date format`
+          );
+          continue;
+        }
+
+        // Validate session isn't expired
+        const age = Date.now() - lastAccess.getTime();
+        if (age > this.sessionTimeout) {
+          logger.debug(
+            `Skipping session ${sessionState.sessionId} - expired (age: ${Math.round(age / 1000)}s)`
+          );
+          continue;
+        }
+
+        // Validate context exists (TypeScript null narrowing)
+        if (!sessionState.context) {
+          logger.warn(`Skipping session ${sessionState.sessionId} - missing context`);
+          continue;
+        }
+
+        // Validate context structure using existing validation
+        const validation = validateInstanceContext(sessionState.context);
+        if (!validation.valid) {
+          const reason = validation.errors?.join(', ') || 'invalid context';
+          logger.warn(
+            `Skipping session ${sessionState.sessionId} - invalid context: ${reason}`
+          );
+          logSecurityEvent('session_restore_failed', {
+            sessionId: sessionState.sessionId,
+            reason
+          });
+          continue;
+        }
+
+        // Restore session metadata
+        this.sessionMetadata[sessionState.sessionId] = {
+          createdAt,
+          lastAccess
+        };
+
+        // Restore session context
+        this.sessionContexts[sessionState.sessionId] = {
+          n8nApiUrl: sessionState.context.n8nApiUrl,
+          n8nApiKey: sessionState.context.n8nApiKey,
+          instanceId: sessionState.context.instanceId,
+          sessionId: sessionState.context.sessionId,
+          metadata: sessionState.context.metadata
+        };
+
+        logger.debug(`Restored session ${sessionState.sessionId}`);
+        logSecurityEvent('session_restore', {
+          sessionId: sessionState.sessionId,
+          instanceId: sessionState.context.instanceId
+        });
+        restoredCount++;
+      } catch (error) {
+        logger.error(`Failed to restore session ${sessionState.sessionId}:`, error);
+        logSecurityEvent('session_restore_failed', {
+          sessionId: sessionState.sessionId,
+          reason: error instanceof Error ? error.message : 'unknown error'
+        });
+        // Continue with next session - don't let one failure break the entire restore
+      }
+    }
+
+    logger.info(
+      `Restored ${restoredCount}/${sessions.length} session(s) from persistence`
+    );
+    return restoredCount;
+  }
 }
 
 // Start if called directly

src/index.ts

@@ -18,6 +18,9 @@ export {
   validateInstanceContext,
   isInstanceContext
 } from './types/instance-context';
+export type {
+  SessionState
+} from './types/session-state';
 
 // Re-export MCP SDK types for convenience
 export type {

src/mcp-engine.ts

@@ -9,6 +9,7 @@ import { Request, Response } from 'express';
 import { SingleSessionHTTPServer } from './http-server-single-session';
 import { logger } from './utils/logger';
 import { InstanceContext } from './types/instance-context';
+import { SessionState } from './types/session-state';
 
 export interface EngineHealth {
   status: 'healthy' | 'unhealthy';
@@ -97,7 +98,7 @@ export class N8NMCPEngine {
           total: Math.round(memoryUsage.heapTotal / 1024 / 1024),
           unit: 'MB'
         },
-        version: '2.3.2'
+        version: '2.24.1'
       };
     } catch (error) {
       logger.error('Health check failed:', error);
@@ -106,7 +107,7 @@ export class N8NMCPEngine {
         uptime: 0,
         sessionActive: false,
         memoryUsage: { used: 0, total: 0, unit: 'MB' },
-        version: '2.3.2'
+        version: '2.24.1'
       };
     }
   }
@@ -118,10 +119,58 @@ export class N8NMCPEngine {
   getSessionInfo(): { active: boolean; sessionId?: string; age?: number } {
     return this.server.getSessionInfo();
   }
-  
+
+  /**
+   * Export all active session state for persistence
+   *
+   * Used by multi-tenant backends to dump sessions before container restart.
+   * Returns an array of session state objects containing metadata and credentials.
+   *
+   * SECURITY WARNING: Exported data contains plaintext n8n API keys.
+   * Encrypt before persisting to disk.
+   *
+   * @returns Array of session state objects
+   *
+   * @example
+   * // Before shutdown
+   * const sessions = engine.exportSessionState();
+   * await saveToEncryptedStorage(sessions);
+   */
+  exportSessionState(): SessionState[] {
+    if (!this.server) {
+      logger.warn('Cannot export sessions: server not initialized');
+      return [];
+    }
+    return this.server.exportSessionState();
+  }
+
+  /**
+   * Restore session state from previously exported data
+   *
+   * Used by multi-tenant backends to restore sessions after container restart.
+   * Restores session metadata and instance context. Transports/servers are
+   * recreated on first request.
+   *
+   * @param sessions - Array of session state objects from exportSessionState()
+   * @returns Number of sessions successfully restored
+   *
+   * @example
+   * // After startup
+   * const sessions = await loadFromEncryptedStorage();
+   * const count = engine.restoreSessionState(sessions);
+   * console.log(`Restored ${count} sessions`);
+   */
+  restoreSessionState(sessions: SessionState[]): number {
+    if (!this.server) {
+      logger.warn('Cannot restore sessions: server not initialized');
+      return 0;
+    }
+    return this.server.restoreSessionState(sessions);
+  }
+
   /**
    * Graceful shutdown for service lifecycle
-   * 
+   *
    * @example
    * process.on('SIGTERM', async () => {
    *   await engine.shutdown();

src/mcp/handlers-n8n-manager.ts

@@ -10,6 +10,7 @@ import {
   ExecutionFilterOptions,
   ExecutionMode
 } from '../types/n8n-api';
+import type { TriggerType, TestWorkflowInput } from '../triggers/types';
 import {
   validateWorkflowStructure,
   hasWebhookTrigger,
@@ -34,6 +35,7 @@ import { ExpressionFormatValidator, ExpressionFormatIssue } from '../services/ex
 import { WorkflowVersioningService } from '../services/workflow-versioning-service';
 import { handleUpdatePartialWorkflow } from './handlers-workflow-diff';
 import { telemetry } from '../telemetry';
+import { TemplateService } from '../templates/template-service';
 import {
   createCacheKey,
   createInstanceCache,
@@ -84,6 +86,31 @@ interface CloudPlatformGuide {
   troubleshooting: string[];
 }
 
+/**
+ * Applied Fix from Auto-Fix Operation
+ */
+interface AppliedFix {
+  node: string;
+  field: string;
+  type: string;
+  before: string;
+  after: string;
+  confidence: string;
+}
+
+/**
+ * Auto-Fix Result Data from handleAutofixWorkflow
+ */
+interface AutofixResultData {
+  fixesApplied?: number;
+  fixes?: AppliedFix[];
+  workflowId?: string;
+  workflowName?: string;
+  message?: string;
+  summary?: string;
+  stats?: Record<string, number>;
+}
+
 /**
  * Workflow Validation Response Data
  */
@@ -395,17 +422,25 @@ const autofixWorkflowSchema = z.object({
     'typeversion-correction',
     'error-output-config',
     'node-type-correction',
-    'webhook-missing-path'
+    'webhook-missing-path',
+    'typeversion-upgrade',
+    'version-migration'
   ])).optional(),
   confidenceThreshold: z.enum(['high', 'medium', 'low']).optional().default('medium'),
   maxFixes: z.number().optional().default(50)
 });
 
-const triggerWebhookSchema = z.object({
-  webhookUrl: z.string().url(),
+// Schema for n8n_test_workflow tool
+const testWorkflowSchema = z.object({
+  workflowId: z.string(),
+  triggerType: z.enum(['webhook', 'form', 'chat']).optional(),
   httpMethod: z.enum(['GET', 'POST', 'PUT', 'DELETE']).optional(),
+  webhookPath: z.string().optional(),
+  message: z.string().optional(),
+  sessionId: z.string().optional(),
   data: z.record(z.unknown()).optional(),
   headers: z.record(z.string()).optional(),
+  timeout: z.number().optional(),
   waitForResponse: z.boolean().optional(),
 });
 
@@ -1207,74 +1242,160 @@ export async function handleAutofixWorkflow(
 
 // Execution Management Handlers
 
-export async function handleTriggerWebhookWorkflow(args: unknown, context?: InstanceContext): Promise<McpToolResponse> {
+/**
+ * Handler for n8n_test_workflow tool
+ * Triggers workflow execution via auto-detected or specified trigger type
+ */
+export async function handleTestWorkflow(args: unknown, context?: InstanceContext): Promise<McpToolResponse> {
   try {
     const client = ensureApiConfigured(context);
-    const input = triggerWebhookSchema.parse(args);
+    const input = testWorkflowSchema.parse(args);
 
-    const webhookRequest: WebhookRequest = {
-      webhookUrl: input.webhookUrl,
-      httpMethod: input.httpMethod || 'POST',
+    // Import trigger system (lazy to avoid circular deps)
+    const {
+      detectTriggerFromWorkflow,
+      ensureRegistryInitialized,
+      TriggerRegistry,
+    } = await import('../triggers');
+
+    // Ensure registry is initialized
+    await ensureRegistryInitialized();
+
+    // Fetch the workflow to analyze its trigger
+    const workflow = await client.getWorkflow(input.workflowId);
+
+    // Determine trigger type
+    let triggerType: TriggerType | undefined = input.triggerType as TriggerType | undefined;
+    let triggerInfo;
+
+    // Auto-detect from workflow
+    const detection = detectTriggerFromWorkflow(workflow);
+
+    if (!triggerType) {
+      if (detection.detected && detection.trigger) {
+        triggerType = detection.trigger.type;
+        triggerInfo = detection.trigger;
+      } else {
+        // No externally-triggerable trigger found
+        return {
+          success: false,
+          error: 'Workflow cannot be triggered externally',
+          details: {
+            workflowId: input.workflowId,
+            reason: detection.reason,
+            hint: 'Only workflows with webhook, form, or chat triggers can be executed via the API. Add one of these trigger nodes to your workflow.',
+          },
+        };
+      }
+    } else {
+      // User specified a trigger type, verify it matches workflow
+      if (detection.detected && detection.trigger?.type === triggerType) {
+        triggerInfo = detection.trigger;
+      } else if (!detection.detected || detection.trigger?.type !== triggerType) {
+        return {
+          success: false,
+          error: `Workflow does not have a ${triggerType} trigger`,
+          details: {
+            workflowId: input.workflowId,
+            requestedTrigger: triggerType,
+            detectedTrigger: detection.trigger?.type || 'none',
+            hint: detection.detected
+              ? `Workflow has a ${detection.trigger?.type} trigger. Either use that type or omit triggerType for auto-detection.`
+              : 'Workflow has no externally-triggerable triggers (webhook, form, or chat).',
+          },
+        };
+      }
+    }
+
+    // Get handler for trigger type
+    const handler = TriggerRegistry.getHandler(triggerType, client, context);
+    if (!handler) {
+      return {
+        success: false,
+        error: `No handler registered for trigger type: ${triggerType}`,
+        details: {
+          supportedTypes: TriggerRegistry.getRegisteredTypes(),
+        },
+      };
+    }
+
+    // Check if workflow is active (if required by handler)
+    if (handler.capabilities.requiresActiveWorkflow && !workflow.active) {
+      return {
+        success: false,
+        error: 'Workflow must be active to trigger via this method',
+        details: {
+          workflowId: input.workflowId,
+          triggerType,
+          hint: 'Activate the workflow in n8n using n8n_update_partial_workflow with [{type: "activateWorkflow"}]',
+        },
+      };
+    }
+
+    // Validate chat trigger has message
+    if (triggerType === 'chat' && !input.message) {
+      return {
+        success: false,
+        error: 'Chat trigger requires a message parameter',
+        details: {
+          hint: 'Provide message="your message" for chat triggers',
+        },
+      };
+    }
+
+    // Build trigger-specific input
+    const triggerInput = {
+      workflowId: input.workflowId,
+      triggerType,
+      httpMethod: input.httpMethod,
+      webhookPath: input.webhookPath,
+      message: input.message || '',
+      sessionId: input.sessionId,
       data: input.data,
+      formData: input.data, // For form triggers
       headers: input.headers,
-      waitForResponse: input.waitForResponse ?? true
+      timeout: input.timeout,
+      waitForResponse: input.waitForResponse,
     };
 
-    const response = await client.triggerWebhook(webhookRequest);
+    // Execute the trigger
+    const response = await handler.execute(triggerInput as any, workflow, triggerInfo);
 
     return {
-      success: true,
-      data: response,
-      message: 'Webhook triggered successfully'
+      success: response.success,
+      data: response.data,
+      message: response.success
+        ? `Workflow triggered successfully via ${triggerType}`
+        : response.error,
+      executionId: response.executionId,
+      workflowId: input.workflowId,
+      details: {
+        triggerType,
+        metadata: response.metadata,
+        ...(response.details || {}),
+      },
     };
   } catch (error) {
     if (error instanceof z.ZodError) {
       return {
         success: false,
         error: 'Invalid input',
-        details: { errors: error.errors }
+        details: { errors: error.errors },
       };
     }
 
     if (error instanceof N8nApiError) {
-      // Try to extract execution context from error response
-      const errorData = error.details as any;
-      const executionId = errorData?.executionId || errorData?.id || errorData?.execution?.id;
-      const workflowId = errorData?.workflowId || errorData?.workflow?.id;
-
-      // If we have execution ID, provide specific guidance with n8n_get_execution
-      if (executionId) {
-        return {
-          success: false,
-          error: formatExecutionError(executionId, workflowId),
-          code: error.code,
-          executionId,
-          workflowId: workflowId || undefined
-        };
-      }
-
-      // No execution ID available - workflow likely didn't start
-      // Provide guidance to check recent executions
-      if (error.code === 'SERVER_ERROR' || error.statusCode && error.statusCode >= 500) {
-        return {
-          success: false,
-          error: formatNoExecutionError(),
-          code: error.code
-        };
-      }
-
-      // For other errors (auth, validation, etc), use standard message
       return {
         success: false,
         error: getUserFriendlyErrorMessage(error),
         code: error.code,
-        details: error.details as Record<string, unknown> | undefined
+        details: error.details as Record<string, unknown> | undefined,
       };
     }
 
     return {
       success: false,
-      error: error instanceof Error ? error.message : 'Unknown error occurred'
+      error: error instanceof Error ? error.message : 'Unknown error occurred',
     };
   }
 }
@@ -1553,7 +1674,7 @@ export async function handleHealthCheck(context?: InstanceContext): Promise<McpT
             '1. Verify n8n instance is running',
             '2. Check N8N_API_URL is correct',
             '3. Verify N8N_API_KEY has proper permissions',
-            '4. Run n8n_diagnostic for detailed analysis'
+            '4. Run n8n_health_check with mode="diagnostic" for detailed analysis'
           ]
         }
       };
@@ -1566,63 +1687,6 @@ export async function handleHealthCheck(context?: InstanceContext): Promise<McpT
   }
 }
 
-export async function handleListAvailableTools(context?: InstanceContext): Promise<McpToolResponse> {
-  const tools = [
-    {
-      category: 'Workflow Management',
-      tools: [
-        { name: 'n8n_create_workflow', description: 'Create new workflows' },
-        { name: 'n8n_get_workflow', description: 'Get workflow by ID' },
-        { name: 'n8n_get_workflow_details', description: 'Get detailed workflow info with stats' },
-        { name: 'n8n_get_workflow_structure', description: 'Get simplified workflow structure' },
-        { name: 'n8n_get_workflow_minimal', description: 'Get minimal workflow info' },
-        { name: 'n8n_update_workflow', description: 'Update existing workflows' },
-        { name: 'n8n_delete_workflow', description: 'Delete workflows' },
-        { name: 'n8n_list_workflows', description: 'List workflows with filters' },
-        { name: 'n8n_validate_workflow', description: 'Validate workflow from n8n instance' },
-        { name: 'n8n_autofix_workflow', description: 'Automatically fix common workflow errors' }
-      ]
-    },
-    {
-      category: 'Execution Management',
-      tools: [
-        { name: 'n8n_trigger_webhook_workflow', description: 'Trigger workflows via webhook' },
-        { name: 'n8n_get_execution', description: 'Get execution details' },
-        { name: 'n8n_list_executions', description: 'List executions with filters' },
-        { name: 'n8n_delete_execution', description: 'Delete execution records' }
-      ]
-    },
-    {
-      category: 'System',
-      tools: [
-        { name: 'n8n_health_check', description: 'Check API connectivity' },
-        { name: 'n8n_list_available_tools', description: 'List all available tools' }
-      ]
-    }
-  ];
-  
-  const config = getN8nApiConfig();
-  const apiConfigured = config !== null;
-  
-  return {
-    success: true,
-    data: {
-      tools,
-      apiConfigured,
-      configuration: config ? {
-        apiUrl: config.baseUrl,
-        timeout: config.timeout,
-        maxRetries: config.maxRetries
-      } : null,
-      limitations: [
-        'Cannot execute workflows directly (must use webhooks)',
-        'Cannot stop running executions',
-        'Tags and credentials have limited API support'
-      ]
-    }
-  };
-}
-
 // Environment-aware debugging helpers
 
 /**
@@ -1844,8 +1908,8 @@ export async function handleDiagnostic(request: any, context?: InstanceContext):
   }
 
   // Check which tools are available
-  const documentationTools = 22; // Base documentation tools
-  const managementTools = apiConfigured ? 16 : 0;
+  const documentationTools = 7; // Base documentation tools (after v2.26.0 consolidation)
+  const managementTools = apiConfigured ? 13 : 0; // Management tools requiring API (includes n8n_deploy_template)
   const totalTools = documentationTools + managementTools;
 
   // Check npm version
@@ -1981,7 +2045,7 @@ export async function handleDiagnostic(request: any, context?: InstanceContext):
             example: 'validate_workflow({workflow: {...}})'
           }
         ],
-        note: '22 documentation tools available without API configuration'
+        note: '14 documentation tools available without API configuration'
       },
       whatYouCannotDo: [
         '✗ Create/update workflows in n8n instance',
@@ -1996,8 +2060,8 @@ export async function handleDiagnostic(request: any, context?: InstanceContext):
           '   N8N_API_URL=https://your-n8n-instance.com',
           '   N8N_API_KEY=your_api_key_here',
           '3. Restart the MCP server',
-          '4. Run n8n_diagnostic again to verify',
-          '5. All 38 tools will be available!'
+          '4. Run n8n_health_check with mode="diagnostic" to verify',
+          '5. All 19 tools will be available!'
         ],
         documentation: 'https://github.com/czlonkowski/n8n-mcp?tab=readme-ov-file#n8n-management-tools-optional---requires-api-configuration'
       }
@@ -2246,3 +2310,316 @@ export async function handleWorkflowVersions(
     };
   }
 }
+
+// ========================================================================
+// Template Deployment Handler
+// ========================================================================
+
+const deployTemplateSchema = z.object({
+  templateId: z.number().positive().int(),
+  name: z.string().optional(),
+  autoUpgradeVersions: z.boolean().default(true),
+  autoFix: z.boolean().default(true),  // Auto-apply fixes after deployment
+  stripCredentials: z.boolean().default(true)
+});
+
+interface RequiredCredential {
+  nodeType: string;
+  nodeName: string;
+  credentialType: string;
+}
+
+/**
+ * Deploy a workflow template from n8n.io directly to the user's n8n instance.
+ *
+ * This handler:
+ * 1. Fetches the template from the local template database
+ * 2. Extracts credential requirements for user guidance
+ * 3. Optionally strips credentials (for user to configure in n8n UI)
+ * 4. Optionally upgrades node typeVersions to latest supported
+ * 5. Optionally validates the workflow structure
+ * 6. Creates the workflow in the n8n instance
+ */
+export async function handleDeployTemplate(
+  args: unknown,
+  templateService: TemplateService,
+  repository: NodeRepository,
+  context?: InstanceContext
+): Promise<McpToolResponse> {
+  try {
+    const client = ensureApiConfigured(context);
+    const input = deployTemplateSchema.parse(args);
+
+    // Fetch template
+    const template = await templateService.getTemplate(input.templateId, 'full');
+    if (!template) {
+      return {
+        success: false,
+        error: `Template ${input.templateId} not found`,
+        details: {
+          hint: 'Use search_templates to find available templates',
+          templateUrl: `https://n8n.io/workflows/${input.templateId}`
+        }
+      };
+    }
+
+    // Extract workflow from template (deep copy to avoid mutation)
+    const workflow = JSON.parse(JSON.stringify(template.workflow));
+    if (!workflow || !workflow.nodes) {
+      return {
+        success: false,
+        error: 'Template has invalid workflow structure',
+        details: { templateId: input.templateId }
+      };
+    }
+
+    // Set workflow name
+    const workflowName = input.name || template.name;
+
+    // Collect required credentials before stripping
+    const requiredCredentials: RequiredCredential[] = [];
+    for (const node of workflow.nodes) {
+      if (node.credentials && typeof node.credentials === 'object') {
+        for (const [credType] of Object.entries(node.credentials)) {
+          requiredCredentials.push({
+            nodeType: node.type,
+            nodeName: node.name,
+            credentialType: credType
+          });
+        }
+      }
+    }
+
+    // Strip credentials if requested
+    if (input.stripCredentials) {
+      workflow.nodes = workflow.nodes.map((node: any) => {
+        const { credentials, ...rest } = node;
+        return rest;
+      });
+    }
+
+    // Auto-upgrade typeVersions if requested
+    if (input.autoUpgradeVersions) {
+      const autoFixer = new WorkflowAutoFixer(repository);
+
+      // Run validation to get issues to fix
+      const validator = new WorkflowValidator(repository, EnhancedConfigValidator);
+      const validationResult = await validator.validateWorkflow(workflow, {
+        validateNodes: true,
+        validateConnections: false,
+        validateExpressions: false,
+        profile: 'runtime'
+      });
+
+      // Generate fixes focused on typeVersion upgrades
+      const fixResult = await autoFixer.generateFixes(
+        workflow,
+        validationResult,
+        [],
+        { fixTypes: ['typeversion-upgrade', 'typeversion-correction'] }
+      );
+
+      // Apply fixes to workflow
+      if (fixResult.operations.length > 0) {
+        for (const op of fixResult.operations) {
+          if (op.type === 'updateNode' && op.updates) {
+            const node = workflow.nodes.find((n: any) =>
+              n.id === op.nodeId || n.name === op.nodeName
+            );
+            if (node) {
+              for (const [path, value] of Object.entries(op.updates)) {
+                if (path === 'typeVersion') {
+                  node.typeVersion = value;
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+
+    // Identify trigger type
+    const triggerNode = workflow.nodes.find((n: any) =>
+      n.type?.includes('Trigger') ||
+      n.type?.includes('webhook') ||
+      n.type === 'n8n-nodes-base.webhook'
+    );
+    const triggerType = triggerNode?.type?.split('.').pop() || 'manual';
+
+    // Create workflow via API (always creates inactive)
+    // Deploy first, then fix - this ensures the workflow exists before we modify it
+    const createdWorkflow = await client.createWorkflow({
+      name: workflowName,
+      nodes: workflow.nodes,
+      connections: workflow.connections,
+      settings: workflow.settings || { executionOrder: 'v1' }
+    });
+
+    // Get base URL for workflow link
+    const apiConfig = context ? getN8nApiConfigFromContext(context) : getN8nApiConfig();
+    const baseUrl = apiConfig?.baseUrl?.replace('/api/v1', '') || '';
+
+    // Auto-fix common issues after deployment (expression format, etc.)
+    let fixesApplied: AppliedFix[] = [];
+    let fixSummary = '';
+    let autoFixStatus: 'success' | 'failed' | 'skipped' = 'skipped';
+
+    if (input.autoFix) {
+      try {
+        // Run autofix on the deployed workflow
+        const autofixResult = await handleAutofixWorkflow(
+          {
+            id: createdWorkflow.id,
+            applyFixes: true,
+            fixTypes: ['expression-format', 'typeversion-upgrade'],
+            confidenceThreshold: 'medium'
+          },
+          repository,
+          context
+        );
+
+        if (autofixResult.success && autofixResult.data) {
+          const fixData = autofixResult.data as AutofixResultData;
+          autoFixStatus = 'success';
+          if (fixData.fixesApplied && fixData.fixesApplied > 0) {
+            fixesApplied = fixData.fixes || [];
+            fixSummary = ` Auto-fixed ${fixData.fixesApplied} issue(s).`;
+          }
+        }
+      } catch (fixError) {
+        // Log but don't fail - autofix is best-effort
+        autoFixStatus = 'failed';
+        logger.warn('Auto-fix failed after template deployment', {
+          workflowId: createdWorkflow.id,
+          error: fixError instanceof Error ? fixError.message : 'Unknown error'
+        });
+        fixSummary = ' Auto-fix failed (workflow deployed successfully).';
+      }
+    }
+
+    return {
+      success: true,
+      data: {
+        workflowId: createdWorkflow.id,
+        name: createdWorkflow.name,
+        active: false,
+        nodeCount: workflow.nodes.length,
+        triggerType,
+        requiredCredentials: requiredCredentials.length > 0 ? requiredCredentials : undefined,
+        url: baseUrl ? `${baseUrl}/workflow/${createdWorkflow.id}` : undefined,
+        templateId: input.templateId,
+        templateUrl: template.url || `https://n8n.io/workflows/${input.templateId}`,
+        autoFixStatus,
+        fixesApplied: fixesApplied.length > 0 ? fixesApplied : undefined
+      },
+      message: `Workflow "${createdWorkflow.name}" deployed successfully from template ${input.templateId}.${fixSummary} ${
+        requiredCredentials.length > 0
+          ? `Configure ${requiredCredentials.length} credential(s) in n8n to activate.`
+          : ''
+      }`
+    };
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      return {
+        success: false,
+        error: 'Invalid input',
+        details: { errors: error.errors }
+      };
+    }
+
+    if (error instanceof N8nApiError) {
+      return {
+        success: false,
+        error: getUserFriendlyErrorMessage(error),
+        code: error.code,
+        details: error.details as Record<string, unknown> | undefined
+      };
+    }
+
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : 'Unknown error occurred'
+    };
+  }
+}
+
+/**
+ * Backward-compatible webhook trigger handler
+ *
+ * @deprecated Use handleTestWorkflow instead. This function is kept for
+ * backward compatibility with existing integration tests.
+ */
+export async function handleTriggerWebhookWorkflow(args: unknown, context?: InstanceContext): Promise<McpToolResponse> {
+  const triggerWebhookSchema = z.object({
+    webhookUrl: z.string().url(),
+    httpMethod: z.enum(['GET', 'POST', 'PUT', 'DELETE']).optional(),
+    data: z.record(z.unknown()).optional(),
+    headers: z.record(z.string()).optional(),
+    waitForResponse: z.boolean().optional(),
+  });
+
+  try {
+    const client = ensureApiConfigured(context);
+    const input = triggerWebhookSchema.parse(args);
+
+    const webhookRequest: WebhookRequest = {
+      webhookUrl: input.webhookUrl,
+      httpMethod: input.httpMethod || 'POST',
+      data: input.data,
+      headers: input.headers,
+      waitForResponse: input.waitForResponse ?? true
+    };
+
+    const response = await client.triggerWebhook(webhookRequest);
+
+    return {
+      success: true,
+      data: response,
+      message: 'Webhook triggered successfully'
+    };
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      return {
+        success: false,
+        error: 'Invalid input',
+        details: { errors: error.errors }
+      };
+    }
+
+    if (error instanceof N8nApiError) {
+      const errorData = error.details as any;
+      const executionId = errorData?.executionId || errorData?.id || errorData?.execution?.id;
+      const workflowId = errorData?.workflowId || errorData?.workflow?.id;
+
+      if (executionId) {
+        return {
+          success: false,
+          error: formatExecutionError(executionId, workflowId),
+          code: error.code,
+          executionId,
+          workflowId: workflowId || undefined
+        };
+      }
+
+      if (error.code === 'SERVER_ERROR' || error.statusCode && error.statusCode >= 500) {
+        return {
+          success: false,
+          error: formatNoExecutionError(),
+          code: error.code
+        };
+      }
+
+      return {
+        success: false,
+        error: getUserFriendlyErrorMessage(error),
+        code: error.code,
+        details: error.details as Record<string, unknown> | undefined
+      };
+    }
+
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : 'Unknown error occurred'
+    };
+  }
+}

src/mcp/server.ts

@@ -19,6 +19,7 @@ import { TaskTemplates } from '../services/task-templates';
 import { ConfigValidator } from '../services/config-validator';
 import { EnhancedConfigValidator, ValidationMode, ValidationProfile } from '../services/enhanced-config-validator';
 import { PropertyDependencies } from '../services/property-dependencies';
+import { TypeStructureService } from '../services/type-structure-service';
 import { SimpleCache } from '../utils/simple-cache';
 import { TemplateService } from '../templates/template-service';
 import { WorkflowValidator } from '../services/workflow-validator';
@@ -58,6 +59,67 @@ interface NodeRow {
   credentials_required?: string;
 }
 
+interface VersionSummary {
+  currentVersion: string;
+  totalVersions: number;
+  hasVersionHistory: boolean;
+}
+
+interface NodeMinimalInfo {
+  nodeType: string;
+  workflowNodeType: string;
+  displayName: string;
+  description: string;
+  category: string;
+  package: string;
+  isAITool: boolean;
+  isTrigger: boolean;
+  isWebhook: boolean;
+}
+
+interface NodeStandardInfo {
+  nodeType: string;
+  displayName: string;
+  description: string;
+  category: string;
+  requiredProperties: any[];
+  commonProperties: any[];
+  operations?: any[];
+  credentials?: any;
+  examples?: any[];
+  versionInfo: VersionSummary;
+}
+
+interface NodeFullInfo {
+  nodeType: string;
+  displayName: string;
+  description: string;
+  category: string;
+  properties: any[];
+  operations?: any[];
+  credentials?: any;
+  documentation?: string;
+  versionInfo: VersionSummary;
+}
+
+interface VersionHistoryInfo {
+  nodeType: string;
+  versions: any[];
+  latestVersion: string;
+  hasBreakingChanges: boolean;
+}
+
+interface VersionComparisonInfo {
+  nodeType: string;
+  fromVersion: string;
+  toVersion: string;
+  changes: any[];
+  breakingChanges?: any[];
+  migrations?: any[];
+}
+
+type NodeInfoResponse = NodeMinimalInfo | NodeStandardInfo | NodeFullInfo | VersionHistoryInfo | VersionComparisonInfo;
+
 export class N8NDocumentationMCPServer {
   private server: Server;
   private db: DatabaseAdapter | null = null;
@@ -768,38 +830,38 @@ export class N8NDocumentationMCPServer {
       let validationResult;
       
       switch (toolName) {
-        case 'validate_node_operation':
+        case 'validate_node':
+          // Consolidated tool handles both modes - validate as operation for now
           validationResult = ToolValidation.validateNodeOperation(args);
           break;
-        case 'validate_node_minimal':
-          validationResult = ToolValidation.validateNodeMinimal(args);
-          break;
         case 'validate_workflow':
-        case 'validate_workflow_connections':
-        case 'validate_workflow_expressions':
           validationResult = ToolValidation.validateWorkflow(args);
           break;
       case 'search_nodes':
         validationResult = ToolValidation.validateSearchNodes(args);
         break;
-      case 'list_node_templates':
-        validationResult = ToolValidation.validateListNodeTemplates(args);
-        break;
       case 'n8n_create_workflow':
         validationResult = ToolValidation.validateCreateWorkflow(args);
         break;
       case 'n8n_get_workflow':
-      case 'n8n_get_workflow_details':
-      case 'n8n_get_workflow_structure':
-      case 'n8n_get_workflow_minimal':
       case 'n8n_update_full_workflow':
       case 'n8n_delete_workflow':
       case 'n8n_validate_workflow':
       case 'n8n_autofix_workflow':
-      case 'n8n_get_execution':
-      case 'n8n_delete_execution':
         validationResult = ToolValidation.validateWorkflowId(args);
         break;
+      case 'n8n_executions':
+        // Requires action parameter, id validation done in handler based on action
+        validationResult = args.action
+          ? { valid: true, errors: [] }
+          : { valid: false, errors: [{ field: 'action', message: 'action is required' }] };
+        break;
+      case 'n8n_deploy_template':
+        // Requires templateId parameter
+        validationResult = args.templateId !== undefined
+          ? { valid: true, errors: [] }
+          : { valid: false, errors: [{ field: 'templateId', message: 'templateId is required' }] };
+        break;
       default:
         // For tools not yet migrated to schema validation, use basic validation
         return this.validateToolParamsBasic(toolName, args, legacyRequiredParams || []);
@@ -953,41 +1015,50 @@ export class N8NDocumentationMCPServer {
       case 'tools_documentation':
         // No required parameters
         return this.getToolsDocumentation(args.topic, args.depth);
-      case 'list_nodes':
-        // No required parameters
-        return this.listNodes(args);
-      case 'get_node_info':
-        this.validateToolParams(name, args, ['nodeType']);
-        return this.getNodeInfo(args.nodeType);
       case 'search_nodes':
         this.validateToolParams(name, args, ['query']);
         // Convert limit to number if provided, otherwise use default
         const limit = args.limit !== undefined ? Number(args.limit) || 20 : 20;
         return this.searchNodes(args.query, limit, { mode: args.mode, includeExamples: args.includeExamples });
-      case 'list_ai_tools':
-        // No required parameters
-        return this.listAITools();
-      case 'get_node_documentation':
+      case 'get_node':
         this.validateToolParams(name, args, ['nodeType']);
-        return this.getNodeDocumentation(args.nodeType);
-      case 'get_database_statistics':
-        // No required parameters
-        return this.getDatabaseStatistics();
-      case 'get_node_essentials':
-        this.validateToolParams(name, args, ['nodeType']);
-        return this.getNodeEssentials(args.nodeType, args.includeExamples);
-      case 'search_node_properties':
-        this.validateToolParams(name, args, ['nodeType', 'query']);
-        const maxResults = args.maxResults !== undefined ? Number(args.maxResults) || 20 : 20;
-        return this.searchNodeProperties(args.nodeType, args.query, maxResults);
-      case 'list_tasks':
-        // No required parameters
-        return this.listTasks(args.category);
-      case 'validate_node_operation':
+        // Handle consolidated modes: docs, search_properties
+        if (args.mode === 'docs') {
+          return this.getNodeDocumentation(args.nodeType);
+        }
+        if (args.mode === 'search_properties') {
+          if (!args.propertyQuery) {
+            throw new Error('propertyQuery is required for mode=search_properties');
+          }
+          const maxResults = args.maxPropertyResults !== undefined ? Number(args.maxPropertyResults) || 20 : 20;
+          return this.searchNodeProperties(args.nodeType, args.propertyQuery, maxResults);
+        }
+        return this.getNode(
+          args.nodeType,
+          args.detail,
+          args.mode,
+          args.includeTypeInfo,
+          args.includeExamples,
+          args.fromVersion,
+          args.toVersion
+        );
+      case 'validate_node':
         this.validateToolParams(name, args, ['nodeType', 'config']);
         // Ensure config is an object
         if (typeof args.config !== 'object' || args.config === null) {
-          logger.warn(`validate_node_operation called with invalid config type: ${typeof args.config}`);
+          logger.warn(`validate_node called with invalid config type: ${typeof args.config}`);
+          const validationMode = args.mode || 'full';
+          if (validationMode === 'minimal') {
+            return {
+              nodeType: args.nodeType || 'unknown',
+              displayName: 'Unknown Node',
+              valid: false,
+              missingRequiredFields: [
+                'Invalid config format - expected object',
+                '🔧 RECOVERY: Use format { "resource": "...", "operation": "..." } or {} for empty config'
+              ]
+            };
+          }
           return {
             nodeType: args.nodeType || 'unknown',
             workflowNodeType: args.nodeType || 'unknown',
@@ -1003,7 +1074,7 @@ export class N8NDocumentationMCPServer {
             suggestions: [
               '🔧 RECOVERY: Invalid config detected. Fix with:',
               '   • Ensure config is an object: { "resource": "...", "operation": "..." }',
-              '   • Use get_node_essentials to see required fields for this node type',
+              '   • Use get_node to see required fields for this node type',
               '   • Check if the node type is correct before configuring it'
             ],
             summary: {
@@ -1014,95 +1085,75 @@ export class N8NDocumentationMCPServer {
             }
           };
         }
-        return this.validateNodeConfig(args.nodeType, args.config, 'operation', args.profile);
-      case 'validate_node_minimal':
-        this.validateToolParams(name, args, ['nodeType', 'config']);
-        // Ensure config is an object
-        if (typeof args.config !== 'object' || args.config === null) {
-          logger.warn(`validate_node_minimal called with invalid config type: ${typeof args.config}`);
-          return {
-            nodeType: args.nodeType || 'unknown',
-            displayName: 'Unknown Node',
-            valid: false,
-            missingRequiredFields: [
-              'Invalid config format - expected object',
-              '🔧 RECOVERY: Use format { "resource": "...", "operation": "..." } or {} for empty config'
-            ]
-          };
+        // Handle mode parameter
+        const validationMode = args.mode || 'full';
+        if (validationMode === 'minimal') {
+          return this.validateNodeMinimal(args.nodeType, args.config);
         }
-        return this.validateNodeMinimal(args.nodeType, args.config);
-      case 'get_property_dependencies':
-        this.validateToolParams(name, args, ['nodeType']);
-        return this.getPropertyDependencies(args.nodeType, args.config);
-      case 'get_node_as_tool_info':
-        this.validateToolParams(name, args, ['nodeType']);
-        return this.getNodeAsToolInfo(args.nodeType);
-      case 'list_templates':
-        // No required params
-        const listLimit = Math.min(Math.max(Number(args.limit) || 10, 1), 100);
-        const listOffset = Math.max(Number(args.offset) || 0, 0);
-        const sortBy = args.sortBy || 'views';
-        const includeMetadata = Boolean(args.includeMetadata);
-        return this.listTemplates(listLimit, listOffset, sortBy, includeMetadata);
-      case 'list_node_templates':
-        this.validateToolParams(name, args, ['nodeTypes']);
-        const templateLimit = Math.min(Math.max(Number(args.limit) || 10, 1), 100);
-        const templateOffset = Math.max(Number(args.offset) || 0, 0);
-        return this.listNodeTemplates(args.nodeTypes, templateLimit, templateOffset);
+        return this.validateNodeConfig(args.nodeType, args.config, 'operation', args.profile);
       case 'get_template':
         this.validateToolParams(name, args, ['templateId']);
         const templateId = Number(args.templateId);
-        const mode = args.mode || 'full';
-        return this.getTemplate(templateId, mode);
-      case 'search_templates':
-        this.validateToolParams(name, args, ['query']);
+        const templateMode = args.mode || 'full';
+        return this.getTemplate(templateId, templateMode);
+      case 'search_templates': {
+        // Consolidated tool with searchMode parameter
+        const searchMode = args.searchMode || 'keyword';
         const searchLimit = Math.min(Math.max(Number(args.limit) || 20, 1), 100);
         const searchOffset = Math.max(Number(args.offset) || 0, 0);
-        const searchFields = args.fields as string[] | undefined;
-        return this.searchTemplates(args.query, searchLimit, searchOffset, searchFields);
-      case 'get_templates_for_task':
-        this.validateToolParams(name, args, ['task']);
-        const taskLimit = Math.min(Math.max(Number(args.limit) || 10, 1), 100);
-        const taskOffset = Math.max(Number(args.offset) || 0, 0);
-        return this.getTemplatesForTask(args.task, taskLimit, taskOffset);
-      case 'search_templates_by_metadata':
-        // No required params - all filters are optional
-        const metadataLimit = Math.min(Math.max(Number(args.limit) || 20, 1), 100);
-        const metadataOffset = Math.max(Number(args.offset) || 0, 0);
-        return this.searchTemplatesByMetadata({
-          category: args.category,
-          complexity: args.complexity,
-          maxSetupMinutes: args.maxSetupMinutes ? Number(args.maxSetupMinutes) : undefined,
-          minSetupMinutes: args.minSetupMinutes ? Number(args.minSetupMinutes) : undefined,
-          requiredService: args.requiredService,
-          targetAudience: args.targetAudience
-        }, metadataLimit, metadataOffset);
+
+        switch (searchMode) {
+          case 'by_nodes':
+            if (!args.nodeTypes || !Array.isArray(args.nodeTypes) || args.nodeTypes.length === 0) {
+              throw new Error('nodeTypes array is required for searchMode=by_nodes');
+            }
+            return this.listNodeTemplates(args.nodeTypes, searchLimit, searchOffset);
+          case 'by_task':
+            if (!args.task) {
+              throw new Error('task is required for searchMode=by_task');
+            }
+            return this.getTemplatesForTask(args.task, searchLimit, searchOffset);
+          case 'by_metadata':
+            return this.searchTemplatesByMetadata({
+              category: args.category,
+              complexity: args.complexity,
+              maxSetupMinutes: args.maxSetupMinutes ? Number(args.maxSetupMinutes) : undefined,
+              minSetupMinutes: args.minSetupMinutes ? Number(args.minSetupMinutes) : undefined,
+              requiredService: args.requiredService,
+              targetAudience: args.targetAudience
+            }, searchLimit, searchOffset);
+          case 'keyword':
+          default:
+            if (!args.query) {
+              throw new Error('query is required for searchMode=keyword');
+            }
+            const searchFields = args.fields as string[] | undefined;
+            return this.searchTemplates(args.query, searchLimit, searchOffset, searchFields);
+        }
+      }
       case 'validate_workflow':
         this.validateToolParams(name, args, ['workflow']);
         return this.validateWorkflow(args.workflow, args.options);
-      case 'validate_workflow_connections':
-        this.validateToolParams(name, args, ['workflow']);
-        return this.validateWorkflowConnections(args.workflow);
-      case 'validate_workflow_expressions':
-        this.validateToolParams(name, args, ['workflow']);
-        return this.validateWorkflowExpressions(args.workflow);
-      
+
       // n8n Management Tools (if API is configured)
       case 'n8n_create_workflow':
         this.validateToolParams(name, args, ['name', 'nodes', 'connections']);
         return n8nHandlers.handleCreateWorkflow(args, this.instanceContext);
-      case 'n8n_get_workflow':
+      case 'n8n_get_workflow': {
         this.validateToolParams(name, args, ['id']);
-        return n8nHandlers.handleGetWorkflow(args, this.instanceContext);
-      case 'n8n_get_workflow_details':
-        this.validateToolParams(name, args, ['id']);
-        return n8nHandlers.handleGetWorkflowDetails(args, this.instanceContext);
-      case 'n8n_get_workflow_structure':
-        this.validateToolParams(name, args, ['id']);
-        return n8nHandlers.handleGetWorkflowStructure(args, this.instanceContext);
-      case 'n8n_get_workflow_minimal':
-        this.validateToolParams(name, args, ['id']);
-        return n8nHandlers.handleGetWorkflowMinimal(args, this.instanceContext);
+        const workflowMode = args.mode || 'full';
+        switch (workflowMode) {
+          case 'details':
+            return n8nHandlers.handleGetWorkflowDetails(args, this.instanceContext);
+          case 'structure':
+            return n8nHandlers.handleGetWorkflowStructure(args, this.instanceContext);
+          case 'minimal':
+            return n8nHandlers.handleGetWorkflowMinimal(args, this.instanceContext);
+          case 'full':
+          default:
+            return n8nHandlers.handleGetWorkflow(args, this.instanceContext);
+        }
+      }
       case 'n8n_update_full_workflow':
         this.validateToolParams(name, args, ['id']);
         return n8nHandlers.handleUpdateWorkflow(args, this.repository!, this.instanceContext);
@@ -1125,31 +1176,46 @@ export class N8NDocumentationMCPServer {
         await this.ensureInitialized();
         if (!this.repository) throw new Error('Repository not initialized');
         return n8nHandlers.handleAutofixWorkflow(args, this.repository, this.instanceContext);
-      case 'n8n_trigger_webhook_workflow':
-        this.validateToolParams(name, args, ['webhookUrl']);
-        return n8nHandlers.handleTriggerWebhookWorkflow(args, this.instanceContext);
-      case 'n8n_get_execution':
-        this.validateToolParams(name, args, ['id']);
-        return n8nHandlers.handleGetExecution(args, this.instanceContext);
-      case 'n8n_list_executions':
-        // No required parameters
-        return n8nHandlers.handleListExecutions(args, this.instanceContext);
-      case 'n8n_delete_execution':
-        this.validateToolParams(name, args, ['id']);
-        return n8nHandlers.handleDeleteExecution(args, this.instanceContext);
+      case 'n8n_test_workflow':
+        this.validateToolParams(name, args, ['workflowId']);
+        return n8nHandlers.handleTestWorkflow(args, this.instanceContext);
+      case 'n8n_executions': {
+        this.validateToolParams(name, args, ['action']);
+        const execAction = args.action;
+        switch (execAction) {
+          case 'get':
+            if (!args.id) {
+              throw new Error('id is required for action=get');
+            }
+            return n8nHandlers.handleGetExecution(args, this.instanceContext);
+          case 'list':
+            return n8nHandlers.handleListExecutions(args, this.instanceContext);
+          case 'delete':
+            if (!args.id) {
+              throw new Error('id is required for action=delete');
+            }
+            return n8nHandlers.handleDeleteExecution(args, this.instanceContext);
+          default:
+            throw new Error(`Unknown action: ${execAction}. Valid actions: get, list, delete`);
+        }
+      }
       case 'n8n_health_check':
-        // No required parameters
+        // No required parameters - supports mode='status' (default) or mode='diagnostic'
+        if (args.mode === 'diagnostic') {
+          return n8nHandlers.handleDiagnostic({ params: { arguments: args } }, this.instanceContext);
+        }
         return n8nHandlers.handleHealthCheck(this.instanceContext);
-      case 'n8n_list_available_tools':
-        // No required parameters
-        return n8nHandlers.handleListAvailableTools(this.instanceContext);
-      case 'n8n_diagnostic':
-        // No required parameters
-        return n8nHandlers.handleDiagnostic({ params: { arguments: args } }, this.instanceContext);
       case 'n8n_workflow_versions':
         this.validateToolParams(name, args, ['mode']);
         return n8nHandlers.handleWorkflowVersions(args, this.repository!, this.instanceContext);
 
+      case 'n8n_deploy_template':
+        this.validateToolParams(name, args, ['templateId']);
+        await this.ensureInitialized();
+        if (!this.templateService) throw new Error('Template service not initialized');
+        if (!this.repository) throw new Error('Repository not initialized');
+        return n8nHandlers.handleDeployTemplate(args, this.templateService, this.repository, this.instanceContext);
+
       default:
         throw new Error(`Unknown tool: ${name}`);
     }
@@ -2137,14 +2203,19 @@ Full documentation is being prepared. For now, use get_node_essentials for confi
     // Get operations (already parsed by repository)
     const operations = node.operations || [];
     
+    // Get the latest version - this is important for AI to use correct typeVersion
+    const latestVersion = node.version ?? '1';
+
     const result = {
       nodeType: node.nodeType,
       workflowNodeType: getWorkflowNodeType(node.package ?? 'n8n-nodes-base', node.nodeType),
       displayName: node.displayName,
       description: node.description,
       category: node.category,
-      version: node.version ?? '1',
+      version: latestVersion,
       isVersioned: node.isVersioned ?? false,
+      // Prominent warning to use the correct typeVersion
+      versionNotice: `⚠️ Use typeVersion: ${latestVersion} when creating this node`,
       requiredProperties: essentials.required,
       commonProperties: essentials.common,
       operations: operations.map((op: any) => ({
@@ -2218,6 +2289,393 @@ Full documentation is being prepared. For now, use get_node_essentials for confi
     return result;
   }
 
+  /**
+   * Unified node information retrieval with multiple detail levels and modes.
+   *
+   * @param nodeType - Full node type identifier (e.g., "nodes-base.httpRequest" or "nodes-langchain.agent")
+   * @param detail - Information detail level (minimal, standard, full). Only applies when mode='info'.
+   *   - minimal: ~200 tokens, basic metadata only (no version info)
+   *   - standard: ~1-2K tokens, essential properties and operations (includes version info, AI-friendly default)
+   *   - full: ~3-8K tokens, complete node information with all properties (includes version info)
+   * @param mode - Operation mode determining the type of information returned:
+   *   - info: Node configuration details (respects detail level)
+   *   - versions: Complete version history with breaking changes summary
+   *   - compare: Property-level comparison between two versions (requires fromVersion)
+   *   - breaking: Breaking changes only between versions (requires fromVersion)
+   *   - migrations: Auto-migratable changes between versions (requires both fromVersion and toVersion)
+   * @param includeTypeInfo - Include type structure metadata for properties (only applies to mode='info').
+   *   Adds ~80-120 tokens per property with type category, JS type, and validation rules.
+   * @param includeExamples - Include real-world configuration examples from templates (only applies to mode='info' with detail='standard').
+   *   Adds ~200-400 tokens per example.
+   * @param fromVersion - Source version for comparison modes (required for compare, breaking, migrations).
+   *   Format: "1.0" or "2.1"
+   * @param toVersion - Target version for comparison modes (optional for compare/breaking, required for migrations).
+   *   Defaults to latest version if omitted.
+   * @returns NodeInfoResponse - Union type containing different response structures based on mode and detail parameters
+   */
+  private async getNode(
+    nodeType: string,
+    detail: string = 'standard',
+    mode: string = 'info',
+    includeTypeInfo?: boolean,
+    includeExamples?: boolean,
+    fromVersion?: string,
+    toVersion?: string
+  ): Promise<NodeInfoResponse> {
+    await this.ensureInitialized();
+    if (!this.repository) throw new Error('Repository not initialized');
+
+    // Validate parameters
+    const validDetailLevels = ['minimal', 'standard', 'full'];
+    const validModes = ['info', 'versions', 'compare', 'breaking', 'migrations'];
+
+    if (!validDetailLevels.includes(detail)) {
+      throw new Error(`get_node: Invalid detail level "${detail}". Valid options: ${validDetailLevels.join(', ')}`);
+    }
+
+    if (!validModes.includes(mode)) {
+      throw new Error(`get_node: Invalid mode "${mode}". Valid options: ${validModes.join(', ')}`);
+    }
+
+    const normalizedType = NodeTypeNormalizer.normalizeToFullForm(nodeType);
+
+    // Version modes - detail level ignored
+    if (mode !== 'info') {
+      return this.handleVersionMode(
+        normalizedType,
+        mode,
+        fromVersion,
+        toVersion
+      );
+    }
+
+    // Info mode - respect detail level
+    return this.handleInfoMode(
+      normalizedType,
+      detail,
+      includeTypeInfo,
+      includeExamples
+    );
+  }
+
+  /**
+   * Handle info mode - returns node information at specified detail level
+   */
+  private async handleInfoMode(
+    nodeType: string,
+    detail: string,
+    includeTypeInfo?: boolean,
+    includeExamples?: boolean
+  ): Promise<NodeMinimalInfo | NodeStandardInfo | NodeFullInfo> {
+    switch (detail) {
+      case 'minimal': {
+        // Get basic node metadata only (no version info for minimal mode)
+        let node = this.repository!.getNode(nodeType);
+
+        if (!node) {
+          const alternatives = getNodeTypeAlternatives(nodeType);
+          for (const alt of alternatives) {
+            const found = this.repository!.getNode(alt);
+            if (found) {
+              node = found;
+              break;
+            }
+          }
+        }
+
+        if (!node) {
+          throw new Error(`Node ${nodeType} not found`);
+        }
+
+        return {
+          nodeType: node.nodeType,
+          workflowNodeType: getWorkflowNodeType(node.package ?? 'n8n-nodes-base', node.nodeType),
+          displayName: node.displayName,
+          description: node.description,
+          category: node.category,
+          package: node.package,
+          isAITool: node.isAITool,
+          isTrigger: node.isTrigger,
+          isWebhook: node.isWebhook
+        };
+      }
+
+      case 'standard': {
+        // Use existing getNodeEssentials logic
+        const essentials = await this.getNodeEssentials(nodeType, includeExamples);
+        const versionSummary = this.getVersionSummary(nodeType);
+
+        // Apply type info enrichment if requested
+        if (includeTypeInfo) {
+          essentials.requiredProperties = this.enrichPropertiesWithTypeInfo(essentials.requiredProperties);
+          essentials.commonProperties = this.enrichPropertiesWithTypeInfo(essentials.commonProperties);
+        }
+
+        return {
+          ...essentials,
+          versionInfo: versionSummary
+        };
+      }
+
+      case 'full': {
+        // Use existing getNodeInfo logic
+        const fullInfo = await this.getNodeInfo(nodeType);
+        const versionSummary = this.getVersionSummary(nodeType);
+
+        // Apply type info enrichment if requested
+        if (includeTypeInfo && fullInfo.properties) {
+          fullInfo.properties = this.enrichPropertiesWithTypeInfo(fullInfo.properties);
+        }
+
+        return {
+          ...fullInfo,
+          versionInfo: versionSummary
+        };
+      }
+
+      default:
+        throw new Error(`Unknown detail level: ${detail}`);
+    }
+  }
+
+  /**
+   * Handle version modes - returns version history and comparison data
+   */
+  private async handleVersionMode(
+    nodeType: string,
+    mode: string,
+    fromVersion?: string,
+    toVersion?: string
+  ): Promise<VersionHistoryInfo | VersionComparisonInfo> {
+    switch (mode) {
+      case 'versions':
+        return this.getVersionHistory(nodeType);
+
+      case 'compare':
+        if (!fromVersion) {
+          throw new Error(`get_node: fromVersion is required for compare mode (nodeType: ${nodeType})`);
+        }
+        return this.compareVersions(nodeType, fromVersion, toVersion);
+
+      case 'breaking':
+        if (!fromVersion) {
+          throw new Error(`get_node: fromVersion is required for breaking mode (nodeType: ${nodeType})`);
+        }
+        return this.getBreakingChanges(nodeType, fromVersion, toVersion);
+
+      case 'migrations':
+        if (!fromVersion || !toVersion) {
+          throw new Error(`get_node: Both fromVersion and toVersion are required for migrations mode (nodeType: ${nodeType})`);
+        }
+        return this.getMigrations(nodeType, fromVersion, toVersion);
+
+      default:
+        throw new Error(`get_node: Unknown mode: ${mode} (nodeType: ${nodeType})`);
+    }
+  }
+
+  /**
+   * Get version summary (always included in info mode responses)
+   * Cached for 24 hours to improve performance
+   */
+  private getVersionSummary(nodeType: string): VersionSummary {
+    const cacheKey = `version-summary:${nodeType}`;
+    const cached = this.cache.get(cacheKey) as VersionSummary | null;
+
+    if (cached) {
+      return cached;
+    }
+
+    const versions = this.repository!.getNodeVersions(nodeType);
+    const latest = this.repository!.getLatestNodeVersion(nodeType);
+
+    const summary: VersionSummary = {
+      currentVersion: latest?.version || 'unknown',
+      totalVersions: versions.length,
+      hasVersionHistory: versions.length > 0
+    };
+
+    // Cache for 24 hours (86400000 ms)
+    this.cache.set(cacheKey, summary, 86400000);
+
+    return summary;
+  }
+
+  /**
+   * Get complete version history for a node
+   */
+  private getVersionHistory(nodeType: string): any {
+    const versions = this.repository!.getNodeVersions(nodeType);
+
+    return {
+      nodeType,
+      totalVersions: versions.length,
+      versions: versions.map(v => ({
+        version: v.version,
+        isCurrent: v.isCurrentMax,
+        minimumN8nVersion: v.minimumN8nVersion,
+        releasedAt: v.releasedAt,
+        hasBreakingChanges: (v.breakingChanges || []).length > 0,
+        breakingChangesCount: (v.breakingChanges || []).length,
+        deprecatedProperties: v.deprecatedProperties || [],
+        addedProperties: v.addedProperties || []
+      })),
+      available: versions.length > 0,
+      message: versions.length === 0 ?
+        'No version history available. Version tracking may not be enabled for this node.' :
+        undefined
+    };
+  }
+
+  /**
+   * Compare two versions of a node
+   */
+  private compareVersions(
+    nodeType: string,
+    fromVersion: string,
+    toVersion?: string
+  ): any {
+    const latest = this.repository!.getLatestNodeVersion(nodeType);
+    const targetVersion = toVersion || latest?.version;
+
+    if (!targetVersion) {
+      throw new Error('No target version available');
+    }
+
+    const changes = this.repository!.getPropertyChanges(
+      nodeType,
+      fromVersion,
+      targetVersion
+    );
+
+    return {
+      nodeType,
+      fromVersion,
+      toVersion: targetVersion,
+      totalChanges: changes.length,
+      breakingChanges: changes.filter(c => c.isBreaking).length,
+      changes: changes.map(c => ({
+        property: c.propertyName,
+        changeType: c.changeType,
+        isBreaking: c.isBreaking,
+        severity: c.severity,
+        oldValue: c.oldValue,
+        newValue: c.newValue,
+        migrationHint: c.migrationHint,
+        autoMigratable: c.autoMigratable
+      }))
+    };
+  }
+
+  /**
+   * Get breaking changes between versions
+   */
+  private getBreakingChanges(
+    nodeType: string,
+    fromVersion: string,
+    toVersion?: string
+  ): any {
+    const breakingChanges = this.repository!.getBreakingChanges(
+      nodeType,
+      fromVersion,
+      toVersion
+    );
+
+    return {
+      nodeType,
+      fromVersion,
+      toVersion: toVersion || 'latest',
+      totalBreakingChanges: breakingChanges.length,
+      changes: breakingChanges.map(c => ({
+        fromVersion: c.fromVersion,
+        toVersion: c.toVersion,
+        property: c.propertyName,
+        changeType: c.changeType,
+        severity: c.severity,
+        migrationHint: c.migrationHint,
+        oldValue: c.oldValue,
+        newValue: c.newValue
+      })),
+      upgradeSafe: breakingChanges.length === 0
+    };
+  }
+
+  /**
+   * Get auto-migratable changes between versions
+   */
+  private getMigrations(
+    nodeType: string,
+    fromVersion: string,
+    toVersion: string
+  ): any {
+    const migrations = this.repository!.getAutoMigratableChanges(
+      nodeType,
+      fromVersion,
+      toVersion
+    );
+
+    const allChanges = this.repository!.getPropertyChanges(
+      nodeType,
+      fromVersion,
+      toVersion
+    );
+
+    return {
+      nodeType,
+      fromVersion,
+      toVersion,
+      autoMigratableChanges: migrations.length,
+      totalChanges: allChanges.length,
+      migrations: migrations.map(m => ({
+        property: m.propertyName,
+        changeType: m.changeType,
+        migrationStrategy: m.migrationStrategy,
+        severity: m.severity
+      })),
+      requiresManualMigration: migrations.length < allChanges.length
+    };
+  }
+
+  /**
+   * Enrich property with type structure metadata
+   */
+  private enrichPropertyWithTypeInfo(property: any): any {
+    if (!property || !property.type) return property;
+
+    const structure = TypeStructureService.getStructure(property.type);
+    if (!structure) return property;
+
+    return {
+      ...property,
+      typeInfo: {
+        category: structure.type,
+        jsType: structure.jsType,
+        description: structure.description,
+        isComplex: TypeStructureService.isComplexType(property.type),
+        isPrimitive: TypeStructureService.isPrimitiveType(property.type),
+        allowsExpressions: structure.validation?.allowExpressions ?? true,
+        allowsEmpty: structure.validation?.allowEmpty ?? false,
+        ...(structure.structure && {
+          structureHints: {
+            hasProperties: !!structure.structure.properties,
+            hasItems: !!structure.structure.items,
+            isFlexible: structure.structure.flexible ?? false,
+            requiredFields: structure.structure.required ?? []
+          }
+        }),
+        ...(structure.notes && { notes: structure.notes })
+      }
+    };
+  }
+
+  /**
+   * Enrich an array of properties with type structure metadata
+   */
+  private enrichPropertiesWithTypeInfo(properties: any[]): any[] {
+    if (!properties || !Array.isArray(properties)) return properties;
+    return properties.map((prop: any) => this.enrichPropertyWithTypeInfo(prop));
+  }
+
   private async searchNodeProperties(nodeType: string, query: string, maxResults: number = 20): Promise<any> {
     await this.ensureInitialized();
     if (!this.repository) throw new Error('Repository not initialized');

src/mcp/tool-docs/configuration/get-node-as-tool-info.ts

@@ -1,71 +0,0 @@
-import { ToolDocumentation } from '../types';
-
-export const getNodeAsToolInfoDoc: ToolDocumentation = {
-  name: 'get_node_as_tool_info',
-  category: 'configuration',
-  essentials: {
-    description: 'Explains how to use ANY node as an AI tool with requirements and examples.',
-    keyParameters: ['nodeType'],
-    example: 'get_node_as_tool_info({nodeType: "nodes-base.slack"})',
-    performance: 'Fast - returns guidance and examples',
-    tips: [
-      'ANY node can be used as AI tool, not just AI-marked ones',
-      'Community nodes need N8N_COMMUNITY_PACKAGES_ALLOW_TOOL_USAGE=true',
-      'Provides specific use cases and connection requirements'
-    ]
-  },
-  full: {
-    description: `Shows how to use any n8n node as an AI tool in AI Agent workflows. In n8n, ANY node can be connected to an AI Agent's tool port, allowing the AI to use that node's functionality. This tool provides specific guidance, requirements, and examples for using a node as an AI tool.`,
-    parameters: {
-      nodeType: {
-        type: 'string',
-        required: true,
-        description: 'Full node type WITH prefix: "nodes-base.slack", "nodes-base.googleSheets", etc.',
-        examples: [
-          'nodes-base.slack',
-          'nodes-base.httpRequest',
-          'nodes-base.googleSheets',
-          'nodes-langchain.documentLoader'
-        ]
-      }
-    },
-    returns: `Object containing:
-- nodeType: The node's full type identifier
-- displayName: Human-readable name
-- isMarkedAsAITool: Whether node has usableAsTool property
-- aiToolCapabilities: Detailed AI tool usage information including:
-  - canBeUsedAsTool: Always true in n8n
-  - requiresEnvironmentVariable: For community nodes
-  - commonUseCases: Specific AI tool use cases
-  - requirements: Connection and environment setup
-  - examples: Code examples for common scenarios
-  - tips: Best practices for AI tool usage`,
-    examples: [
-      'get_node_as_tool_info({nodeType: "nodes-base.slack"}) - Get AI tool guidance for Slack',
-      'get_node_as_tool_info({nodeType: "nodes-base.httpRequest"}) - Learn to use HTTP Request as AI tool',
-      'get_node_as_tool_info({nodeType: "nodes-base.postgres"}) - Database queries as AI tools'
-    ],
-    useCases: [
-      'Understanding how to connect any node to AI Agent',
-      'Learning environment requirements for community nodes',
-      'Getting specific use case examples for AI tool usage',
-      'Checking if a node is optimized for AI usage',
-      'Understanding credential requirements for AI tools'
-    ],
-    performance: 'Very fast - returns pre-computed guidance and examples',
-    bestPractices: [
-      'Use this before configuring nodes as AI tools',
-      'Check environment requirements for community nodes',
-      'Review common use cases to understand best applications',
-      'Test nodes independently before connecting to AI Agent',
-      'Give tools descriptive names in AI Agent configuration'
-    ],
-    pitfalls: [
-      'Community nodes require environment variable to be used as tools',
-      'Not all nodes make sense as AI tools (e.g., triggers)',
-      'Some nodes require specific credentials configuration',
-      'Tool descriptions in AI Agent must be clear and detailed'
-    ],
-    relatedTools: ['list_ai_tools', 'get_node_essentials', 'validate_node_operation']
-  }
-};

src/mcp/tool-docs/configuration/get-node-documentation.ts

@@ -1,45 +0,0 @@
-import { ToolDocumentation } from '../types';
-
-export const getNodeDocumentationDoc: ToolDocumentation = {
-  name: 'get_node_documentation',
-  category: 'configuration',
-  essentials: {
-    description: 'Get readable docs with examples/auth/patterns. Better than raw schema! 87% coverage. Format: "nodes-base.slack"',
-    keyParameters: ['nodeType'],
-    example: 'get_node_documentation({nodeType: "nodes-base.slack"})',
-    performance: 'Fast - pre-parsed',
-    tips: [
-      '87% coverage',
-      'Includes auth examples',
-      'Human-readable format'
-    ]
-  },
-  full: {
-    description: 'Returns human-readable documentation parsed from n8n-docs including examples, authentication setup, and common patterns. More useful than raw schema for understanding node usage.',
-    parameters: {
-      nodeType: { type: 'string', required: true, description: 'Full node type with prefix (e.g., "nodes-base.slack")' }
-    },
-    returns: 'Parsed markdown documentation with examples, authentication guides, common patterns',
-    examples: [
-      'get_node_documentation({nodeType: "nodes-base.slack"}) - Slack usage guide',
-      'get_node_documentation({nodeType: "nodes-base.googleSheets"}) - Sheets examples'
-    ],
-    useCases: [
-      'Understanding authentication setup',
-      'Finding usage examples',
-      'Learning common patterns'
-    ],
-    performance: 'Fast - Pre-parsed documentation stored in database',
-    bestPractices: [
-      'Use for learning node usage',
-      'Check coverage with get_database_statistics',
-      'Combine with get_node_essentials'
-    ],
-    pitfalls: [
-      'Not all nodes have docs (87% coverage)',
-      'May be outdated for new features',
-      'Requires full node type prefix'
-    ],
-    relatedTools: ['get_node_info', 'get_node_essentials', 'search_nodes']
-  }
-};

src/mcp/tool-docs/configuration/get-node-essentials.ts

@@ -1,86 +0,0 @@
-import { ToolDocumentation } from '../types';
-
-export const getNodeEssentialsDoc: ToolDocumentation = {
-  name: 'get_node_essentials',
-  category: 'configuration',
-  essentials: {
-    description: 'Returns only the most commonly-used properties for a node (10-20 fields). Response is 95% smaller than get_node_info (5KB vs 100KB+). Essential properties include required fields, common options, and authentication settings. Use validate_node_operation for working configurations.',
-    keyParameters: ['nodeType'],
-    example: 'get_node_essentials({nodeType: "nodes-base.slack"})',
-    performance: '<10ms, ~5KB response',
-    tips: [
-      'Always use this before get_node_info',
-      'Use validate_node_operation for examples',
-      'Perfect for understanding node structure'
-    ]
-  },
-  full: {
-    description: 'Returns a curated subset of node properties focusing on the most commonly-used fields. Essential properties are hand-picked for each node type and include: required fields, primary operations, authentication options, and the most frequent configuration patterns. NOTE: Examples have been removed to avoid confusion - use validate_node_operation to get working configurations with proper validation.',
-    parameters: {
-      nodeType: { type: 'string', description: 'Full node type with prefix, e.g., "nodes-base.slack", "nodes-base.httpRequest"', required: true }
-    },
-    returns: `Object containing:
-{
-  "nodeType": "nodes-base.slack",
-  "displayName": "Slack",
-  "description": "Consume Slack API",
-  "category": "output",
-  "version": "2.3",
-  "requiredProperties": [],  // Most nodes have no strictly required fields
-  "commonProperties": [
-    {
-      "name": "resource",
-      "displayName": "Resource",
-      "type": "options",
-      "options": ["channel", "message", "user"],
-      "default": "message"
-    },
-    {
-      "name": "operation",
-      "displayName": "Operation", 
-      "type": "options",
-      "options": ["post", "update", "delete"],
-      "default": "post"
-    },
-    // ... 10-20 most common properties
-  ],
-  "operations": [
-    {"name": "Post", "description": "Post a message"},
-    {"name": "Update", "description": "Update a message"}
-  ],
-  "metadata": {
-    "totalProperties": 121,
-    "isAITool": false,
-    "hasCredentials": true
-  }
-}`,
-    examples: [
-      'get_node_essentials({nodeType: "nodes-base.httpRequest"}) - HTTP configuration basics',
-      'get_node_essentials({nodeType: "nodes-base.slack"}) - Slack messaging essentials',
-      'get_node_essentials({nodeType: "nodes-base.googleSheets"}) - Sheets operations',
-      '// Workflow: search → essentials → validate',
-      'const nodes = search_nodes({query: "database"});',
-      'const mysql = get_node_essentials({nodeType: "nodes-base.mySql"});',
-      'validate_node_operation("nodes-base.mySql", {operation: "select"}, "minimal");'
-    ],
-    useCases: [
-      'Quickly understand node structure without information overload',
-      'Identify which properties are most important',
-      'Learn node basics before diving into advanced features',
-      'Build workflows faster with curated property sets'
-    ],
-    performance: '<10ms response time, ~5KB payload (vs 100KB+ for full schema)',
-    bestPractices: [
-      'Always start with essentials, only use get_node_info if needed',
-      'Use validate_node_operation to get working configurations',
-      'Check authentication requirements first',
-      'Use search_node_properties if specific property not in essentials'
-    ],
-    pitfalls: [
-      'Advanced properties not included - use get_node_info for complete schema',
-      'Node-specific validators may require additional fields',
-      'Some nodes have 50+ properties, essentials shows only top 10-20'
-    ],
-    relatedTools: ['get_node_info for complete schema', 'search_node_properties for finding specific fields', 'validate_node_minimal to check configuration']
-  }
-};

src/mcp/tool-docs/configuration/get-node-info.ts

@@ -1,98 +0,0 @@
-import { ToolDocumentation } from '../types';
-
-export const getNodeInfoDoc: ToolDocumentation = {
-  name: 'get_node_info',
-  category: 'configuration',
-  essentials: {
-    description: 'Returns complete node schema with ALL properties (100KB+ response). Only use when you need advanced properties not in get_node_essentials. Contains 200+ properties for complex nodes like HTTP Request. Requires full prefix like "nodes-base.httpRequest".',
-    keyParameters: ['nodeType'],
-    example: 'get_node_info({nodeType: "nodes-base.slack"})',
-    performance: '100-500ms, 50-500KB response',
-    tips: [
-      'Try get_node_essentials first (95% smaller)',
-      'Use only for advanced configurations',
-      'Response may have 200+ properties'
-    ]
-  },
-  full: {
-    description: 'Returns the complete JSON schema for a node including all properties, operations, authentication methods, version information, and metadata. Response sizes range from 50KB to 500KB. Use this only when get_node_essentials doesn\'t provide the specific property you need.',
-    parameters: {
-      nodeType: { type: 'string', required: true, description: 'Full node type with prefix. Examples: "nodes-base.slack", "nodes-base.httpRequest", "nodes-langchain.openAi"' }
-    },
-    returns: `Complete node object containing:
-{
-  "displayName": "Slack",
-  "name": "slack",
-  "type": "nodes-base.slack",
-  "typeVersion": 2.2,
-  "description": "Consume Slack API",
-  "defaults": {"name": "Slack"},
-  "inputs": ["main"],
-  "outputs": ["main"],
-  "credentials": [
-    {
-      "name": "slackApi",
-      "required": true,
-      "displayOptions": {...}
-    }
-  ],
-  "properties": [
-    // 200+ property definitions including:
-    {
-      "displayName": "Resource",
-      "name": "resource",
-      "type": "options",
-      "options": ["channel", "message", "user", "file", ...],
-      "default": "message"
-    },
-    {
-      "displayName": "Operation", 
-      "name": "operation",
-      "type": "options",
-      "displayOptions": {
-        "show": {"resource": ["message"]}
-      },
-      "options": ["post", "update", "delete", "get", ...],
-      "default": "post"
-    },
-    // ... 200+ more properties with complex conditions
-  ],
-  "version": 2.2,
-  "subtitle": "={{$parameter[\"operation\"] + \": \" + $parameter[\"resource\"]}}",
-  "codex": {...},
-  "supportedWebhooks": [...]
-}`,
-    examples: [
-      'get_node_info({nodeType: "nodes-base.httpRequest"}) - 300+ properties for HTTP requests',
-      'get_node_info({nodeType: "nodes-base.googleSheets"}) - Complex operations and auth',
-      '// When to use get_node_info:',
-      '// 1. First try essentials',
-      'const essentials = get_node_essentials({nodeType: "nodes-base.slack"});',
-      '// 2. If property missing, search for it',
-      'const props = search_node_properties({nodeType: "nodes-base.slack", query: "thread"});',
-      '// 3. Only if needed, get full schema',
-      'const full = get_node_info({nodeType: "nodes-base.slack"});'
-    ],
-    useCases: [
-      'Analyzing all available operations for a node',
-      'Understanding complex property dependencies',
-      'Discovering all authentication methods',
-      'Building UI that shows all node options',
-      'Debugging property visibility conditions'
-    ],
-    performance: '100-500ms depending on node complexity. HTTP Request node: ~300KB, Simple nodes: ~50KB',
-    bestPractices: [
-      'Always try get_node_essentials first - it\'s 95% smaller',
-      'Use search_node_properties to find specific advanced properties',
-      'Cache results locally - schemas rarely change',
-      'Parse incrementally - don\'t load entire response into memory at once'
-    ],
-    pitfalls: [
-      'Response can exceed 500KB for complex nodes',
-      'Contains many rarely-used properties that add noise',
-      'Property conditions can be deeply nested and complex',
-      'Must use full node type with prefix (nodes-base.X not just X)'
-    ],
-    relatedTools: ['get_node_essentials for common properties', 'search_node_properties to find specific fields', 'get_property_dependencies to understand conditions']
-  }
-};

src/mcp/tool-docs/configuration/get-node.ts

@@ -0,0 +1,88 @@
+import { ToolDocumentation } from '../types';
+
+export const getNodeDoc: ToolDocumentation = {
+  name: 'get_node',
+  category: 'configuration',
+  essentials: {
+    description: 'Unified node information tool with progressive detail levels and multiple modes. Get node schema, docs, search properties, or version info.',
+    keyParameters: ['nodeType', 'detail', 'mode', 'includeTypeInfo', 'includeExamples'],
+    example: 'get_node({nodeType: "nodes-base.httpRequest", detail: "standard"})',
+    performance: 'Instant (<10ms) for minimal/standard, moderate for full',
+    tips: [
+      'Use detail="standard" (default) for most tasks - shows required fields',
+      'Use mode="docs" for readable markdown documentation',
+      'Use mode="search_properties" with propertyQuery to find specific fields',
+      'Use mode="versions" to check version history and breaking changes',
+      'Add includeExamples=true to get real-world configuration examples'
+    ]
+  },
+  full: {
+    description: `**Detail Levels (mode="info", default):**
+- minimal (~200 tokens): Basic metadata only - nodeType, displayName, description, category
+- standard (~1-2K tokens): Essential properties + operations - recommended for most tasks
+- full (~3-8K tokens): Complete node schema - use only when standard insufficient
+
+**Operation Modes:**
+- info (default): Node schema with configurable detail level
+- docs: Readable markdown documentation with examples and patterns
+- search_properties: Find specific properties within a node
+- versions: List all available versions with breaking changes summary
+- compare: Compare two versions with property-level changes
+- breaking: Show only breaking changes between versions
+- migrations: Show auto-migratable changes between versions`,
+    parameters: {
+      nodeType: { type: 'string', required: true, description: 'Full node type with prefix: "nodes-base.httpRequest" or "nodes-langchain.agent"' },
+      detail: { type: 'string', required: false, description: 'Detail level for mode=info: "minimal", "standard" (default), "full"' },
+      mode: { type: 'string', required: false, description: 'Operation mode: "info" (default), "docs", "search_properties", "versions", "compare", "breaking", "migrations"' },
+      includeTypeInfo: { type: 'boolean', required: false, description: 'Include type structure metadata (validation rules, JS types). Adds ~80-120 tokens per property' },
+      includeExamples: { type: 'boolean', required: false, description: 'Include real-world configuration examples from templates. Adds ~200-400 tokens per example' },
+      propertyQuery: { type: 'string', required: false, description: 'For mode=search_properties: search term to find properties (e.g., "auth", "header", "body")' },
+      maxPropertyResults: { type: 'number', required: false, description: 'For mode=search_properties: max results (default 20)' },
+      fromVersion: { type: 'string', required: false, description: 'For compare/breaking/migrations modes: source version (e.g., "1.0")' },
+      toVersion: { type: 'string', required: false, description: 'For compare mode: target version (e.g., "2.0"). Defaults to latest' }
+    },
+    returns: `Depends on mode:
+- info: Node schema with properties based on detail level
+- docs: Markdown documentation string
+- search_properties: Array of matching property paths with descriptions
+- versions: Version history with breaking changes flags
+- compare/breaking/migrations: Version comparison details`,
+    examples: [
+      '// Standard detail (recommended for AI agents)\nget_node({nodeType: "nodes-base.httpRequest"})',
+      '// Minimal for quick metadata check\nget_node({nodeType: "nodes-base.slack", detail: "minimal"})',
+      '// Full detail with examples\nget_node({nodeType: "nodes-base.googleSheets", detail: "full", includeExamples: true})',
+      '// Get readable documentation\nget_node({nodeType: "nodes-base.webhook", mode: "docs"})',
+      '// Search for authentication properties\nget_node({nodeType: "nodes-base.httpRequest", mode: "search_properties", propertyQuery: "auth"})',
+      '// Check version history\nget_node({nodeType: "nodes-base.executeWorkflow", mode: "versions"})',
+      '// Compare specific versions\nget_node({nodeType: "nodes-base.httpRequest", mode: "compare", fromVersion: "3.0", toVersion: "4.1"})'
+    ],
+    useCases: [
+      'Configure nodes for workflow building (use detail=standard)',
+      'Find specific configuration options (use mode=search_properties)',
+      'Get human-readable node documentation (use mode=docs)',
+      'Check for breaking changes before version upgrades (use mode=breaking)',
+      'Understand complex types with includeTypeInfo=true'
+    ],
+    performance: `Token costs by detail level:
+- minimal: ~200 tokens
+- standard: ~1000-2000 tokens (default)
+- full: ~3000-8000 tokens
+- includeTypeInfo: +80-120 tokens per property
+- includeExamples: +200-400 tokens per example
+- Version modes: ~400-1200 tokens`,
+    bestPractices: [
+      'Start with detail="standard" - it covers 95% of use cases',
+      'Only use detail="full" if standard is missing required properties',
+      'Use mode="docs" when explaining nodes to users',
+      'Combine includeTypeInfo=true for complex nodes (filter, resourceMapper)',
+      'Check version history before configuring versioned nodes'
+    ],
+    pitfalls: [
+      'detail="full" returns large responses (~100KB) - use sparingly',
+      'Node type must include prefix (nodes-base. or nodes-langchain.)',
+      'includeExamples only works with mode=info and detail=standard',
+      'Version modes require nodes with multiple versions in database'
+    ],
+    relatedTools: ['search_nodes', 'validate_node', 'validate_workflow']
+  }
+};

src/mcp/tool-docs/configuration/get-property-dependencies.ts

@@ -1,79 +0,0 @@
-import { ToolDocumentation } from '../types';
-
-export const getPropertyDependenciesDoc: ToolDocumentation = {
-  name: 'get_property_dependencies',
-  category: 'configuration',
-  essentials: {
-    description: 'Shows property dependencies and visibility rules - which fields appear when.',
-    keyParameters: ['nodeType', 'config?'],
-    example: 'get_property_dependencies({nodeType: "nodes-base.httpRequest"})',
-    performance: 'Fast - analyzes property conditions',
-    tips: [
-      'Shows which properties depend on other property values',
-      'Test visibility impact with optional config parameter',
-      'Helps understand complex conditional property displays'
-    ]
-  },
-  full: {
-    description: `Analyzes property dependencies and visibility conditions for a node. Shows which properties control the visibility of other properties (e.g., sendBody=true reveals body-related fields). Optionally test how a specific configuration affects property visibility.`,
-    parameters: {
-      nodeType: {
-        type: 'string',
-        required: true,
-        description: 'The node type to analyze (e.g., "nodes-base.httpRequest")',
-        examples: [
-          'nodes-base.httpRequest',
-          'nodes-base.slack',
-          'nodes-base.if',
-          'nodes-base.switch'
-        ]
-      },
-      config: {
-        type: 'object',
-        required: false,
-        description: 'Optional partial configuration to check visibility impact',
-        examples: [
-          '{ method: "POST", sendBody: true }',
-          '{ operation: "create", resource: "contact" }',
-          '{ mode: "rules" }'
-        ]
-      }
-    },
-    returns: `Object containing:
-- nodeType: The analyzed node type
-- displayName: Human-readable node name
-- controllingProperties: Properties that control visibility of others
-- dependentProperties: Properties whose visibility depends on others
-- complexDependencies: Multi-condition dependencies
-- currentConfig: If config provided, shows:
-  - providedValues: The configuration you passed
-  - visibilityImpact: Which properties are visible/hidden`,
-    examples: [
-      'get_property_dependencies({nodeType: "nodes-base.httpRequest"}) - Analyze HTTP Request dependencies',
-      'get_property_dependencies({nodeType: "nodes-base.httpRequest", config: {sendBody: true}}) - Test visibility with sendBody enabled',
-      'get_property_dependencies({nodeType: "nodes-base.if", config: {mode: "rules"}}) - Check If node in rules mode'
-    ],
-    useCases: [
-      'Understanding which properties control others',
-      'Debugging why certain fields are not visible',
-      'Building dynamic UIs that match n8n behavior',
-      'Testing configurations before applying them',
-      'Understanding complex node property relationships'
-    ],
-    performance: 'Fast - analyzes property metadata without database queries',
-    bestPractices: [
-      'Use before configuring complex nodes with many conditional fields',
-      'Test different config values to understand visibility rules',
-      'Check dependencies when properties seem to be missing',
-      'Use for nodes with multiple operation modes (Slack, Google Sheets)',
-      'Combine with search_node_properties to find specific fields'
-    ],
-    pitfalls: [
-      'Some properties have complex multi-condition dependencies',
-      'Visibility rules can be nested (property A controls B which controls C)',
-      'Not all hidden properties are due to dependencies (some are deprecated)',
-      'Config parameter only tests visibility, does not validate values'
-    ],
-    relatedTools: ['search_node_properties', 'get_node_essentials', 'validate_node_operation']
-  }
-};

src/mcp/tool-docs/configuration/index.ts

@@ -1,6 +1 @@
-export { getNodeInfoDoc } from './get-node-info';
-export { getNodeEssentialsDoc } from './get-node-essentials';
-export { getNodeDocumentationDoc } from './get-node-documentation';
-export { searchNodePropertiesDoc } from './search-node-properties';
-export { getNodeAsToolInfoDoc } from './get-node-as-tool-info';
-export { getPropertyDependenciesDoc } from './get-property-dependencies';
+export { getNodeDoc } from './get-node';

src/mcp/tool-docs/configuration/search-node-properties.ts

@@ -1,97 +0,0 @@
-import { ToolDocumentation } from '../types';
-
-export const searchNodePropertiesDoc: ToolDocumentation = {
-  name: 'search_node_properties',
-  category: 'configuration',
-  essentials: {
-    description: 'Find specific properties in a node without downloading all 200+ properties.',
-    keyParameters: ['nodeType', 'query'],
-    example: 'search_node_properties({nodeType: "nodes-base.httpRequest", query: "auth"})',
-    performance: 'Fast - searches indexed properties',
-    tips: [
-      'Search for "auth", "header", "body", "json", "credential"',
-      'Returns property paths and descriptions',
-      'Much faster than get_node_info for finding specific fields'
-    ]
-  },
-  full: {
-    description: `Searches for specific properties within a node's configuration schema. Essential for finding authentication fields, headers, body parameters, or any specific property without downloading the entire node schema (which can be 100KB+). Returns matching properties with their paths, types, and descriptions.`,
-    parameters: {
-      nodeType: {
-        type: 'string',
-        required: true,
-        description: 'Full type with prefix',
-        examples: [
-          'nodes-base.httpRequest',
-          'nodes-base.slack',
-          'nodes-base.postgres',
-          'nodes-base.googleSheets'
-        ]
-      },
-      query: {
-        type: 'string',
-        required: true,
-        description: 'Property to find: "auth", "header", "body", "json"',
-        examples: [
-          'auth',
-          'header',
-          'body',
-          'json',
-          'credential',
-          'timeout',
-          'retry',
-          'pagination'
-        ]
-      },
-      maxResults: {
-        type: 'number',
-        required: false,
-        description: 'Max results (default 20)',
-        default: 20
-      }
-    },
-    returns: `Object containing:
-- nodeType: The searched node type
-- query: Your search term
-- matches: Array of matching properties with:
-  - name: Property identifier
-  - displayName: Human-readable name
-  - type: Property type (string, number, options, etc.)
-  - description: Property description
-  - path: Full path to property (for nested properties)
-  - required: Whether property is required
-  - default: Default value if any
-  - options: Available options for selection properties
-  - showWhen: Visibility conditions
-- totalMatches: Number of matches found
-- searchedIn: Total properties searched`,
-    examples: [
-      'search_node_properties({nodeType: "nodes-base.httpRequest", query: "auth"}) - Find authentication fields',
-      'search_node_properties({nodeType: "nodes-base.slack", query: "channel"}) - Find channel-related properties',
-      'search_node_properties({nodeType: "nodes-base.postgres", query: "query"}) - Find query fields',
-      'search_node_properties({nodeType: "nodes-base.webhook", query: "response"}) - Find response options'
-    ],
-    useCases: [
-      'Finding authentication/credential fields quickly',
-      'Locating specific parameters without full node info',
-      'Discovering header or body configuration options',
-      'Finding nested properties in complex nodes',
-      'Checking if a node supports specific features (retry, pagination, etc.)'
-    ],
-    performance: 'Very fast - searches pre-indexed property metadata',
-    bestPractices: [
-      'Use before get_node_info to find specific properties',
-      'Search for common terms: auth, header, body, credential',
-      'Check showWhen conditions to understand visibility',
-      'Use with get_property_dependencies for complete understanding',
-      'Limit results if you only need to check existence'
-    ],
-    pitfalls: [
-      'Some properties may be hidden due to visibility conditions',
-      'Property names may differ from display names',
-      'Nested properties show full path (e.g., "options.retry.limit")',
-      'Search is case-sensitive for property names'
-    ],
-    relatedTools: ['get_node_essentials', 'get_property_dependencies', 'get_node_info']
-  }
-};

src/mcp/tool-docs/discovery/get-database-statistics.ts

@@ -1,67 +0,0 @@
-import { ToolDocumentation } from '../types';
-
-export const getDatabaseStatisticsDoc: ToolDocumentation = {
-  name: 'get_database_statistics',
-  category: 'discovery',
-  essentials: {
-    description: 'Returns database health metrics and node inventory. Shows 525 total nodes, 263 AI-capable nodes, 104 triggers, with 87% documentation coverage. Primary use: verify MCP connection is working correctly.',
-    keyParameters: [],
-    example: 'get_database_statistics()',
-    performance: 'Instant',
-    tips: [
-      'First tool to call when testing MCP connection',
-      'Shows exact counts for all node categories',
-      'Documentation coverage indicates data quality'
-    ]
-  },
-  full: {
-    description: 'Returns comprehensive database statistics showing the complete inventory of n8n nodes, their categories, documentation coverage, and package distribution. Essential for verifying MCP connectivity and understanding available resources.',
-    parameters: {},
-    returns: `Object containing:
-{
-  "total_nodes": 525,              // All nodes in database
-  "nodes_with_properties": 520,    // Nodes with extracted properties (99%)
-  "nodes_with_operations": 334,    // Nodes with multiple operations (64%)
-  "ai_tools": 263,                 // AI-capable nodes
-  "triggers": 104,                 // Workflow trigger nodes
-  "documentation_coverage": "87%", // Nodes with official docs
-  "packages": {
-    "n8n-nodes-base": 456,         // Core n8n nodes
-    "@n8n/n8n-nodes-langchain": 69 // AI/LangChain nodes
-  },
-  "categories": {
-    "trigger": 104,
-    "transform": 250,
-    "output": 45,
-    "input": 38,
-    "AI": 88
-  }
-}`,
-    examples: [
-      'get_database_statistics() - Returns complete statistics object',
-      '// Common check:',
-      'const stats = get_database_statistics();',
-      'if (stats.total_nodes < 500) console.error("Database incomplete!");'
-    ],
-    useCases: [
-      'Verify MCP server is connected and responding',
-      'Check if database rebuild is needed (low node count)',
-      'Monitor documentation coverage improvements',
-      'Validate AI tools availability for workflows',
-      'Audit node distribution across packages'
-    ],
-    performance: 'Instant (<1ms) - Statistics are pre-calculated and cached',
-    bestPractices: [
-      'Call this first to verify MCP connection before other operations',
-      'Check total_nodes >= 500 to ensure complete database',
-      'Monitor documentation_coverage for data quality',
-      'Use ai_tools count to verify AI capabilities'
-    ],
-    pitfalls: [
-      'Statistics are cached at database build time, not real-time',
-      'Won\'t reflect changes until database is rebuilt',
-      'Package counts may vary with n8n version updates'
-    ],
-    relatedTools: ['list_nodes for detailed node listing', 'list_ai_tools for AI nodes', 'n8n_health_check for API connectivity']
-  }
-};

src/mcp/tool-docs/discovery/index.ts

@@ -1,4 +1 @@
 export { searchNodesDoc } from './search-nodes';
-export { listNodesDoc } from './list-nodes';
-export { listAiToolsDoc } from './list-ai-tools';
-export { getDatabaseStatisticsDoc } from './get-database-statistics';

src/mcp/tool-docs/discovery/list-ai-tools.ts

@@ -1,51 +0,0 @@
-import { ToolDocumentation } from '../types';
-
-export const listAiToolsDoc: ToolDocumentation = {
-  name: 'list_ai_tools',
-  category: 'discovery',
-  essentials: {
-    description: 'DEPRECATED: Basic list of 263 AI nodes. For comprehensive AI Agent guidance, use tools_documentation({topic: "ai_agents_guide"}). That guide covers architecture, connections, tools, validation, and best practices. Use search_nodes({query: "AI", includeExamples: true}) for AI nodes with working examples.',
-    keyParameters: [],
-    example: 'tools_documentation({topic: "ai_agents_guide"}) // Recommended alternative',
-    performance: 'Instant (cached)',
-    tips: [
-      'NEW: Use ai_agents_guide for comprehensive AI workflow documentation',
-      'Use search_nodes({includeExamples: true}) for AI nodes with real-world examples',
-      'ANY node can be an AI tool - not limited to AI-specific nodes',
-      'Use get_node_as_tool_info for guidance on any node'
-    ]
-  },
-  full: {
-    description: '**DEPRECATED in favor of ai_agents_guide**. Lists 263 nodes with built-in AI capabilities. For comprehensive documentation on building AI Agent workflows, use tools_documentation({topic: "ai_agents_guide"}) which covers architecture, the 8 AI connection types, validation, and best practices with real examples. IMPORTANT: This basic list is NOT a complete guide - use the full AI Agents guide instead.',
-    parameters: {},
-    returns: 'Array of 263 AI-optimized nodes. RECOMMENDED: Use ai_agents_guide for comprehensive guidance, or search_nodes({query: "AI", includeExamples: true}) for AI nodes with working configuration examples.',
-    examples: [
-      '// RECOMMENDED: Use the comprehensive AI Agents guide',
-      'tools_documentation({topic: "ai_agents_guide"})',
-      '',
-      '// Or search for AI nodes with real-world examples',
-      'search_nodes({query: "AI Agent", includeExamples: true})',
-      '',
-      '// Basic list (deprecated)',
-      'list_ai_tools() - Returns 263 AI-optimized nodes'
-    ],
-    useCases: [
-      'Discover AI model integrations (OpenAI, Anthropic, Google AI)',
-      'Find vector databases for RAG applications',
-      'Locate embedding generators and processors',
-      'Build AI agent tool chains with ANY n8n node'
-    ],
-    performance: 'Instant - results are pre-cached in memory',
-    bestPractices: [
-      'Remember: ANY node works as an AI tool when connected to AI Agent',
-      'Common non-AI nodes used as tools: Slack (messaging), Google Sheets (data), HTTP Request (APIs), Code (custom logic)',
-      'For community nodes: set N8N_COMMUNITY_PACKAGES_ALLOW_TOOL_USAGE=true'
-    ],
-    pitfalls: [
-      'This list is NOT exhaustive - it only shows nodes with AI-specific features',
-      'Don\'t limit yourself to this list when building AI workflows',
-      'Community nodes require environment variable to work as tools'
-    ],
-    relatedTools: ['get_node_as_tool_info for any node usage', 'search_nodes to find specific nodes', 'get_node_essentials to configure nodes']
-  }
-};

src/mcp/tool-docs/discovery/list-nodes.ts

@@ -1,52 +0,0 @@
-import { ToolDocumentation } from '../types';
-
-export const listNodesDoc: ToolDocumentation = {
-  name: 'list_nodes',
-  category: 'discovery',
-  essentials: {
-    description: 'Lists n8n nodes with filtering options. Returns up to 525 total nodes. Default limit is 50, use limit:200 to get all nodes. Filter by category to find specific node types like triggers (104 nodes) or AI nodes (263 nodes).',
-    keyParameters: ['category', 'package', 'limit', 'isAITool'],
-    example: 'list_nodes({limit:200})',
-    performance: '<10ms for any query size',
-    tips: [
-      'Use limit:200 to get all 525 nodes',
-      'Categories: trigger (104), transform (250+), output/input (50+)',
-      'Use search_nodes for keyword search'
-    ]
-  },
-  full: {
-    description: 'Lists n8n nodes with comprehensive filtering options. Returns an array of node metadata including type, name, description, and category. Database contains 525 total nodes: 456 from n8n-nodes-base package and 69 from @n8n/n8n-nodes-langchain package.',
-    parameters: {
-      category: { type: 'string', description: 'Filter by category: "trigger" (104 nodes), "transform" (250+ nodes), "output", "input", or "AI"', required: false },
-      package: { type: 'string', description: 'Filter by package: "n8n-nodes-base" (456 core nodes) or "@n8n/n8n-nodes-langchain" (69 AI nodes)', required: false },
-      limit: { type: 'number', description: 'Maximum results to return. Default: 50. Use 200+ to get all 525 nodes', required: false },
-      isAITool: { type: 'boolean', description: 'Filter to show only AI-capable nodes (263 nodes)', required: false },
-      developmentStyle: { type: 'string', description: 'Filter by style: "programmatic" or "declarative". Most nodes are programmatic', required: false }
-    },
-    returns: 'Array of node objects, each containing: nodeType (e.g., "nodes-base.webhook"), displayName (e.g., "Webhook"), description, category, package, isAITool flag',
-    examples: [
-      'list_nodes({limit:200}) - Returns all 525 nodes',
-      'list_nodes({category:"trigger"}) - Returns 104 trigger nodes (Webhook, Schedule, Email Trigger, etc.)',
-      'list_nodes({package:"@n8n/n8n-nodes-langchain"}) - Returns 69 AI/LangChain nodes',
-      'list_nodes({isAITool:true}) - Returns 263 AI-capable nodes',
-      'list_nodes({category:"trigger", isAITool:true}) - Combines filters for AI-capable triggers'
-    ],
-    useCases: [
-      'Browse all available nodes when building workflows',
-      'Find all trigger nodes to start workflows',
-      'Discover AI/ML nodes for intelligent automation',
-      'Check available nodes in specific packages'
-    ],
-    performance: '<10ms for any query size. Results are cached in memory',
-    bestPractices: [
-      'Use limit:200 when you need the complete node inventory',
-      'Filter by category for focused discovery',
-      'Combine with get_node_essentials to configure selected nodes'
-    ],
-    pitfalls: [
-      'No text search capability - use search_nodes for keyword search',
-      'developmentStyle filter rarely useful - most nodes are "programmatic"'
-    ],
-    relatedTools: ['search_nodes for keyword search', 'list_ai_tools for AI-specific discovery', 'get_node_essentials to configure nodes']
-  }
-};

src/mcp/tool-docs/discovery/search-nodes.ts

@@ -4,7 +4,7 @@ export const searchNodesDoc: ToolDocumentation = {
   name: 'search_nodes',
   category: 'discovery',
   essentials: {
-    description: 'Text search across node names and descriptions. Returns most relevant nodes first, with frequently-used nodes (HTTP Request, Webhook, Set, Code, Slack) prioritized in results. Searches all 525 nodes in the database.',
+    description: 'Text search across node names and descriptions. Returns most relevant nodes first, with frequently-used nodes (HTTP Request, Webhook, Set, Code, Slack) prioritized in results. Searches all 500+ nodes in the database.',
     keyParameters: ['query', 'mode', 'limit'],
     example: 'search_nodes({query: "webhook"})',
     performance: '<20ms even for complex queries',
@@ -42,13 +42,13 @@ export const searchNodesDoc: ToolDocumentation = {
       'Start with single keywords for broadest results',
       'Use FUZZY mode when users might misspell node names',
       'AND mode works best for 2-3 word searches',
-      'Combine with get_node_essentials after finding the right node'
+      'Combine with get_node after finding the right node'
     ],
     pitfalls: [
       'AND mode searches all fields (name, description) not just node names',
       'FUZZY mode with very short queries (1-2 chars) may return unexpected results',
       'Exact matches in quotes are case-sensitive'
     ],
-    relatedTools: ['list_nodes for browsing by category', 'get_node_essentials to configure found nodes', 'list_ai_tools for AI-specific search']
+    relatedTools: ['get_node to configure found nodes', 'search_templates to find workflow examples', 'validate_node to check configurations']
   }
 };

src/mcp/tool-docs/guides/ai-agents-guide.ts

@@ -690,7 +690,7 @@ n8n_validate_workflow({id: "workflow_id"})
 - **FINAL_AI_VALIDATION_SPEC.md**: Complete validation rules
 - **n8n_update_partial_workflow**: Workflow modification tool
 - **search_nodes({query: "AI", includeExamples: true})**: Find AI nodes with examples
-- **get_node_essentials({nodeType: "...", includeExamples: true})**: Node details with examples
+- **get_node({nodeType: "...", detail: "standard", includeExamples: true})**: Node details with examples
 
 ---
 
@@ -731,8 +731,7 @@ n8n_validate_workflow({id: "workflow_id"})
       'n8n_update_partial_workflow',
       'n8n_validate_workflow',
       'search_nodes',
-      'get_node_essentials',
-      'list_ai_tools'
+      'get_node'
     ]
   }
 };

src/mcp/tool-docs/index.ts

@@ -1,113 +1,66 @@
 import { ToolDocumentation } from './types';
 
 // Import all tool documentations
-import { searchNodesDoc, listNodesDoc, listAiToolsDoc, getDatabaseStatisticsDoc } from './discovery';
-import { 
-  getNodeEssentialsDoc, 
-  getNodeInfoDoc, 
-  getNodeDocumentationDoc,
-  searchNodePropertiesDoc,
-  getNodeAsToolInfoDoc,
-  getPropertyDependenciesDoc
-} from './configuration';
-import { 
-  validateNodeMinimalDoc, 
-  validateNodeOperationDoc,
-  validateWorkflowDoc,
-  validateWorkflowConnectionsDoc,
-  validateWorkflowExpressionsDoc
-} from './validation';
-import {
-  listTasksDoc,
-  listNodeTemplatesDoc,
-  getTemplateDoc,
-  searchTemplatesDoc,
-  searchTemplatesByMetadataDoc,
-  getTemplatesForTaskDoc
-} from './templates';
+import { searchNodesDoc } from './discovery';
+import { getNodeDoc } from './configuration';
+import { validateNodeDoc, validateWorkflowDoc } from './validation';
+import { getTemplateDoc, searchTemplatesDoc } from './templates';
 import {
   toolsDocumentationDoc,
-  n8nDiagnosticDoc,
-  n8nHealthCheckDoc,
-  n8nListAvailableToolsDoc
+  n8nHealthCheckDoc
 } from './system';
-import {
-  aiAgentsGuide
-} from './guides';
+import { aiAgentsGuide } from './guides';
 import {
   n8nCreateWorkflowDoc,
   n8nGetWorkflowDoc,
-  n8nGetWorkflowDetailsDoc,
-  n8nGetWorkflowStructureDoc,
-  n8nGetWorkflowMinimalDoc,
   n8nUpdateFullWorkflowDoc,
   n8nUpdatePartialWorkflowDoc,
   n8nDeleteWorkflowDoc,
   n8nListWorkflowsDoc,
   n8nValidateWorkflowDoc,
   n8nAutofixWorkflowDoc,
-  n8nTriggerWebhookWorkflowDoc,
-  n8nGetExecutionDoc,
-  n8nListExecutionsDoc,
-  n8nDeleteExecutionDoc
+  n8nTestWorkflowDoc,
+  n8nExecutionsDoc,
+  n8nWorkflowVersionsDoc,
+  n8nDeployTemplateDoc
 } from './workflow_management';
 
 // Combine all tool documentations into a single object
 export const toolsDocumentation: Record<string, ToolDocumentation> = {
   // System tools
   tools_documentation: toolsDocumentationDoc,
-  n8n_diagnostic: n8nDiagnosticDoc,
   n8n_health_check: n8nHealthCheckDoc,
-  n8n_list_available_tools: n8nListAvailableToolsDoc,
 
   // Guides
   ai_agents_guide: aiAgentsGuide,
 
   // Discovery tools
   search_nodes: searchNodesDoc,
-  list_nodes: listNodesDoc,
-  list_ai_tools: listAiToolsDoc,
-  get_database_statistics: getDatabaseStatisticsDoc,
-  
+
   // Configuration tools
-  get_node_essentials: getNodeEssentialsDoc,
-  get_node_info: getNodeInfoDoc,
-  get_node_documentation: getNodeDocumentationDoc,
-  search_node_properties: searchNodePropertiesDoc,
-  get_node_as_tool_info: getNodeAsToolInfoDoc,
-  get_property_dependencies: getPropertyDependenciesDoc,
-  
+  get_node: getNodeDoc,
+
   // Validation tools
-  validate_node_minimal: validateNodeMinimalDoc,
-  validate_node_operation: validateNodeOperationDoc,
+  validate_node: validateNodeDoc,
   validate_workflow: validateWorkflowDoc,
-  validate_workflow_connections: validateWorkflowConnectionsDoc,
-  validate_workflow_expressions: validateWorkflowExpressionsDoc,
-  
+
   // Template tools
-  list_tasks: listTasksDoc,
-  list_node_templates: listNodeTemplatesDoc,
   get_template: getTemplateDoc,
   search_templates: searchTemplatesDoc,
-  search_templates_by_metadata: searchTemplatesByMetadataDoc,
-  get_templates_for_task: getTemplatesForTaskDoc,
-  
+
   // Workflow Management tools (n8n API)
   n8n_create_workflow: n8nCreateWorkflowDoc,
   n8n_get_workflow: n8nGetWorkflowDoc,
-  n8n_get_workflow_details: n8nGetWorkflowDetailsDoc,
-  n8n_get_workflow_structure: n8nGetWorkflowStructureDoc,
-  n8n_get_workflow_minimal: n8nGetWorkflowMinimalDoc,
   n8n_update_full_workflow: n8nUpdateFullWorkflowDoc,
   n8n_update_partial_workflow: n8nUpdatePartialWorkflowDoc,
   n8n_delete_workflow: n8nDeleteWorkflowDoc,
   n8n_list_workflows: n8nListWorkflowsDoc,
   n8n_validate_workflow: n8nValidateWorkflowDoc,
   n8n_autofix_workflow: n8nAutofixWorkflowDoc,
-  n8n_trigger_webhook_workflow: n8nTriggerWebhookWorkflowDoc,
-  n8n_get_execution: n8nGetExecutionDoc,
-  n8n_list_executions: n8nListExecutionsDoc,
-  n8n_delete_execution: n8nDeleteExecutionDoc
+  n8n_test_workflow: n8nTestWorkflowDoc,
+  n8n_executions: n8nExecutionsDoc,
+  n8n_workflow_versions: n8nWorkflowVersionsDoc,
+  n8n_deploy_template: n8nDeployTemplateDoc
 };
 
 // Re-export types

src/mcp/tool-docs/system/index.ts

@@ -1,4 +1,2 @@
 export { toolsDocumentationDoc } from './tools-documentation';
-export { n8nDiagnosticDoc } from './n8n-diagnostic';
-export { n8nHealthCheckDoc } from './n8n-health-check';
-export { n8nListAvailableToolsDoc } from './n8n-list-available-tools';
+export { n8nHealthCheckDoc } from './n8n-health-check';

src/mcp/tool-docs/system/n8n-health-check.ts

@@ -5,8 +5,8 @@ export const n8nHealthCheckDoc: ToolDocumentation = {
   category: 'system',
   essentials: {
     description: 'Check n8n instance health, API connectivity, version status, and performance metrics',
-    keyParameters: [],
-    example: 'n8n_health_check({})',
+    keyParameters: ['mode', 'verbose'],
+    example: 'n8n_health_check({mode: "status"})',
     performance: 'Fast - single API call (~150-200ms median)',
     tips: [
       'Use before starting workflow operations to ensure n8n is responsive',
@@ -31,7 +31,21 @@ Health checks are crucial for:
 - Detecting performance degradation
 - Verifying API compatibility before operations
 - Ensuring authentication is working correctly`,
-    parameters: {},
+    parameters: {
+      mode: {
+        type: 'string',
+        required: false,
+        description: 'Operation mode: "status" (default) for quick health check, "diagnostic" for detailed debug info including env vars and tool status',
+        default: 'status',
+        enum: ['status', 'diagnostic']
+      },
+      verbose: {
+        type: 'boolean',
+        required: false,
+        description: 'Include extra details in diagnostic mode',
+        default: false
+      }
+    },
     returns: `Health status object containing:
 - status: Overall health status ('healthy', 'degraded', 'error')
 - n8nVersion: n8n instance version information
@@ -81,6 +95,6 @@ Health checks are crucial for:
       'Does not check individual workflow health',
       'Health endpoint might be cached - not real-time for all metrics'
     ],
-    relatedTools: ['n8n_diagnostic', 'n8n_list_available_tools', 'n8n_list_workflows']
+    relatedTools: ['n8n_list_workflows', 'n8n_validate_workflow', 'n8n_workflow_versions']
   }
 };

src/mcp/tool-docs/system/tools-documentation.ts

@@ -58,6 +58,6 @@ export const toolsDocumentationDoc: ToolDocumentation = {
       'Not all internal functions are documented',
       'Special topics (code guides) require exact names'
     ],
-    relatedTools: ['n8n_list_available_tools for dynamic tool discovery', 'list_tasks for common configurations', 'get_database_statistics to verify MCP connection']
+    relatedTools: ['n8n_health_check for verifying API connection', 'search_templates for workflow examples', 'search_nodes for finding nodes']
   }
 };

src/mcp/tool-docs/templates/get-template.ts

@@ -4,23 +4,30 @@ export const getTemplateDoc: ToolDocumentation = {
   name: 'get_template',
   category: 'templates',
   essentials: {
-    description: 'Get complete workflow JSON by ID. Ready to import. IDs from list_node_templates or search_templates.',
-    keyParameters: ['templateId'],
-    example: 'get_template({templateId: 1234})',
+    description: 'Get workflow template by ID with configurable detail level. Ready to import. IDs from search_templates.',
+    keyParameters: ['templateId', 'mode'],
+    example: 'get_template({templateId: 1234, mode: "full"})',
     performance: 'Fast (<100ms) - single database lookup',
     tips: [
-      'Get template IDs from list_node_templates or search_templates first',
-      'Returns complete workflow JSON ready for import into n8n',
-      'Includes all nodes, connections, and settings'
+      'Get template IDs from search_templates first',
+      'Use mode="nodes_only" for quick overview, "structure" for topology, "full" for import',
+      'Returns complete workflow JSON ready for import into n8n'
     ]
   },
   full: {
-    description: `Retrieves the complete workflow JSON for a specific template by its ID. The returned workflow can be directly imported into n8n through the UI or API. This tool fetches pre-built workflows from the community template library containing 399+ curated workflows.`,
+    description: `Retrieves the complete workflow JSON for a specific template by its ID. The returned workflow can be directly imported into n8n through the UI or API. This tool fetches pre-built workflows from the community template library containing 2,700+ curated workflows.`,
     parameters: {
       templateId: {
         type: 'number',
         required: true,
-        description: 'The numeric ID of the template to retrieve. Get IDs from list_node_templates or search_templates'
+        description: 'The numeric ID of the template to retrieve. Get IDs from search_templates'
+      },
+      mode: {
+        type: 'string',
+        required: false,
+        description: 'Response detail level: "nodes_only" (minimal - just node list), "structure" (nodes + connections), "full" (complete workflow JSON, default)',
+        default: 'full',
+        enum: ['nodes_only', 'structure', 'full']
       }
     },
     returns: `Returns an object containing:
@@ -39,9 +46,10 @@ export const getTemplateDoc: ToolDocumentation = {
     - settings: Workflow configuration (timezone, error handling, etc.)
 - usage: Instructions for using the workflow`,
     examples: [
-      'get_template({templateId: 1234}) - Get Slack notification workflow',
-      'get_template({templateId: 5678}) - Get data sync workflow',
-      'get_template({templateId: 9012}) - Get AI chatbot workflow'
+      'get_template({templateId: 1234}) - Get complete workflow (default mode="full")',
+      'get_template({templateId: 1234, mode: "nodes_only"}) - Get just the node list',
+      'get_template({templateId: 1234, mode: "structure"}) - Get nodes and connections',
+      'get_template({templateId: 5678, mode: "full"}) - Get complete workflow JSON for import'
     ],
     useCases: [
       'Download workflows for direct import into n8n',
@@ -69,6 +77,6 @@ export const getTemplateDoc: ToolDocumentation = {
       'Not all templates work with all n8n versions',
       'Template may reference external services you don\'t have access to'
     ],
-    relatedTools: ['list_node_templates', 'search_templates', 'get_templates_for_task', 'n8n_create_workflow']
+    relatedTools: ['search_templates', 'n8n_create_workflow']
   }
 };

src/mcp/tool-docs/templates/get-templates-for-task.ts

@@ -1,74 +0,0 @@
-import { ToolDocumentation } from '../types';
-
-export const getTemplatesForTaskDoc: ToolDocumentation = {
-  name: 'get_templates_for_task',
-  category: 'templates',
-  essentials: {
-    description: 'Curated templates by task: ai_automation, data_sync, webhooks, email, slack, data_transform, files, scheduling, api, database.',
-    keyParameters: ['task'],
-    example: 'get_templates_for_task({task: "slack_integration"})',
-    performance: 'Fast (<100ms) - pre-categorized results',
-    tips: [
-      'Returns hand-picked templates for specific automation tasks',
-      'Use list_tasks to see all available task categories',
-      'Templates are curated for quality and relevance'
-    ]
-  },
-  full: {
-    description: `Retrieves curated workflow templates for specific automation tasks. This tool provides hand-picked templates organized by common use cases, making it easy to find the right workflow for your needs. Each task category contains the most popular and effective templates for that particular automation scenario.`,
-    parameters: {
-      task: {
-        type: 'string',
-        required: true,
-        description: 'The type of task to get templates for. Options: ai_automation, data_sync, webhook_processing, email_automation, slack_integration, data_transformation, file_processing, scheduling, api_integration, database_operations'
-      }
-    },
-    returns: `Returns an object containing:
-- task: The requested task type
-- templates: Array of curated templates
-  - id: Template ID
-  - name: Template name
-  - description: What the workflow does
-  - author: Creator information
-  - nodes: Array of node types used
-  - views: Popularity metric
-  - created: Creation date
-  - url: Link to template
-- totalFound: Number of templates in this category
-- availableTasks: List of all task categories (if no templates found)`,
-    examples: [
-      'get_templates_for_task({task: "slack_integration"}) - Get Slack automation workflows',
-      'get_templates_for_task({task: "ai_automation"}) - Get AI-powered workflows',
-      'get_templates_for_task({task: "data_sync"}) - Get data synchronization workflows',
-      'get_templates_for_task({task: "webhook_processing"}) - Get webhook handler workflows',
-      'get_templates_for_task({task: "email_automation"}) - Get email automation workflows'
-    ],
-    useCases: [
-      'Find workflows for specific business needs',
-      'Discover best practices for common automations',
-      'Get started quickly with pre-built solutions',
-      'Learn patterns for specific integration types',
-      'Browse curated collections of quality workflows'
-    ],
-    performance: `Excellent performance with pre-categorized templates:
-- Query time: <10ms (indexed by task)
-- No filtering needed (pre-curated)
-- Returns 5-20 templates per category
-- Total response time: <100ms`,
-    bestPractices: [
-      'Start with task-based search for faster results',
-      'Review multiple templates to find best patterns',
-      'Check template age for most current approaches',
-      'Combine templates from same category for complex workflows',
-      'Use returned node lists to understand requirements'
-    ],
-    pitfalls: [
-      'Not all tasks have many templates available',
-      'Task categories are predefined - no custom categories',
-      'Some templates may overlap between categories',
-      'Curation is subjective - browse all results',
-      'Templates may need updates for latest n8n features'
-    ],
-    relatedTools: ['search_templates', 'list_node_templates', 'get_template', 'list_tasks']
-  }
-};

src/mcp/tool-docs/templates/index.ts

@@ -1,6 +1,2 @@
-export { listTasksDoc } from './list-tasks';
-export { listNodeTemplatesDoc } from './list-node-templates';
 export { getTemplateDoc } from './get-template';
 export { searchTemplatesDoc } from './search-templates';
-export { searchTemplatesByMetadataDoc } from './search-templates-by-metadata';
-export { getTemplatesForTaskDoc } from './get-templates-for-task';

src/mcp/tool-docs/templates/list-node-templates.ts

@@ -1,78 +0,0 @@
-import { ToolDocumentation } from '../types';
-
-export const listNodeTemplatesDoc: ToolDocumentation = {
-  name: 'list_node_templates',
-  category: 'templates',
-  essentials: {
-    description: 'Find templates using specific nodes. 399 community workflows. Use FULL types: "n8n-nodes-base.httpRequest".',
-    keyParameters: ['nodeTypes', 'limit'],
-    example: 'list_node_templates({nodeTypes: ["n8n-nodes-base.slack"]})',
-    performance: 'Fast (<100ms) - indexed node search',
-    tips: [
-      'Must use FULL node type with package prefix: "n8n-nodes-base.slack"',
-      'Can search for multiple nodes to find workflows using all of them',
-      'Returns templates sorted by popularity (view count)'
-    ]
-  },
-  full: {
-    description: `Finds workflow templates that use specific n8n nodes. This is the best way to discover how particular nodes are used in real workflows. Search the community library of 399+ templates by specifying which nodes you want to see in action. Templates are sorted by popularity to show the most useful examples first.`,
-    parameters: {
-      nodeTypes: {
-        type: 'array',
-        required: true,
-        description: 'Array of node types to search for. Must use full type names with package prefix (e.g., ["n8n-nodes-base.httpRequest", "n8n-nodes-base.openAi"])'
-      },
-      limit: {
-        type: 'number',
-        required: false,
-        description: 'Maximum number of templates to return. Default 10, max 100'
-      }
-    },
-    returns: `Returns an object containing:
-- templates: Array of matching templates
-  - id: Template ID for retrieval
-  - name: Template name
-  - description: What the workflow does
-  - author: Creator details (name, username, verified)
-  - nodes: Complete list of nodes used
-  - views: View count (popularity metric)
-  - created: Creation date
-  - url: Link to template on n8n.io
-- totalFound: Total number of matching templates
-- tip: Usage hints if no results`,
-    examples: [
-      'list_node_templates({nodeTypes: ["n8n-nodes-base.slack"]}) - Find all Slack workflows',
-      'list_node_templates({nodeTypes: ["n8n-nodes-base.httpRequest", "n8n-nodes-base.postgres"]}) - Find workflows using both HTTP and Postgres',
-      'list_node_templates({nodeTypes: ["@n8n/n8n-nodes-langchain.openAi"], limit: 20}) - Find AI workflows with OpenAI',
-      'list_node_templates({nodeTypes: ["n8n-nodes-base.webhook", "n8n-nodes-base.respondToWebhook"]}) - Find webhook examples'
-    ],
-    useCases: [
-      'Learn how to use specific nodes through examples',
-      'Find workflows combining particular integrations',
-      'Discover patterns for node combinations',
-      'See real-world usage of complex nodes',
-      'Find templates for your exact tech stack'
-    ],
-    performance: `Optimized for node-based searches:
-- Indexed by node type for fast lookups
-- Query time: <50ms for single node
-- Multiple nodes: <100ms (uses AND logic)
-- Returns pre-sorted by popularity
-- No full-text search needed`,
-    bestPractices: [
-      'Always use full node type with package prefix',
-      'Search for core nodes that define the workflow purpose',
-      'Start with single node searches, then refine',
-      'Check node types with list_nodes if unsure of names',
-      'Review multiple templates to learn different approaches'
-    ],
-    pitfalls: [
-      'Node types must match exactly - no partial matches',
-      'Package prefix required: "slack" won\'t work, use "n8n-nodes-base.slack"',
-      'Some nodes have version numbers: "n8n-nodes-base.httpRequestV3"',
-      'Templates may use old node versions not in current n8n',
-      'AND logic means all specified nodes must be present'
-    ],
-    relatedTools: ['get_template', 'search_templates', 'get_templates_for_task', 'list_nodes']
-  }
-};

src/mcp/tool-docs/templates/list-tasks.ts

@@ -1,46 +0,0 @@
-import { ToolDocumentation } from '../types';
-
-export const listTasksDoc: ToolDocumentation = {
-  name: 'list_tasks',
-  category: 'templates',
-  essentials: {
-    description: 'List task templates by category: HTTP/API, Webhooks, Database, AI, Data Processing, Communication.',
-    keyParameters: ['category'],
-    example: 'list_tasks({category: "HTTP/API"})',
-    performance: 'Instant',
-    tips: [
-      'Categories: HTTP/API, Webhooks, Database, AI',
-      'Shows pre-configured node settings',
-      'Use get_node_for_task for details'
-    ]
-  },
-  full: {
-    description: 'Lists available task templates organized by category. Each task represents a common automation pattern with pre-configured node settings. Categories include HTTP/API, Webhooks, Database, AI, Data Processing, and Communication.',
-    parameters: {
-      category: { type: 'string', description: 'Filter by category (optional)' }
-    },
-    returns: 'Array of tasks with name, category, description, nodeType',
-    examples: [
-      'list_tasks() - Get all task templates',
-      'list_tasks({category: "Database"}) - Database-related tasks',
-      'list_tasks({category: "AI"}) - AI automation tasks'
-    ],
-    useCases: [
-      'Discover common automation patterns',
-      'Find pre-configured solutions',
-      'Learn node usage patterns',
-      'Quick workflow setup'
-    ],
-    performance: 'Instant - Static task list',
-    bestPractices: [
-      'Browse all categories first',
-      'Use get_node_for_task for config',
-      'Combine multiple tasks in workflows'
-    ],
-    pitfalls: [
-      'Tasks are templates, customize as needed',
-      'Not all nodes have task templates'
-    ],
-    relatedTools: ['get_node_for_task', 'search_templates', 'get_templates_for_task']
-  }
-};

src/mcp/tool-docs/templates/search-templates-by-metadata.ts

@@ -1,118 +0,0 @@
-import { ToolDocumentation } from '../types';
-
-export const searchTemplatesByMetadataDoc: ToolDocumentation = {
-  name: 'search_templates_by_metadata',
-  category: 'templates',
-  essentials: {
-    description: 'Search templates using AI-generated metadata filters. Find templates by complexity, setup time, required services, or target audience. Enables smart template discovery beyond simple text search.',
-    keyParameters: ['category', 'complexity', 'maxSetupMinutes', 'targetAudience'],
-    example: 'search_templates_by_metadata({complexity: "simple", maxSetupMinutes: 30})',
-    performance: 'Fast (<100ms) - JSON extraction queries',
-    tips: [
-      'All filters are optional - combine them for precise results',
-      'Use getAvailableCategories() to see valid category values',
-      'Complexity levels: simple, medium, complex',
-      'Setup time is in minutes (5-480 range)'
-    ]
-  },
-  full: {
-    description: `Advanced template search using AI-generated metadata. Each template has been analyzed by GPT-4 to extract structured information about its purpose, complexity, setup requirements, and target users. This enables intelligent filtering beyond simple keyword matching, helping you find templates that match your specific needs, skill level, and available time.`,
-    parameters: {
-      category: {
-        type: 'string',
-        required: false,
-        description: 'Filter by category like "automation", "integration", "data processing", "communication". Use template service getAvailableCategories() for full list.'
-      },
-      complexity: {
-        type: 'string (enum)',
-        required: false,
-        description: 'Filter by implementation complexity: "simple" (beginner-friendly), "medium" (some experience needed), or "complex" (advanced features)'
-      },
-      maxSetupMinutes: {
-        type: 'number',
-        required: false,
-        description: 'Maximum acceptable setup time in minutes (5-480). Find templates you can implement within your time budget.'
-      },
-      minSetupMinutes: {
-        type: 'number',
-        required: false,
-        description: 'Minimum setup time in minutes (5-480). Find more substantial templates that offer comprehensive solutions.'
-      },
-      requiredService: {
-        type: 'string',
-        required: false,
-        description: 'Filter by required external service like "openai", "slack", "google", "shopify". Ensures you have necessary accounts/APIs.'
-      },
-      targetAudience: {
-        type: 'string',
-        required: false,
-        description: 'Filter by intended users: "developers", "marketers", "analysts", "operations", "sales". Find templates for your role.'
-      },
-      limit: {
-        type: 'number',
-        required: false,
-        description: 'Maximum results to return. Default 20, max 100.'
-      },
-      offset: {
-        type: 'number',
-        required: false,
-        description: 'Pagination offset for results. Default 0.'
-      }
-    },
-    returns: `Returns an object containing:
-- items: Array of matching templates with full metadata
-  - id: Template ID
-  - name: Template name
-  - description: Purpose and functionality
-  - author: Creator details
-  - nodes: Array of nodes used
-  - views: Popularity count
-  - metadata: AI-generated structured data
-    - categories: Primary use categories
-    - complexity: Difficulty level
-    - use_cases: Specific applications
-    - estimated_setup_minutes: Time to implement
-    - required_services: External dependencies
-    - key_features: Main capabilities
-    - target_audience: Intended users
-- total: Total matching templates
-- filters: Applied filter criteria
-- filterSummary: Human-readable filter description
-- availableCategories: Suggested categories if no results
-- availableAudiences: Suggested audiences if no results
-- tip: Contextual guidance`,
-    examples: [
-      'search_templates_by_metadata({complexity: "simple"}) - Find beginner-friendly templates',
-      'search_templates_by_metadata({category: "automation", maxSetupMinutes: 30}) - Quick automation templates',
-      'search_templates_by_metadata({targetAudience: "marketers"}) - Marketing-focused workflows',
-      'search_templates_by_metadata({requiredService: "openai", complexity: "medium"}) - AI templates with moderate complexity',
-      'search_templates_by_metadata({minSetupMinutes: 60, category: "integration"}) - Comprehensive integration solutions'
-    ],
-    useCases: [
-      'Finding beginner-friendly templates by setting complexity:"simple"',
-      'Discovering templates you can implement quickly with maxSetupMinutes:30',
-      'Finding role-specific workflows with targetAudience filter',
-      'Identifying templates that need specific APIs with requiredService filter',
-      'Combining multiple filters for precise template discovery'
-    ],
-    performance: 'Fast (<100ms) - Uses SQLite JSON extraction on pre-generated metadata. 97.5% coverage (2,534/2,598 templates).',
-    bestPractices: [
-      'Start with broad filters and narrow down based on results',
-      'Use getAvailableCategories() to discover valid category values',
-      'Combine complexity and setup time for skill-appropriate templates',
-      'Check required services before selecting templates to ensure you have necessary accounts'
-    ],
-    pitfalls: [
-      'Not all templates have metadata (97.5% coverage)',
-      'Setup time estimates assume basic n8n familiarity',
-      'Categories/audiences use partial matching - be specific',
-      'Metadata is AI-generated and may occasionally be imprecise'
-    ],
-    relatedTools: [
-      'list_templates',
-      'search_templates',
-      'list_node_templates',
-      'get_templates_for_task'
-    ]
-  }
-};

src/mcp/tool-docs/templates/search-templates.ts

@@ -4,86 +4,138 @@ export const searchTemplatesDoc: ToolDocumentation = {
   name: 'search_templates',
   category: 'templates',
   essentials: {
-    description: 'Search templates by name/description keywords. NOT for node types! For nodes use list_node_templates. Example: "chatbot".',
-    keyParameters: ['query', 'limit', 'fields'],
-    example: 'search_templates({query: "chatbot", fields: ["id", "name"]})',
+    description: 'Unified template search with multiple modes: keyword search, by node types, by task type, or by metadata. 2,700+ templates available.',
+    keyParameters: ['searchMode', 'query', 'nodeTypes', 'task', 'limit'],
+    example: 'search_templates({searchMode: "by_task", task: "webhook_processing"})',
     performance: 'Fast (<100ms) - FTS5 full-text search',
     tips: [
-      'Searches template names and descriptions, NOT node types',
-      'Use keywords like "automation", "sync", "notification"',
-      'For node-specific search, use list_node_templates instead',
-      'Use fields parameter to get only specific data (reduces response by 70-90%)'
+      'searchMode="keyword" (default): Search by name/description',
+      'searchMode="by_nodes": Find templates using specific nodes',
+      'searchMode="by_task": Get curated templates for common tasks',
+      'searchMode="by_metadata": Filter by complexity, services, audience'
     ]
   },
   full: {
-    description: `Performs full-text search across workflow template names and descriptions. This tool is ideal for finding workflows based on their purpose or functionality rather than specific nodes used. It searches through the community library of 399+ templates using SQLite FTS5 for fast, fuzzy matching.`,
+    description: `**Search Modes:**
+- keyword (default): Full-text search across template names and descriptions
+- by_nodes: Find templates that use specific node types
+- by_task: Get curated templates for predefined task categories
+- by_metadata: Filter by complexity, setup time, required services, or target audience
+
+**Available Task Types (for searchMode="by_task"):**
+ai_automation, data_sync, webhook_processing, email_automation, slack_integration, data_transformation, file_processing, scheduling, api_integration, database_operations`,
     parameters: {
+      searchMode: {
+        type: 'string',
+        required: false,
+        description: 'Search mode: "keyword" (default), "by_nodes", "by_task", "by_metadata"'
+      },
       query: {
         type: 'string',
-        required: true,
-        description: 'Search query for template names/descriptions. NOT for node types! Examples: "chatbot", "automation", "social media", "webhook". For node-based search use list_node_templates instead.'
+        required: false,
+        description: 'For searchMode=keyword: Search keywords (e.g., "chatbot", "automation")'
+      },
+      nodeTypes: {
+        type: 'array',
+        required: false,
+        description: 'For searchMode=by_nodes: Array of node types (e.g., ["n8n-nodes-base.httpRequest", "n8n-nodes-base.slack"])'
+      },
+      task: {
+        type: 'string',
+        required: false,
+        description: 'For searchMode=by_task: Task type (ai_automation, data_sync, webhook_processing, email_automation, slack_integration, data_transformation, file_processing, scheduling, api_integration, database_operations)'
+      },
+      complexity: {
+        type: 'string',
+        required: false,
+        description: 'For searchMode=by_metadata: Filter by complexity ("simple", "medium", "complex")'
+      },
+      maxSetupMinutes: {
+        type: 'number',
+        required: false,
+        description: 'For searchMode=by_metadata: Maximum setup time in minutes (5-480)'
+      },
+      minSetupMinutes: {
+        type: 'number',
+        required: false,
+        description: 'For searchMode=by_metadata: Minimum setup time in minutes (5-480)'
+      },
+      requiredService: {
+        type: 'string',
+        required: false,
+        description: 'For searchMode=by_metadata: Filter by required service (e.g., "openai", "slack", "google")'
+      },
+      targetAudience: {
+        type: 'string',
+        required: false,
+        description: 'For searchMode=by_metadata: Filter by target audience (e.g., "developers", "marketers")'
+      },
+      category: {
+        type: 'string',
+        required: false,
+        description: 'For searchMode=by_metadata: Filter by category (e.g., "automation", "integration")'
       },
       fields: {
         type: 'array',
         required: false,
-        description: 'Fields to include in response. Options: "id", "name", "description", "author", "nodes", "views", "created", "url", "metadata". Default: all fields. Example: ["id", "name"] for minimal response.'
+        description: 'For searchMode=keyword: Fields to include (id, name, description, author, nodes, views, created, url, metadata)'
       },
       limit: {
         type: 'number',
         required: false,
-        description: 'Maximum number of results. Default 20, max 100'
+        description: 'Maximum results (default 20, max 100)'
+      },
+      offset: {
+        type: 'number',
+        required: false,
+        description: 'Pagination offset (default 0)'
       }
     },
     returns: `Returns an object containing:
-- templates: Array of matching templates sorted by relevance
-  - id: Template ID for retrieval
-  - name: Template name (with match highlights)
+- templates: Array of matching templates
+  - id: Template ID for get_template()
+  - name: Template name
   - description: What the workflow does
   - author: Creator information
-  - nodes: Array of all nodes used
+  - nodes: Array of node types used
   - views: Popularity metric
   - created: Creation date
   - url: Link to template
-  - relevanceScore: Search match score
+  - metadata: AI-generated metadata (complexity, services, etc.)
 - totalFound: Total matching templates
-- searchQuery: The processed search query
-- tip: Helpful hints if no results`,
+- searchMode: The mode used`,
     examples: [
-      'search_templates({query: "chatbot"}) - Find chatbot and conversational AI workflows',
-      'search_templates({query: "email notification"}) - Find email alert workflows',
-      'search_templates({query: "data sync"}) - Find data synchronization workflows',
-      'search_templates({query: "webhook automation", limit: 30}) - Find webhook-based automations',
-      'search_templates({query: "social media scheduler"}) - Find social posting workflows',
-      'search_templates({query: "slack", fields: ["id", "name"]}) - Get only IDs and names of Slack templates',
-      'search_templates({query: "automation", fields: ["id", "name", "description"]}) - Get minimal info for automation templates'
+      '// Keyword search (default)\nsearch_templates({query: "chatbot"})',
+      '// Find templates using specific nodes\nsearch_templates({searchMode: "by_nodes", nodeTypes: ["n8n-nodes-base.httpRequest", "n8n-nodes-base.slack"]})',
+      '// Get templates for a task type\nsearch_templates({searchMode: "by_task", task: "webhook_processing"})',
+      '// Filter by metadata\nsearch_templates({searchMode: "by_metadata", complexity: "simple", requiredService: "openai"})',
+      '// Combine metadata filters\nsearch_templates({searchMode: "by_metadata", maxSetupMinutes: 30, targetAudience: "developers"})'
     ],
     useCases: [
-      'Find workflows by business purpose',
-      'Discover automations for specific use cases',
-      'Search by workflow functionality',
-      'Find templates by problem they solve',
-      'Explore workflows by industry or domain'
+      'Find workflows by business purpose (keyword search)',
+      'Find templates using specific integrations (by_nodes)',
+      'Get pre-built solutions for common tasks (by_task)',
+      'Filter by complexity for team skill level (by_metadata)',
+      'Find templates requiring specific services (by_metadata)'
     ],
-    performance: `Excellent performance with FTS5 indexing:
-- Full-text search: <50ms for most queries
-- Fuzzy matching enabled for typos
-- Relevance-based sorting included
-- Searches both title and description
-- Returns highlighted matches`,
+    performance: `Fast performance across all modes:
+- keyword: <50ms with FTS5 indexing
+- by_nodes: <100ms with indexed lookups
+- by_task: <50ms from curated cache
+- by_metadata: <100ms with filtered queries`,
     bestPractices: [
-      'Use descriptive keywords about the workflow purpose',
-      'Try multiple related terms if first search has few results',
-      'Combine terms for more specific results',
-      'Check both name and description in results',
-      'Use quotes for exact phrase matching'
+      'Use searchMode="by_task" for common automation patterns',
+      'Use searchMode="by_nodes" when you know which integrations you need',
+      'Use searchMode="keyword" for general discovery',
+      'Combine by_metadata filters for precise matching',
+      'Use get_template(id) to get the full workflow JSON'
     ],
     pitfalls: [
-      'Does NOT search by node types - use list_node_templates',
-      'Search is case-insensitive but not semantic',
-      'Very specific terms may return no results',
-      'Descriptions may be brief - check full template',
-      'Relevance scoring may not match your expectations'
+      'searchMode="keyword" searches names/descriptions, not node types',
+      'by_nodes requires full node type with prefix (n8n-nodes-base.xxx)',
+      'by_metadata filters may return fewer results',
+      'Not all templates have complete metadata'
     ],
-    relatedTools: ['list_node_templates', 'get_templates_for_task', 'get_template', 'search_nodes']
+    relatedTools: ['get_template', 'search_nodes', 'validate_workflow']
   }
 };

src/mcp/tool-docs/validation/index.ts

@@ -1,5 +1,2 @@
-export { validateNodeMinimalDoc } from './validate-node-minimal';
-export { validateNodeOperationDoc } from './validate-node-operation';
+export { validateNodeDoc } from './validate-node';
 export { validateWorkflowDoc } from './validate-workflow';
-export { validateWorkflowConnectionsDoc } from './validate-workflow-connections';
-export { validateWorkflowExpressionsDoc } from './validate-workflow-expressions';

src/mcp/tool-docs/validation/validate-node-minimal.ts

@@ -1,47 +0,0 @@
-import { ToolDocumentation } from '../types';
-
-export const validateNodeMinimalDoc: ToolDocumentation = {
-  name: 'validate_node_minimal',
-  category: 'validation',
-  essentials: {
-    description: 'Fast check for missing required fields only. No warnings/suggestions. Returns: list of missing fields.',
-    keyParameters: ['nodeType', 'config'],
-    example: 'validate_node_minimal("nodes-base.slack", {resource: "message"})',
-    performance: 'Instant',
-    tips: [
-      'Returns only missing required fields',
-      'No warnings or suggestions',
-      'Perfect for real-time validation'
-    ]
-  },
-  full: {
-    description: 'Minimal validation that only checks for missing required fields. Returns array of missing field names without any warnings or suggestions. Ideal for quick validation during node configuration.',
-    parameters: {
-      nodeType: { type: 'string', required: true, description: 'Node type with prefix (e.g., "nodes-base.slack")' },
-      config: { type: 'object', required: true, description: 'Node configuration to validate' }
-    },
-    returns: 'Array of missing required field names (empty if valid)',
-    examples: [
-      'validate_node_minimal("nodes-base.slack", {resource: "message", operation: "post"}) - Check Slack config',
-      'validate_node_minimal("nodes-base.httpRequest", {method: "GET"}) - Check HTTP config'
-    ],
-    useCases: [
-      'Real-time form validation',
-      'Quick configuration checks',
-      'Pre-deployment validation',
-      'Interactive configuration builders'
-    ],
-    performance: 'Instant - Simple field checking without complex validation',
-    bestPractices: [
-      'Use for quick feedback loops',
-      'Follow with validate_node_operation for thorough check',
-      'Check return array length for validity'
-    ],
-    pitfalls: [
-      'Only checks required fields',
-      'No type validation',
-      'No operation-specific validation'
-    ],
-    relatedTools: ['validate_node_operation', 'get_node_essentials', 'get_property_dependencies']
-  }
-};

src/mcp/tool-docs/validation/validate-node-operation.ts

@@ -1,98 +0,0 @@
-import { ToolDocumentation } from '../types';
-
-export const validateNodeOperationDoc: ToolDocumentation = {
-  name: 'validate_node_operation',
-  category: 'validation',
-  essentials: {
-    description: 'Validates node configuration with operation awareness. Checks required fields, data types, and operation-specific rules. Returns specific errors with automated fix suggestions. Different profiles for different validation needs.',
-    keyParameters: ['nodeType', 'config', 'profile'],
-    example: 'validate_node_operation({nodeType: "nodes-base.slack", config: {resource: "message", operation: "post", text: "Hi"}})',
-    performance: '<100ms',
-    tips: [
-      'Profile choices: minimal (editing), runtime (execution), ai-friendly (balanced), strict (deployment)',
-      'Returns fixes you can apply directly',
-      'Operation-aware - knows Slack post needs text',
-      'Validates operator structures for IF and Switch nodes with conditions'
-    ]
-  },
-  full: {
-    description: 'Comprehensive node configuration validation that understands operation context. For example, it knows Slack message posting requires text field, while channel listing doesn\'t. Provides different validation profiles for different stages of workflow development.',
-    parameters: {
-      nodeType: { type: 'string', required: true, description: 'Full node type with prefix: "nodes-base.slack", "nodes-base.httpRequest"' },
-      config: { type: 'object', required: true, description: 'Node configuration. Must include operation fields (resource/operation/action) if the node has multiple operations' },
-      profile: { type: 'string', required: false, description: 'Validation profile - controls what\'s checked. Default: "ai-friendly"' }
-    },
-    returns: `Object containing:
-{
-  "isValid": false,
-  "errors": [
-    {
-      "field": "channel",
-      "message": "Required field 'channel' is missing",
-      "severity": "error",
-      "fix": "#general"
-    }
-  ],
-  "warnings": [
-    {
-      "field": "retryOnFail", 
-      "message": "Consider enabling retry for reliability",
-      "severity": "warning",
-      "fix": true
-    }
-  ],
-  "suggestions": [
-    {
-      "field": "timeout",
-      "message": "Set timeout to prevent hanging",
-      "fix": 30000
-    }
-  ],
-  "fixes": {
-    "channel": "#general",
-    "retryOnFail": true,
-    "timeout": 30000
-  }
-}`,
-    examples: [
-      '// Missing required field',
-      'validate_node_operation({nodeType: "nodes-base.slack", config: {resource: "message", operation: "post"}})',
-      '// Returns: {isValid: false, errors: [{field: "text", message: "Required field missing"}], fixes: {text: "Message text"}}',
-      '',
-      '// Validate with strict profile for production',
-      'validate_node_operation({nodeType: "nodes-base.httpRequest", config: {method: "POST", url: "https://api.example.com"}, profile: "strict"})',
-      '',
-      '// Apply fixes automatically',
-      'const result = validate_node_operation({nodeType: "nodes-base.slack", config: myConfig});',
-      'if (!result.isValid) {',
-      '  myConfig = {...myConfig, ...result.fixes};',
-      '}'
-    ],
-    useCases: [
-      'Validate configuration before workflow execution',
-      'Debug why a node isn\'t working as expected',
-      'Generate configuration fixes automatically',
-      'Different validation for editing vs production',
-      'Check IF/Switch operator structures (binary vs unary operators)',
-      'Validate conditions.options metadata for filter-based nodes'
-    ],
-    performance: '<100ms for most nodes, <200ms for complex nodes with many conditions',
-    bestPractices: [
-      'Use "minimal" profile during user editing for fast feedback',
-      'Use "runtime" profile (default) before execution',
-      'Use "ai-friendly" when AI configures nodes',
-      'Use "strict" profile before production deployment',
-      'Always include operation fields (resource/operation) in config',
-      'Apply suggested fixes to resolve issues quickly'
-    ],
-    pitfalls: [
-      'Must include operation fields for multi-operation nodes',
-      'Fixes are suggestions - review before applying',
-      'Profile affects what\'s validated - minimal skips many checks',
-      '**Binary vs Unary operators**: Binary operators (equals, contains, greaterThan) must NOT have singleValue:true. Unary operators (isEmpty, isNotEmpty, true, false) REQUIRE singleValue:true',
-      '**IF and Switch nodes with conditions**: Must have complete conditions.options structure: {version: 2, leftValue: "", caseSensitive: true/false, typeValidation: "strict"}',
-      '**Operator type field**: Must be data type (string/number/boolean/dateTime/array/object), NOT operation name (e.g., use type:"string" operation:"equals", not type:"equals")'
-    ],
-    relatedTools: ['validate_node_minimal for quick checks', 'get_node_essentials for valid examples', 'validate_workflow for complete workflow validation']
-  }
-};

src/mcp/tool-docs/validation/validate-node.ts

@@ -0,0 +1,80 @@
+import { ToolDocumentation } from '../types';
+
+export const validateNodeDoc: ToolDocumentation = {
+  name: 'validate_node',
+  category: 'validation',
+  essentials: {
+    description: 'Validate n8n node configuration. Use mode="full" for comprehensive validation with errors/warnings/suggestions, mode="minimal" for quick required fields check.',
+    keyParameters: ['nodeType', 'config', 'mode', 'profile'],
+    example: 'validate_node({nodeType: "nodes-base.slack", config: {resource: "channel", operation: "create"}})',
+    performance: 'Fast (<100ms)',
+    tips: [
+      'Always call get_node({detail:"standard"}) first to see required fields',
+      'Use mode="minimal" for quick checks during development',
+      'Use mode="full" with profile="strict" before production deployment',
+      'Includes automatic structure validation for filter, resourceMapper, etc.'
+    ]
+  },
+  full: {
+    description: `**Validation Modes:**
+- full (default): Comprehensive validation with errors, warnings, suggestions, and automatic structure validation
+- minimal: Quick check for required fields only - fast but less thorough
+
+**Validation Profiles (for mode="full"):**
+- minimal: Very lenient, basic checks only
+- runtime: Standard validation (default)
+- ai-friendly: Balanced for AI agent workflows
+- strict: Most thorough, recommended for production
+
+**Automatic Structure Validation:**
+Validates complex n8n types automatically:
+- filter (FilterValue): 40+ operations (equals, contains, regex, etc.)
+- resourceMapper (ResourceMapperValue): Data mapping configuration
+- assignmentCollection (AssignmentCollectionValue): Variable assignments
+- resourceLocator (INodeParameterResourceLocator): Resource selection modes`,
+    parameters: {
+      nodeType: { type: 'string', required: true, description: 'Node type with prefix: "nodes-base.slack"' },
+      config: { type: 'object', required: true, description: 'Configuration object to validate. Use {} for empty config' },
+      mode: { type: 'string', required: false, description: 'Validation mode: "full" (default) or "minimal"' },
+      profile: { type: 'string', required: false, description: 'Validation profile for mode=full: "minimal", "runtime" (default), "ai-friendly", "strict"' }
+    },
+    returns: `Object containing:
+- nodeType: The validated node type
+- workflowNodeType: Type to use in workflow JSON
+- displayName: Human-readable node name
+- valid: Boolean indicating if configuration is valid
+- errors: Array of error objects with type, property, message, fix
+- warnings: Array of warning objects with suggestions
+- suggestions: Array of improvement suggestions
+- missingRequiredFields: (mode=minimal only) Array of missing required field names
+- summary: Object with hasErrors, errorCount, warningCount, suggestionCount`,
+    examples: [
+      '// Full validation with default profile\nvalidate_node({nodeType: "nodes-base.slack", config: {resource: "channel", operation: "create"}})',
+      '// Quick required fields check\nvalidate_node({nodeType: "nodes-base.webhook", config: {}, mode: "minimal"})',
+      '// Strict validation for production\nvalidate_node({nodeType: "nodes-base.httpRequest", config: {...}, mode: "full", profile: "strict"})',
+      '// Validate IF node with filter\nvalidate_node({nodeType: "nodes-base.if", config: {conditions: {combinator: "and", conditions: [...]}}})'
+    ],
+    useCases: [
+      'Validate node configuration before adding to workflow',
+      'Quick check for required fields during development',
+      'Pre-production validation with strict profile',
+      'Validate complex structures (filters, resource mappers)',
+      'Get suggestions for improving node configuration'
+    ],
+    performance: 'Fast validation: <50ms for minimal mode, <100ms for full mode. Structure validation adds minimal overhead.',
+    bestPractices: [
+      'Always call get_node() first to understand required fields',
+      'Use mode="minimal" for rapid iteration during development',
+      'Use profile="strict" before deploying to production',
+      'Pay attention to warnings - they often prevent runtime issues',
+      'Validate after any configuration changes'
+    ],
+    pitfalls: [
+      'Empty config {} is valid for some nodes (e.g., manual trigger)',
+      'mode="minimal" only checks required fields, not value validity',
+      'Some warnings may be acceptable for specific use cases',
+      'Credential validation requires runtime context'
+    ],
+    relatedTools: ['get_node', 'validate_workflow', 'n8n_autofix_workflow']
+  }
+};

src/mcp/tool-docs/validation/validate-workflow-connections.ts

@@ -1,56 +0,0 @@
-import { ToolDocumentation } from '../types';
-
-export const validateWorkflowConnectionsDoc: ToolDocumentation = {
-  name: 'validate_workflow_connections',
-  category: 'validation',
-  essentials: {
-    description: 'Check workflow connections only: valid nodes, no cycles, proper triggers, AI tool links. Fast structure validation.',
-    keyParameters: ['workflow'],
-    example: 'validate_workflow_connections({workflow: {nodes: [...], connections: {...}}})',
-    performance: 'Fast (<100ms)',
-    tips: [
-      'Use for quick structure checks when editing connections',
-      'Detects orphaned nodes and circular dependencies',
-      'Validates AI Agent tool connections to ensure proper node references'
-    ]
-  },
-  full: {
-    description: 'Validates only the connection structure of a workflow without checking node configurations or expressions. This focused validation checks that all referenced nodes exist, detects circular dependencies, ensures proper trigger node placement, validates AI tool connections, and identifies orphaned or unreachable nodes.',
-    parameters: {
-      workflow: { 
-        type: 'object', 
-        required: true, 
-        description: 'The workflow JSON with nodes array and connections object.' 
-      }
-    },
-    returns: 'Object with valid (boolean), errors (array), warnings (array), and statistics about connections',
-    examples: [
-      'validate_workflow_connections({workflow: myWorkflow}) - Check all connections',
-      'validate_workflow_connections({workflow: {nodes: [...], connections: {...}}}) - Validate structure only'
-    ],
-    useCases: [
-      'Quick validation when modifying workflow connections',
-      'Ensure all node references in connections are valid',
-      'Detect circular dependencies that would cause infinite loops',
-      'Validate AI Agent nodes have proper tool connections',
-      'Check workflow has at least one trigger node',
-      'Find orphaned nodes not connected to any flow'
-    ],
-    performance: 'Fast (<100ms). Only validates structure, not node content. Scales linearly with connection count.',
-    bestPractices: [
-      'Run after adding or removing connections',
-      'Use before validate_workflow for quick structural checks',
-      'Check for warnings about orphaned nodes',
-      'Ensure trigger nodes are properly positioned',
-      'Validate after using n8n_update_partial_workflow with connection operations'
-    ],
-    pitfalls: [
-      'Does not validate node configurations - use validate_workflow for full validation',
-      'Cannot detect logical errors in connection flow',
-      'Some valid workflows may have intentionally disconnected nodes',
-      'Circular dependency detection only catches direct loops',
-      'Does not validate connection types match node capabilities'
-    ],
-    relatedTools: ['validate_workflow', 'validate_workflow_expressions', 'n8n_update_partial_workflow']
-  }
-};

src/mcp/tool-docs/validation/validate-workflow-expressions.ts

@@ -1,56 +0,0 @@
-import { ToolDocumentation } from '../types';
-
-export const validateWorkflowExpressionsDoc: ToolDocumentation = {
-  name: 'validate_workflow_expressions',
-  category: 'validation',
-  essentials: {
-    description: 'Validate n8n expressions: syntax {{}}, variables ($json/$node), references. Returns errors with locations.',
-    keyParameters: ['workflow'],
-    example: 'validate_workflow_expressions({workflow: {nodes: [...], connections: {...}}})',
-    performance: 'Fast (<100ms)',
-    tips: [
-      'Catches syntax errors in {{}} expressions before runtime',
-      'Validates $json, $node, and other n8n variables',
-      'Shows exact location of expression errors in node parameters'
-    ]
-  },
-  full: {
-    description: 'Validates all n8n expressions within a workflow for syntax correctness and reference validity. This tool scans all node parameters for n8n expressions (enclosed in {{}}), checks expression syntax, validates variable references like $json and $node("NodeName"), ensures referenced nodes exist in the workflow, and provides detailed error locations for debugging.',
-    parameters: {
-      workflow: { 
-        type: 'object', 
-        required: true, 
-        description: 'The workflow JSON to check for expression errors.' 
-      }
-    },
-    returns: 'Object with valid (boolean), errors (array with node ID, parameter path, and error details), and expression count',
-    examples: [
-      'validate_workflow_expressions({workflow: myWorkflow}) - Check all expressions',
-      'validate_workflow_expressions({workflow: {nodes: [...], connections: {...}}}) - Validate expression syntax'
-    ],
-    useCases: [
-      'Catch expression syntax errors before workflow execution',
-      'Validate node references in $node() expressions exist',
-      'Find typos in variable names like $json or $input',
-      'Ensure complex expressions are properly formatted',
-      'Debug expression errors with exact parameter locations',
-      'Validate expressions after workflow modifications'
-    ],
-    performance: 'Fast (<100ms). Scans all string parameters in all nodes. Performance scales with workflow size and expression count.',
-    bestPractices: [
-      'Run after modifying any expressions in node parameters',
-      'Check all $node() references when renaming nodes',
-      'Validate expressions before workflow deployment',
-      'Pay attention to nested object paths in expressions',
-      'Use with validate_workflow for comprehensive validation'
-    ],
-    pitfalls: [
-      'Cannot validate expression logic, only syntax',
-      'Runtime data availability not checked (e.g., if $json.field exists)',
-      'Complex JavaScript in expressions may need runtime testing',
-      'Does not validate expression return types',
-      'Some valid expressions may use advanced features not fully parsed'
-    ],
-    relatedTools: ['validate_workflow', 'validate_workflow_connections', 'validate_node_operation']
-  }
-};

src/mcp/tool-docs/validation/validate-workflow.ts

@@ -79,6 +79,6 @@ export const validateWorkflowDoc: ToolDocumentation = {
       'Validation cannot catch all runtime errors (e.g., API failures)',
       'Profile setting only affects node validation, not connection/expression checks'
     ],
-    relatedTools: ['validate_workflow_connections', 'validate_workflow_expressions', 'validate_node_operation', 'n8n_create_workflow', 'n8n_update_partial_workflow', 'n8n_autofix_workflow']
+    relatedTools: ['validate_node', 'n8n_create_workflow', 'n8n_update_partial_workflow', 'n8n_autofix_workflow']
   }
 };

src/mcp/tool-docs/workflow_management/index.ts

@@ -1,15 +1,12 @@
 export { n8nCreateWorkflowDoc } from './n8n-create-workflow';
 export { n8nGetWorkflowDoc } from './n8n-get-workflow';
-export { n8nGetWorkflowDetailsDoc } from './n8n-get-workflow-details';
-export { n8nGetWorkflowStructureDoc } from './n8n-get-workflow-structure';
-export { n8nGetWorkflowMinimalDoc } from './n8n-get-workflow-minimal';
 export { n8nUpdateFullWorkflowDoc } from './n8n-update-full-workflow';
 export { n8nUpdatePartialWorkflowDoc } from './n8n-update-partial-workflow';
 export { n8nDeleteWorkflowDoc } from './n8n-delete-workflow';
 export { n8nListWorkflowsDoc } from './n8n-list-workflows';
 export { n8nValidateWorkflowDoc } from './n8n-validate-workflow';
 export { n8nAutofixWorkflowDoc } from './n8n-autofix-workflow';
-export { n8nTriggerWebhookWorkflowDoc } from './n8n-trigger-webhook-workflow';
-export { n8nGetExecutionDoc } from './n8n-get-execution';
-export { n8nListExecutionsDoc } from './n8n-list-executions';
-export { n8nDeleteExecutionDoc } from './n8n-delete-execution';
+export { n8nTestWorkflowDoc } from './n8n-test-workflow';
+export { n8nExecutionsDoc } from './n8n-executions';
+export { n8nWorkflowVersionsDoc } from './n8n-workflow-versions';
+export { n8nDeployTemplateDoc } from './n8n-deploy-template';

src/mcp/tool-docs/workflow_management/n8n-autofix-workflow.ts

@@ -153,9 +153,8 @@ Requires N8N_API_URL and N8N_API_KEY environment variables to be configured.`,
     relatedTools: [
       'n8n_validate_workflow',
       'validate_workflow',
-      'n8n_update_partial_workflow',
-      'validate_workflow_expressions',
-      'validate_node_operation'
+      'validate_node',
+      'n8n_update_partial_workflow'
     ]
   }
 };

src/mcp/tool-docs/workflow_management/n8n-create-workflow.ts

@@ -84,7 +84,7 @@ n8n_create_workflow({
       'Validate with validate_workflow first',
       'Use unique node IDs',
       'Position nodes for readability',
-      'Test with n8n_trigger_webhook_workflow'
+      'Test with n8n_test_workflow'
     ],
     pitfalls: [
       '**REQUIRES N8N_API_URL and N8N_API_KEY environment variables** - tool unavailable without n8n API access',
@@ -95,6 +95,6 @@ n8n_create_workflow({
       '**Auto-sanitization runs on creation**: All nodes sanitized before workflow created (operator structures fixed, missing metadata added)',
       '**Auto-sanitization cannot prevent all failures**: Broken connections or invalid node configurations may still cause creation to fail'
     ],
-    relatedTools: ['validate_workflow', 'n8n_update_partial_workflow', 'n8n_trigger_webhook_workflow']
+    relatedTools: ['validate_workflow', 'n8n_update_partial_workflow', 'n8n_test_workflow']
   }
 };

src/mcp/tool-docs/workflow_management/n8n-delete-execution.ts

@@ -1,57 +0,0 @@
-import { ToolDocumentation } from '../types';
-
-export const n8nDeleteExecutionDoc: ToolDocumentation = {
-  name: 'n8n_delete_execution',
-  category: 'workflow_management',
-  essentials: {
-    description: 'Delete an execution record. This only removes the execution history, not any data processed.',
-    keyParameters: ['id'],
-    example: 'n8n_delete_execution({id: "12345"})',
-    performance: 'Immediate deletion, no undo available',
-    tips: [
-      'Deletion is permanent - execution cannot be recovered',
-      'Only removes execution history, not external data changes',
-      'Use for cleanup of test executions or sensitive data'
-    ]
-  },
-  full: {
-    description: `Permanently deletes a workflow execution record from n8n's history. This removes the execution metadata, logs, and any stored input/output data. However, it does NOT undo any actions the workflow performed (API calls, database changes, file operations, etc.). Use this for cleaning up test executions, removing sensitive data, or managing storage.`,
-    parameters: {
-      id: {
-        type: 'string',
-        required: true,
-        description: 'The execution ID to delete. This action cannot be undone'
-      }
-    },
-    returns: `Confirmation of deletion or error if execution not found. No data is returned about the deleted execution.`,
-    examples: [
-      'n8n_delete_execution({id: "12345"}) - Delete a specific execution',
-      'n8n_delete_execution({id: "test-run-567"}) - Clean up test execution',
-      'n8n_delete_execution({id: "sensitive-data-890"}) - Remove execution with sensitive data',
-      'n8n_delete_execution({id: "failed-execution-123"}) - Delete failed execution after debugging'
-    ],
-    useCases: [
-      'Clean up test or development execution history',
-      'Remove executions containing sensitive or personal data',
-      'Manage storage by deleting old execution records',
-      'Clean up after debugging failed workflows',
-      'Comply with data retention policies'
-    ],
-    performance: `Deletion is immediate and permanent. The operation is fast (< 100ms) as it only removes database records. No external systems or data are affected.`,
-    bestPractices: [
-      'Verify execution ID before deletion - action cannot be undone',
-      'Consider exporting execution data before deletion if needed',
-      'Use list_executions to find executions to delete',
-      'Document why executions were deleted for audit trails',
-      'Remember deletion only affects n8n records, not external changes'
-    ],
-    pitfalls: [
-      'Deletion is PERMANENT - no undo or recovery possible',
-      'Does NOT reverse workflow actions (API calls, DB changes, etc.)',
-      'Deleting executions breaks audit trails and debugging history',
-      'Cannot delete currently running executions (waiting status)',
-      'Bulk deletion not supported - must delete one at a time'
-    ],
-    relatedTools: ['n8n_list_executions', 'n8n_get_execution', 'n8n_trigger_webhook_workflow']
-  }
-};

src/mcp/tool-docs/workflow_management/n8n-delete-workflow.ts

@@ -11,7 +11,7 @@ export const n8nDeleteWorkflowDoc: ToolDocumentation = {
     tips: [
       'Action is irreversible',
       'Deletes all execution history',
-      'Check workflow first with get_minimal'
+      'Check workflow first with n8n_get_workflow({mode: "minimal"})'
     ]
   },
   full: {
@@ -34,7 +34,7 @@ export const n8nDeleteWorkflowDoc: ToolDocumentation = {
     performance: 'Fast operation - typically 50-150ms. May take longer if workflow has extensive execution history.',
     bestPractices: [
       'Always confirm before deletion',
-      'Check workflow with get_minimal first',
+      'Check workflow with n8n_get_workflow({mode: "minimal"}) first',
       'Consider deactivating instead of deleting',
       'Export workflow before deletion for backup'
     ],
@@ -45,6 +45,6 @@ export const n8nDeleteWorkflowDoc: ToolDocumentation = {
       'Active workflows can be deleted',
       'No built-in confirmation'
     ],
-    relatedTools: ['n8n_get_workflow_minimal', 'n8n_list_workflows', 'n8n_update_partial_workflow', 'n8n_delete_execution']
+    relatedTools: ['n8n_get_workflow', 'n8n_list_workflows', 'n8n_update_partial_workflow', 'n8n_executions']
   }
 };

src/mcp/tool-docs/workflow_management/n8n-deploy-template.ts

@@ -0,0 +1,71 @@
+import { ToolDocumentation } from '../types';
+
+export const n8nDeployTemplateDoc: ToolDocumentation = {
+  name: 'n8n_deploy_template',
+  category: 'workflow_management',
+  essentials: {
+    description: 'Deploy a workflow template from n8n.io directly to your n8n instance. Deploys first, then auto-fixes common issues (expression format, typeVersions).',
+    keyParameters: ['templateId', 'name', 'autoUpgradeVersions', 'autoFix', 'stripCredentials'],
+    example: 'n8n_deploy_template({templateId: 2776, name: "My Deployed Template"})',
+    performance: 'Network-dependent',
+    tips: [
+      'Auto-fixes expression format issues after deployment',
+      'Workflow created inactive - configure credentials in n8n UI first',
+      'Returns list of required credentials and fixes applied',
+      'Use search_templates to find template IDs'
+    ]
+  },
+  full: {
+    description: 'Deploys a workflow template from n8n.io directly to your n8n instance. This tool deploys first, then automatically fixes common issues like missing expression prefixes (=) and outdated typeVersions. Templates are stored locally and fetched from the database. The workflow is always created in an inactive state, allowing you to configure credentials before activation.',
+    parameters: {
+      templateId: { type: 'number', required: true, description: 'Template ID from n8n.io (find via search_templates)' },
+      name: { type: 'string', description: 'Custom workflow name (default: template name)' },
+      autoUpgradeVersions: { type: 'boolean', description: 'Upgrade node typeVersions to latest supported (default: true)' },
+      autoFix: { type: 'boolean', description: 'Auto-apply fixes after deployment for expression format issues, missing = prefix, etc. (default: true)' },
+      stripCredentials: { type: 'boolean', description: 'Remove credential references - user configures in n8n UI (default: true)' }
+    },
+    returns: 'Object with workflowId, name, nodeCount, triggerType, requiredCredentials array, url, templateId, templateUrl, autoFixStatus (success/failed/skipped), and fixesApplied array',
+    examples: [
+      `// Deploy template with default settings (auto-fix enabled)
+n8n_deploy_template({templateId: 2776})`,
+      `// Deploy with custom name
+n8n_deploy_template({
+  templateId: 2776,
+  name: "My Google Drive to Airtable Sync"
+})`,
+      `// Deploy without auto-fix (not recommended)
+n8n_deploy_template({
+  templateId: 2776,
+  autoFix: false
+})`,
+      `// Keep original node versions (useful for compatibility)
+n8n_deploy_template({
+  templateId: 2776,
+  autoUpgradeVersions: false
+})`
+    ],
+    useCases: [
+      'Quickly deploy pre-built workflow templates',
+      'Set up common automation patterns',
+      'Bootstrap new projects with proven workflows',
+      'Deploy templates found via search_templates'
+    ],
+    performance: 'Network-dependent - Typically 300-800ms (template fetch + workflow creation + autofix)',
+    bestPractices: [
+      'Use search_templates to find templates by use case',
+      'Review required credentials in the response',
+      'Check autoFixStatus in response - "success", "failed", or "skipped"',
+      'Check fixesApplied in response to see what was automatically corrected',
+      'Configure credentials in n8n UI before activating',
+      'Test workflow before connecting to production systems'
+    ],
+    pitfalls: [
+      '**REQUIRES N8N_API_URL and N8N_API_KEY environment variables** - tool unavailable without n8n API access',
+      'Workflows created in INACTIVE state - must configure credentials and activate in n8n',
+      'Templates may reference services you do not have (Slack, Google, etc.)',
+      'Template database must be populated - run npm run fetch:templates if templates not found',
+      'Some issues may not be auto-fixable (e.g., missing required fields that need user input)'
+    ],
+    relatedTools: ['search_templates', 'get_template', 'n8n_create_workflow', 'n8n_autofix_workflow']
+  }
+};

src/mcp/tool-docs/workflow_management/n8n-executions.ts

@@ -0,0 +1,82 @@
+import { ToolDocumentation } from '../types';
+
+export const n8nExecutionsDoc: ToolDocumentation = {
+  name: 'n8n_executions',
+  category: 'workflow_management',
+  essentials: {
+    description: 'Manage workflow executions: get details, list, or delete. Unified tool for all execution operations.',
+    keyParameters: ['action', 'id', 'workflowId', 'status'],
+    example: 'n8n_executions({action: "list", workflowId: "abc123", status: "error"})',
+    performance: 'Fast (50-200ms)',
+    tips: [
+      'action="get": Get execution details by ID',
+      'action="list": List executions with filters',
+      'action="delete": Delete execution record',
+      'Use mode parameter for action=get to control detail level'
+    ]
+  },
+  full: {
+    description: `**Actions:**
+- get: Retrieve execution details by ID with configurable detail level
+- list: List executions with filtering and pagination
+- delete: Remove an execution record from history
+
+**Detail Modes for action="get":**
+- preview: Structure only, no data
+- summary: 2 items per node (default)
+- filtered: Custom items limit, optionally filter by node names
+- full: All execution data (can be very large)`,
+    parameters: {
+      action: { type: 'string', required: true, description: 'Operation: "get", "list", or "delete"' },
+      id: { type: 'string', required: false, description: 'Execution ID (required for action=get or action=delete)' },
+      mode: { type: 'string', required: false, description: 'For action=get: "preview", "summary" (default), "filtered", "full"' },
+      nodeNames: { type: 'array', required: false, description: 'For action=get with mode=filtered: Filter to specific nodes by name' },
+      itemsLimit: { type: 'number', required: false, description: 'For action=get with mode=filtered: Items per node (0=structure, 2=default, -1=unlimited)' },
+      includeInputData: { type: 'boolean', required: false, description: 'For action=get: Include input data in addition to output (default: false)' },
+      workflowId: { type: 'string', required: false, description: 'For action=list: Filter by workflow ID' },
+      status: { type: 'string', required: false, description: 'For action=list: Filter by status ("success", "error", "waiting")' },
+      limit: { type: 'number', required: false, description: 'For action=list: Number of results (1-100, default: 100)' },
+      cursor: { type: 'string', required: false, description: 'For action=list: Pagination cursor from previous response' },
+      projectId: { type: 'string', required: false, description: 'For action=list: Filter by project ID (enterprise)' },
+      includeData: { type: 'boolean', required: false, description: 'For action=list: Include execution data (default: false)' }
+    },
+    returns: `Depends on action:
+- get: Execution object with data based on mode
+- list: { data: [...executions], nextCursor?: string }
+- delete: { success: boolean, message: string }`,
+    examples: [
+      '// List recent executions for a workflow\nn8n_executions({action: "list", workflowId: "abc123", limit: 10})',
+      '// List failed executions\nn8n_executions({action: "list", status: "error"})',
+      '// Get execution summary\nn8n_executions({action: "get", id: "exec_456"})',
+      '// Get full execution data\nn8n_executions({action: "get", id: "exec_456", mode: "full"})',
+      '// Get specific nodes from execution\nn8n_executions({action: "get", id: "exec_456", mode: "filtered", nodeNames: ["HTTP Request", "Slack"]})',
+      '// Delete an execution\nn8n_executions({action: "delete", id: "exec_456"})'
+    ],
+    useCases: [
+      'Debug workflow failures (get with mode=full)',
+      'Monitor workflow health (list with status filter)',
+      'Audit execution history',
+      'Clean up old execution records',
+      'Analyze specific node outputs'
+    ],
+    performance: `Response times:
+- list: 50-150ms depending on filters
+- get (preview/summary): 30-100ms
+- get (full): 100-500ms+ depending on data size
+- delete: 30-80ms`,
+    bestPractices: [
+      'Use mode="summary" (default) for debugging - shows enough data',
+      'Use mode="filtered" with nodeNames for large workflows',
+      'Filter by workflowId when listing to reduce results',
+      'Use cursor for pagination through large result sets',
+      'Delete old executions to save storage'
+    ],
+    pitfalls: [
+      'Requires N8N_API_URL and N8N_API_KEY configured',
+      'mode="full" can return very large responses for complex workflows',
+      'Execution must exist or returns 404',
+      'Delete is permanent - cannot undo'
+    ],
+    relatedTools: ['n8n_get_workflow', 'n8n_test_workflow', 'n8n_validate_workflow']
+  }
+};

src/mcp/tool-docs/workflow_management/n8n-get-execution.ts

@@ -1,283 +0,0 @@
-import { ToolDocumentation } from '../types';
-
-export const n8nGetExecutionDoc: ToolDocumentation = {
-  name: 'n8n_get_execution',
-  category: 'workflow_management',
-  essentials: {
-    description: 'Get execution details with smart filtering to avoid token limits. Use preview mode first to assess data size, then fetch appropriately.',
-    keyParameters: ['id', 'mode', 'itemsLimit', 'nodeNames'],
-    example: `
-// RECOMMENDED WORKFLOW:
-// 1. Preview first
-n8n_get_execution({id: "12345", mode: "preview"})
-// Returns: structure, counts, size estimate, recommendation
-
-// 2. Based on recommendation, fetch data:
-n8n_get_execution({id: "12345", mode: "summary"}) // 2 items per node
-n8n_get_execution({id: "12345", mode: "filtered", itemsLimit: 5}) // 5 items
-n8n_get_execution({id: "12345", nodeNames: ["HTTP Request"]}) // Specific node
-`,
-    performance: 'Preview: <50ms, Summary: <200ms, Full: depends on data size',
-    tips: [
-      'ALWAYS use preview mode first for large datasets',
-      'Preview shows structure + counts without consuming tokens for data',
-      'Summary mode (2 items per node) is safe default',
-      'Use nodeNames to focus on specific nodes only',
-      'itemsLimit: 0 = structure only, -1 = unlimited',
-      'Check recommendation.suggestedMode from preview'
-    ]
-  },
-  full: {
-    description: `Retrieves and intelligently filters execution data to enable inspection without exceeding token limits. This tool provides multiple modes for different use cases, from quick previews to complete data retrieval.
-
-**The Problem**: Workflows processing large datasets (50+ database records) generate execution data that exceeds token/response limits, making traditional full-data fetching impossible.
-
-**The Solution**: Four retrieval modes with smart filtering:
-1. **Preview**: Structure + counts only (no actual data)
-2. **Summary**: 2 sample items per node (safe default)
-3. **Filtered**: Custom limits and node selection
-4. **Full**: Complete data (use with caution)
-
-**Recommended Workflow**:
-1. Start with preview mode to assess size
-2. Use recommendation to choose appropriate mode
-3. Fetch filtered data as needed`,
-
-    parameters: {
-      id: {
-        type: 'string',
-        required: true,
-        description: 'The execution ID to retrieve. Obtained from list_executions or webhook trigger responses'
-      },
-      mode: {
-        type: 'string',
-        required: false,
-        description: `Retrieval mode (default: auto-detect from other params):
-- 'preview': Structure, counts, size estimates - NO actual data (fastest)
-- 'summary': Metadata + 2 sample items per node (safe default)
-- 'filtered': Custom filtering with itemsLimit/nodeNames
-- 'full': Complete execution data (use with caution)`
-      },
-      nodeNames: {
-        type: 'array',
-        required: false,
-        description: 'Filter to specific nodes by name. Example: ["HTTP Request", "Filter"]. Useful when you only need to inspect specific nodes.'
-      },
-      itemsLimit: {
-        type: 'number',
-        required: false,
-        description: `Items to return per node (default: 2):
-- 0: Structure only (see data shape without values)
-- 1-N: Return N items per node
-- -1: Unlimited (return all items)
-
-Note: Structure-only mode (0) shows JSON schema without actual values.`
-      },
-      includeInputData: {
-        type: 'boolean',
-        required: false,
-        description: 'Include input data in addition to output data (default: false). Useful for debugging data transformations.'
-      },
-      includeData: {
-        type: 'boolean',
-        required: false,
-        description: 'DEPRECATED: Legacy parameter. Use mode instead. If true, maps to mode="summary" for backward compatibility.'
-      }
-    },
-
-    returns: `**Preview Mode Response**:
-{
-  mode: 'preview',
-  preview: {
-    totalNodes: number,
-    executedNodes: number,
-    estimatedSizeKB: number,
-    nodes: {
-      [nodeName]: {
-        status: 'success' | 'error',
-        itemCounts: { input: number, output: number },
-        dataStructure: {...}, // JSON schema
-        estimatedSizeKB: number
-      }
-    }
-  },
-  recommendation: {
-    canFetchFull: boolean,
-    suggestedMode: 'preview'|'summary'|'filtered'|'full',
-    suggestedItemsLimit?: number,
-    reason: string
-  }
-}
-
-**Summary/Filtered/Full Mode Response**:
-{
-  mode: 'summary' | 'filtered' | 'full',
-  summary: {
-    totalNodes: number,
-    executedNodes: number,
-    totalItems: number,
-    hasMoreData: boolean  // true if truncated
-  },
-  nodes: {
-    [nodeName]: {
-      executionTime: number,
-      itemsInput: number,
-      itemsOutput: number,
-      status: 'success' | 'error',
-      error?: string,
-      data: {
-        output: [...],  // Actual data items
-        metadata: {
-          totalItems: number,
-          itemsShown: number,
-          truncated: boolean
-        }
-      }
-    }
-  }
-}`,
-
-    examples: [
-      `// Example 1: Preview workflow (RECOMMENDED FIRST STEP)
-n8n_get_execution({id: "exec_123", mode: "preview"})
-// Returns structure, counts, size, recommendation
-// Use this to decide how to fetch data`,
-
-      `// Example 2: Follow recommendation
-const preview = n8n_get_execution({id: "exec_123", mode: "preview"});
-if (preview.recommendation.canFetchFull) {
-  n8n_get_execution({id: "exec_123", mode: "full"});
-} else {
-  n8n_get_execution({
-    id: "exec_123",
-    mode: "filtered",
-    itemsLimit: preview.recommendation.suggestedItemsLimit
-  });
-}`,
-
-      `// Example 3: Summary mode (safe default for unknown datasets)
-n8n_get_execution({id: "exec_123", mode: "summary"})
-// Gets 2 items per node - safe for most cases`,
-
-      `// Example 4: Filter to specific node
-n8n_get_execution({
-  id: "exec_123",
-  mode: "filtered",
-  nodeNames: ["HTTP Request"],
-  itemsLimit: 5
-})
-// Gets only HTTP Request node, 5 items`,
-
-      `// Example 5: Structure only (see data shape)
-n8n_get_execution({
-  id: "exec_123",
-  mode: "filtered",
-  itemsLimit: 0
-})
-// Returns JSON schema without actual values`,
-
-      `// Example 6: Debug with input data
-n8n_get_execution({
-  id: "exec_123",
-  mode: "filtered",
-  nodeNames: ["Transform"],
-  itemsLimit: 2,
-  includeInputData: true
-})
-// See both input and output for debugging`,
-
-      `// Example 7: Backward compatibility (legacy)
-n8n_get_execution({id: "exec_123"}) // Minimal data
-n8n_get_execution({id: "exec_123", includeData: true}) // Maps to summary mode`
-    ],
-
-    useCases: [
-      'Monitor status of triggered workflows',
-      'Debug failed workflows by examining error messages and partial data',
-      'Inspect large datasets without exceeding token limits',
-      'Validate data transformations between nodes',
-      'Understand execution flow and timing',
-      'Track workflow performance metrics',
-      'Verify successful completion before proceeding',
-      'Extract specific data from execution results'
-    ],
-
-    performance: `**Response Times** (approximate):
-- Preview mode: <50ms (no data, just structure)
-- Summary mode: <200ms (2 items per node)
-- Filtered mode: 50-500ms (depends on filters)
-- Full mode: 200ms-5s (depends on data size)
-
-**Token Consumption**:
-- Preview: ~500 tokens (no data values)
-- Summary (2 items): ~2-5K tokens
-- Filtered (5 items): ~5-15K tokens
-- Full (50+ items): 50K+ tokens (may exceed limits)
-
-**Optimization Tips**:
-- Use preview for all large datasets
-- Use nodeNames to focus on relevant nodes only
-- Start with small itemsLimit and increase if needed
-- Use itemsLimit: 0 to see structure without data`,
-
-    bestPractices: [
-      'ALWAYS use preview mode first for unknown datasets',
-      'Trust the recommendation.suggestedMode from preview',
-      'Use nodeNames to filter to relevant nodes only',
-      'Start with summary mode if preview indicates moderate size',
-      'Use itemsLimit: 0 to understand data structure',
-      'Check hasMoreData to know if results are truncated',
-      'Store execution IDs from triggers for later inspection',
-      'Use mode="filtered" with custom limits for large datasets',
-      'Include input data only when debugging transformations',
-      'Monitor summary.totalItems to understand dataset size'
-    ],
-
-    pitfalls: [
-      'DON\'T fetch full mode without previewing first - may timeout',
-      'DON\'T assume all data fits - always check hasMoreData',
-      'DON\'T ignore the recommendation from preview mode',
-      'Execution data is retained based on n8n settings - old executions may be purged',
-      'Binary data (files, images) is not fully included - only metadata',
-      'Status "waiting" indicates execution is still running',
-      'Error executions may have partial data from successful nodes',
-      'Very large individual items (>1MB) may be truncated',
-      'Preview mode estimates may be off by 10-20% for complex structures',
-      'Node names are case-sensitive in nodeNames filter'
-    ],
-
-    modeComparison: `**When to use each mode**:
-
-**Preview**:
-- ALWAYS use first for unknown datasets
-- When you need to know if data is safe to fetch
-- To see data structure without consuming tokens
-- To get size estimates and recommendations
-
-**Summary** (default):
-- Safe default for most cases
-- When you need representative samples
-- When preview recommends it
-- For quick data inspection
-
-**Filtered**:
-- When you need specific nodes only
-- When you need more than 2 items but not all
-- When preview recommends it with itemsLimit
-- For targeted data extraction
-
-**Full**:
-- ONLY when preview says canFetchFull: true
-- For small executions (< 20 items total)
-- When you genuinely need all data
-- When you're certain data fits in token limit`,
-
-    relatedTools: [
-      'n8n_list_executions - Find execution IDs',
-      'n8n_trigger_webhook_workflow - Trigger and get execution ID',
-      'n8n_delete_execution - Clean up old executions',
-      'n8n_get_workflow - Get workflow structure',
-      'validate_workflow - Validate before executing'
-    ]
-  }
-};

src/mcp/tool-docs/workflow_management/n8n-get-workflow-details.ts

@@ -1,49 +0,0 @@
-import { ToolDocumentation } from '../types';
-
-export const n8nGetWorkflowDetailsDoc: ToolDocumentation = {
-  name: 'n8n_get_workflow_details',
-  category: 'workflow_management',
-  essentials: {
-    description: 'Get workflow details with metadata, version, execution stats. More info than get_workflow.',
-    keyParameters: ['id'],
-    example: 'n8n_get_workflow_details({id: "workflow_123"})',
-    performance: 'Fast (100-300ms)',
-    tips: [
-      'Includes execution statistics',
-      'Shows version history info',
-      'Contains metadata like tags'
-    ]
-  },
-  full: {
-    description: 'Retrieves comprehensive workflow details including metadata, execution statistics, version information, and usage analytics. Provides more information than get_workflow, including data not typically needed for editing but useful for monitoring and analysis.',
-    parameters: {
-      id: { type: 'string', required: true, description: 'Workflow ID to retrieve details for' }
-    },
-    returns: 'Extended workflow object with: id, name, nodes, connections, settings, plus metadata (tags, owner, shared users), execution stats (success/error counts, average runtime), version info, created/updated timestamps',
-    examples: [
-      'n8n_get_workflow_details({id: "abc123"}) - Get workflow with stats',
-      'const details = n8n_get_workflow_details({id: "xyz789"}); // Analyze performance'
-    ],
-    useCases: [
-      'Monitor workflow performance',
-      'Analyze execution patterns',
-      'View workflow metadata',
-      'Check version information',
-      'Audit workflow usage'
-    ],
-    performance: 'Slightly slower than get_workflow due to additional metadata - typically 100-300ms. Stats may be cached.',
-    bestPractices: [
-      'Use for monitoring and analysis',
-      'Check execution stats before optimization',
-      'Review error counts for debugging',
-      'Monitor average execution times'
-    ],
-    pitfalls: [
-      'Requires N8N_API_URL and N8N_API_KEY configured',
-      'More data than needed for simple edits',
-      'Stats may have slight delay',
-      'Not all n8n versions support all fields'
-    ],
-    relatedTools: ['n8n_get_workflow', 'n8n_list_executions', 'n8n_get_execution', 'n8n_list_workflows']
-  }
-};

src/mcp/tool-docs/workflow_management/n8n-get-workflow-minimal.ts

@@ -1,49 +0,0 @@
-import { ToolDocumentation } from '../types';
-
-export const n8nGetWorkflowMinimalDoc: ToolDocumentation = {
-  name: 'n8n_get_workflow_minimal',
-  category: 'workflow_management',
-  essentials: {
-    description: 'Get minimal info: ID, name, active status, tags. Fast for listings.',
-    keyParameters: ['id'],
-    example: 'n8n_get_workflow_minimal({id: "workflow_123"})',
-    performance: 'Very fast (<50ms)',
-    tips: [
-      'Fastest way to check workflow exists',
-      'Perfect for status checks',
-      'Use in list displays'
-    ]
-  },
-  full: {
-    description: 'Retrieves only essential workflow information without nodes or connections. Returns minimal data needed for listings, status checks, and quick lookups. Optimized for performance when full workflow data is not needed.',
-    parameters: {
-      id: { type: 'string', required: true, description: 'Workflow ID to retrieve minimal info for' }
-    },
-    returns: 'Minimal workflow object with: id, name, active status, tags array, createdAt, updatedAt. No nodes, connections, or settings included.',
-    examples: [
-      'n8n_get_workflow_minimal({id: "abc123"}) - Quick existence check',
-      'const info = n8n_get_workflow_minimal({id: "xyz789"}); // Check if active'
-    ],
-    useCases: [
-      'Quick workflow existence checks',
-      'Display workflow lists',
-      'Check active/inactive status',
-      'Get workflow tags',
-      'Performance-critical operations'
-    ],
-    performance: 'Extremely fast - typically under 50ms. Returns only database metadata without loading workflow definition.',
-    bestPractices: [
-      'Use for list displays and dashboards',
-      'Ideal for existence checks before operations',
-      'Cache results for UI responsiveness',
-      'Combine with list_workflows for bulk checks'
-    ],
-    pitfalls: [
-      'Requires N8N_API_URL and N8N_API_KEY configured',
-      'No workflow content - cannot edit or validate',
-      'Tags may be empty array',
-      'Must use get_workflow for actual workflow data'
-    ],
-    relatedTools: ['n8n_list_workflows', 'n8n_get_workflow', 'n8n_get_workflow_structure', 'n8n_update_partial_workflow']
-  }
-};

src/mcp/tool-docs/workflow_management/n8n-get-workflow-structure.ts

@@ -1,49 +0,0 @@
-import { ToolDocumentation } from '../types';
-
-export const n8nGetWorkflowStructureDoc: ToolDocumentation = {
-  name: 'n8n_get_workflow_structure',
-  category: 'workflow_management',
-  essentials: {
-    description: 'Get workflow structure: nodes and connections only. No parameter details.',
-    keyParameters: ['id'],
-    example: 'n8n_get_workflow_structure({id: "workflow_123"})',
-    performance: 'Fast (75-150ms)',
-    tips: [
-      'Shows workflow topology',
-      'Node types without parameters',
-      'Perfect for visualization'
-    ]
-  },
-  full: {
-    description: 'Retrieves workflow structural information including node types, positions, and connections, but without detailed node parameters. Ideal for understanding workflow topology, creating visualizations, or analyzing workflow complexity without the overhead of full parameter data.',
-    parameters: {
-      id: { type: 'string', required: true, description: 'Workflow ID to retrieve structure for' }
-    },
-    returns: 'Workflow structure with: id, name, nodes array (id, name, type, position only), connections object. No node parameters, credentials, or settings included.',
-    examples: [
-      'n8n_get_workflow_structure({id: "abc123"}) - Visualize workflow',
-      'const structure = n8n_get_workflow_structure({id: "xyz789"}); // Analyze complexity'
-    ],
-    useCases: [
-      'Generate workflow visualizations',
-      'Analyze workflow complexity',
-      'Understand node relationships',
-      'Create workflow diagrams',
-      'Quick topology validation'
-    ],
-    performance: 'Fast retrieval - typically 75-150ms. Faster than get_workflow as parameters are stripped.',
-    bestPractices: [
-      'Use for visualization tools',
-      'Ideal for workflow analysis',
-      'Good for connection validation',
-      'Cache for UI diagram rendering'
-    ],
-    pitfalls: [
-      'Requires N8N_API_URL and N8N_API_KEY configured',
-      'No parameter data for configuration',
-      'Cannot validate node settings',
-      'Must use get_workflow for editing'
-    ],
-    relatedTools: ['n8n_get_workflow', 'n8n_validate_workflow_connections', 'n8n_get_workflow_minimal', 'validate_workflow_connections']
-  }
-};

src/mcp/tool-docs/workflow_management/n8n-get-workflow.ts

@@ -4,46 +4,63 @@ export const n8nGetWorkflowDoc: ToolDocumentation = {
   name: 'n8n_get_workflow',
   category: 'workflow_management',
   essentials: {
-    description: 'Get a workflow by ID. Returns the complete workflow including nodes, connections, and settings.',
-    keyParameters: ['id'],
-    example: 'n8n_get_workflow({id: "workflow_123"})',
+    description: 'Get workflow by ID with different detail levels. Use mode to control response size and content.',
+    keyParameters: ['id', 'mode'],
+    example: 'n8n_get_workflow({id: "workflow_123", mode: "structure"})',
     performance: 'Fast (50-200ms)',
     tips: [
-      'Returns complete workflow JSON',
-      'Includes all node parameters',
-      'Use get_workflow_minimal for faster listings'
+      'mode="full" (default): Complete workflow with all data',
+      'mode="details": Full workflow + execution stats',
+      'mode="structure": Just nodes and connections (topology)',
+      'mode="minimal": Only id, name, active status, tags'
     ]
   },
   full: {
-    description: 'Retrieves a complete workflow from n8n by its ID. Returns full workflow definition including all nodes with their parameters, connections between nodes, and workflow settings. This is the primary tool for fetching workflows for viewing, editing, or cloning.',
+    description: `**Modes:**
+- full (default): Complete workflow including all nodes with parameters, connections, and settings
+- details: Full workflow plus execution statistics (success/error counts, last execution time)
+- structure: Nodes and connections only - useful for topology analysis
+- minimal: Just id, name, active status, and tags - fastest response`,
     parameters: {
-      id: { type: 'string', required: true, description: 'Workflow ID to retrieve' }
+      id: { type: 'string', required: true, description: 'Workflow ID to retrieve' },
+      mode: { type: 'string', required: false, description: 'Detail level: "full" (default), "details", "structure", "minimal"' }
     },
-    returns: 'Complete workflow object containing: id, name, active status, nodes array (with full parameters), connections object, settings, createdAt, updatedAt',
+    returns: `Depends on mode:
+- full: Complete workflow object (id, name, active, nodes[], connections{}, settings, createdAt, updatedAt)
+- details: Full workflow + executionStats (successCount, errorCount, lastExecution, etc.)
+- structure: { nodes: [...], connections: {...} } - topology only
+- minimal: { id, name, active, tags, createdAt, updatedAt }`,
     examples: [
-      'n8n_get_workflow({id: "abc123"}) - Get workflow for editing',
-      'const wf = n8n_get_workflow({id: "xyz789"}); // Clone workflow structure'
+      '// Get complete workflow (default)\nn8n_get_workflow({id: "abc123"})',
+      '// Get workflow with execution stats\nn8n_get_workflow({id: "abc123", mode: "details"})',
+      '// Get just the topology\nn8n_get_workflow({id: "abc123", mode: "structure"})',
+      '// Quick metadata check\nn8n_get_workflow({id: "abc123", mode: "minimal"})'
     ],
     useCases: [
-      'View workflow configuration',
-      'Export workflow for backup',
-      'Clone workflow structure',
-      'Debug workflow issues',
-      'Prepare for updates'
+      'View and edit workflow (mode=full)',
+      'Analyze workflow performance (mode=details)',
+      'Clone or compare workflow structure (mode=structure)',
+      'List workflows with status (mode=minimal)',
+      'Debug workflow issues'
     ],
-    performance: 'Fast retrieval - typically 50-200ms depending on workflow size. Cached by n8n for performance.',
+    performance: `Response times vary by mode:
+- minimal: ~20-50ms (smallest response)
+- structure: ~30-80ms (nodes + connections only)
+- full: ~50-200ms (complete workflow)
+- details: ~100-300ms (includes execution queries)`,
     bestPractices: [
-      'Check workflow exists before updating',
-      'Use for complete workflow data needs',
-      'Cache results when making multiple operations',
-      'Validate after retrieving if modifying'
+      'Use mode="minimal" when listing or checking status',
+      'Use mode="structure" for workflow analysis or cloning',
+      'Use mode="full" (default) when editing',
+      'Use mode="details" for debugging execution issues',
+      'Validate workflow after retrieval if planning modifications'
     ],
     pitfalls: [
       'Requires N8N_API_URL and N8N_API_KEY configured',
-      'Returns all data - use minimal/structure for performance',
-      'Workflow must exist or returns 404',
-      'Credentials are referenced but not included'
+      'mode="details" adds database queries for execution stats',
+      'Workflow must exist or returns 404 error',
+      'Credentials are referenced by ID but values not included'
     ],
-    relatedTools: ['n8n_get_workflow_minimal', 'n8n_get_workflow_structure', 'n8n_update_full_workflow', 'n8n_validate_workflow']
+    relatedTools: ['n8n_list_workflows', 'n8n_update_full_workflow', 'n8n_update_partial_workflow', 'n8n_validate_workflow']
   }
 };

src/mcp/tool-docs/workflow_management/n8n-list-executions.ts

@@ -1,84 +0,0 @@
-import { ToolDocumentation } from '../types';
-
-export const n8nListExecutionsDoc: ToolDocumentation = {
-  name: 'n8n_list_executions',
-  category: 'workflow_management',
-  essentials: {
-    description: 'List workflow executions with optional filters. Supports pagination for large result sets.',
-    keyParameters: ['workflowId', 'status', 'limit'],
-    example: 'n8n_list_executions({workflowId: "abc123", status: "error"})',
-    performance: 'Fast metadata retrieval, use pagination for large datasets',
-    tips: [
-      'Filter by status (success/error/waiting) to find specific execution types',
-      'Use workflowId to see all executions for a specific workflow',
-      'Pagination via cursor allows retrieving large execution histories'
-    ]
-  },
-  full: {
-    description: `Lists workflow executions with powerful filtering options. This tool is essential for monitoring workflow performance, finding failed executions, and tracking workflow activity. Supports pagination for retrieving large execution histories and filtering by workflow, status, and project.`,
-    parameters: {
-      limit: {
-        type: 'number',
-        required: false,
-        description: 'Number of executions to return (1-100, default: 100). Use with cursor for pagination'
-      },
-      cursor: {
-        type: 'string',
-        required: false,
-        description: 'Pagination cursor from previous response. Used to retrieve next page of results'
-      },
-      workflowId: {
-        type: 'string',
-        required: false,
-        description: 'Filter executions by specific workflow ID. Shows all executions for that workflow'
-      },
-      projectId: {
-        type: 'string',
-        required: false,
-        description: 'Filter by project ID (enterprise feature). Groups executions by project'
-      },
-      status: {
-        type: 'string',
-        required: false,
-        enum: ['success', 'error', 'waiting'],
-        description: 'Filter by execution status. Success = completed, Error = failed, Waiting = running'
-      },
-      includeData: {
-        type: 'boolean',
-        required: false,
-        description: 'Include execution data in results (default: false). Significantly increases response size'
-      }
-    },
-    returns: `Array of execution objects with metadata, pagination cursor for next page, and optionally execution data. Each execution includes ID, status, start/end times, and workflow reference.`,
-    examples: [
-      'n8n_list_executions({limit: 10}) - Get 10 most recent executions',
-      'n8n_list_executions({workflowId: "abc123"}) - All executions for specific workflow',
-      'n8n_list_executions({status: "error", limit: 50}) - Find failed executions',
-      'n8n_list_executions({status: "waiting"}) - Monitor currently running workflows',
-      'n8n_list_executions({cursor: "next-page-token"}) - Get next page of results'
-    ],
-    useCases: [
-      'Monitor workflow execution history and patterns',
-      'Find and debug failed workflow executions',
-      'Track currently running workflows (waiting status)',
-      'Analyze workflow performance and execution frequency',
-      'Generate execution reports for specific workflows'
-    ],
-    performance: `Listing executions is fast for metadata only. Including data (includeData: true) significantly impacts performance. Use pagination (limit + cursor) for large result sets. Default limit of 100 balances performance with usability.`,
-    bestPractices: [
-      'Use status filters to focus on specific execution types',
-      'Implement pagination for large execution histories',
-      'Avoid includeData unless you need execution details',
-      'Filter by workflowId when monitoring specific workflows',
-      'Check for cursor in response to detect more pages'
-    ],
-    pitfalls: [
-      'Large limits with includeData can cause timeouts',
-      'Execution retention depends on n8n configuration',
-      'Cursor tokens expire - use them promptly',
-      'Status "waiting" includes both running and queued executions',
-      'Deleted workflows still show in execution history'
-    ],
-    relatedTools: ['n8n_get_execution', 'n8n_trigger_webhook_workflow', 'n8n_delete_execution', 'n8n_list_workflows']
-  }
-};

src/mcp/tool-docs/workflow_management/n8n-list-workflows.ts

@@ -50,6 +50,6 @@ export const n8nListWorkflowsDoc: ToolDocumentation = {
       'Server may return fewer than requested limit',
       'returned field is count of current page only, not system total'
     ],
-    relatedTools: ['n8n_get_workflow_minimal', 'n8n_get_workflow', 'n8n_update_partial_workflow', 'n8n_list_executions']
+    relatedTools: ['n8n_get_workflow', 'n8n_update_partial_workflow', 'n8n_executions']
   }
 };

src/mcp/tool-docs/workflow_management/n8n-test-workflow.ts

@@ -0,0 +1,138 @@
+import { ToolDocumentation } from '../types';
+
+export const n8nTestWorkflowDoc: ToolDocumentation = {
+  name: 'n8n_test_workflow',
+  category: 'workflow_management',
+  essentials: {
+    description: 'Test/trigger workflow execution. Auto-detects trigger type (webhook/form/chat). Only workflows with these triggers can be executed externally.',
+    keyParameters: ['workflowId', 'triggerType', 'data', 'message'],
+    example: 'n8n_test_workflow({workflowId: "123"}) - auto-detect trigger',
+    performance: 'Immediate trigger, response time depends on workflow complexity',
+    tips: [
+      'Auto-detects trigger type from workflow if not specified',
+      'Workflow must have a webhook, form, or chat trigger to be executable',
+      'For chat triggers, message is required',
+      'All trigger types require the workflow to be ACTIVE'
+    ]
+  },
+  full: {
+    description: `Test and trigger n8n workflows through HTTP-based methods. This unified tool supports multiple trigger types:
+
+**Trigger Types:**
+- **webhook**: HTTP-based triggers (GET/POST/PUT/DELETE)
+- **form**: Form submission triggers
+- **chat**: AI chat triggers with conversation support
+
+**Important:** n8n's public API does not support direct workflow execution. Only workflows with webhook, form, or chat triggers can be executed externally. Workflows with schedule, manual, or other trigger types cannot be triggered via this API.
+
+The tool auto-detects the appropriate trigger type by analyzing the workflow's trigger node. You can override this with the triggerType parameter.`,
+    parameters: {
+      workflowId: {
+        type: 'string',
+        required: true,
+        description: 'Workflow ID to execute'
+      },
+      triggerType: {
+        type: 'string',
+        required: false,
+        enum: ['webhook', 'form', 'chat'],
+        description: 'Trigger type. Auto-detected if not specified. Workflow must have matching trigger node.'
+      },
+      httpMethod: {
+        type: 'string',
+        required: false,
+        enum: ['GET', 'POST', 'PUT', 'DELETE'],
+        description: 'For webhook: HTTP method (default: from workflow config or POST)'
+      },
+      webhookPath: {
+        type: 'string',
+        required: false,
+        description: 'For webhook: override the webhook path'
+      },
+      message: {
+        type: 'string',
+        required: false,
+        description: 'For chat: message to send (required for chat triggers)'
+      },
+      sessionId: {
+        type: 'string',
+        required: false,
+        description: 'For chat: session ID for conversation continuity'
+      },
+      data: {
+        type: 'object',
+        required: false,
+        description: 'Input data/payload for webhook or form fields'
+      },
+      headers: {
+        type: 'object',
+        required: false,
+        description: 'Custom HTTP headers'
+      },
+      timeout: {
+        type: 'number',
+        required: false,
+        description: 'Timeout in ms (default: 120000)'
+      },
+      waitForResponse: {
+        type: 'boolean',
+        required: false,
+        description: 'Wait for workflow completion (default: true)'
+      }
+    },
+    returns: `Execution response including:
+- success: boolean
+- data: workflow output data
+- executionId: for tracking/debugging
+- triggerType: detected or specified trigger type
+- metadata: timing and request details`,
+    examples: [
+      'n8n_test_workflow({workflowId: "123"}) - Auto-detect and trigger',
+      'n8n_test_workflow({workflowId: "123", triggerType: "webhook", data: {name: "John"}}) - Webhook with data',
+      'n8n_test_workflow({workflowId: "123", triggerType: "chat", message: "Hello AI"}) - Chat trigger',
+      'n8n_test_workflow({workflowId: "123", triggerType: "form", data: {email: "test@example.com"}}) - Form submission'
+    ],
+    useCases: [
+      'Test workflows during development',
+      'Trigger AI chat workflows with messages',
+      'Submit form data to form-triggered workflows',
+      'Integrate n8n workflows with external systems via webhooks'
+    ],
+    performance: `Performance varies based on workflow complexity and waitForResponse setting:
+- Webhook: Immediate trigger, depends on workflow
+- Form: Immediate trigger, depends on workflow
+- Chat: May have additional AI processing time`,
+    errorHandling: `**Error Response with Execution Guidance**
+
+When execution fails, the response includes guidance for debugging:
+
+**With Execution ID** (workflow started but failed):
+- Use n8n_executions({action: 'get', id: executionId, mode: 'preview'}) to investigate
+
+**Without Execution ID** (workflow didn't start):
+- Use n8n_executions({action: 'list', workflowId: 'wf_id'}) to find recent executions
+
+**Common Errors:**
+- "Workflow not found" - Check workflow ID exists
+- "Workflow not active" - Activate workflow (required for all trigger types)
+- "Workflow cannot be triggered externally" - Workflow has no webhook/form/chat trigger
+- "Chat message required" - Provide message parameter for chat triggers
+- "SSRF protection" - URL validation failed`,
+    bestPractices: [
+      'Let auto-detection choose the trigger type when possible',
+      'Ensure workflow has a webhook, form, or chat trigger before testing',
+      'For chat workflows, provide sessionId for multi-turn conversations',
+      'Use mode="preview" with n8n_executions for efficient debugging',
+      'Test with small data payloads first',
+      'Activate workflows before testing (use n8n_update_partial_workflow with activateWorkflow)'
+    ],
+    pitfalls: [
+      'All trigger types require the workflow to be ACTIVE',
+      'Workflows without webhook/form/chat triggers cannot be executed externally',
+      'Chat trigger requires message parameter',
+      'Form data must match expected form fields',
+      'Webhook method must match node configuration'
+    ],
+    relatedTools: ['n8n_executions', 'n8n_get_workflow', 'n8n_create_workflow', 'n8n_validate_workflow']
+  }
+};

src/mcp/tool-docs/workflow_management/n8n-trigger-webhook-workflow.ts

@@ -1,118 +0,0 @@
-import { ToolDocumentation } from '../types';
-
-export const n8nTriggerWebhookWorkflowDoc: ToolDocumentation = {
-  name: 'n8n_trigger_webhook_workflow',
-  category: 'workflow_management',
-  essentials: {
-    description: 'Trigger workflow via webhook. Must be ACTIVE with Webhook node. Method must match config.',
-    keyParameters: ['webhookUrl', 'httpMethod', 'data'],
-    example: 'n8n_trigger_webhook_workflow({webhookUrl: "https://n8n.example.com/webhook/abc-def-ghi"})',
-    performance: 'Immediate trigger, response time depends on workflow complexity',
-    tips: [
-      'Workflow MUST be active and contain a Webhook node for triggering',
-      'HTTP method must match webhook node configuration (often GET)',
-      'Use waitForResponse:false for async execution without waiting'
-    ]
-  },
-  full: {
-    description: `Triggers a workflow execution via its webhook URL. This is the primary method for external systems to start n8n workflows. The target workflow must be active and contain a properly configured Webhook node as the trigger. The HTTP method used must match the webhook configuration.`,
-    parameters: {
-      webhookUrl: {
-        type: 'string',
-        required: true,
-        description: 'Full webhook URL from n8n workflow (e.g., https://n8n.example.com/webhook/abc-def-ghi)'
-      },
-      httpMethod: {
-        type: 'string',
-        required: false,
-        enum: ['GET', 'POST', 'PUT', 'DELETE'],
-        description: 'HTTP method (must match webhook configuration, often GET). Defaults to GET if not specified'
-      },
-      data: {
-        type: 'object',
-        required: false,
-        description: 'Data to send with the webhook request. For GET requests, becomes query parameters'
-      },
-      headers: {
-        type: 'object',
-        required: false,
-        description: 'Additional HTTP headers to include in the request'
-      },
-      waitForResponse: {
-        type: 'boolean',
-        required: false,
-        description: 'Wait for workflow completion and return results (default: true). Set to false for fire-and-forget'
-      }
-    },
-    returns: `Webhook response data if waitForResponse is true, or immediate acknowledgment if false. Response format depends on webhook node configuration.`,
-    examples: [
-      'n8n_trigger_webhook_workflow({webhookUrl: "https://n8n.example.com/webhook/order-process"}) - Trigger with GET',
-      'n8n_trigger_webhook_workflow({webhookUrl: "https://n8n.example.com/webhook/data-import", httpMethod: "POST", data: {name: "John", email: "john@example.com"}}) - POST with data',
-      'n8n_trigger_webhook_workflow({webhookUrl: "https://n8n.example.com/webhook/async-job", waitForResponse: false}) - Fire and forget',
-      'n8n_trigger_webhook_workflow({webhookUrl: "https://n8n.example.com/webhook/api", headers: {"API-Key": "secret"}}) - With auth headers'
-    ],
-    useCases: [
-      'Trigger data processing workflows from external applications',
-      'Start scheduled jobs manually via webhook',
-      'Integrate n8n workflows with third-party services',
-      'Create REST API endpoints using n8n workflows',
-      'Implement event-driven architectures with n8n'
-    ],
-    performance: `Performance varies based on workflow complexity and waitForResponse setting. Synchronous calls (waitForResponse: true) block until workflow completes. For long-running workflows, use async mode (waitForResponse: false) and monitor execution separately.`,
-    errorHandling: `**Enhanced Error Messages with Execution Guidance**
-
-When a webhook trigger fails, the error response now includes specific guidance to help debug the issue:
-
-**Error with Execution ID** (workflow started but failed):
-- Format: "Workflow {workflowId} execution {executionId} failed. Use n8n_get_execution({id: '{executionId}', mode: 'preview'}) to investigate the error."
-- Response includes: executionId and workflowId fields for direct access
-- Recommended action: Use n8n_get_execution with mode='preview' for fast, efficient error inspection
-
-**Error without Execution ID** (workflow didn't start):
-- Format: "Workflow failed to execute. Use n8n_list_executions to find recent executions, then n8n_get_execution with mode='preview' to investigate."
-- Recommended action: Check recent executions with n8n_list_executions
-
-**Why mode='preview'?**
-- Fast: <50ms response time
-- Efficient: ~500 tokens (vs 50K+ for full mode)
-- Safe: No timeout or token limit risks
-- Informative: Shows structure, counts, and error details
-- Provides recommendations for fetching more data if needed
-
-**Example Error Responses**:
-\`\`\`json
-{
-  "success": false,
-  "error": "Workflow wf_123 execution exec_456 failed. Use n8n_get_execution({id: 'exec_456', mode: 'preview'}) to investigate the error.",
-  "executionId": "exec_456",
-  "workflowId": "wf_123",
-  "code": "SERVER_ERROR"
-}
-\`\`\`
-
-**Investigation Workflow**:
-1. Trigger returns error with execution ID
-2. Call n8n_get_execution({id: executionId, mode: 'preview'}) to see structure and error
-3. Based on preview recommendation, fetch more data if needed
-4. Fix issues in workflow and retry`,
-    bestPractices: [
-      'Always verify workflow is active before attempting webhook triggers',
-      'Match HTTP method exactly with webhook node configuration',
-      'Use async mode (waitForResponse: false) for long-running workflows',
-      'Include authentication headers when webhook requires them',
-      'Test webhook URL manually first to ensure it works',
-      'When errors occur, use n8n_get_execution with mode="preview" first for efficient debugging',
-      'Store execution IDs from error responses for later investigation'
-    ],
-    pitfalls: [
-      'Workflow must be ACTIVE - inactive workflows cannot be triggered',
-      'HTTP method mismatch returns 404 even if URL is correct',
-      'Webhook node must be the trigger node in the workflow',
-      'Timeout errors occur with long workflows in sync mode',
-      'Data format must match webhook node expectations',
-      'Error messages always include n8n_get_execution guidance - follow the suggested steps for efficient debugging',
-      'Execution IDs in error responses are crucial for debugging - always check for and use them'
-    ],
-    relatedTools: ['n8n_get_execution', 'n8n_list_executions', 'n8n_get_workflow', 'n8n_create_workflow']
-  }
-};

src/mcp/tool-docs/workflow_management/n8n-update-partial-workflow.ts

@@ -90,7 +90,6 @@ Full support for all 8 AI connection types used in n8n AI workflows:
 
 **Important Notes**:
 - **AI nodes do NOT require main connections**: Nodes like OpenAI Chat Model, Postgres Chat Memory, Embeddings OpenAI, and Supabase Vector Store use AI-specific connection types exclusively. They should ONLY have connections like \`ai_languageModel\`, \`ai_memory\`, \`ai_embedding\`, or \`ai_tool\` - NOT \`main\` connections.
-- **Fixed in v2.21.1**: Validation now correctly recognizes AI nodes that only have AI-specific connections without requiring \`main\` connections (resolves issue #357).
 
 **Best Practices**:
 - Always specify \`sourceOutput\` for AI connections (defaults to "main" if omitted)

src/mcp/tool-docs/workflow_management/n8n-validate-workflow.ts

@@ -66,6 +66,6 @@ Requires N8N_API_URL and N8N_API_KEY environment variables to be configured.`,
       'Profile affects validation time - strict is slower but more thorough',
       'Expression validation may flag working but non-standard syntax'
     ],
-    relatedTools: ['validate_workflow', 'n8n_get_workflow', 'validate_workflow_expressions', 'n8n_health_check', 'n8n_autofix_workflow']
+    relatedTools: ['validate_workflow', 'n8n_get_workflow', 'n8n_health_check', 'n8n_autofix_workflow']
   }
 };

src/mcp/tool-docs/workflow_management/n8n-workflow-versions.ts

@@ -0,0 +1,168 @@
+import { ToolDocumentation } from '../types';
+
+export const n8nWorkflowVersionsDoc: ToolDocumentation = {
+  name: 'n8n_workflow_versions',
+  category: 'workflow_management',
+  essentials: {
+    description: 'Manage workflow version history, rollback to previous versions, and cleanup old versions',
+    keyParameters: ['mode', 'workflowId', 'versionId'],
+    example: 'n8n_workflow_versions({mode: "list", workflowId: "abc123"})',
+    performance: 'Fast for list/get (~100ms), moderate for rollback (~200-500ms)',
+    tips: [
+      'Use mode="list" to see all saved versions before rollback',
+      'Rollback creates a backup version automatically',
+      'Use prune to clean up old versions and save storage',
+      'truncate requires explicit confirmTruncate: true'
+    ]
+  },
+  full: {
+    description: `Comprehensive workflow version management system. Supports six operations:
+
+**list** - Show version history for a workflow
+- Returns all saved versions with timestamps, snapshot sizes, and metadata
+- Use limit parameter to control how many versions to return
+
+**get** - Get details of a specific version
+- Returns the complete workflow snapshot from that version
+- Use to compare versions or extract old configurations
+
+**rollback** - Restore workflow to a previous version
+- Creates a backup of the current workflow before rollback
+- Optionally validates the workflow structure before applying
+- Returns the restored workflow and backup version ID
+
+**delete** - Delete specific version(s)
+- Delete a single version by versionId
+- Delete all versions for a workflow with deleteAll: true
+
+**prune** - Clean up old versions
+- Keeps only the N most recent versions (default: 10)
+- Useful for managing storage and keeping history manageable
+
+**truncate** - Delete ALL versions for ALL workflows
+- Dangerous operation requiring explicit confirmation
+- Use for complete version history cleanup`,
+    parameters: {
+      mode: {
+        type: 'string',
+        required: true,
+        description: 'Operation mode: "list", "get", "rollback", "delete", "prune", or "truncate"',
+        enum: ['list', 'get', 'rollback', 'delete', 'prune', 'truncate']
+      },
+      workflowId: {
+        type: 'string',
+        required: false,
+        description: 'Workflow ID (required for list, rollback, delete, prune modes)'
+      },
+      versionId: {
+        type: 'number',
+        required: false,
+        description: 'Version ID (required for get mode, optional for rollback to specific version, required for single delete)'
+      },
+      limit: {
+        type: 'number',
+        required: false,
+        default: 10,
+        description: 'Maximum versions to return in list mode'
+      },
+      validateBefore: {
+        type: 'boolean',
+        required: false,
+        default: true,
+        description: 'Validate workflow structure before rollback (rollback mode only)'
+      },
+      deleteAll: {
+        type: 'boolean',
+        required: false,
+        default: false,
+        description: 'Delete all versions for workflow (delete mode only)'
+      },
+      maxVersions: {
+        type: 'number',
+        required: false,
+        default: 10,
+        description: 'Keep N most recent versions (prune mode only)'
+      },
+      confirmTruncate: {
+        type: 'boolean',
+        required: false,
+        default: false,
+        description: 'REQUIRED: Must be true to truncate all versions (truncate mode only)'
+      }
+    },
+    returns: `Response varies by mode:
+
+**list mode:**
+- versions: Array of version objects with id, workflowId, snapshotSize, createdAt
+- totalCount: Total number of versions
+
+**get mode:**
+- version: Complete version object including workflow snapshot
+
+**rollback mode:**
+- success: Boolean indicating success
+- restoredVersion: The version that was restored
+- backupVersionId: ID of the backup created before rollback
+
+**delete mode:**
+- deletedCount: Number of versions deleted
+
+**prune mode:**
+- prunedCount: Number of old versions removed
+- remainingCount: Number of versions kept
+
+**truncate mode:**
+- deletedCount: Total versions deleted across all workflows`,
+    examples: [
+      '// List version history\nn8n_workflow_versions({mode: "list", workflowId: "abc123", limit: 5})',
+      '// Get specific version details\nn8n_workflow_versions({mode: "get", versionId: 42})',
+      '// Rollback to latest saved version\nn8n_workflow_versions({mode: "rollback", workflowId: "abc123"})',
+      '// Rollback to specific version\nn8n_workflow_versions({mode: "rollback", workflowId: "abc123", versionId: 42})',
+      '// Delete specific version\nn8n_workflow_versions({mode: "delete", workflowId: "abc123", versionId: 42})',
+      '// Delete all versions for workflow\nn8n_workflow_versions({mode: "delete", workflowId: "abc123", deleteAll: true})',
+      '// Prune to keep only 5 most recent\nn8n_workflow_versions({mode: "prune", workflowId: "abc123", maxVersions: 5})',
+      '// Truncate all versions (dangerous!)\nn8n_workflow_versions({mode: "truncate", confirmTruncate: true})'
+    ],
+    useCases: [
+      'Recover from accidental workflow changes',
+      'Compare workflow versions to understand changes',
+      'Maintain audit trail of workflow modifications',
+      'Clean up old versions to save database storage',
+      'Roll back failed workflow deployments'
+    ],
+    performance: `Performance varies by operation:
+- list: Fast (~100ms) - simple database query
+- get: Fast (~100ms) - single row retrieval
+- rollback: Moderate (~200-500ms) - includes backup creation and workflow update
+- delete: Fast (~50-100ms) - database delete operation
+- prune: Moderate (~100-300ms) - depends on number of versions to delete
+- truncate: Slow (1-5s) - deletes all records across all workflows`,
+    modeComparison: `| Mode | Required Params | Optional Params | Risk Level |
+|------|-----------------|-----------------|------------|
+| list | workflowId | limit | Low |
+| get | versionId | - | Low |
+| rollback | workflowId | versionId, validateBefore | Medium |
+| delete | workflowId | versionId, deleteAll | High |
+| prune | workflowId | maxVersions | Medium |
+| truncate | confirmTruncate=true | - | Critical |`,
+    bestPractices: [
+      'Always list versions before rollback to pick the right one',
+      'Enable validateBefore for rollback to catch structural issues',
+      'Use prune regularly to keep version history manageable',
+      'Never use truncate in production without explicit need',
+      'Document why you are rolling back for audit purposes'
+    ],
+    pitfalls: [
+      'Rollback overwrites current workflow - backup is created automatically',
+      'Deleted versions cannot be recovered',
+      'Truncate affects ALL workflows - use with extreme caution',
+      'Version IDs are sequential but may have gaps after deletes',
+      'Large workflows may have significant version storage overhead'
+    ],
+    relatedTools: [
+      'n8n_get_workflow - View current workflow state',
+      'n8n_update_partial_workflow - Make incremental changes',
+      'n8n_validate_workflow - Validate before deployment'
+    ]
+  }
+};

src/mcp/tools-documentation.ts

@@ -84,57 +84,67 @@ When working with Code nodes, always start by calling the relevant guide:
 
 ## Standard Workflow Pattern
 
-⚠️ **CRITICAL**: Always call get_node_essentials() FIRST before configuring any node!
+⚠️ **CRITICAL**: Always call get_node() with detail='standard' FIRST before configuring any node!
 
 1. **Find** the node you need:
    - search_nodes({query: "slack"}) - Search by keyword
-   - list_nodes({category: "communication"}) - List by category
-   - list_ai_tools() - List AI-capable nodes
+   - search_nodes({query: "communication"}) - Search by category name
+   - search_nodes({query: "AI langchain"}) - Search for AI-capable nodes
 
-2. **Configure** the node (ALWAYS START WITH ESSENTIALS):
-   - ✅ get_node_essentials("nodes-base.slack") - Get essential properties FIRST (5KB, shows required fields)
-   - get_node_info("nodes-base.slack") - Get complete schema only if essentials insufficient (100KB+)
-   - search_node_properties("nodes-base.slack", "auth") - Find specific properties
+2. **Configure** the node (ALWAYS START WITH STANDARD DETAIL):
+   - ✅ get_node({nodeType: "nodes-base.slack", detail: "standard"}) - Get essential properties FIRST (~1-2KB, shows required fields)
+   - get_node({nodeType: "nodes-base.slack", detail: "full"}) - Get complete schema only if standard insufficient (~100KB+)
+   - get_node({nodeType: "nodes-base.slack", mode: "docs"}) - Get readable markdown documentation
+   - get_node({nodeType: "nodes-base.slack", mode: "search_properties", propertyQuery: "auth"}) - Find specific properties
 
 3. **Validate** before deployment:
-   - validate_node_minimal("nodes-base.slack", config) - Check required fields
-   - validate_node_operation("nodes-base.slack", config) - Full validation with fixes
-   - validate_workflow(workflow) - Validate entire workflow
+   - validate_node({nodeType: "nodes-base.slack", config: {...}, mode: "minimal"}) - Quick required fields check
+   - validate_node({nodeType: "nodes-base.slack", config: {...}}) - Full validation with errors/warnings/suggestions
+   - validate_workflow({workflow: {...}}) - Validate entire workflow
 
-## Tool Categories
+## Tool Categories (19 Tools Total)
 
-**Discovery Tools**
-- search_nodes - Full-text search across all nodes
-- list_nodes - List nodes with filtering by category, package, or type
-- list_ai_tools - List all AI-capable nodes with usage guidance
+**Discovery Tools** (1 tool)
+- search_nodes - Full-text search across all nodes (supports OR, AND, FUZZY modes)
 
-**Configuration Tools**
-- get_node_essentials - ✅ CALL THIS FIRST! Returns 10-20 key properties with examples and required fields
-- get_node_info - Returns complete node schema (only use if essentials is insufficient)
-- search_node_properties - Search for specific properties within a node
-- get_property_dependencies - Analyze property visibility dependencies
+**Configuration Tools** (1 consolidated tool)
+- get_node - Unified node information tool:
+  - detail='minimal'/'standard'/'full': Progressive detail levels
+  - mode='docs': Readable markdown documentation
+  - mode='search_properties': Find specific properties
+  - mode='versions'/'compare'/'breaking'/'migrations': Version management
 
-**Validation Tools**
-- validate_node_minimal - Quick validation of required fields only
-- validate_node_operation - Full validation with operation awareness
-- validate_workflow - Complete workflow validation including connections
+**Validation Tools** (2 tools)
+- validate_node - Unified validation with mode='full' or mode='minimal'
+- validate_workflow - Complete workflow validation (nodes, connections, expressions)
 
-**Template Tools**
-- list_tasks - List common task templates
-- get_node_for_task - Get pre-configured node for specific tasks
-- search_templates - Search workflow templates by keyword
+**Template Tools** (2 tools)
 - get_template - Get complete workflow JSON by ID
+- search_templates - Unified template search:
+  - searchMode='keyword': Text search (default)
+  - searchMode='by_nodes': Find templates using specific nodes
+  - searchMode='by_task': Curated task-based templates
+  - searchMode='by_metadata': Filter by complexity/services
 
-**n8n API Tools** (requires N8N_API_URL configuration)
+**n8n API Tools** (13 tools, requires N8N_API_URL configuration)
 - n8n_create_workflow - Create new workflows
-- n8n_update_partial_workflow - Update workflows using diff operations
-- n8n_validate_workflow - Validate workflow from n8n instance
-- n8n_trigger_webhook_workflow - Trigger workflow execution
+- n8n_get_workflow - Get workflow with mode='full'/'details'/'structure'/'minimal'
+- n8n_update_full_workflow - Full workflow replacement
+- n8n_update_partial_workflow - Incremental diff-based updates
+- n8n_delete_workflow - Delete workflow
+- n8n_list_workflows - List workflows with filters
+- n8n_validate_workflow - Validate workflow by ID
+- n8n_autofix_workflow - Auto-fix common issues
+- n8n_test_workflow - Test/trigger workflows (webhook, form, chat, execute)
+- n8n_executions - Unified execution management (action='get'/'list'/'delete')
+- n8n_health_check - Check n8n API connectivity
+- n8n_workflow_versions - Version history and rollback
+- n8n_deploy_template - Deploy templates directly to n8n instance
 
 ## Performance Characteristics
-- Instant (<10ms): search_nodes, list_nodes, get_node_essentials
-- Fast (<100ms): validate_node_minimal, get_node_for_task
-- Moderate (100-500ms): validate_workflow, get_node_info
+- Instant (<10ms): search_nodes, get_node (minimal/standard)
+- Fast (<100ms): validate_node, get_template
+- Moderate (100-500ms): validate_workflow, get_node (full detail)
 - Network-dependent: All n8n_* tools
 
 For comprehensive documentation on any tool:
@@ -167,7 +177,7 @@ ${tools.map(toolName => {
 
 ## Usage Notes
 - All node types require the "nodes-base." or "nodes-langchain." prefix
-- Use get_node_essentials() first for most tasks (95% smaller than get_node_info)
+- Use get_node() with detail='standard' first for most tasks (~95% smaller than detail='full')
 - Validation profiles: minimal (editing), runtime (default), strict (deployment)
 - n8n API tools only available when N8N_API_URL and N8N_API_KEY are configured
 
@@ -413,8 +423,8 @@ try {
 5. Use descriptive variable names
 
 ## Related Tools
-- get_node_essentials("nodes-base.code")
-- validate_node_operation()
+- get_node({nodeType: "nodes-base.code"}) - Get Code node configuration details
+- validate_node({nodeType: "nodes-base.code", config: {...}}) - Validate Code node setup
 - python_code_node_guide (for Python syntax)`;
 }
 
@@ -682,7 +692,7 @@ except json.JSONDecodeError:
 \`\`\`
 
 ## Related Tools
-- get_node_essentials("nodes-base.code")
-- validate_node_operation()
+- get_node({nodeType: "nodes-base.code"}) - Get Code node configuration details
+- validate_node({nodeType: "nodes-base.code", config: {...}}) - Validate Code node setup
 - javascript_code_node_guide (for JavaScript syntax)`;
 }

src/mcp/tools-n8n-friendly.ts

@@ -13,25 +13,18 @@ export const n8nFriendlyDescriptions: Record<string, {
   description: string;
   params: Record<string, string>;
 }> = {
-  // Validation tools - most prone to errors
-  validate_node_operation: {
-    description: 'Validate n8n node. ALWAYS pass two parameters: nodeType (string) and config (object). Example call: {"nodeType": "nodes-base.slack", "config": {"resource": "channel", "operation": "create"}}',
+  // Consolidated validation tool (replaces validate_node_operation and validate_node_minimal)
+  validate_node: {
+    description: 'Validate n8n node config. Pass nodeType (string) and config (object). Use mode="full" for comprehensive validation, mode="minimal" for quick check. Example: {"nodeType": "nodes-base.slack", "config": {"resource": "channel", "operation": "create"}}',
     params: {
       nodeType: 'String value like "nodes-base.slack"',
       config: 'Object value like {"resource": "channel", "operation": "create"} or empty object {}',
+      mode: 'Optional string: "full" (default) or "minimal"',
       profile: 'Optional string: "minimal" or "runtime" or "ai-friendly" or "strict"'
     }
   },
-  
-  validate_node_minimal: {
-    description: 'Check required fields. MUST pass: nodeType (string) and config (object). Example: {"nodeType": "nodes-base.webhook", "config": {}}',
-    params: {
-      nodeType: 'String like "nodes-base.webhook"',
-      config: 'Object, use {} for empty'
-    }
-  },
-  
-  // Search and info tools
+
+  // Search tool
   search_nodes: {
     description: 'Search nodes. Pass query (string). Example: {"query": "webhook"}',
     params: {
@@ -39,98 +32,53 @@ export const n8nFriendlyDescriptions: Record<string, {
       limit: 'Optional number, default 20'
     }
   },
-  
-  get_node_info: {
-    description: 'Get node details. Pass nodeType (string). Example: {"nodeType": "nodes-base.httpRequest"}',
+
+  // Consolidated node info tool (replaces get_node_info, get_node_essentials, get_node_documentation, search_node_properties)
+  get_node: {
+    description: 'Get node info with multiple modes. Pass nodeType (string). Use mode="info" for config, mode="docs" for documentation, mode="search_properties" with propertyQuery for finding fields. Example: {"nodeType": "nodes-base.httpRequest", "detail": "standard"}',
     params: {
-      nodeType: 'String with prefix like "nodes-base.httpRequest"'
+      nodeType: 'String with prefix like "nodes-base.httpRequest"',
+      mode: 'Optional string: "info" (default), "docs", "search_properties", "versions", "compare", "breaking", "migrations"',
+      detail: 'Optional string: "minimal", "standard" (default), "full"',
+      propertyQuery: 'For mode="search_properties": search term like "auth"'
     }
   },
-  
-  get_node_essentials: {
-    description: 'Get node basics. Pass nodeType (string). Example: {"nodeType": "nodes-base.slack"}',
-    params: {
-      nodeType: 'String with prefix like "nodes-base.slack"'
-    }
-  },
-  
-  // Task tools
-  get_node_for_task: {
-    description: 'Find node for task. Pass task (string). Example: {"task": "send_http_request"}',
-    params: {
-      task: 'String task name like "send_http_request"'
-    }
-  },
-  
-  list_tasks: {
-    description: 'List tasks by category. Pass category (string). Example: {"category": "HTTP/API"}',
-    params: {
-      category: 'String: "HTTP/API" or "Webhooks" or "Database" or "AI/LangChain" or "Data Processing" or "Communication"'
-    }
-  },
-  
+
   // Workflow validation
   validate_workflow: {
-    description: 'Validate workflow. Pass workflow object. MUST have: {"workflow": {"nodes": [array of node objects], "connections": {object with node connections}}}. Each node needs: name, type, typeVersion, position.',
+    description: 'Validate workflow structure, connections, and expressions. Pass workflow object. MUST have: {"workflow": {"nodes": [array of node objects], "connections": {object with node connections}}}. Each node needs: name, type, typeVersion, position.',
     params: {
       workflow: 'Object with two required fields: nodes (array) and connections (object). Example: {"nodes": [{"name": "Webhook", "type": "n8n-nodes-base.webhook", "typeVersion": 2, "position": [250, 300], "parameters": {}}], "connections": {}}',
-      options: 'Optional object. Example: {"validateNodes": true, "profile": "runtime"}'
+      options: 'Optional object. Example: {"validateNodes": true, "validateConnections": true, "validateExpressions": true, "profile": "runtime"}'
     }
   },
-  
-  validate_workflow_connections: {
-    description: 'Validate workflow connections only. Pass workflow object. Example: {"workflow": {"nodes": [...], "connections": {}}}',
-    params: {
-      workflow: 'Object with nodes array and connections object. Minimal example: {"nodes": [{"name": "Webhook"}], "connections": {}}'
-    }
-  },
-  
-  validate_workflow_expressions: {
-    description: 'Validate n8n expressions in workflow. Pass workflow object. Example: {"workflow": {"nodes": [...], "connections": {}}}',
-    params: {
-      workflow: 'Object with nodes array and connections object containing n8n expressions like {{ $json.data }}'
-    }
-  },
-  
-  // Property tools
-  get_property_dependencies: {
-    description: 'Get field dependencies. Pass nodeType (string) and optional config (object). Example: {"nodeType": "nodes-base.httpRequest", "config": {}}',
-    params: {
-      nodeType: 'String like "nodes-base.httpRequest"',
-      config: 'Optional object, use {} for empty'
-    }
-  },
-  
-  // AI tool info
-  get_node_as_tool_info: {
-    description: 'Get AI tool usage. Pass nodeType (string). Example: {"nodeType": "nodes-base.slack"}',
-    params: {
-      nodeType: 'String with prefix like "nodes-base.slack"'
-    }
-  },
-  
-  // Template tools
+
+  // Consolidated template search (replaces search_templates, list_node_templates, search_templates_by_metadata, get_templates_for_task)
   search_templates: {
-    description: 'Search workflow templates. Pass query (string). Example: {"query": "chatbot"}',
+    description: 'Search workflow templates with multiple modes. Use searchMode="keyword" for text search, searchMode="by_nodes" to find by node types, searchMode="by_task" for task-based templates, searchMode="by_metadata" for filtering. Example: {"query": "chatbot"} or {"searchMode": "by_task", "task": "webhook_processing"}',
     params: {
-      query: 'String keyword like "chatbot" or "webhook"',
+      query: 'For searchMode="keyword": string keyword like "chatbot"',
+      searchMode: 'Optional: "keyword" (default), "by_nodes", "by_task", "by_metadata"',
+      nodeTypes: 'For searchMode="by_nodes": array like ["n8n-nodes-base.httpRequest"]',
+      task: 'For searchMode="by_task": task like "webhook_processing", "ai_automation"',
       limit: 'Optional number, default 20'
     }
   },
-  
+
   get_template: {
     description: 'Get template by ID. Pass templateId (number). Example: {"templateId": 1234}',
     params: {
-      templateId: 'Number ID like 1234'
+      templateId: 'Number ID like 1234',
+      mode: 'Optional: "full" (default), "nodes_only", "structure"'
     }
   },
-  
+
   // Documentation tool
   tools_documentation: {
     description: 'Get tool docs. Pass optional depth (string). Example: {"depth": "essentials"} or {}',
     params: {
-      depth: 'Optional string: "essentials" or "overview" or "detailed"',
-      topic: 'Optional string topic name'
+      depth: 'Optional string: "essentials" (default) or "full"',
+      topic: 'Optional string tool name like "search_nodes"'
     }
   }
 };

src/mcp/tools-n8n-manager.ts

@@ -70,55 +70,19 @@ export const n8nManagementTools: ToolDefinition[] = [
   },
   {
     name: 'n8n_get_workflow',
-    description: `Get a workflow by ID. Returns the complete workflow including nodes, connections, and settings.`,
+    description: `Get workflow by ID with different detail levels. Use mode='full' for complete workflow, 'details' for metadata+stats, 'structure' for nodes/connections only, 'minimal' for id/name/active/tags.`,
     inputSchema: {
       type: 'object',
       properties: {
-        id: { 
-          type: 'string', 
-          description: 'Workflow ID' 
-        }
-      },
-      required: ['id']
-    }
-  },
-  {
-    name: 'n8n_get_workflow_details',
-    description: `Get workflow details with metadata, version, execution stats. More info than get_workflow.`,
-    inputSchema: {
-      type: 'object',
-      properties: {
-        id: { 
-          type: 'string', 
-          description: 'Workflow ID' 
-        }
-      },
-      required: ['id']
-    }
-  },
-  {
-    name: 'n8n_get_workflow_structure',
-    description: `Get workflow structure: nodes and connections only. No parameter details.`,
-    inputSchema: {
-      type: 'object',
-      properties: {
-        id: { 
-          type: 'string', 
-          description: 'Workflow ID' 
-        }
-      },
-      required: ['id']
-    }
-  },
-  {
-    name: 'n8n_get_workflow_minimal',
-    description: `Get minimal info: ID, name, active status, tags. Fast for listings.`,
-    inputSchema: {
-      type: 'object',
-      properties: {
-        id: { 
-          type: 'string', 
-          description: 'Workflow ID' 
+        id: {
+          type: 'string',
+          description: 'Workflow ID'
+        },
+        mode: {
+          type: 'string',
+          enum: ['full', 'details', 'structure', 'minimal'],
+          default: 'full',
+          description: 'Detail level: full=complete workflow, details=full+execution stats, structure=nodes/connections topology, minimal=metadata only'
         }
       },
       required: ['id']
@@ -312,153 +276,142 @@ export const n8nManagementTools: ToolDefinition[] = [
 
   // Execution Management Tools
   {
-    name: 'n8n_trigger_webhook_workflow',
-    description: `Trigger workflow via webhook. Must be ACTIVE with Webhook node. Method must match config.`,
+    name: 'n8n_test_workflow',
+    description: `Test/trigger workflow execution. Auto-detects trigger type (webhook/form/chat). Supports: webhook (HTTP), form (fields), chat (message). Note: Only workflows with these trigger types can be executed externally.`,
     inputSchema: {
       type: 'object',
       properties: {
-        webhookUrl: { 
-          type: 'string', 
-          description: 'Full webhook URL from n8n workflow (e.g., https://n8n.example.com/webhook/abc-def-ghi)' 
+        workflowId: {
+          type: 'string',
+          description: 'Workflow ID to execute (required)'
         },
-        httpMethod: { 
-          type: 'string', 
+        triggerType: {
+          type: 'string',
+          enum: ['webhook', 'form', 'chat'],
+          description: 'Trigger type. Auto-detected if not specified. Workflow must have a matching trigger node.'
+        },
+        // Webhook options
+        httpMethod: {
+          type: 'string',
           enum: ['GET', 'POST', 'PUT', 'DELETE'],
-          description: 'HTTP method (must match webhook configuration, often GET)' 
+          description: 'For webhook: HTTP method (default: from workflow config or POST)'
         },
-        data: { 
-          type: 'object', 
-          description: 'Data to send with the webhook request' 
+        webhookPath: {
+          type: 'string',
+          description: 'For webhook: override the webhook path'
         },
-        headers: { 
-          type: 'object', 
-          description: 'Additional HTTP headers' 
+        // Chat options
+        message: {
+          type: 'string',
+          description: 'For chat: message to send (required for chat triggers)'
         },
-        waitForResponse: { 
-          type: 'boolean', 
-          description: 'Wait for workflow completion (default: true)' 
+        sessionId: {
+          type: 'string',
+          description: 'For chat: session ID for conversation continuity'
+        },
+        // Common options
+        data: {
+          type: 'object',
+          description: 'Input data/payload for webhook, form fields, or execution data'
+        },
+        headers: {
+          type: 'object',
+          description: 'Custom HTTP headers'
+        },
+        timeout: {
+          type: 'number',
+          description: 'Timeout in ms (default: 120000)'
+        },
+        waitForResponse: {
+          type: 'boolean',
+          description: 'Wait for workflow completion (default: true)'
         }
       },
-      required: ['webhookUrl']
+      required: ['workflowId']
     }
   },
   {
-    name: 'n8n_get_execution',
-    description: `Get execution details with smart filtering. RECOMMENDED: Use mode='preview' first to assess data size.
-Examples:
-- {id, mode:'preview'} - Structure & counts (fast, no data)
-- {id, mode:'summary'} - 2 samples per node (default)
-- {id, mode:'filtered', itemsLimit:5} - 5 items per node
-- {id, nodeNames:['HTTP Request']} - Specific node only
-- {id, mode:'full'} - Complete data (use with caution)`,
+    name: 'n8n_executions',
+    description: `Manage workflow executions: get details, list, or delete. Use action='get' with id for execution details, action='list' for listing executions, action='delete' to remove execution record.`,
     inputSchema: {
       type: 'object',
       properties: {
+        action: {
+          type: 'string',
+          enum: ['get', 'list', 'delete'],
+          description: 'Operation: get=get execution details, list=list executions, delete=delete execution'
+        },
+        // For action='get' and action='delete'
         id: {
           type: 'string',
-          description: 'Execution ID'
+          description: 'Execution ID (required for action=get or action=delete)'
         },
+        // For action='get' - detail level
         mode: {
           type: 'string',
           enum: ['preview', 'summary', 'filtered', 'full'],
-          description: 'Data retrieval mode: preview=structure only, summary=2 items, filtered=custom, full=all data'
+          description: 'For action=get: preview=structure only, summary=2 items (default), filtered=custom, full=all data'
         },
         nodeNames: {
           type: 'array',
           items: { type: 'string' },
-          description: 'Filter to specific nodes by name (for filtered mode)'
+          description: 'For action=get with mode=filtered: filter to specific nodes by name'
         },
         itemsLimit: {
           type: 'number',
-          description: 'Items per node: 0=structure only, 2=default, -1=unlimited (for filtered mode)'
+          description: 'For action=get with mode=filtered: items per node (0=structure, 2=default, -1=unlimited)'
         },
         includeInputData: {
           type: 'boolean',
-          description: 'Include input data in addition to output (default: false)'
+          description: 'For action=get: include input data in addition to output (default: false)'
+        },
+        // For action='list'
+        limit: {
+          type: 'number',
+          description: 'For action=list: number of executions to return (1-100, default: 100)'
+        },
+        cursor: {
+          type: 'string',
+          description: 'For action=list: pagination cursor from previous response'
+        },
+        workflowId: {
+          type: 'string',
+          description: 'For action=list: filter by workflow ID'
+        },
+        projectId: {
+          type: 'string',
+          description: 'For action=list: filter by project ID (enterprise feature)'
+        },
+        status: {
+          type: 'string',
+          enum: ['success', 'error', 'waiting'],
+          description: 'For action=list: filter by execution status'
         },
         includeData: {
           type: 'boolean',
-          description: 'Legacy: Include execution data. Maps to mode=summary if true (deprecated, use mode instead)'
+          description: 'For action=list: include execution data (default: false)'
         }
       },
-      required: ['id']
-    }
-  },
-  {
-    name: 'n8n_list_executions',
-    description: `List workflow executions (returns up to limit). Check hasMore/nextCursor for pagination.`,
-    inputSchema: {
-      type: 'object',
-      properties: {
-        limit: { 
-          type: 'number', 
-          description: 'Number of executions to return (1-100, default: 100)' 
-        },
-        cursor: { 
-          type: 'string', 
-          description: 'Pagination cursor from previous response' 
-        },
-        workflowId: { 
-          type: 'string', 
-          description: 'Filter by workflow ID' 
-        },
-        projectId: { 
-          type: 'string', 
-          description: 'Filter by project ID (enterprise feature)' 
-        },
-        status: { 
-          type: 'string', 
-          enum: ['success', 'error', 'waiting'],
-          description: 'Filter by execution status' 
-        },
-        includeData: { 
-          type: 'boolean', 
-          description: 'Include execution data (default: false)' 
-        }
-      }
-    }
-  },
-  {
-    name: 'n8n_delete_execution',
-    description: `Delete an execution record. This only removes the execution history, not any data processed.`,
-    inputSchema: {
-      type: 'object',
-      properties: {
-        id: { 
-          type: 'string', 
-          description: 'Execution ID to delete' 
-        }
-      },
-      required: ['id']
+      required: ['action']
     }
   },
 
   // System Tools
   {
     name: 'n8n_health_check',
-    description: `Check n8n instance health and API connectivity. Returns status and available features.`,
-    inputSchema: {
-      type: 'object',
-      properties: {}
-    }
-  },
-  {
-    name: 'n8n_list_available_tools',
-    description: `List available n8n tools and capabilities.`,
-    inputSchema: {
-      type: 'object',
-      properties: {}
-    }
-  },
-  {
-    name: 'n8n_diagnostic',
-    description: `Diagnose n8n API config. Shows tool status, API connectivity, env vars. Helps troubleshoot missing tools.`,
+    description: `Check n8n instance health and API connectivity. Use mode='diagnostic' for detailed troubleshooting with env vars and tool status.`,
     inputSchema: {
       type: 'object',
       properties: {
+        mode: {
+          type: 'string',
+          enum: ['status', 'diagnostic'],
+          description: 'Mode: "status" (default) for quick health check, "diagnostic" for detailed debug info including env vars and tool status',
+          default: 'status'
+        },
         verbose: {
           type: 'boolean',
-          description: 'Include detailed debug information (default: false)'
+          description: 'Include extra details in diagnostic mode (default: false)'
         }
       }
     }
@@ -516,5 +469,40 @@ Examples:
       },
       required: ['mode']
     }
+  },
+
+  // Template Deployment Tool
+  {
+    name: 'n8n_deploy_template',
+    description: `Deploy a workflow template from n8n.io directly to your n8n instance. Deploys first, then auto-fixes common issues (expression format, typeVersions). Returns workflow ID, required credentials, and fixes applied.`,
+    inputSchema: {
+      type: 'object',
+      properties: {
+        templateId: {
+          type: 'number',
+          description: 'Template ID from n8n.io (required)'
+        },
+        name: {
+          type: 'string',
+          description: 'Custom workflow name (default: template name)'
+        },
+        autoUpgradeVersions: {
+          type: 'boolean',
+          default: true,
+          description: 'Automatically upgrade node typeVersions to latest supported (default: true)'
+        },
+        autoFix: {
+          type: 'boolean',
+          default: true,
+          description: 'Auto-apply fixes after deployment for expression format issues, missing = prefix, etc. (default: true)'
+        },
+        stripCredentials: {
+          type: 'boolean',
+          default: true,
+          description: 'Remove credential references from nodes - user configures in n8n UI (default: true)'
+        }
+      },
+      required: ['templateId']
+    }
   }
 ];

src/mcp/tools.ts

@@ -26,51 +26,6 @@ export const n8nDocumentationToolsFinal: ToolDefinition[] = [
       },
     },
   },
-  {
-    name: 'list_nodes',
-    description: `List n8n nodes. Common: list_nodes({limit:200}) for all, list_nodes({category:'trigger'}) for triggers. Package: "n8n-nodes-base" or "@n8n/n8n-nodes-langchain". Categories: trigger/transform/output/input.`,
-    inputSchema: {
-      type: 'object',
-      properties: {
-        package: {
-          type: 'string',
-          description: '"n8n-nodes-base" (core) or "@n8n/n8n-nodes-langchain" (AI)',
-        },
-        category: {
-          type: 'string',
-          description: 'trigger|transform|output|input|AI',
-        },
-        developmentStyle: {
-          type: 'string',
-          enum: ['declarative', 'programmatic'],
-          description: 'Usually "programmatic"',
-        },
-        isAITool: {
-          type: 'boolean',
-          description: 'Filter AI-capable nodes',
-        },
-        limit: {
-          type: 'number',
-          description: 'Max results (default 50, use 200+ for all)',
-          default: 50,
-        },
-      },
-    },
-  },
-  {
-    name: 'get_node_info',
-    description: `Get full node documentation. Pass nodeType as string with prefix. Example: nodeType="nodes-base.webhook"`,
-    inputSchema: {
-      type: 'object',
-      properties: {
-        nodeType: {
-          type: 'string',
-          description: 'Full type: "nodes-base.{name}" or "nodes-langchain.{name}". Examples: nodes-base.httpRequest, nodes-base.webhook, nodes-base.slack',
-        },
-      },
-      required: ['nodeType'],
-    },
-  },
   {
     name: 'search_nodes',
     description: `Search n8n nodes by keyword with optional real-world examples. Pass query as string. Example: query="webhook" or query="database". Returns max 20 results. Use includeExamples=true to get top 2 template configs per node.`,
@@ -102,93 +57,61 @@ export const n8nDocumentationToolsFinal: ToolDefinition[] = [
     },
   },
   {
-    name: 'list_ai_tools',
-    description: `List 263 AI-optimized nodes. Note: ANY node can be AI tool! Connect any node to AI Agent's tool port. Community nodes need N8N_COMMUNITY_PACKAGES_ALLOW_TOOL_USAGE=true.`,
-    inputSchema: {
-      type: 'object',
-      properties: {},
-    },
-  },
-  {
-    name: 'get_node_documentation',
-    description: `Get readable docs with examples/auth/patterns. Better than raw schema! 87% coverage. Format: "nodes-base.slack"`,
+    name: 'get_node',
+    description: `Get node info with progressive detail levels and multiple modes. Detail: minimal (~200 tokens), standard (~1-2K, default), full (~3-8K). Modes: info (default), docs (markdown documentation), search_properties (find properties), versions/compare/breaking/migrations (version info). Use format='docs' for readable documentation, mode='search_properties' with propertyQuery for finding specific fields.`,
     inputSchema: {
       type: 'object',
       properties: {
         nodeType: {
           type: 'string',
-          description: 'Full type with prefix: "nodes-base.slack"',
+          description: 'Full node type: "nodes-base.httpRequest" or "nodes-langchain.agent"',
         },
-      },
-      required: ['nodeType'],
-    },
-  },
-  {
-    name: 'get_database_statistics',
-    description: `Node stats: 525 total, 263 AI tools, 104 triggers, 87% docs coverage. Verifies MCP working.`,
-    inputSchema: {
-      type: 'object',
-      properties: {},
-    },
-  },
-  {
-    name: 'get_node_essentials',
-    description: `Get node essential info with optional real-world examples from templates. Pass nodeType as string with prefix. Example: nodeType="nodes-base.slack". Use includeExamples=true to get top 3 template configs.`,
-    inputSchema: {
-      type: 'object',
-      properties: {
-        nodeType: {
+        detail: {
           type: 'string',
-          description: 'Full type: "nodes-base.httpRequest"',
+          enum: ['minimal', 'standard', 'full'],
+          default: 'standard',
+          description: 'Information detail level. standard=essential properties (recommended), full=everything',
+        },
+        mode: {
+          type: 'string',
+          enum: ['info', 'docs', 'search_properties', 'versions', 'compare', 'breaking', 'migrations'],
+          default: 'info',
+          description: 'Operation mode. info=node schema, docs=readable markdown documentation, search_properties=find specific properties, versions/compare/breaking/migrations=version info',
+        },
+        includeTypeInfo: {
+          type: 'boolean',
+          default: false,
+          description: 'Include type structure metadata (type category, JS type, validation rules). Only applies to mode=info. Adds ~80-120 tokens per property.',
         },
         includeExamples: {
           type: 'boolean',
-          description: 'Include top 3 real-world configuration examples from popular templates (default: false)',
           default: false,
+          description: 'Include real-world configuration examples from templates. Only applies to mode=info with detail=standard. Adds ~200-400 tokens per example.',
+        },
+        fromVersion: {
+          type: 'string',
+          description: 'Source version for compare/breaking/migrations modes (e.g., "1.0")',
+        },
+        toVersion: {
+          type: 'string',
+          description: 'Target version for compare mode (e.g., "2.0"). Defaults to latest if omitted.',
+        },
+        propertyQuery: {
+          type: 'string',
+          description: 'For mode=search_properties: search term to find properties (e.g., "auth", "header", "body")',
+        },
+        maxPropertyResults: {
+          type: 'number',
+          description: 'For mode=search_properties: max results (default 20)',
+          default: 20,
         },
       },
       required: ['nodeType'],
     },
   },
   {
-    name: 'search_node_properties',
-    description: `Find specific properties in a node (auth, headers, body, etc). Returns paths and descriptions.`,
-    inputSchema: {
-      type: 'object',
-      properties: {
-        nodeType: {
-          type: 'string',
-          description: 'Full type with prefix',
-        },
-        query: {
-          type: 'string',
-          description: 'Property to find: "auth", "header", "body", "json"',
-        },
-        maxResults: {
-          type: 'number',
-          description: 'Max results (default 20)',
-          default: 20,
-        },
-      },
-      required: ['nodeType', 'query'],
-    },
-  },
-  {
-    name: 'list_tasks',
-    description: `List task templates by category: HTTP/API, Webhooks, Database, AI, Data Processing, Communication.`,
-    inputSchema: {
-      type: 'object',
-      properties: {
-        category: {
-          type: 'string',
-          description: 'Filter by category (optional)',
-        },
-      },
-    },
-  },
-  {
-    name: 'validate_node_operation',
-    description: `Validate n8n node configuration. Pass nodeType as string and config as object. Example: nodeType="nodes-base.slack", config={resource:"channel",operation:"create"}`,
+    name: 'validate_node',
+    description: `Validate n8n node configuration. Use mode='full' for comprehensive validation with errors/warnings/suggestions, mode='minimal' for quick required fields check. Example: nodeType="nodes-base.slack", config={resource:"channel",operation:"create"}`,
     inputSchema: {
       type: 'object',
       properties: {
@@ -200,10 +123,16 @@ export const n8nDocumentationToolsFinal: ToolDefinition[] = [
           type: 'object',
           description: 'Configuration as object. For simple nodes use {}. For complex nodes include fields like {resource:"channel",operation:"create"}',
         },
+        mode: {
+          type: 'string',
+          enum: ['full', 'minimal'],
+          description: 'Validation mode. full=comprehensive validation with errors/warnings/suggestions, minimal=quick required fields check only. Default is "full"',
+          default: 'full',
+        },
         profile: {
           type: 'string',
           enum: ['strict', 'runtime', 'ai-friendly', 'minimal'],
-          description: 'Profile string: "minimal", "runtime", "ai-friendly", or "strict". Default is "ai-friendly"',
+          description: 'Profile for mode=full: "minimal", "runtime", "ai-friendly", or "strict". Default is "ai-friendly"',
           default: 'ai-friendly',
         },
       },
@@ -242,6 +171,11 @@ export const n8nDocumentationToolsFinal: ToolDefinition[] = [
           }
         },
         suggestions: { type: 'array', items: { type: 'string' } },
+        missingRequiredFields: {
+          type: 'array',
+          items: { type: 'string' },
+          description: 'Only present in mode=minimal'
+        },
         summary: {
           type: 'object',
           properties: {
@@ -252,132 +186,7 @@ export const n8nDocumentationToolsFinal: ToolDefinition[] = [
           }
         }
       },
-      required: ['nodeType', 'displayName', 'valid', 'errors', 'warnings', 'suggestions', 'summary']
-    },
-  },
-  {
-    name: 'validate_node_minimal',
-    description: `Check n8n node required fields. Pass nodeType as string and config as empty object {}. Example: nodeType="nodes-base.webhook", config={}`,
-    inputSchema: {
-      type: 'object',
-      properties: {
-        nodeType: {
-          type: 'string',
-          description: 'Node type as string. Example: "nodes-base.slack"',
-        },
-        config: {
-          type: 'object',
-          description: 'Configuration object. Always pass {} for empty config',
-        },
-      },
-      required: ['nodeType', 'config'],
-      additionalProperties: false,
-    },
-    outputSchema: {
-      type: 'object',
-      properties: {
-        nodeType: { type: 'string' },
-        displayName: { type: 'string' },
-        valid: { type: 'boolean' },
-        missingRequiredFields: {
-          type: 'array',
-          items: { type: 'string' }
-        }
-      },
-      required: ['nodeType', 'displayName', 'valid', 'missingRequiredFields']
-    },
-  },
-  {
-    name: 'get_property_dependencies',
-    description: `Shows property dependencies and visibility rules. Example: sendBody=true reveals body fields. Test visibility with optional config.`,
-    inputSchema: {
-      type: 'object',
-      properties: {
-        nodeType: {
-          type: 'string',
-          description: 'The node type to analyze (e.g., "nodes-base.httpRequest")',
-        },
-        config: {
-          type: 'object',
-          description: 'Optional partial configuration to check visibility impact',
-        },
-      },
-      required: ['nodeType'],
-    },
-  },
-  {
-    name: 'get_node_as_tool_info',
-    description: `How to use ANY node as AI tool. Shows requirements, use cases, examples. Works for all nodes, not just AI-marked ones.`,
-    inputSchema: {
-      type: 'object',
-      properties: {
-        nodeType: {
-          type: 'string',
-          description: 'Full node type WITH prefix: "nodes-base.slack", "nodes-base.googleSheets", etc.',
-        },
-      },
-      required: ['nodeType'],
-    },
-  },
-  {
-    name: 'list_templates',
-    description: `List all templates with minimal data (id, name, description, views, node count). Optionally include AI-generated metadata for smart filtering.`,
-    inputSchema: {
-      type: 'object',
-      properties: {
-        limit: {
-          type: 'number',
-          description: 'Number of results (1-100). Default 10.',
-          default: 10,
-          minimum: 1,
-          maximum: 100,
-        },
-        offset: {
-          type: 'number',
-          description: 'Pagination offset. Default 0.',
-          default: 0,
-          minimum: 0,
-        },
-        sortBy: {
-          type: 'string',
-          enum: ['views', 'created_at', 'name'],
-          description: 'Sort field. Default: views (popularity).',
-          default: 'views',
-        },
-        includeMetadata: {
-          type: 'boolean',
-          description: 'Include AI-generated metadata (categories, complexity, setup time, etc.). Default false.',
-          default: false,
-        },
-      },
-    },
-  },
-  {
-    name: 'list_node_templates',
-    description: `Find templates using specific nodes. Returns paginated results. Use FULL types: "n8n-nodes-base.httpRequest".`,
-    inputSchema: {
-      type: 'object',
-      properties: {
-        nodeTypes: {
-          type: 'array',
-          items: { type: 'string' },
-          description: 'Array of node types to search for (e.g., ["n8n-nodes-base.httpRequest", "n8n-nodes-base.openAi"])',
-        },
-        limit: {
-          type: 'number',
-          description: 'Maximum number of templates to return. Default 10.',
-          default: 10,
-          minimum: 1,
-          maximum: 100,
-        },
-        offset: {
-          type: 'number',
-          description: 'Pagination offset. Default 0.',
-          default: 0,
-          minimum: 0,
-        },
-      },
-      required: ['nodeTypes'],
+      required: ['nodeType', 'displayName', 'valid']
     },
   },
   {
@@ -402,13 +211,20 @@ export const n8nDocumentationToolsFinal: ToolDefinition[] = [
   },
   {
     name: 'search_templates',
-    description: `Search templates by name/description keywords. Returns paginated results. NOT for node types! For nodes use list_node_templates.`,
+    description: `Search templates with multiple modes. Use searchMode='keyword' for text search, 'by_nodes' to find templates using specific nodes, 'by_task' for curated task-based templates, 'by_metadata' for filtering by complexity/setup time/services.`,
     inputSchema: {
       type: 'object',
       properties: {
+        searchMode: {
+          type: 'string',
+          enum: ['keyword', 'by_nodes', 'by_task', 'by_metadata'],
+          description: 'Search mode. keyword=text search (default), by_nodes=find by node types, by_task=curated task templates, by_metadata=filter by complexity/services',
+          default: 'keyword',
+        },
+        // For searchMode='keyword'
         query: {
           type: 'string',
-          description: 'Search keyword as string. Example: "chatbot"',
+          description: 'For searchMode=keyword: search keyword (e.g., "chatbot")',
         },
         fields: {
           type: 'array',
@@ -416,36 +232,20 @@ export const n8nDocumentationToolsFinal: ToolDefinition[] = [
             type: 'string',
             enum: ['id', 'name', 'description', 'author', 'nodes', 'views', 'created', 'url', 'metadata'],
           },
-          description: 'Fields to include in response. Default: all fields. Example: ["id", "name"] for minimal response.',
+          description: 'For searchMode=keyword: fields to include in response. Default: all fields.',
         },
-        limit: {
-          type: 'number',
-          description: 'Maximum number of results. Default 20.',
-          default: 20,
-          minimum: 1,
-          maximum: 100,
+        // For searchMode='by_nodes'
+        nodeTypes: {
+          type: 'array',
+          items: { type: 'string' },
+          description: 'For searchMode=by_nodes: array of node types (e.g., ["n8n-nodes-base.httpRequest", "n8n-nodes-base.slack"])',
         },
-        offset: {
-          type: 'number',
-          description: 'Pagination offset. Default 0.',
-          default: 0,
-          minimum: 0,
-        },
-      },
-      required: ['query'],
-    },
-  },
-  {
-    name: 'get_templates_for_task',
-    description: `Curated templates by task. Returns paginated results sorted by popularity.`,
-    inputSchema: {
-      type: 'object',
-      properties: {
+        // For searchMode='by_task'
         task: {
           type: 'string',
           enum: [
             'ai_automation',
-            'data_sync', 
+            'data_sync',
             'webhook_processing',
             'email_automation',
             'slack_integration',
@@ -455,60 +255,39 @@ export const n8nDocumentationToolsFinal: ToolDefinition[] = [
             'api_integration',
             'database_operations'
           ],
-          description: 'The type of task to get templates for',
+          description: 'For searchMode=by_task: the type of task',
         },
-        limit: {
-          type: 'number',
-          description: 'Maximum number of results. Default 10.',
-          default: 10,
-          minimum: 1,
-          maximum: 100,
-        },
-        offset: {
-          type: 'number',
-          description: 'Pagination offset. Default 0.',
-          default: 0,
-          minimum: 0,
-        },
-      },
-      required: ['task'],
-    },
-  },
-  {
-    name: 'search_templates_by_metadata',
-    description: `Search templates by AI-generated metadata. Filter by category, complexity, setup time, services, or audience. Returns rich metadata for smart template discovery.`,
-    inputSchema: {
-      type: 'object',
-      properties: {
+        // For searchMode='by_metadata'
         category: {
           type: 'string',
-          description: 'Filter by category (e.g., "automation", "integration", "data processing")',
+          description: 'For searchMode=by_metadata: filter by category (e.g., "automation", "integration")',
         },
         complexity: {
           type: 'string',
           enum: ['simple', 'medium', 'complex'],
-          description: 'Filter by complexity level',
+          description: 'For searchMode=by_metadata: filter by complexity level',
         },
         maxSetupMinutes: {
           type: 'number',
-          description: 'Maximum setup time in minutes',
+          description: 'For searchMode=by_metadata: maximum setup time in minutes',
           minimum: 5,
           maximum: 480,
         },
         minSetupMinutes: {
           type: 'number',
-          description: 'Minimum setup time in minutes',
+          description: 'For searchMode=by_metadata: minimum setup time in minutes',
           minimum: 5,
           maximum: 480,
         },
         requiredService: {
           type: 'string',
-          description: 'Filter by required service (e.g., "openai", "slack", "google")',
+          description: 'For searchMode=by_metadata: filter by required service (e.g., "openai", "slack")',
         },
         targetAudience: {
           type: 'string',
-          description: 'Filter by target audience (e.g., "developers", "marketers", "analysts")',
+          description: 'For searchMode=by_metadata: filter by target audience (e.g., "developers", "marketers")',
         },
+        // Common pagination
         limit: {
           type: 'number',
           description: 'Maximum number of results. Default 20.',
@@ -523,7 +302,6 @@ export const n8nDocumentationToolsFinal: ToolDefinition[] = [
           minimum: 0,
         },
       },
-      additionalProperties: false,
     },
   },
   {
@@ -611,143 +389,43 @@ export const n8nDocumentationToolsFinal: ToolDefinition[] = [
       required: ['valid', 'summary']
     },
   },
-  {
-    name: 'validate_workflow_connections',
-    description: `Check workflow connections only: valid nodes, no cycles, proper triggers, AI tool links. Fast structure validation.`,
-    inputSchema: {
-      type: 'object',
-      properties: {
-        workflow: {
-          type: 'object',
-          description: 'The workflow JSON with nodes array and connections object.',
-        },
-      },
-      required: ['workflow'],
-      additionalProperties: false,
-    },
-    outputSchema: {
-      type: 'object',
-      properties: {
-        valid: { type: 'boolean' },
-        statistics: {
-          type: 'object',
-          properties: {
-            totalNodes: { type: 'number' },
-            triggerNodes: { type: 'number' },
-            validConnections: { type: 'number' },
-            invalidConnections: { type: 'number' }
-          }
-        },
-        errors: {
-          type: 'array',
-          items: {
-            type: 'object',
-            properties: {
-              node: { type: 'string' },
-              message: { type: 'string' }
-            }
-          }
-        },
-        warnings: {
-          type: 'array',
-          items: {
-            type: 'object',
-            properties: {
-              node: { type: 'string' },
-              message: { type: 'string' }
-            }
-          }
-        }
-      },
-      required: ['valid', 'statistics']
-    },
-  },
-  {
-    name: 'validate_workflow_expressions',
-    description: `Validate n8n expressions: syntax {{}}, variables ($json/$node), references. Returns errors with locations.`,
-    inputSchema: {
-      type: 'object',
-      properties: {
-        workflow: {
-          type: 'object',
-          description: 'The workflow JSON to check for expression errors.',
-        },
-      },
-      required: ['workflow'],
-      additionalProperties: false,
-    },
-    outputSchema: {
-      type: 'object',
-      properties: {
-        valid: { type: 'boolean' },
-        statistics: {
-          type: 'object',
-          properties: {
-            totalNodes: { type: 'number' },
-            expressionsValidated: { type: 'number' }
-          }
-        },
-        errors: {
-          type: 'array',
-          items: {
-            type: 'object',
-            properties: {
-              node: { type: 'string' },
-              message: { type: 'string' }
-            }
-          }
-        },
-        warnings: {
-          type: 'array',
-          items: {
-            type: 'object',
-            properties: {
-              node: { type: 'string' },
-              message: { type: 'string' }
-            }
-          }
-        },
-        tips: { type: 'array', items: { type: 'string' } }
-      },
-      required: ['valid', 'statistics']
-    },
-  },
 ];
 
 /**
  * QUICK REFERENCE for AI Agents:
- * 
+ *
  * 1. RECOMMENDED WORKFLOW:
- *    - Start: search_nodes → get_node_essentials → get_node_for_task → validate_node_operation
- *    - Discovery: list_nodes({category:"trigger"}) for browsing categories
- *    - Quick Config: get_node_essentials("nodes-base.httpRequest") - only essential properties
- *    - Full Details: get_node_info only when essentials aren't enough
- *    - Validation: Use validate_node_operation for complex nodes (Slack, Google Sheets, etc.)
- * 
+ *    - Start: search_nodes → get_node → validate_node
+ *    - Discovery: search_nodes({query:"trigger"}) for finding nodes
+ *    - Quick Config: get_node("nodes-base.httpRequest", {detail:"standard"}) - only essential properties
+ *    - Documentation: get_node("nodes-base.httpRequest", {mode:"docs"}) - readable markdown docs
+ *    - Find Properties: get_node("nodes-base.httpRequest", {mode:"search_properties", propertyQuery:"auth"})
+ *    - Full Details: get_node with detail="full" only when standard isn't enough
+ *    - Validation: Use validate_node for complex nodes (Slack, Google Sheets, etc.)
+ *
  * 2. COMMON NODE TYPES:
  *    Triggers: webhook, schedule, emailReadImap, slackTrigger
  *    Core: httpRequest, code, set, if, merge, splitInBatches
  *    Integrations: slack, gmail, googleSheets, postgres, mongodb
  *    AI: agent, openAi, chainLlm, documentLoader
- * 
+ *
  * 3. SEARCH TIPS:
  *    - search_nodes returns ANY word match (OR logic)
  *    - Single words more precise, multiple words broader
- *    - If no results: use list_nodes with category filter
- * 
+ *    - If no results: try different keywords or partial names
+ *
  * 4. TEMPLATE SEARCHING:
  *    - search_templates("slack") searches template names/descriptions, NOT node types!
- *    - To find templates using Slack node: list_node_templates(["n8n-nodes-base.slack"])
- *    - For task-based templates: get_templates_for_task("slack_integration")
- *    - 399 templates available from the last year
- * 
+ *    - To find templates using Slack node: search_templates({searchMode:"by_nodes", nodeTypes:["n8n-nodes-base.slack"]})
+ *    - For task-based templates: search_templates({searchMode:"by_task", task:"slack_integration"})
+ *
  * 5. KNOWN ISSUES:
  *    - Some nodes have duplicate properties with different conditions
  *    - Package names: use 'n8n-nodes-base' not '@n8n/n8n-nodes-base'
  *    - Check showWhen/hideWhen to identify the right property variant
- * 
+ *
  * 6. PERFORMANCE:
- *    - get_node_essentials: Fast (<5KB)
- *    - get_node_info: Slow (100KB+) - use sparingly
- *    - search_nodes/list_nodes: Fast, cached
+ *    - get_node (detail=standard): Fast (<5KB)
+ *    - get_node (detail=full): Slow (100KB+) - use sparingly
+ *    - search_nodes: Fast, cached
  */

src/services/enhanced-config-validator.ts

@@ -13,6 +13,8 @@ import { ResourceSimilarityService } from './resource-similarity-service';
 import { NodeRepository } from '../database/node-repository';
 import { DatabaseAdapter } from '../database/database-adapter';
 import { NodeTypeNormalizer } from '../utils/node-type-normalizer';
+import { TypeStructureService } from './type-structure-service';
+import type { NodePropertyTypes } from 'n8n-workflow';
 
 export type ValidationMode = 'full' | 'operation' | 'minimal';
 export type ValidationProfile = 'strict' | 'runtime' | 'ai-friendly' | 'minimal';
@@ -111,7 +113,7 @@ export class EnhancedConfigValidator extends ConfigValidator {
     this.applyProfileFilters(enhancedResult, profile);
     
     // Add operation-specific enhancements
-    this.addOperationSpecificEnhancements(nodeType, config, enhancedResult);
+    this.addOperationSpecificEnhancements(nodeType, config, filteredProperties, enhancedResult);
     
     // Deduplicate errors
     enhancedResult.errors = this.deduplicateErrors(enhancedResult.errors);
@@ -247,6 +249,7 @@ export class EnhancedConfigValidator extends ConfigValidator {
   private static addOperationSpecificEnhancements(
     nodeType: string,
     config: Record<string, any>,
+    properties: any[],
     result: EnhancedValidationResult
   ): void {
     // Type safety check - this should never happen with proper validation
@@ -263,6 +266,9 @@ export class EnhancedConfigValidator extends ConfigValidator {
     // Validate resource and operation using similarity services
     this.validateResourceAndOperation(nodeType, config, result);
 
+    // Validate special type structures (filter, resourceMapper, assignmentCollection, resourceLocator)
+    this.validateSpecialTypeStructures(config, properties, result);
+
     // First, validate fixedCollection properties for known problematic nodes
     this.validateFixedCollectionStructures(nodeType, config, result);
     
@@ -982,4 +988,280 @@ export class EnhancedConfigValidator extends ConfigValidator {
       }
     }
   }
+
+  /**
+   * Validate special type structures (filter, resourceMapper, assignmentCollection, resourceLocator)
+   *
+   * Integrates TypeStructureService to validate complex property types against their
+   * expected structures. This catches configuration errors for advanced node types.
+   *
+   * @param config - Node configuration to validate
+   * @param properties - Property definitions from node schema
+   * @param result - Validation result to populate with errors/warnings
+   */
+  private static validateSpecialTypeStructures(
+    config: Record<string, any>,
+    properties: any[],
+    result: EnhancedValidationResult
+  ): void {
+    for (const [key, value] of Object.entries(config)) {
+      if (value === undefined || value === null) continue;
+
+      // Find property definition
+      const propDef = properties.find(p => p.name === key);
+      if (!propDef) continue;
+
+      // Check if this property uses a special type
+      let structureType: NodePropertyTypes | null = null;
+
+      if (propDef.type === 'filter') {
+        structureType = 'filter';
+      } else if (propDef.type === 'resourceMapper') {
+        structureType = 'resourceMapper';
+      } else if (propDef.type === 'assignmentCollection') {
+        structureType = 'assignmentCollection';
+      } else if (propDef.type === 'resourceLocator') {
+        structureType = 'resourceLocator';
+      }
+
+      if (!structureType) continue;
+
+      // Get structure definition
+      const structure = TypeStructureService.getStructure(structureType);
+      if (!structure) {
+        console.warn(`No structure definition found for type: ${structureType}`);
+        continue;
+      }
+
+      // Validate using TypeStructureService for basic type checking
+      const validationResult = TypeStructureService.validateTypeCompatibility(
+        value,
+        structureType
+      );
+
+      // Add errors from structure validation
+      if (!validationResult.valid) {
+        for (const error of validationResult.errors) {
+          result.errors.push({
+            type: 'invalid_configuration',
+            property: key,
+            message: error,
+            fix: `Ensure ${key} follows the expected structure for ${structureType} type. Example: ${JSON.stringify(structure.example)}`
+          });
+        }
+      }
+
+      // Add warnings
+      for (const warning of validationResult.warnings) {
+        result.warnings.push({
+          type: 'best_practice',
+          property: key,
+          message: warning
+        });
+      }
+
+      // Perform deep structure validation for complex types
+      if (typeof value === 'object' && value !== null) {
+        this.validateComplexTypeStructure(key, value, structureType, structure, result);
+      }
+
+      // Special handling for filter operation validation
+      if (structureType === 'filter' && value.conditions) {
+        this.validateFilterOperations(value.conditions, key, result);
+      }
+    }
+  }
+
+  /**
+   * Deep validation for complex type structures
+   */
+  private static validateComplexTypeStructure(
+    propertyName: string,
+    value: any,
+    type: NodePropertyTypes,
+    structure: any,
+    result: EnhancedValidationResult
+  ): void {
+    switch (type) {
+      case 'filter':
+        // Validate filter structure: must have combinator and conditions
+        if (!value.combinator) {
+          result.errors.push({
+            type: 'invalid_configuration',
+            property: `${propertyName}.combinator`,
+            message: 'Filter must have a combinator field',
+            fix: 'Add combinator: "and" or combinator: "or" to the filter configuration'
+          });
+        } else if (value.combinator !== 'and' && value.combinator !== 'or') {
+          result.errors.push({
+            type: 'invalid_configuration',
+            property: `${propertyName}.combinator`,
+            message: `Invalid combinator value: ${value.combinator}. Must be "and" or "or"`,
+            fix: 'Set combinator to either "and" or "or"'
+          });
+        }
+
+        if (!value.conditions) {
+          result.errors.push({
+            type: 'invalid_configuration',
+            property: `${propertyName}.conditions`,
+            message: 'Filter must have a conditions field',
+            fix: 'Add conditions array to the filter configuration'
+          });
+        } else if (!Array.isArray(value.conditions)) {
+          result.errors.push({
+            type: 'invalid_configuration',
+            property: `${propertyName}.conditions`,
+            message: 'Filter conditions must be an array',
+            fix: 'Ensure conditions is an array of condition objects'
+          });
+        }
+        break;
+
+      case 'resourceLocator':
+        // Validate resourceLocator structure: must have mode and value
+        if (!value.mode) {
+          result.errors.push({
+            type: 'invalid_configuration',
+            property: `${propertyName}.mode`,
+            message: 'ResourceLocator must have a mode field',
+            fix: 'Add mode: "id", mode: "url", or mode: "list" to the resourceLocator configuration'
+          });
+        } else if (!['id', 'url', 'list', 'name'].includes(value.mode)) {
+          result.errors.push({
+            type: 'invalid_configuration',
+            property: `${propertyName}.mode`,
+            message: `Invalid mode value: ${value.mode}. Must be "id", "url", "list", or "name"`,
+            fix: 'Set mode to one of: "id", "url", "list", "name"'
+          });
+        }
+
+        if (!value.hasOwnProperty('value')) {
+          result.errors.push({
+            type: 'invalid_configuration',
+            property: `${propertyName}.value`,
+            message: 'ResourceLocator must have a value field',
+            fix: 'Add value field to the resourceLocator configuration'
+          });
+        }
+        break;
+
+      case 'assignmentCollection':
+        // Validate assignmentCollection structure: must have assignments array
+        if (!value.assignments) {
+          result.errors.push({
+            type: 'invalid_configuration',
+            property: `${propertyName}.assignments`,
+            message: 'AssignmentCollection must have an assignments field',
+            fix: 'Add assignments array to the assignmentCollection configuration'
+          });
+        } else if (!Array.isArray(value.assignments)) {
+          result.errors.push({
+            type: 'invalid_configuration',
+            property: `${propertyName}.assignments`,
+            message: 'AssignmentCollection assignments must be an array',
+            fix: 'Ensure assignments is an array of assignment objects'
+          });
+        }
+        break;
+
+      case 'resourceMapper':
+        // Validate resourceMapper structure: must have mappingMode
+        if (!value.mappingMode) {
+          result.errors.push({
+            type: 'invalid_configuration',
+            property: `${propertyName}.mappingMode`,
+            message: 'ResourceMapper must have a mappingMode field',
+            fix: 'Add mappingMode: "defineBelow" or mappingMode: "autoMapInputData"'
+          });
+        } else if (!['defineBelow', 'autoMapInputData'].includes(value.mappingMode)) {
+          result.errors.push({
+            type: 'invalid_configuration',
+            property: `${propertyName}.mappingMode`,
+            message: `Invalid mappingMode: ${value.mappingMode}. Must be "defineBelow" or "autoMapInputData"`,
+            fix: 'Set mappingMode to either "defineBelow" or "autoMapInputData"'
+          });
+        }
+        break;
+    }
+  }
+
+  /**
+   * Validate filter operations match operator types
+   *
+   * Ensures that filter operations are compatible with their operator types.
+   * For example, 'gt' (greater than) is only valid for numbers, not strings.
+   *
+   * @param conditions - Array of filter conditions to validate
+   * @param propertyName - Name of the filter property (for error reporting)
+   * @param result - Validation result to populate with errors
+   */
+  private static validateFilterOperations(
+    conditions: any,
+    propertyName: string,
+    result: EnhancedValidationResult
+  ): void {
+    if (!Array.isArray(conditions)) return;
+
+    // Operation validation rules based on n8n filter type definitions
+    const VALID_OPERATIONS_BY_TYPE: Record<string, string[]> = {
+      string: [
+        'empty', 'notEmpty', 'equals', 'notEquals',
+        'contains', 'notContains', 'startsWith', 'notStartsWith',
+        'endsWith', 'notEndsWith', 'regex', 'notRegex',
+        'exists', 'notExists', 'isNotEmpty' // exists checks field presence, isNotEmpty alias for notEmpty
+      ],
+      number: [
+        'empty', 'notEmpty', 'equals', 'notEquals', 'gt', 'lt', 'gte', 'lte',
+        'exists', 'notExists', 'isNotEmpty'
+      ],
+      dateTime: [
+        'empty', 'notEmpty', 'equals', 'notEquals', 'after', 'before', 'afterOrEquals', 'beforeOrEquals',
+        'exists', 'notExists', 'isNotEmpty'
+      ],
+      boolean: [
+        'empty', 'notEmpty', 'true', 'false', 'equals', 'notEquals',
+        'exists', 'notExists', 'isNotEmpty'
+      ],
+      array: [
+        'contains', 'notContains', 'lengthEquals', 'lengthNotEquals',
+        'lengthGt', 'lengthLt', 'lengthGte', 'lengthLte', 'empty', 'notEmpty',
+        'exists', 'notExists', 'isNotEmpty'
+      ],
+      object: [
+        'empty', 'notEmpty',
+        'exists', 'notExists', 'isNotEmpty'
+      ],
+      any: ['exists', 'notExists', 'isNotEmpty']
+    };
+
+    for (let i = 0; i < conditions.length; i++) {
+      const condition = conditions[i];
+      if (!condition.operator || typeof condition.operator !== 'object') continue;
+
+      const { type, operation } = condition.operator;
+      if (!type || !operation) continue;
+
+      // Get valid operations for this type
+      const validOperations = VALID_OPERATIONS_BY_TYPE[type];
+      if (!validOperations) {
+        result.warnings.push({
+          type: 'best_practice',
+          property: `${propertyName}.conditions[${i}].operator.type`,
+          message: `Unknown operator type: ${type}`
+        });
+        continue;
+      }
+
+      // Check if operation is valid for this type
+      if (!validOperations.includes(operation)) {
+        result.errors.push({
+          type: 'invalid_value',
+          property: `${propertyName}.conditions[${i}].operator.operation`,
+          message: `Operation '${operation}' is not valid for type '${type}'`,
+          fix: `Use one of the valid operations for ${type}: ${validOperations.join(', ')}`
+        });
+      }
+    }
+  }
 }

src/services/expression-validator.ts

@@ -97,12 +97,12 @@ export class ExpressionValidator {
       errors.push('Unmatched expression brackets {{ }}');
     }
 
-    // Check for nested expressions (not supported in n8n)
-    if (expression.includes('{{') && expression.includes('{{', expression.indexOf('{{') + 2)) {
-      const match = expression.match(/\{\{.*\{\{/);
-      if (match) {
-        errors.push('Nested expressions are not supported');
-      }
+    // Check for truly nested expressions (not supported in n8n)
+    // This means {{ inside another {{ }}, like {{ {{ $json }} }}
+    // NOT multiple expressions like {{ $json.a }} text {{ $json.b }} (which is valid)
+    const nestedPattern = /\{\{[^}]*\{\{/;
+    if (nestedPattern.test(expression)) {
+      errors.push('Nested expressions are not supported (expression inside another expression)');
     }
 
     // Check for empty expressions

src/services/n8n-validation.ts

@@ -62,6 +62,7 @@ export const workflowSettingsSchema = z.object({
   executionTimeout: z.number().optional(),
   errorWorkflow: z.string().optional(),
   callerPolicy: z.enum(['any', 'workflowsFromSameOwner', 'workflowsFromAList']).optional(),
+  availableInMCP: z.boolean().optional(),
 });
 
 // Default settings for workflow creation
@@ -181,7 +182,9 @@ export function cleanWorkflowForUpdate(workflow: Workflow): Partial<Workflow> {
     'executionTimeout',
     'errorWorkflow',
     'timezone',
-    'executionOrder'
+    'executionOrder',
+    'callerPolicy',
+    'availableInMCP',
   ];
 
   if (cleanedWorkflow.settings && typeof cleanedWorkflow.settings === 'object') {

src/services/node-specific-validators.ts

@@ -234,17 +234,11 @@ export class NodeSpecificValidators {
   static validateGoogleSheets(context: NodeValidationContext): void {
     const { config, errors, warnings, suggestions } = context;
     const { operation } = config;
-    
-    // Common validations
-    if (!config.sheetId && !config.documentId) {
-      errors.push({
-        type: 'missing_required',
-        property: 'sheetId',
-        message: 'Spreadsheet ID is required',
-        fix: 'Provide the Google Sheets document ID from the URL'
-      });
-    }
-    
+
+    // NOTE: Skip sheetId validation - it comes from credentials, not configuration
+    // In real workflows, sheetId is provided by Google Sheets credentials
+    // See Phase 3 validation results: 113/124 failures were false positives for this
+
     // Operation-specific validations
     switch (operation) {
       case 'append':
@@ -260,11 +254,30 @@ export class NodeSpecificValidators {
         this.validateGoogleSheetsDelete(context);
         break;
     }
-    
+
     // Range format validation
     if (config.range) {
       this.validateGoogleSheetsRange(config.range, errors, warnings);
     }
+
+    // FINAL STEP: Filter out sheetId errors (credential-provided field)
+    // Remove any sheetId validation errors that might have been added by nested validators
+    const filteredErrors: ValidationError[] = [];
+    for (const error of errors) {
+      // Skip sheetId errors - this field is provided by credentials
+      if (error.property === 'sheetId' && error.type === 'missing_required') {
+        continue;
+      }
+      // Skip errors about sheetId in nested paths (e.g., from resourceMapper validation)
+      if (error.property && error.property.includes('sheetId') && error.type === 'missing_required') {
+        continue;
+      }
+      filteredErrors.push(error);
+    }
+
+    // Replace errors array with filtered version
+    errors.length = 0;
+    errors.push(...filteredErrors);
   }
   
   private static validateGoogleSheetsAppend(context: NodeValidationContext): void {
@@ -1707,4 +1720,5 @@ export class NodeSpecificValidators {
       }
     }
   }
+
 }

src/services/property-filter.ts

@@ -16,6 +16,11 @@ export interface SimplifiedProperty {
   placeholder?: string;
   showWhen?: Record<string, any>;
   usageHint?: string;
+  expectedFormat?: {
+    structure: Record<string, string>;
+    modes?: string[];
+    example: Record<string, any>;
+  };
 }
 
 export interface EssentialConfig {
@@ -322,7 +327,18 @@ export class PropertyFilter {
         };
       });
     }
-    
+
+    // Add expectedFormat for resourceLocator types - critical for correct configuration
+    if (prop.type === 'resourceLocator') {
+      const modes = prop.modes?.map((m: any) => m.name || m) || ['list', 'id'];
+      const defaultValue = prop.default?.value || 'your-resource-id';
+      simplified.expectedFormat = {
+        structure: { mode: 'string', value: 'string' },
+        modes,
+        example: { mode: 'id', value: defaultValue }
+      };
+    }
+
     // Include simple display conditions (max 2 conditions)
     if (prop.displayOptions?.show) {
       const conditions = Object.keys(prop.displayOptions.show);

src/services/type-structure-service.ts

@@ -0,0 +1,427 @@
+/**
+ * Type Structure Service
+ *
+ * Provides methods to query and work with n8n property type structures.
+ * This service is stateless and uses static methods following the project's
+ * PropertyFilter and ConfigValidator patterns.
+ *
+ * @module services/type-structure-service
+ * @since 2.23.0
+ */
+
+import type { NodePropertyTypes } from 'n8n-workflow';
+import type { TypeStructure } from '../types/type-structures';
+import {
+	isComplexType as isComplexTypeGuard,
+	isPrimitiveType as isPrimitiveTypeGuard,
+} from '../types/type-structures';
+import { TYPE_STRUCTURES, COMPLEX_TYPE_EXAMPLES } from '../constants/type-structures';
+
+/**
+ * Result of type validation
+ */
+export interface TypeValidationResult {
+	/**
+	 * Whether the value is valid for the type
+	 */
+	valid: boolean;
+
+	/**
+	 * Validation errors if invalid
+	 */
+	errors: string[];
+
+	/**
+	 * Warnings that don't prevent validity
+	 */
+	warnings: string[];
+}
+
+/**
+ * Service for querying and working with node property type structures
+ *
+ * Provides static methods to:
+ * - Get type structure definitions
+ * - Get example values
+ * - Validate type compatibility
+ * - Query type categories
+ *
+ * @example
+ * ```typescript
+ * // Get structure for a type
+ * const structure = TypeStructureService.getStructure('collection');
+ * console.log(structure.description); // "A group of related properties..."
+ *
+ * // Get example value
+ * const example = TypeStructureService.getExample('filter');
+ * console.log(example.combinator); // "and"
+ *
+ * // Check if type is complex
+ * if (TypeStructureService.isComplexType('resourceMapper')) {
+ *   console.log('This type needs special handling');
+ * }
+ * ```
+ */
+export class TypeStructureService {
+	/**
+	 * Get the structure definition for a property type
+	 *
+	 * Returns the complete structure definition including:
+	 * - Type category (primitive/object/collection/special)
+	 * - JavaScript type
+	 * - Expected structure for complex types
+	 * - Example values
+	 * - Validation rules
+	 *
+	 * @param type - The NodePropertyType to query
+	 * @returns Type structure definition, or null if type is unknown
+	 *
+	 * @example
+	 * ```typescript
+	 * const structure = TypeStructureService.getStructure('string');
+	 * console.log(structure.jsType); // "string"
+	 * console.log(structure.example); // "Hello World"
+	 * ```
+	 */
+	static getStructure(type: NodePropertyTypes): TypeStructure | null {
+		return TYPE_STRUCTURES[type] || null;
+	}
+
+	/**
+	 * Get all type structure definitions
+	 *
+	 * Returns a record of all 22 NodePropertyTypes with their structures.
+	 * Useful for documentation, validation setup, or UI generation.
+	 *
+	 * @returns Record mapping all types to their structures
+	 *
+	 * @example
+	 * ```typescript
+	 * const allStructures = TypeStructureService.getAllStructures();
+	 * console.log(Object.keys(allStructures).length); // 22
+	 * ```
+	 */
+	static getAllStructures(): Record<NodePropertyTypes, TypeStructure> {
+		return { ...TYPE_STRUCTURES };
+	}
+
+	/**
+	 * Get example value for a property type
+	 *
+	 * Returns a working example value that conforms to the type's
+	 * expected structure. Useful for testing, documentation, or
+	 * generating default values.
+	 *
+	 * @param type - The NodePropertyType to get an example for
+	 * @returns Example value, or null if type is unknown
+	 *
+	 * @example
+	 * ```typescript
+	 * const example = TypeStructureService.getExample('number');
+	 * console.log(example); // 42
+	 *
+	 * const filterExample = TypeStructureService.getExample('filter');
+	 * console.log(filterExample.combinator); // "and"
+	 * ```
+	 */
+	static getExample(type: NodePropertyTypes): any {
+		const structure = this.getStructure(type);
+		return structure ? structure.example : null;
+	}
+
+	/**
+	 * Get all example values for a property type
+	 *
+	 * Some types have multiple examples to show different use cases.
+	 * This returns all available examples, or falls back to the
+	 * primary example if only one exists.
+	 *
+	 * @param type - The NodePropertyType to get examples for
+	 * @returns Array of example values
+	 *
+	 * @example
+	 * ```typescript
+	 * const examples = TypeStructureService.getExamples('string');
+	 * console.log(examples.length); // 4
+	 * console.log(examples[0]); // ""
+	 * console.log(examples[1]); // "A simple text"
+	 * ```
+	 */
+	static getExamples(type: NodePropertyTypes): any[] {
+		const structure = this.getStructure(type);
+		if (!structure) return [];
+
+		return structure.examples || [structure.example];
+	}
+
+	/**
+	 * Check if a property type is complex
+	 *
+	 * Complex types have nested structures and require special
+	 * validation logic beyond simple type checking.
+	 *
+	 * Complex types: collection, fixedCollection, resourceLocator,
+	 * resourceMapper, filter, assignmentCollection
+	 *
+	 * @param type - The property type to check
+	 * @returns True if the type is complex
+	 *
+	 * @example
+	 * ```typescript
+	 * TypeStructureService.isComplexType('collection'); // true
+	 * TypeStructureService.isComplexType('string'); // false
+	 * ```
+	 */
+	static isComplexType(type: NodePropertyTypes): boolean {
+		return isComplexTypeGuard(type);
+	}
+
+	/**
+	 * Check if a property type is primitive
+	 *
+	 * Primitive types map to simple JavaScript values and only
+	 * need basic type validation.
+	 *
+	 * Primitive types: string, number, boolean, dateTime, color, json
+	 *
+	 * @param type - The property type to check
+	 * @returns True if the type is primitive
+	 *
+	 * @example
+	 * ```typescript
+	 * TypeStructureService.isPrimitiveType('string'); // true
+	 * TypeStructureService.isPrimitiveType('collection'); // false
+	 * ```
+	 */
+	static isPrimitiveType(type: NodePropertyTypes): boolean {
+		return isPrimitiveTypeGuard(type);
+	}
+
+	/**
+	 * Get all complex property types
+	 *
+	 * Returns an array of all property types that are classified
+	 * as complex (having nested structures).
+	 *
+	 * @returns Array of complex type names
+	 *
+	 * @example
+	 * ```typescript
+	 * const complexTypes = TypeStructureService.getComplexTypes();
+	 * console.log(complexTypes);
+	 * // ['collection', 'fixedCollection', 'resourceLocator', ...]
+	 * ```
+	 */
+	static getComplexTypes(): NodePropertyTypes[] {
+		return Object.entries(TYPE_STRUCTURES)
+			.filter(([, structure]) => structure.type === 'collection' || structure.type === 'special')
+			.filter(([type]) => this.isComplexType(type as NodePropertyTypes))
+			.map(([type]) => type as NodePropertyTypes);
+	}
+
+	/**
+	 * Get all primitive property types
+	 *
+	 * Returns an array of all property types that are classified
+	 * as primitive (simple JavaScript values).
+	 *
+	 * @returns Array of primitive type names
+	 *
+	 * @example
+	 * ```typescript
+	 * const primitiveTypes = TypeStructureService.getPrimitiveTypes();
+	 * console.log(primitiveTypes);
+	 * // ['string', 'number', 'boolean', 'dateTime', 'color', 'json']
+	 * ```
+	 */
+	static getPrimitiveTypes(): NodePropertyTypes[] {
+		return Object.keys(TYPE_STRUCTURES).filter((type) =>
+			this.isPrimitiveType(type as NodePropertyTypes)
+		) as NodePropertyTypes[];
+	}
+
+	/**
+	 * Get real-world examples for complex types
+	 *
+	 * Returns curated examples from actual n8n workflows showing
+	 * different usage patterns for complex types.
+	 *
+	 * @param type - The complex type to get examples for
+	 * @returns Object with named example scenarios, or null
+	 *
+	 * @example
+	 * ```typescript
+	 * const examples = TypeStructureService.getComplexExamples('fixedCollection');
+	 * console.log(examples.httpHeaders);
+	 * // { headers: [{ name: 'Content-Type', value: 'application/json' }] }
+	 * ```
+	 */
+	static getComplexExamples(
+		type: 'collection' | 'fixedCollection' | 'filter' | 'resourceMapper' | 'assignmentCollection'
+	): Record<string, any> | null {
+		return COMPLEX_TYPE_EXAMPLES[type] || null;
+	}
+
+	/**
+	 * Validate basic type compatibility of a value
+	 *
+	 * Performs simple type checking to verify a value matches the
+	 * expected JavaScript type for a property type. Does not perform
+	 * deep structure validation for complex types.
+	 *
+	 * @param value - The value to validate
+	 * @param type - The expected property type
+	 * @returns Validation result with errors if invalid
+	 *
+	 * @example
+	 * ```typescript
+	 * const result = TypeStructureService.validateTypeCompatibility(
+	 *   'Hello',
+	 *   'string'
+	 * );
+	 * console.log(result.valid); // true
+	 *
+	 * const result2 = TypeStructureService.validateTypeCompatibility(
+	 *   123,
+	 *   'string'
+	 * );
+	 * console.log(result2.valid); // false
+	 * console.log(result2.errors[0]); // "Expected string but got number"
+	 * ```
+	 */
+	static validateTypeCompatibility(
+		value: any,
+		type: NodePropertyTypes
+	): TypeValidationResult {
+		const structure = this.getStructure(type);
+
+		if (!structure) {
+			return {
+				valid: false,
+				errors: [`Unknown property type: ${type}`],
+				warnings: [],
+			};
+		}
+
+		const errors: string[] = [];
+		const warnings: string[] = [];
+
+		// Handle null/undefined
+		if (value === null || value === undefined) {
+			if (!structure.validation?.allowEmpty) {
+				errors.push(`Value is required for type ${type}`);
+			}
+			return { valid: errors.length === 0, errors, warnings };
+		}
+
+		// Check JavaScript type compatibility
+		const actualType = Array.isArray(value) ? 'array' : typeof value;
+		const expectedType = structure.jsType;
+
+		if (expectedType !== 'any' && actualType !== expectedType) {
+			// Special case: expressions are strings but might be allowed
+			const isExpression = typeof value === 'string' && value.includes('{{');
+			if (isExpression && structure.validation?.allowExpressions) {
+				warnings.push(
+					`Value contains n8n expression - cannot validate type until runtime`
+				);
+			} else {
+				errors.push(`Expected ${expectedType} but got ${actualType}`);
+			}
+		}
+
+		// Additional validation for specific types
+		if (type === 'dateTime' && typeof value === 'string') {
+			const pattern = structure.validation?.pattern;
+			if (pattern && !new RegExp(pattern).test(value)) {
+				errors.push(`Invalid dateTime format. Expected ISO 8601 format.`);
+			}
+		}
+
+		if (type === 'color' && typeof value === 'string') {
+			const pattern = structure.validation?.pattern;
+			if (pattern && !new RegExp(pattern).test(value)) {
+				errors.push(`Invalid color format. Expected 6-digit hex color (e.g., #FF5733).`);
+			}
+		}
+
+		if (type === 'json' && typeof value === 'string') {
+			try {
+				JSON.parse(value);
+			} catch {
+				errors.push(`Invalid JSON string. Must be valid JSON when parsed.`);
+			}
+		}
+
+		return {
+			valid: errors.length === 0,
+			errors,
+			warnings,
+		};
+	}
+
+	/**
+	 * Get type description
+	 *
+	 * Returns the human-readable description of what a property type
+	 * represents and how it should be used.
+	 *
+	 * @param type - The property type
+	 * @returns Description string, or null if type unknown
+	 *
+	 * @example
+	 * ```typescript
+	 * const description = TypeStructureService.getDescription('filter');
+	 * console.log(description);
+	 * // "Defines conditions for filtering data with boolean logic"
+	 * ```
+	 */
+	static getDescription(type: NodePropertyTypes): string | null {
+		const structure = this.getStructure(type);
+		return structure ? structure.description : null;
+	}
+
+	/**
+	 * Get type notes
+	 *
+	 * Returns additional notes, warnings, or usage tips for a type.
+	 * Not all types have notes.
+	 *
+	 * @param type - The property type
+	 * @returns Array of note strings, or empty array
+	 *
+	 * @example
+	 * ```typescript
+	 * const notes = TypeStructureService.getNotes('filter');
+	 * console.log(notes[0]);
+	 * // "Advanced filtering UI in n8n"
+	 * ```
+	 */
+	static getNotes(type: NodePropertyTypes): string[] {
+		const structure = this.getStructure(type);
+		return structure?.notes || [];
+	}
+
+	/**
+	 * Get JavaScript type for a property type
+	 *
+	 * Returns the underlying JavaScript type that the property
+	 * type maps to (string, number, boolean, object, array, any).
+	 *
+	 * @param type - The property type
+	 * @returns JavaScript type name, or null if unknown
+	 *
+	 * @example
+	 * ```typescript
+	 * TypeStructureService.getJavaScriptType('string'); // "string"
+	 * TypeStructureService.getJavaScriptType('collection'); // "object"
+	 * TypeStructureService.getJavaScriptType('multiOptions'); // "array"
+	 * ```
+	 */
+	static getJavaScriptType(
+		type: NodePropertyTypes
+	): 'string' | 'number' | 'boolean' | 'object' | 'array' | 'any' | null {
+		const structure = this.getStructure(type);
+		return structure ? structure.jsType : null;
+	}
+}

src/services/workflow-diff-engine.ts

@@ -757,7 +757,8 @@ export class WorkflowDiffEngine {
     const { sourceOutput, sourceIndex } = this.resolveSmartParameters(workflow, operation);
 
     // Use nullish coalescing to properly handle explicit 0 values
-    const targetInput = operation.targetInput ?? 'main';
+    // Default targetInput to sourceOutput to preserve connection type for AI connections (ai_tool, ai_memory, etc.)
+    const targetInput = operation.targetInput ?? sourceOutput;
     const targetIndex = operation.targetIndex ?? 0;
 
     // Initialize source node connections object

src/services/workflow-validator.ts

@@ -383,14 +383,11 @@ export class WorkflowValidator {
             });
           }
         }
-        // Normalize node type FIRST to ensure consistent lookup
+        // Normalize node type for database lookup (DO NOT mutate the original workflow)
+        // The normalizer converts to short form (nodes-base.*) for database queries,
+        // but n8n API requires full form (n8n-nodes-base.*). Never modify the input workflow.
         const normalizedType = NodeTypeNormalizer.normalizeToFullForm(node.type);
 
-        // Update node type in place if it was normalized
-        if (normalizedType !== node.type) {
-          node.type = normalizedType;
-        }
-
         // Get node definition using normalized type (needed for typeVersion validation)
         const nodeInfo = this.nodeRepository.getNode(normalizedType);
 
@@ -684,7 +681,12 @@ export class WorkflowValidator {
         }
 
         // Special validation for SplitInBatches node
-        if (sourceNode && sourceNode.type === 'nodes-base.splitInBatches') {
+        // Check both full form (n8n-nodes-base.*) and short form (nodes-base.*)
+        const isSplitInBatches = sourceNode && (
+          sourceNode.type === 'n8n-nodes-base.splitInBatches' ||
+          sourceNode.type === 'nodes-base.splitInBatches'
+        );
+        if (isSplitInBatches) {
           this.validateSplitInBatchesConnection(
             sourceNode,
             outputIndex,
@@ -696,8 +698,8 @@ export class WorkflowValidator {
 
         // Check for self-referencing connections
         if (connection.node === sourceName) {
-          // This is only a warning for non-loop nodes
-          if (sourceNode && sourceNode.type !== 'nodes-base.splitInBatches') {
+          // This is only a warning for non-loop nodes (not SplitInBatches)
+          if (sourceNode && !isSplitInBatches) {
             result.warnings.push({
               type: 'warning',
               message: `Node "${sourceName}" has a self-referencing connection. This can cause infinite loops.`
@@ -1135,16 +1137,23 @@ export class WorkflowValidator {
     }
 
     // Check for AI Agent workflows
-    const aiAgentNodes = workflow.nodes.filter(n => 
-      n.type.toLowerCase().includes('agent') || 
+    const aiAgentNodes = workflow.nodes.filter(n =>
+      n.type.toLowerCase().includes('agent') ||
       n.type.includes('langchain.agent')
     );
-    
+
     if (aiAgentNodes.length > 0) {
       // Check if AI agents have tools connected
+      // Tools connect TO the agent, so we need to find connections where the target is the agent
       for (const agentNode of aiAgentNodes) {
-        const connections = workflow.connections[agentNode.name];
-        if (!connections?.ai_tool || connections.ai_tool.flat().filter(c => c).length === 0) {
+        // Search all connections to find ones targeting this agent via ai_tool
+        const hasToolConnected = Object.values(workflow.connections).some(sourceOutputs => {
+          const aiToolConnections = sourceOutputs.ai_tool;
+          if (!aiToolConnections) return false;
+          return aiToolConnections.flat().some(conn => conn && conn.node === agentNode.name);
+        });
+
+        if (!hasToolConnected) {
           result.warnings.push({
             type: 'warning',
             nodeId: agentNode.id,

src/triggers/handlers/base-handler.ts

@@ -0,0 +1,149 @@
+/**
+ * Base trigger handler - abstract class for all trigger handlers
+ */
+
+import { z } from 'zod';
+import { Workflow } from '../../types/n8n-api';
+import { InstanceContext } from '../../types/instance-context';
+import { N8nApiClient } from '../../services/n8n-api-client';
+import { getN8nApiConfig } from '../../config/n8n-api';
+import {
+  TriggerType,
+  TriggerResponse,
+  TriggerHandlerCapabilities,
+  DetectedTrigger,
+  BaseTriggerInput,
+} from '../types';
+
+/**
+ * Constructor type for trigger handlers
+ */
+export type TriggerHandlerConstructor = new (
+  client: N8nApiClient,
+  context?: InstanceContext
+) => BaseTriggerHandler;
+
+/**
+ * Abstract base class for all trigger handlers
+ *
+ * Each handler implements:
+ * - Input validation via Zod schema
+ * - Capability declaration (active workflow required, etc.)
+ * - Execution logic specific to the trigger type
+ */
+export abstract class BaseTriggerHandler<T extends BaseTriggerInput = BaseTriggerInput> {
+  protected client: N8nApiClient;
+  protected context?: InstanceContext;
+
+  /** The trigger type this handler supports */
+  abstract readonly triggerType: TriggerType;
+
+  /** Handler capabilities */
+  abstract readonly capabilities: TriggerHandlerCapabilities;
+
+  /** Zod schema for input validation */
+  abstract readonly inputSchema: z.ZodSchema<T>;
+
+  constructor(client: N8nApiClient, context?: InstanceContext) {
+    this.client = client;
+    this.context = context;
+  }
+
+  /**
+   * Validate input against schema
+   * @throws ZodError if validation fails
+   */
+  validate(input: unknown): T {
+    return this.inputSchema.parse(input);
+  }
+
+  /**
+   * Execute the trigger
+   *
+   * @param input - Validated trigger input
+   * @param workflow - The workflow being triggered
+   * @param triggerInfo - Detected trigger information (may be undefined for 'execute' type)
+   */
+  abstract execute(
+    input: T,
+    workflow: Workflow,
+    triggerInfo?: DetectedTrigger
+  ): Promise<TriggerResponse>;
+
+  /**
+   * Get the n8n instance base URL from context or environment config
+   */
+  protected getBaseUrl(): string | undefined {
+    // First try context (for multi-tenant scenarios)
+    if (this.context?.n8nApiUrl) {
+      return this.context.n8nApiUrl.replace(/\/api\/v1\/?$/, '');
+    }
+    // Fallback to environment config
+    const config = getN8nApiConfig();
+    if (config?.baseUrl) {
+      return config.baseUrl.replace(/\/api\/v1\/?$/, '');
+    }
+    return undefined;
+  }
+
+  /**
+   * Get the n8n API key from context or environment config
+   */
+  protected getApiKey(): string | undefined {
+    // First try context (for multi-tenant scenarios)
+    if (this.context?.n8nApiKey) {
+      return this.context.n8nApiKey;
+    }
+    // Fallback to environment config
+    const config = getN8nApiConfig();
+    return config?.apiKey;
+  }
+
+  /**
+   * Normalize response to unified format
+   */
+  protected normalizeResponse(
+    result: unknown,
+    input: T,
+    startTime: number,
+    extra?: Partial<TriggerResponse>
+  ): TriggerResponse {
+    const endTime = Date.now();
+    const duration = endTime - startTime;
+
+    return {
+      success: true,
+      triggerType: this.triggerType,
+      workflowId: input.workflowId,
+      data: result,
+      metadata: {
+        duration,
+      },
+      ...extra,
+    };
+  }
+
+  /**
+   * Create error response
+   */
+  protected errorResponse(
+    input: BaseTriggerInput,
+    error: string,
+    startTime: number,
+    extra?: Partial<TriggerResponse>
+  ): TriggerResponse {
+    const endTime = Date.now();
+    const duration = endTime - startTime;
+
+    return {
+      success: false,
+      triggerType: this.triggerType,
+      workflowId: input.workflowId,
+      error,
+      metadata: {
+        duration,
+      },
+      ...extra,
+    };
+  }
+}

src/triggers/handlers/chat-handler.ts

@@ -0,0 +1,141 @@
+/**
+ * Chat trigger handler
+ *
+ * Handles chat-based workflow triggers:
+ * - POST to webhook endpoint with chat payload
+ * - Payload structure: { action: 'sendMessage', sessionId, chatInput }
+ * - Sync mode only (no SSE streaming)
+ */
+
+import { z } from 'zod';
+import axios, { AxiosRequestConfig } from 'axios';
+import { Workflow } from '../../types/n8n-api';
+import {
+  TriggerType,
+  TriggerResponse,
+  TriggerHandlerCapabilities,
+  DetectedTrigger,
+  ChatTriggerInput,
+} from '../types';
+import { BaseTriggerHandler } from './base-handler';
+import { buildTriggerUrl } from '../trigger-detector';
+
+/**
+ * Zod schema for chat input validation
+ */
+const chatInputSchema = z.object({
+  workflowId: z.string(),
+  triggerType: z.literal('chat'),
+  message: z.string(),
+  sessionId: z.string().optional(),
+  data: z.record(z.unknown()).optional(),
+  headers: z.record(z.string()).optional(),
+  timeout: z.number().optional(),
+  waitForResponse: z.boolean().optional(),
+});
+
+/**
+ * Generate a unique session ID
+ */
+function generateSessionId(): string {
+  return `session_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`;
+}
+
+/**
+ * Chat trigger handler
+ */
+export class ChatHandler extends BaseTriggerHandler<ChatTriggerInput> {
+  readonly triggerType: TriggerType = 'chat';
+
+  readonly capabilities: TriggerHandlerCapabilities = {
+    requiresActiveWorkflow: true,
+    canPassInputData: true,
+  };
+
+  readonly inputSchema = chatInputSchema;
+
+  async execute(
+    input: ChatTriggerInput,
+    workflow: Workflow,
+    triggerInfo?: DetectedTrigger
+  ): Promise<TriggerResponse> {
+    const startTime = Date.now();
+
+    try {
+      // Build chat webhook URL
+      const baseUrl = this.getBaseUrl();
+      if (!baseUrl) {
+        return this.errorResponse(input, 'Cannot determine n8n base URL', startTime);
+      }
+
+      // Use trigger info to build URL or fallback to default pattern
+      let chatUrl: string;
+      if (triggerInfo?.webhookPath) {
+        chatUrl = buildTriggerUrl(baseUrl, triggerInfo, 'production');
+      } else {
+        // Default chat webhook path pattern
+        chatUrl = `${baseUrl.replace(/\/+$/, '')}/webhook/${input.workflowId}`;
+      }
+
+      // SSRF protection
+      const { SSRFProtection } = await import('../../utils/ssrf-protection');
+      const validation = await SSRFProtection.validateWebhookUrl(chatUrl);
+      if (!validation.valid) {
+        return this.errorResponse(input, `SSRF protection: ${validation.reason}`, startTime);
+      }
+
+      // Generate or use provided session ID
+      const sessionId = input.sessionId || generateSessionId();
+
+      // Build chat payload
+      const chatPayload = {
+        action: 'sendMessage',
+        sessionId,
+        chatInput: input.message,
+        // Include any additional data
+        ...input.data,
+      };
+
+      // Build request config
+      const config: AxiosRequestConfig = {
+        method: 'POST',
+        url: chatUrl,
+        headers: {
+          'Content-Type': 'application/json',
+          ...input.headers,
+        },
+        data: chatPayload,
+        timeout: input.timeout || (input.waitForResponse !== false ? 120000 : 30000),
+        validateStatus: (status) => status < 500,
+      };
+
+      // Make the request (sync mode - no streaming)
+      const response = await axios.request(config);
+
+      // Extract the chat response
+      const chatResponse = response.data;
+
+      return this.normalizeResponse(chatResponse, input, startTime, {
+        status: response.status,
+        statusText: response.statusText,
+        metadata: {
+          duration: Date.now() - startTime,
+          sessionId,
+          webhookPath: triggerInfo?.webhookPath,
+        },
+      });
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+
+      // Try to extract execution ID from error if available
+      const errorDetails = (error as any)?.response?.data;
+      const executionId = errorDetails?.executionId || errorDetails?.id;
+
+      return this.errorResponse(input, errorMessage, startTime, {
+        executionId,
+        code: (error as any)?.code,
+        details: errorDetails,
+      });
+    }
+  }
+}

src/triggers/handlers/form-handler.ts

@@ -0,0 +1,460 @@
+/**
+ * Form trigger handler
+ *
+ * Handles form-based workflow triggers:
+ * - POST to /form/<webhookId> with multipart/form-data
+ * - Supports all n8n form field types: text, textarea, email, number, password, date, dropdown, checkbox, file, hidden
+ * - Workflow must be active (for production endpoint)
+ */
+
+import { z } from 'zod';
+import axios, { AxiosRequestConfig } from 'axios';
+import FormData from 'form-data';
+import { Workflow, WorkflowNode } from '../../types/n8n-api';
+import {
+  TriggerType,
+  TriggerResponse,
+  TriggerHandlerCapabilities,
+  DetectedTrigger,
+  FormTriggerInput,
+} from '../types';
+import { BaseTriggerHandler } from './base-handler';
+
+/**
+ * Zod schema for form input validation
+ */
+const formInputSchema = z.object({
+  workflowId: z.string(),
+  triggerType: z.literal('form'),
+  formData: z.record(z.unknown()).optional(),
+  data: z.record(z.unknown()).optional(),
+  headers: z.record(z.string()).optional(),
+  timeout: z.number().optional(),
+  waitForResponse: z.boolean().optional(),
+});
+
+/**
+ * Form field types supported by n8n
+ */
+const FORM_FIELD_TYPES = {
+  TEXT: 'text',
+  TEXTAREA: 'textarea',
+  EMAIL: 'email',
+  NUMBER: 'number',
+  PASSWORD: 'password',
+  DATE: 'date',
+  DROPDOWN: 'dropdown',
+  CHECKBOX: 'checkbox',
+  FILE: 'file',
+  HIDDEN: 'hiddenField',
+  HTML: 'html',
+} as const;
+
+/**
+ * Maximum file size for base64 uploads (10MB)
+ */
+const MAX_FILE_SIZE_BYTES = 10 * 1024 * 1024;
+
+/**
+ * n8n form field option structure
+ */
+interface FormFieldOption {
+  option: string;
+}
+
+/**
+ * n8n form field value structure from workflow parameters
+ */
+interface FormFieldValue {
+  fieldType?: string;
+  fieldLabel?: string;
+  fieldName?: string;
+  elementName?: string;
+  requiredField?: boolean;
+  fieldOptions?: {
+    values?: FormFieldOption[];
+  };
+}
+
+/**
+ * Form field definition extracted from workflow
+ */
+interface FormFieldDef {
+  index: number;
+  fieldName: string;        // field-0, field-1, etc.
+  label: string;
+  type: string;
+  required: boolean;
+  options?: string[];       // For dropdown/checkbox
+}
+
+/**
+ * Check if a string is valid base64
+ */
+function isValidBase64(str: string): boolean {
+  if (!str || str.length === 0) {
+    return false;
+  }
+  // Check for valid base64 characters and proper padding
+  const base64Regex = /^[A-Za-z0-9+/]*={0,2}$/;
+  if (!base64Regex.test(str)) {
+    return false;
+  }
+  try {
+    // Verify round-trip encoding
+    const decoded = Buffer.from(str, 'base64');
+    return decoded.toString('base64') === str;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Extract form field definitions from workflow
+ */
+function extractFormFields(workflow: Workflow, triggerNode?: WorkflowNode): FormFieldDef[] {
+  const node = triggerNode || workflow.nodes.find(n =>
+    n.type.toLowerCase().includes('formtrigger')
+  );
+
+  const params = node?.parameters as Record<string, unknown> | undefined;
+  const formFields = params?.formFields as { values?: unknown[] } | undefined;
+
+  if (!formFields?.values) {
+    return [];
+  }
+
+  const fields: FormFieldDef[] = [];
+  let fieldIndex = 0;
+
+  for (const rawField of formFields.values) {
+    const field = rawField as FormFieldValue;
+    const fieldType = field.fieldType || FORM_FIELD_TYPES.TEXT;
+
+    // HTML fields are rendered as hidden inputs but are display-only
+    // They still get a field index
+    const def: FormFieldDef = {
+      index: fieldIndex,
+      fieldName: `field-${fieldIndex}`,
+      label: field.fieldLabel || field.fieldName || field.elementName || `field-${fieldIndex}`,
+      type: fieldType,
+      required: field.requiredField === true,
+    };
+
+    // Extract options for dropdown/checkbox
+    if (field.fieldOptions?.values) {
+      def.options = field.fieldOptions.values.map((v: FormFieldOption) => v.option);
+    }
+
+    fields.push(def);
+    fieldIndex++;
+  }
+
+  return fields;
+}
+
+/**
+ * Generate helpful usage hint for form fields
+ */
+function generateFormUsageHint(fields: FormFieldDef[]): string {
+  if (fields.length === 0) {
+    return 'No form fields detected in workflow.';
+  }
+
+  const lines: string[] = ['Form fields (use these keys in data parameter):'];
+
+  for (const field of fields) {
+    let hint = `  "${field.fieldName}": `;
+
+    switch (field.type) {
+      case FORM_FIELD_TYPES.CHECKBOX:
+        hint += `["${field.options?.[0] || 'option1'}", ...]`;
+        if (field.options) {
+          hint += ` (options: ${field.options.join(', ')})`;
+        }
+        break;
+      case FORM_FIELD_TYPES.DROPDOWN:
+        hint += `"${field.options?.[0] || 'value'}"`;
+        if (field.options) {
+          hint += ` (options: ${field.options.join(', ')})`;
+        }
+        break;
+      case FORM_FIELD_TYPES.DATE:
+        hint += '"YYYY-MM-DD"';
+        break;
+      case FORM_FIELD_TYPES.EMAIL:
+        hint += '"user@example.com"';
+        break;
+      case FORM_FIELD_TYPES.NUMBER:
+        hint += '123';
+        break;
+      case FORM_FIELD_TYPES.FILE:
+        hint += '{ filename: "test.txt", content: "base64..." } or skip (sends empty file)';
+        break;
+      case FORM_FIELD_TYPES.PASSWORD:
+        hint += '"secret"';
+        break;
+      case FORM_FIELD_TYPES.TEXTAREA:
+        hint += '"multi-line text..."';
+        break;
+      case FORM_FIELD_TYPES.HTML:
+        hint += '"" (display-only, can be omitted)';
+        break;
+      case FORM_FIELD_TYPES.HIDDEN:
+        hint += '"value" (hidden field)';
+        break;
+      default:
+        hint += '"text value"';
+    }
+
+    hint += field.required ? ' [REQUIRED]' : '';
+    hint += ` // ${field.label}`;
+    lines.push(hint);
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * Form trigger handler
+ */
+export class FormHandler extends BaseTriggerHandler<FormTriggerInput> {
+  readonly triggerType: TriggerType = 'form';
+
+  readonly capabilities: TriggerHandlerCapabilities = {
+    requiresActiveWorkflow: true,
+    canPassInputData: true,
+  };
+
+  readonly inputSchema = formInputSchema;
+
+  async execute(
+    input: FormTriggerInput,
+    workflow: Workflow,
+    triggerInfo?: DetectedTrigger
+  ): Promise<TriggerResponse> {
+    const startTime = Date.now();
+
+    // Extract form field definitions for helpful error messages
+    const formFieldDefs = extractFormFields(workflow, triggerInfo?.node);
+
+    try {
+      // Build form URL
+      const baseUrl = this.getBaseUrl();
+      if (!baseUrl) {
+        return this.errorResponse(input, 'Cannot determine n8n base URL', startTime, {
+          details: {
+            formFields: formFieldDefs,
+            hint: generateFormUsageHint(formFieldDefs),
+          },
+        });
+      }
+
+      // Form triggers use /form/<webhookId> endpoint
+      const formPath = triggerInfo?.webhookPath || triggerInfo?.node?.parameters?.path || input.workflowId;
+      const formUrl = `${baseUrl.replace(/\/+$/, '')}/form/${formPath}`;
+
+      // Merge formData and data (formData takes precedence)
+      const inputFields = {
+        ...input.data,
+        ...input.formData,
+      };
+
+      // SSRF protection
+      const { SSRFProtection } = await import('../../utils/ssrf-protection');
+      const validation = await SSRFProtection.validateWebhookUrl(formUrl);
+      if (!validation.valid) {
+        return this.errorResponse(input, `SSRF protection: ${validation.reason}`, startTime);
+      }
+
+      // Build multipart/form-data (required by n8n form triggers)
+      const formData = new FormData();
+      const warnings: string[] = [];
+
+      // Process each defined form field
+      for (const fieldDef of formFieldDefs) {
+        const value = inputFields[fieldDef.fieldName];
+
+        switch (fieldDef.type) {
+          case FORM_FIELD_TYPES.CHECKBOX:
+            // Checkbox fields need array syntax with [] suffix
+            if (Array.isArray(value)) {
+              for (const item of value) {
+                formData.append(`${fieldDef.fieldName}[]`, String(item ?? ''));
+              }
+            } else if (value !== undefined && value !== null) {
+              // Single value provided, wrap in array
+              formData.append(`${fieldDef.fieldName}[]`, String(value));
+            } else if (fieldDef.required) {
+              warnings.push(`Required checkbox field "${fieldDef.fieldName}" (${fieldDef.label}) not provided`);
+            }
+            break;
+
+          case FORM_FIELD_TYPES.FILE:
+            // File fields - handle file upload or send empty placeholder
+            if (value && typeof value === 'object' && 'content' in value) {
+              // File object with content (base64 or buffer)
+              const fileObj = value as { filename?: string; content: string | Buffer };
+              let buffer: Buffer;
+
+              if (typeof fileObj.content === 'string') {
+                // Validate base64 encoding
+                if (!isValidBase64(fileObj.content)) {
+                  warnings.push(`Invalid base64 encoding for file field "${fieldDef.fieldName}" (${fieldDef.label})`);
+                  buffer = Buffer.from('');
+                } else {
+                  buffer = Buffer.from(fileObj.content, 'base64');
+                  // Check file size
+                  if (buffer.length > MAX_FILE_SIZE_BYTES) {
+                    warnings.push(`File too large for "${fieldDef.fieldName}" (${fieldDef.label}): ${Math.round(buffer.length / 1024 / 1024)}MB exceeds ${MAX_FILE_SIZE_BYTES / 1024 / 1024}MB limit`);
+                    buffer = Buffer.from('');
+                  }
+                }
+              } else {
+                buffer = fileObj.content;
+                // Check file size for Buffer input
+                if (buffer.length > MAX_FILE_SIZE_BYTES) {
+                  warnings.push(`File too large for "${fieldDef.fieldName}" (${fieldDef.label}): ${Math.round(buffer.length / 1024 / 1024)}MB exceeds ${MAX_FILE_SIZE_BYTES / 1024 / 1024}MB limit`);
+                  buffer = Buffer.from('');
+                }
+              }
+
+              formData.append(fieldDef.fieldName, buffer, {
+                filename: fileObj.filename || 'file.txt',
+                contentType: 'application/octet-stream',
+              });
+            } else if (value && typeof value === 'string') {
+              // String value - treat as base64 content
+              if (!isValidBase64(value)) {
+                warnings.push(`Invalid base64 encoding for file field "${fieldDef.fieldName}" (${fieldDef.label})`);
+                formData.append(fieldDef.fieldName, Buffer.from(''), {
+                  filename: 'empty.txt',
+                  contentType: 'text/plain',
+                });
+              } else {
+                const buffer = Buffer.from(value, 'base64');
+                if (buffer.length > MAX_FILE_SIZE_BYTES) {
+                  warnings.push(`File too large for "${fieldDef.fieldName}" (${fieldDef.label}): ${Math.round(buffer.length / 1024 / 1024)}MB exceeds ${MAX_FILE_SIZE_BYTES / 1024 / 1024}MB limit`);
+                  formData.append(fieldDef.fieldName, Buffer.from(''), {
+                    filename: 'empty.txt',
+                    contentType: 'text/plain',
+                  });
+                } else {
+                  formData.append(fieldDef.fieldName, buffer, {
+                    filename: 'file.txt',
+                    contentType: 'application/octet-stream',
+                  });
+                }
+              }
+            } else {
+              // No file provided - send empty file as placeholder
+              formData.append(fieldDef.fieldName, Buffer.from(''), {
+                filename: 'empty.txt',
+                contentType: 'text/plain',
+              });
+              if (fieldDef.required) {
+                warnings.push(`Required file field "${fieldDef.fieldName}" (${fieldDef.label}) not provided - sending empty placeholder`);
+              }
+            }
+            break;
+
+          case FORM_FIELD_TYPES.HTML:
+            // HTML is display-only, but n8n renders it as hidden input
+            // Send empty string or provided value
+            formData.append(fieldDef.fieldName, String(value ?? ''));
+            break;
+
+          case FORM_FIELD_TYPES.HIDDEN:
+            // Hidden fields
+            formData.append(fieldDef.fieldName, String(value ?? ''));
+            break;
+
+          default:
+            // Standard fields: text, textarea, email, number, password, date, dropdown
+            if (value !== undefined && value !== null) {
+              formData.append(fieldDef.fieldName, String(value));
+            } else if (fieldDef.required) {
+              warnings.push(`Required field "${fieldDef.fieldName}" (${fieldDef.label}) not provided`);
+            }
+            break;
+        }
+      }
+
+      // Also include any extra fields not in the form definition (for flexibility)
+      const definedFieldNames = new Set(formFieldDefs.map(f => f.fieldName));
+      for (const [key, value] of Object.entries(inputFields)) {
+        if (!definedFieldNames.has(key)) {
+          if (Array.isArray(value)) {
+            for (const item of value) {
+              formData.append(`${key}[]`, String(item ?? ''));
+            }
+          } else {
+            formData.append(key, String(value ?? ''));
+          }
+        }
+      }
+
+      // Build request config
+      const config: AxiosRequestConfig = {
+        method: 'POST',
+        url: formUrl,
+        headers: {
+          ...formData.getHeaders(),
+          ...input.headers,
+        },
+        data: formData,
+        timeout: input.timeout || (input.waitForResponse !== false ? 120000 : 30000),
+        validateStatus: (status) => status < 500,
+      };
+
+      // Make the request
+      const response = await axios.request(config);
+
+      const result = this.normalizeResponse(response.data, input, startTime, {
+        status: response.status,
+        statusText: response.statusText,
+        metadata: {
+          duration: Date.now() - startTime,
+        },
+      });
+
+      // Add fields submitted count to details
+      result.details = {
+        ...result.details,
+        fieldsSubmitted: formFieldDefs.length,
+      };
+
+      // Add warnings if any
+      if (warnings.length > 0) {
+        result.details = {
+          ...result.details,
+          warnings,
+        };
+      }
+
+      return result;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+
+      // Try to extract execution ID from error if available
+      const errorDetails = (error as any)?.response?.data;
+      const executionId = errorDetails?.executionId || errorDetails?.id;
+
+      return this.errorResponse(input, errorMessage, startTime, {
+        executionId,
+        code: (error as any)?.code,
+        details: {
+          ...errorDetails,
+          formFields: formFieldDefs.map(f => ({
+            name: f.fieldName,
+            label: f.label,
+            type: f.type,
+            required: f.required,
+            options: f.options,
+          })),
+          hint: generateFormUsageHint(formFieldDefs),
+        },
+      });
+    }
+  }
+}

src/triggers/handlers/webhook-handler.ts

@@ -0,0 +1,125 @@
+/**
+ * Webhook trigger handler
+ *
+ * Handles webhook-based workflow triggers:
+ * - Supports GET, POST, PUT, DELETE methods
+ * - Passes data as body (POST/PUT/DELETE) or query params (GET)
+ * - Includes SSRF protection
+ */
+
+import { z } from 'zod';
+import { Workflow, WebhookRequest } from '../../types/n8n-api';
+import {
+  TriggerType,
+  TriggerResponse,
+  TriggerHandlerCapabilities,
+  DetectedTrigger,
+  WebhookTriggerInput,
+} from '../types';
+import { BaseTriggerHandler } from './base-handler';
+import { buildTriggerUrl } from '../trigger-detector';
+
+/**
+ * Zod schema for webhook input validation
+ */
+const webhookInputSchema = z.object({
+  workflowId: z.string(),
+  triggerType: z.literal('webhook'),
+  httpMethod: z.enum(['GET', 'POST', 'PUT', 'DELETE']).optional(),
+  webhookPath: z.string().optional(),
+  data: z.record(z.unknown()).optional(),
+  headers: z.record(z.string()).optional(),
+  timeout: z.number().optional(),
+  waitForResponse: z.boolean().optional(),
+});
+
+/**
+ * Webhook trigger handler
+ */
+export class WebhookHandler extends BaseTriggerHandler<WebhookTriggerInput> {
+  readonly triggerType: TriggerType = 'webhook';
+
+  readonly capabilities: TriggerHandlerCapabilities = {
+    requiresActiveWorkflow: true,
+    supportedMethods: ['GET', 'POST', 'PUT', 'DELETE'],
+    canPassInputData: true,
+  };
+
+  readonly inputSchema = webhookInputSchema;
+
+  async execute(
+    input: WebhookTriggerInput,
+    workflow: Workflow,
+    triggerInfo?: DetectedTrigger
+  ): Promise<TriggerResponse> {
+    const startTime = Date.now();
+
+    try {
+      // Build webhook URL
+      const baseUrl = this.getBaseUrl();
+      if (!baseUrl) {
+        return this.errorResponse(input, 'Cannot determine n8n base URL', startTime);
+      }
+
+      // Use provided webhook path or extract from trigger info
+      let webhookUrl: string;
+      if (input.webhookPath) {
+        // User provided explicit path
+        webhookUrl = `${baseUrl.replace(/\/+$/, '')}/webhook/${input.webhookPath}`;
+      } else if (triggerInfo?.webhookPath) {
+        // Use detected path from workflow
+        webhookUrl = buildTriggerUrl(baseUrl, triggerInfo, 'production');
+      } else {
+        return this.errorResponse(
+          input,
+          'No webhook path available. Provide webhookPath parameter or ensure workflow has a webhook trigger.',
+          startTime
+        );
+      }
+
+      // Determine HTTP method
+      const httpMethod = input.httpMethod || triggerInfo?.httpMethod || 'POST';
+
+      // SSRF protection - validate the webhook URL before making the request
+      const { SSRFProtection } = await import('../../utils/ssrf-protection');
+      const validation = await SSRFProtection.validateWebhookUrl(webhookUrl);
+      if (!validation.valid) {
+        return this.errorResponse(input, `SSRF protection: ${validation.reason}`, startTime);
+      }
+
+      // Build webhook request
+      const webhookRequest: WebhookRequest = {
+        webhookUrl,
+        httpMethod: httpMethod as 'GET' | 'POST' | 'PUT' | 'DELETE',
+        data: input.data,
+        headers: input.headers,
+        waitForResponse: input.waitForResponse ?? true,
+      };
+
+      // Trigger the webhook
+      const response = await this.client.triggerWebhook(webhookRequest);
+
+      return this.normalizeResponse(response, input, startTime, {
+        status: response.status,
+        statusText: response.statusText,
+        metadata: {
+          duration: Date.now() - startTime,
+          webhookPath: input.webhookPath || triggerInfo?.webhookPath,
+          httpMethod,
+        },
+      });
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+
+      // Try to extract execution ID from error if available
+      const errorDetails = (error as any)?.details;
+      const executionId = errorDetails?.executionId || errorDetails?.id;
+
+      return this.errorResponse(input, errorMessage, startTime, {
+        executionId,
+        code: (error as any)?.code,
+        details: errorDetails,
+      });
+    }
+  }
+}

src/triggers/index.ts

@@ -0,0 +1,46 @@
+/**
+ * Trigger system for n8n_test_workflow tool
+ *
+ * Provides extensible trigger handling for different n8n trigger types:
+ * - webhook: HTTP-based triggers
+ * - form: Form submission triggers
+ * - chat: Chat/AI triggers
+ *
+ * Note: n8n's public API does not support direct workflow execution.
+ * Only workflows with these trigger types can be triggered externally.
+ */
+
+// Types
+export {
+  TriggerType,
+  BaseTriggerInput,
+  WebhookTriggerInput,
+  FormTriggerInput,
+  ChatTriggerInput,
+  TriggerInput,
+  TriggerResponse,
+  TriggerHandlerCapabilities,
+  DetectedTrigger,
+  TriggerDetectionResult,
+  TestWorkflowInput,
+} from './types';
+
+// Detector
+export {
+  detectTriggerFromWorkflow,
+  buildTriggerUrl,
+  describeTrigger,
+} from './trigger-detector';
+
+// Registry
+export {
+  TriggerRegistry,
+  initializeTriggerRegistry,
+  ensureRegistryInitialized,
+} from './trigger-registry';
+
+// Base handler
+export {
+  BaseTriggerHandler,
+  TriggerHandlerConstructor,
+} from './handlers/base-handler';

src/triggers/trigger-detector.ts

@@ -0,0 +1,321 @@
+/**
+ * Trigger detector - analyzes workflows to detect trigger type
+ */
+
+import { Workflow, WorkflowNode } from '../types/n8n-api';
+import { normalizeNodeType } from '../utils/node-type-utils';
+import { TriggerType, DetectedTrigger, TriggerDetectionResult } from './types';
+
+/**
+ * Node type patterns for each trigger type
+ */
+const WEBHOOK_PATTERNS = [
+  'webhook',
+  'webhooktrigger',
+];
+
+const FORM_PATTERNS = [
+  'formtrigger',
+  'form',
+];
+
+const CHAT_PATTERNS = [
+  'chattrigger',
+];
+
+/**
+ * Detect the trigger type from a workflow
+ *
+ * Priority order:
+ * 1. Webhook trigger (most common for API access)
+ * 2. Chat trigger (AI-specific)
+ * 3. Form trigger
+ *
+ * Note: n8n's public API does not support direct workflow execution.
+ * Only workflows with webhook/form/chat triggers can be triggered externally.
+ */
+export function detectTriggerFromWorkflow(workflow: Workflow): TriggerDetectionResult {
+  if (!workflow.nodes || workflow.nodes.length === 0) {
+    return {
+      detected: false,
+      reason: 'Workflow has no nodes',
+    };
+  }
+
+  // Find all trigger nodes
+  const triggerNodes = workflow.nodes.filter(node => !node.disabled && isTriggerNodeType(node.type));
+
+  if (triggerNodes.length === 0) {
+    return {
+      detected: false,
+      reason: 'No trigger nodes found in workflow',
+    };
+  }
+
+  // Check for specific trigger types in priority order
+  for (const node of triggerNodes) {
+    const webhookTrigger = detectWebhookTrigger(node);
+    if (webhookTrigger) {
+      return {
+        detected: true,
+        trigger: webhookTrigger,
+      };
+    }
+  }
+
+  for (const node of triggerNodes) {
+    const chatTrigger = detectChatTrigger(node);
+    if (chatTrigger) {
+      return {
+        detected: true,
+        trigger: chatTrigger,
+      };
+    }
+  }
+
+  for (const node of triggerNodes) {
+    const formTrigger = detectFormTrigger(node);
+    if (formTrigger) {
+      return {
+        detected: true,
+        trigger: formTrigger,
+      };
+    }
+  }
+
+  // No externally-triggerable trigger found
+  return {
+    detected: false,
+    reason: `Workflow has trigger nodes but none support external triggering (found: ${triggerNodes.map(n => n.type).join(', ')}). Only webhook, form, and chat triggers can be triggered via the API.`,
+  };
+}
+
+/**
+ * Check if a node type is a trigger
+ */
+function isTriggerNodeType(nodeType: string): boolean {
+  const normalized = normalizeNodeType(nodeType).toLowerCase();
+  return (
+    normalized.includes('trigger') ||
+    normalized.includes('webhook') ||
+    normalized === 'nodes-base.start'
+  );
+}
+
+/**
+ * Detect webhook trigger and extract configuration
+ */
+function detectWebhookTrigger(node: WorkflowNode): DetectedTrigger | null {
+  const normalized = normalizeNodeType(node.type).toLowerCase();
+  const nodeName = normalized.split('.').pop() || '';
+
+  const isWebhook = WEBHOOK_PATTERNS.some(pattern =>
+    nodeName === pattern || nodeName.includes(pattern)
+  );
+
+  if (!isWebhook) {
+    return null;
+  }
+
+  // Extract webhook path from parameters
+  const params = node.parameters || {};
+  const webhookPath = extractWebhookPath(params, node.id, node.webhookId);
+  const httpMethod = extractHttpMethod(params);
+
+  return {
+    type: 'webhook',
+    node,
+    webhookPath,
+    httpMethod,
+  };
+}
+
+/**
+ * Detect form trigger and extract configuration
+ */
+function detectFormTrigger(node: WorkflowNode): DetectedTrigger | null {
+  const normalized = normalizeNodeType(node.type).toLowerCase();
+  const nodeName = normalized.split('.').pop() || '';
+
+  const isForm = FORM_PATTERNS.some(pattern =>
+    nodeName === pattern || nodeName.includes(pattern)
+  );
+
+  if (!isForm) {
+    return null;
+  }
+
+  // Extract form fields from parameters
+  const params = node.parameters || {};
+  const formFields = extractFormFields(params);
+  const webhookPath = extractWebhookPath(params, node.id, node.webhookId);
+
+  return {
+    type: 'form',
+    node,
+    webhookPath,
+    formFields,
+  };
+}
+
+/**
+ * Detect chat trigger and extract configuration
+ */
+function detectChatTrigger(node: WorkflowNode): DetectedTrigger | null {
+  const normalized = normalizeNodeType(node.type).toLowerCase();
+  const nodeName = normalized.split('.').pop() || '';
+
+  const isChat = CHAT_PATTERNS.some(pattern =>
+    nodeName === pattern || nodeName.includes(pattern)
+  );
+
+  if (!isChat) {
+    return null;
+  }
+
+  // Extract chat configuration
+  const params = node.parameters || {};
+  const responseMode = (params.options as any)?.responseMode || 'lastNode';
+  const webhookPath = extractWebhookPath(params, node.id, node.webhookId);
+
+  return {
+    type: 'chat',
+    node,
+    webhookPath,
+    chatConfig: {
+      responseMode,
+    },
+  };
+}
+
+/**
+ * Extract webhook path from node parameters
+ *
+ * Priority:
+ * 1. Explicit path parameter in node config
+ * 2. HTTP method specific path
+ * 3. webhookId on the node (n8n assigns this for all webhook-like triggers)
+ * 4. Fallback to node ID
+ */
+function extractWebhookPath(params: Record<string, unknown>, nodeId: string, webhookId?: string): string {
+  // Check for explicit path parameter
+  if (typeof params.path === 'string' && params.path) {
+    return params.path;
+  }
+
+  // Check for httpMethod specific path
+  if (typeof params.httpMethod === 'string') {
+    const methodPath = params[`path_${params.httpMethod.toLowerCase()}`];
+    if (typeof methodPath === 'string' && methodPath) {
+      return methodPath;
+    }
+  }
+
+  // Use webhookId if available (n8n assigns this for chat/form/webhook triggers)
+  if (typeof webhookId === 'string' && webhookId) {
+    return webhookId;
+  }
+
+  // Default: use node ID as path (n8n default behavior)
+  return nodeId;
+}
+
+/**
+ * Extract HTTP method from webhook parameters
+ */
+function extractHttpMethod(params: Record<string, unknown>): string {
+  if (typeof params.httpMethod === 'string') {
+    return params.httpMethod.toUpperCase();
+  }
+  return 'POST'; // Default to POST
+}
+
+/**
+ * Extract form field names from form trigger parameters
+ */
+function extractFormFields(params: Record<string, unknown>): string[] {
+  const fields: string[] = [];
+
+  // Check for formFields parameter (common pattern)
+  if (Array.isArray(params.formFields)) {
+    for (const field of params.formFields) {
+      if (field && typeof field.fieldLabel === 'string') {
+        fields.push(field.fieldLabel);
+      } else if (field && typeof field.fieldName === 'string') {
+        fields.push(field.fieldName);
+      }
+    }
+  }
+
+  // Check for fields in options
+  const options = params.options as Record<string, unknown> | undefined;
+  if (options && Array.isArray(options.formFields)) {
+    for (const field of options.formFields) {
+      if (field && typeof field.fieldLabel === 'string') {
+        fields.push(field.fieldLabel);
+      }
+    }
+  }
+
+  return fields;
+}
+
+/**
+ * Build the trigger URL based on detected trigger and n8n base URL
+ *
+ * @param baseUrl - n8n instance base URL (e.g., https://n8n.example.com)
+ * @param trigger - Detected trigger information
+ * @param mode - 'production' uses /webhook/, 'test' uses /webhook-test/
+ */
+export function buildTriggerUrl(
+  baseUrl: string,
+  trigger: DetectedTrigger,
+  mode: 'production' | 'test' = 'production'
+): string {
+  const cleanBaseUrl = baseUrl.replace(/\/+$/, ''); // Remove trailing slashes
+
+  switch (trigger.type) {
+    case 'webhook': {
+      const prefix = mode === 'test' ? 'webhook-test' : 'webhook';
+      const path = trigger.webhookPath || trigger.node.id;
+      return `${cleanBaseUrl}/${prefix}/${path}`;
+    }
+
+    case 'chat': {
+      // Chat triggers use /webhook/<webhookId>/chat endpoint
+      const prefix = mode === 'test' ? 'webhook-test' : 'webhook';
+      const path = trigger.webhookPath || trigger.node.id;
+      return `${cleanBaseUrl}/${prefix}/${path}/chat`;
+    }
+
+    case 'form': {
+      // Form triggers use /form/<webhookId> endpoint
+      const prefix = mode === 'test' ? 'form-test' : 'form';
+      const path = trigger.webhookPath || trigger.node.id;
+      return `${cleanBaseUrl}/${prefix}/${path}`;
+    }
+
+    default:
+      throw new Error(`Cannot build URL for trigger type: ${trigger.type}`);
+  }
+}
+
+/**
+ * Get a human-readable description of the detected trigger
+ */
+export function describeTrigger(trigger: DetectedTrigger): string {
+  switch (trigger.type) {
+    case 'webhook':
+      return `Webhook trigger (${trigger.httpMethod || 'POST'} /${trigger.webhookPath || trigger.node.id})`;
+
+    case 'form':
+      const fieldCount = trigger.formFields?.length || 0;
+      return `Form trigger (${fieldCount} fields)`;
+
+    case 'chat':
+      return `Chat trigger (${trigger.chatConfig?.responseMode || 'lastNode'} mode)`;
+
+    default:
+      return 'Unknown trigger';
+  }
+}

src/triggers/trigger-registry.ts

@@ -0,0 +1,118 @@
+/**
+ * Trigger Registry - central registry for trigger handlers
+ *
+ * Uses the plugin pattern for extensibility:
+ * - Register handlers at startup
+ * - Get handler by trigger type
+ * - List all registered types
+ */
+
+import { N8nApiClient } from '../services/n8n-api-client';
+import { InstanceContext } from '../types/instance-context';
+import { TriggerType } from './types';
+import { BaseTriggerHandler, TriggerHandlerConstructor } from './handlers/base-handler';
+
+/**
+ * Central registry for trigger handlers
+ */
+export class TriggerRegistry {
+  private static handlers: Map<TriggerType, TriggerHandlerConstructor> = new Map();
+  private static initialized = false;
+
+  /**
+   * Register a trigger handler
+   *
+   * @param type - The trigger type this handler supports
+   * @param HandlerClass - The handler class constructor
+   */
+  static register(type: TriggerType, HandlerClass: TriggerHandlerConstructor): void {
+    this.handlers.set(type, HandlerClass);
+  }
+
+  /**
+   * Get a handler instance for a trigger type
+   *
+   * @param type - The trigger type
+   * @param client - n8n API client
+   * @param context - Optional instance context
+   * @returns Handler instance or undefined if not registered
+   */
+  static getHandler(
+    type: TriggerType,
+    client: N8nApiClient,
+    context?: InstanceContext
+  ): BaseTriggerHandler | undefined {
+    const HandlerClass = this.handlers.get(type);
+    if (!HandlerClass) {
+      return undefined;
+    }
+    return new HandlerClass(client, context);
+  }
+
+  /**
+   * Check if a trigger type has a registered handler
+   */
+  static hasHandler(type: TriggerType): boolean {
+    return this.handlers.has(type);
+  }
+
+  /**
+   * Get all registered trigger types
+   */
+  static getRegisteredTypes(): TriggerType[] {
+    return Array.from(this.handlers.keys());
+  }
+
+  /**
+   * Clear all registered handlers (useful for testing)
+   */
+  static clear(): void {
+    this.handlers.clear();
+    this.initialized = false;
+  }
+
+  /**
+   * Check if registry is initialized
+   */
+  static isInitialized(): boolean {
+    return this.initialized;
+  }
+
+  /**
+   * Mark registry as initialized
+   */
+  static markInitialized(): void {
+    this.initialized = true;
+  }
+}
+
+/**
+ * Initialize the registry with all handlers
+ * Called once at startup
+ */
+export async function initializeTriggerRegistry(): Promise<void> {
+  if (TriggerRegistry.isInitialized()) {
+    return;
+  }
+
+  // Import handlers dynamically to avoid circular dependencies
+  const { WebhookHandler } = await import('./handlers/webhook-handler');
+  const { FormHandler } = await import('./handlers/form-handler');
+  const { ChatHandler } = await import('./handlers/chat-handler');
+
+  // Register all handlers
+  TriggerRegistry.register('webhook', WebhookHandler);
+  TriggerRegistry.register('form', FormHandler);
+  TriggerRegistry.register('chat', ChatHandler);
+
+  TriggerRegistry.markInitialized();
+}
+
+/**
+ * Ensure registry is initialized (lazy initialization)
+ */
+export async function ensureRegistryInitialized(): Promise<void> {
+  if (!TriggerRegistry.isInitialized()) {
+    await initializeTriggerRegistry();
+  }
+}

src/triggers/types.ts

@@ -0,0 +1,137 @@
+/**
+ * Trigger system types for n8n_test_workflow tool
+ *
+ * Supports 3 trigger categories (all input-capable):
+ * - webhook: AI can pass HTTP body/headers/params
+ * - form: AI can pass form field values
+ * - chat: AI can pass message + sessionId
+ *
+ * Note: Direct workflow execution via API is not supported by n8n's public API.
+ * Workflows must have webhook/form/chat triggers to be executable externally.
+ */
+
+import { Workflow, WorkflowNode } from '../types/n8n-api';
+
+/**
+ * Supported trigger types (all input-capable)
+ */
+export type TriggerType = 'webhook' | 'form' | 'chat';
+
+/**
+ * Base input for all trigger handlers
+ */
+export interface BaseTriggerInput {
+  workflowId: string;
+  triggerType?: TriggerType;
+  data?: Record<string, unknown>;
+  headers?: Record<string, string>;
+  timeout?: number;
+  waitForResponse?: boolean;
+}
+
+/**
+ * Webhook-specific input
+ */
+export interface WebhookTriggerInput extends BaseTriggerInput {
+  triggerType: 'webhook';
+  httpMethod?: 'GET' | 'POST' | 'PUT' | 'DELETE';
+  webhookPath?: string;
+}
+
+/**
+ * Form-specific input
+ */
+export interface FormTriggerInput extends BaseTriggerInput {
+  triggerType: 'form';
+  formData?: Record<string, unknown>;
+}
+
+/**
+ * Chat-specific input (sync mode only)
+ */
+export interface ChatTriggerInput extends BaseTriggerInput {
+  triggerType: 'chat';
+  message: string;
+  sessionId?: string;
+}
+
+/**
+ * Discriminated union of all trigger inputs
+ */
+export type TriggerInput =
+  | WebhookTriggerInput
+  | FormTriggerInput
+  | ChatTriggerInput;
+
+/**
+ * Unified response from all trigger handlers
+ */
+export interface TriggerResponse {
+  success: boolean;
+  triggerType: TriggerType;
+  workflowId: string;
+  executionId?: string;
+  status?: number;
+  statusText?: string;
+  data?: unknown;
+  error?: string;
+  code?: string;
+  details?: Record<string, unknown>;
+  metadata: {
+    duration: number;
+    webhookPath?: string;
+    sessionId?: string;
+    httpMethod?: string;
+  };
+}
+
+/**
+ * Handler capability flags
+ */
+export interface TriggerHandlerCapabilities {
+  /** Whether workflow must be active for this trigger */
+  requiresActiveWorkflow: boolean;
+  /** Supported HTTP methods (for webhook) */
+  supportedMethods?: string[];
+  /** Whether this handler can pass input data to workflow */
+  canPassInputData: boolean;
+}
+
+/**
+ * Detected trigger information from workflow analysis
+ */
+export interface DetectedTrigger {
+  type: TriggerType;
+  node: WorkflowNode;
+  webhookPath?: string;
+  httpMethod?: string;
+  formFields?: string[];
+  chatConfig?: {
+    responseMode?: string;
+  };
+}
+
+/**
+ * Result of trigger detection
+ */
+export interface TriggerDetectionResult {
+  detected: boolean;
+  trigger?: DetectedTrigger;
+  reason?: string;
+}
+
+/**
+ * Input for the MCP tool (before trigger type detection)
+ */
+export interface TestWorkflowInput {
+  workflowId: string;
+  triggerType?: TriggerType;
+  httpMethod?: 'GET' | 'POST' | 'PUT' | 'DELETE';
+  webhookPath?: string;
+  message?: string;
+  sessionId?: string;
+  data?: Record<string, unknown>;
+  headers?: Record<string, string>;
+  timeout?: number;
+  waitForResponse?: boolean;
+}

src/types/index.ts

@@ -1,5 +1,8 @@
 // Export n8n node type definitions and utilities
 export * from './node-types';
+export * from './type-structures';
+export * from './instance-context';
+export * from './session-state';
 
 export interface MCPServerConfig {
   port: number;

src/types/n8n-api.ts

@@ -30,6 +30,7 @@ export interface WorkflowNode {
   waitBetweenTries?: number;
   alwaysOutputData?: boolean;
   executeOnce?: boolean;
+  webhookId?: string; // n8n assigns this for webhook/form/chat trigger nodes
 }
 
 export interface WorkflowConnection {

src/types/session-state.ts

@@ -0,0 +1,92 @@
+/**
+ * Session persistence types for multi-tenant deployments
+ *
+ * These types support exporting and restoring MCP session state across
+ * container restarts, enabling seamless session persistence in production.
+ */
+
+import { InstanceContext } from './instance-context.js';
+
+/**
+ * Serializable session state for persistence across restarts
+ *
+ * This interface represents the minimal state needed to restore an MCP session
+ * after a container restart. Only the session metadata and instance context are
+ * persisted - transport and server objects are recreated on the first request.
+ *
+ * @example
+ * // Export sessions before shutdown
+ * const sessions = server.exportSessionState();
+ * await saveToEncryptedStorage(sessions);
+ *
+ * @example
+ * // Restore sessions on startup
+ * const sessions = await loadFromEncryptedStorage();
+ * const count = server.restoreSessionState(sessions);
+ * console.log(`Restored ${count} sessions`);
+ */
+export interface SessionState {
+  /**
+   * Unique session identifier
+   * Format: UUID v4 or custom format from MCP proxy
+   */
+  sessionId: string;
+
+  /**
+   * Session timing metadata for expiration tracking
+   */
+  metadata: {
+    /**
+     * When the session was created (ISO 8601 timestamp)
+     * Used to track total session age
+     */
+    createdAt: string;
+
+    /**
+     * When the session was last accessed (ISO 8601 timestamp)
+     * Used to determine if session has expired based on timeout
+     */
+    lastAccess: string;
+  };
+
+  /**
+   * n8n instance context (credentials and configuration)
+   *
+   * Contains the n8n API credentials and instance-specific settings.
+   * This is the critical data needed to reconnect to the correct n8n instance.
+   *
+   * Note: API keys are stored in plaintext. The downstream application
+   * MUST encrypt this data before persisting to disk.
+   */
+  context: {
+    /**
+     * n8n instance API URL
+     * Example: "https://n8n.example.com"
+     */
+    n8nApiUrl: string;
+
+    /**
+     * n8n instance API key (plaintext - encrypt before storage!)
+     * Example: "n8n_api_1234567890abcdef"
+     */
+    n8nApiKey: string;
+
+    /**
+     * Instance identifier (optional)
+     * Custom identifier for tracking which n8n instance this session belongs to
+     */
+    instanceId?: string;
+
+    /**
+     * Session-specific ID (optional)
+     * May differ from top-level sessionId in some proxy configurations
+     */
+    sessionId?: string;
+
+    /**
+     * Additional metadata (optional)
+     * Extensible field for custom application data
+     */
+    metadata?: Record<string, any>;
+  };
+}

src/types/type-structures.ts

@@ -0,0 +1,301 @@
+/**
+ * Type Structure Definitions
+ *
+ * Defines the structure and validation rules for n8n node property types.
+ * These structures help validate node configurations and provide better
+ * AI assistance by clearly defining what each property type expects.
+ *
+ * @module types/type-structures
+ * @since 2.23.0
+ */
+
+import type { NodePropertyTypes } from 'n8n-workflow';
+
+/**
+ * Structure definition for a node property type
+ *
+ * Describes the expected data structure, JavaScript type,
+ * example values, and validation rules for each property type.
+ *
+ * @interface TypeStructure
+ *
+ * @example
+ * ```typescript
+ * const stringStructure: TypeStructure = {
+ *   type: 'primitive',
+ *   jsType: 'string',
+ *   description: 'A text value',
+ *   example: 'Hello World',
+ *   validation: {
+ *     allowEmpty: true,
+ *     allowExpressions: true
+ *   }
+ * };
+ * ```
+ */
+export interface TypeStructure {
+	/**
+	 * Category of the type
+	 * - primitive: Basic JavaScript types (string, number, boolean)
+	 * - object: Complex object structures
+	 * - array: Array types
+	 * - collection: n8n collection types (nested properties)
+	 * - special: Special n8n types with custom behavior
+	 */
+	type: 'primitive' | 'object' | 'array' | 'collection' | 'special';
+
+	/**
+	 * Underlying JavaScript type
+	 */
+	jsType: 'string' | 'number' | 'boolean' | 'object' | 'array' | 'any';
+
+	/**
+	 * Human-readable description of the type
+	 */
+	description: string;
+
+	/**
+	 * Detailed structure definition for complex types
+	 * Describes the expected shape of the data
+	 */
+	structure?: {
+		/**
+		 * For objects: map of property names to their types
+		 */
+		properties?: Record<string, TypePropertyDefinition>;
+
+		/**
+		 * For arrays: type of array items
+		 */
+		items?: TypePropertyDefinition;
+
+		/**
+		 * Whether the structure is flexible (allows additional properties)
+		 */
+		flexible?: boolean;
+
+		/**
+		 * Required properties (for objects)
+		 */
+		required?: string[];
+	};
+
+	/**
+	 * Example value demonstrating correct usage
+	 */
+	example: any;
+
+	/**
+	 * Additional example values for complex types
+	 */
+	examples?: any[];
+
+	/**
+	 * Validation rules specific to this type
+	 */
+	validation?: {
+		/**
+		 * Whether empty values are allowed
+		 */
+		allowEmpty?: boolean;
+
+		/**
+		 * Whether n8n expressions ({{ ... }}) are allowed
+		 */
+		allowExpressions?: boolean;
+
+		/**
+		 * Minimum value (for numbers)
+		 */
+		min?: number;
+
+		/**
+		 * Maximum value (for numbers)
+		 */
+		max?: number;
+
+		/**
+		 * Pattern to match (for strings)
+		 */
+		pattern?: string;
+
+		/**
+		 * Custom validation function name
+		 */
+		customValidator?: string;
+	};
+
+	/**
+	 * Version when this type was introduced
+	 */
+	introducedIn?: string;
+
+	/**
+	 * Version when this type was deprecated (if applicable)
+	 */
+	deprecatedIn?: string;
+
+	/**
+	 * Type that replaces this one (if deprecated)
+	 */
+	replacedBy?: NodePropertyTypes;
+
+	/**
+	 * Additional notes or warnings
+	 */
+	notes?: string[];
+}
+
+/**
+ * Property definition within a structure
+ */
+export interface TypePropertyDefinition {
+	/**
+	 * Type of this property
+	 */
+	type: 'string' | 'number' | 'boolean' | 'object' | 'array' | 'any';
+
+	/**
+	 * Description of this property
+	 */
+	description?: string;
+
+	/**
+	 * Whether this property is required
+	 */
+	required?: boolean;
+
+	/**
+	 * Nested properties (for object types)
+	 */
+	properties?: Record<string, TypePropertyDefinition>;
+
+	/**
+	 * Type of array items (for array types)
+	 */
+	items?: TypePropertyDefinition;
+
+	/**
+	 * Example value
+	 */
+	example?: any;
+
+	/**
+	 * Allowed values (enum)
+	 */
+	enum?: Array<string | number | boolean>;
+
+	/**
+	 * Whether this structure allows additional properties beyond those defined
+	 */
+	flexible?: boolean;
+}
+
+/**
+ * Complex property types that have nested structures
+ *
+ * These types require special handling and validation
+ * beyond simple type checking.
+ */
+export type ComplexPropertyType =
+	| 'collection'
+	| 'fixedCollection'
+	| 'resourceLocator'
+	| 'resourceMapper'
+	| 'filter'
+	| 'assignmentCollection';
+
+/**
+ * Primitive property types (simple values)
+ *
+ * These types map directly to JavaScript primitives
+ * and don't require complex validation.
+ */
+export type PrimitivePropertyType =
+	| 'string'
+	| 'number'
+	| 'boolean'
+	| 'dateTime'
+	| 'color'
+	| 'json';
+
+/**
+ * Type guard to check if a property type is complex
+ *
+ * Complex types have nested structures and require
+ * special validation logic.
+ *
+ * @param type - The property type to check
+ * @returns True if the type is complex
+ *
+ * @example
+ * ```typescript
+ * if (isComplexType('collection')) {
+ *   // Handle complex type
+ * }
+ * ```
+ */
+export function isComplexType(type: NodePropertyTypes): type is ComplexPropertyType {
+	return (
+		type === 'collection' ||
+		type === 'fixedCollection' ||
+		type === 'resourceLocator' ||
+		type === 'resourceMapper' ||
+		type === 'filter' ||
+		type === 'assignmentCollection'
+	);
+}
+
+/**
+ * Type guard to check if a property type is primitive
+ *
+ * Primitive types map to simple JavaScript values
+ * and only need basic type validation.
+ *
+ * @param type - The property type to check
+ * @returns True if the type is primitive
+ *
+ * @example
+ * ```typescript
+ * if (isPrimitiveType('string')) {
+ *   // Handle as primitive
+ * }
+ * ```
+ */
+export function isPrimitiveType(type: NodePropertyTypes): type is PrimitivePropertyType {
+	return (
+		type === 'string' ||
+		type === 'number' ||
+		type === 'boolean' ||
+		type === 'dateTime' ||
+		type === 'color' ||
+		type === 'json'
+	);
+}
+
+/**
+ * Type guard to check if a value is a valid TypeStructure
+ *
+ * @param value - The value to check
+ * @returns True if the value conforms to TypeStructure interface
+ *
+ * @example
+ * ```typescript
+ * const maybeStructure = getStructureFromSomewhere();
+ * if (isTypeStructure(maybeStructure)) {
+ *   console.log(maybeStructure.example);
+ * }
+ * ```
+ */
+export function isTypeStructure(value: any): value is TypeStructure {
+	return (
+		value !== null &&
+		typeof value === 'object' &&
+		'type' in value &&
+		'jsType' in value &&
+		'description' in value &&
+		'example' in value &&
+		['primitive', 'object', 'array', 'collection', 'special'].includes(value.type) &&
+		['string', 'number', 'boolean', 'object', 'array', 'any'].includes(value.jsType)
+	);
+}

tests/integration/mcp-protocol/basic-connection.test.ts

@@ -4,72 +4,71 @@ import { N8NDocumentationMCPServer } from '../../../src/mcp/server';
 describe('Basic MCP Connection', () => {
   it('should initialize MCP server', async () => {
     const server = new N8NDocumentationMCPServer();
-    
-    // Test executeTool directly - it returns raw data
-    const result = await server.executeTool('get_database_statistics', {});
+
+    // Test executeTool directly - tools_documentation returns a string
+    const result = await server.executeTool('tools_documentation', {});
     expect(result).toBeDefined();
-    expect(typeof result).toBe('object');
-    expect(result.totalNodes).toBeDefined();
-    expect(result.statistics).toBeDefined();
-    
+    expect(typeof result).toBe('string');
+    expect(result).toContain('n8n MCP');
+
     await server.shutdown();
   });
-  
-  it('should execute list_nodes tool', async () => {
+
+  it('should execute search_nodes tool', async () => {
     const server = new N8NDocumentationMCPServer();
-    
-    // First check if we have any nodes in the database
-    const stats = await server.executeTool('get_database_statistics', {});
-    const hasNodes = stats.totalNodes > 0;
-    
-    const result = await server.executeTool('list_nodes', { limit: 5 });
-    expect(result).toBeDefined();
-    expect(typeof result).toBe('object');
-    expect(result.nodes).toBeDefined();
-    expect(Array.isArray(result.nodes)).toBe(true);
-    
-    if (hasNodes) {
-      // If database has nodes, we should get up to 5
-      expect(result.nodes.length).toBeLessThanOrEqual(5);
-      expect(result.nodes.length).toBeGreaterThan(0);
-      expect(result.nodes[0]).toHaveProperty('nodeType');
-      expect(result.nodes[0]).toHaveProperty('displayName');
-    } else {
-      // In test environment with empty database, we expect empty results
-      expect(result.nodes).toHaveLength(0);
+
+    try {
+      // Search for a common node to verify database has content
+      const result = await server.executeTool('search_nodes', { query: 'http', limit: 5 });
+      expect(result).toBeDefined();
+      expect(typeof result).toBe('object');
+      expect(result.results).toBeDefined();
+      expect(Array.isArray(result.results)).toBe(true);
+
+      if (result.totalCount > 0) {
+        // If database has nodes, we should get results
+        expect(result.results.length).toBeLessThanOrEqual(5);
+        expect(result.results.length).toBeGreaterThan(0);
+        expect(result.results[0]).toHaveProperty('nodeType');
+        expect(result.results[0]).toHaveProperty('displayName');
+      }
+    } catch (error: any) {
+      // In test environment with empty database, expect appropriate error
+      expect(error.message).toContain('Database is empty');
     }
-    
+
     await server.shutdown();
   });
-  
-  it('should search nodes', async () => {
+
+  it('should search nodes by keyword', async () => {
     const server = new N8NDocumentationMCPServer();
-    
-    // First check if we have any nodes in the database
-    const stats = await server.executeTool('get_database_statistics', {});
-    const hasNodes = stats.totalNodes > 0;
-    
-    const result = await server.executeTool('search_nodes', { query: 'webhook' });
-    expect(result).toBeDefined();
-    expect(typeof result).toBe('object');
-    expect(result.results).toBeDefined();
-    expect(Array.isArray(result.results)).toBe(true);
-    
-    // Only expect results if the database has nodes
-    if (hasNodes) {
-      expect(result.results.length).toBeGreaterThan(0);
-      expect(result.totalCount).toBeGreaterThan(0);
-      
-      // Should find webhook node
-      const webhookNode = result.results.find((n: any) => n.nodeType === 'nodes-base.webhook');
-      expect(webhookNode).toBeDefined();
-      expect(webhookNode.displayName).toContain('Webhook');
-    } else {
-      // In test environment with empty database, we expect empty results
-      expect(result.results).toHaveLength(0);
-      expect(result.totalCount).toBe(0);
+
+    try {
+      // Search to check if database has nodes
+      const searchResult = await server.executeTool('search_nodes', { query: 'set', limit: 1 });
+      const hasNodes = searchResult.totalCount > 0;
+
+      const result = await server.executeTool('search_nodes', { query: 'webhook' });
+      expect(result).toBeDefined();
+      expect(typeof result).toBe('object');
+      expect(result.results).toBeDefined();
+      expect(Array.isArray(result.results)).toBe(true);
+
+      // Only expect results if the database has nodes
+      if (hasNodes) {
+        expect(result.results.length).toBeGreaterThan(0);
+        expect(result.totalCount).toBeGreaterThan(0);
+
+        // Should find webhook node
+        const webhookNode = result.results.find((n: any) => n.nodeType === 'nodes-base.webhook');
+        expect(webhookNode).toBeDefined();
+        expect(webhookNode.displayName).toContain('Webhook');
+      }
+    } catch (error: any) {
+      // In test environment with empty database, expect appropriate error
+      expect(error.message).toContain('Database is empty');
     }
-    
+
     await server.shutdown();
   });
 });

tests/integration/mcp-protocol/error-handling.test.ts

@@ -59,7 +59,7 @@ describe('MCP Error Handling', () => {
     it('should handle invalid params', async () => {
       try {
         // Missing required parameter
-        await client.callTool({ name: 'get_node_info', arguments: {} });
+        await client.callTool({ name: 'get_node', arguments: {} });
         expect.fail('Should have thrown an error');
       } catch (error: any) {
         expect(error).toBeDefined();
@@ -71,7 +71,7 @@ describe('MCP Error Handling', () => {
     it('should handle internal errors gracefully', async () => {
       try {
         // Invalid node type format should cause internal processing error
-        await client.callTool({ name: 'get_node_info', arguments: {
+        await client.callTool({ name: 'get_node', arguments: {
           nodeType: 'completely-invalid-format-$$$$'
         } });
         expect.fail('Should have thrown an error');
@@ -84,16 +84,16 @@ describe('MCP Error Handling', () => {
 
   describe('Tool-Specific Errors', () => {
     describe('Node Discovery Errors', () => {
-      it('should handle invalid category filter', async () => {
-        const response = await client.callTool({ name: 'list_nodes', arguments: {
-          category: 'invalid_category'
+      it('should handle search with no matching results', async () => {
+        const response = await client.callTool({ name: 'search_nodes', arguments: {
+          query: 'xyznonexistentnode123'
         } });
 
         // Should return empty array, not error
         const result = JSON.parse((response as any).content[0].text);
-        expect(result).toHaveProperty('nodes');
-        expect(Array.isArray(result.nodes)).toBe(true);
-        expect(result.nodes).toHaveLength(0);
+        expect(result).toHaveProperty('results');
+        expect(Array.isArray(result.results)).toBe(true);
+        expect(result.results).toHaveLength(0);
       });
 
       it('should handle invalid search mode', async () => {
@@ -123,7 +123,7 @@ describe('MCP Error Handling', () => {
 
       it('should handle non-existent node types', async () => {
         try {
-          await client.callTool({ name: 'get_node_info', arguments: {
+          await client.callTool({ name: 'get_node', arguments: {
             nodeType: 'nodes-base.thisDoesNotExist'
           } });
           expect.fail('Should have thrown an error');
@@ -135,11 +135,13 @@ describe('MCP Error Handling', () => {
     });
 
     describe('Validation Errors', () => {
+      // v2.26.0: validate_node_operation consolidated into validate_node
       it('should handle invalid validation profile', async () => {
         try {
-          await client.callTool({ name: 'validate_node_operation', arguments: {
+          await client.callTool({ name: 'validate_node', arguments: {
             nodeType: 'nodes-base.httpRequest',
             config: { method: 'GET', url: 'https://api.example.com' },
+            mode: 'full',
             profile: 'invalid_profile' as any
           } });
           expect.fail('Should have thrown an error');
@@ -228,15 +230,17 @@ describe('MCP Error Handling', () => {
   describe('Large Payload Handling', () => {
     it('should handle large node info requests', async () => {
       // HTTP Request node has extensive properties
-      const response = await client.callTool({ name: 'get_node_info', arguments: {
-        nodeType: 'nodes-base.httpRequest'
+      const response = await client.callTool({ name: 'get_node', arguments: {
+        nodeType: 'nodes-base.httpRequest',
+        detail: 'full'
       } });
 
       expect((response as any).content[0].text.length).toBeGreaterThan(10000);
-      
+
       // Should be valid JSON
       const nodeInfo = JSON.parse((response as any).content[0].text);
-      expect(nodeInfo).toHaveProperty('properties');
+      expect(nodeInfo).toHaveProperty('nodeType');
+      expect(nodeInfo).toHaveProperty('displayName');
     });
 
     it('should handle large workflow validation', async () => {
@@ -277,9 +281,9 @@ describe('MCP Error Handling', () => {
 
       for (let i = 0; i < requestCount; i++) {
         promises.push(
-          client.callTool({ name: 'list_nodes', arguments: {
-            limit: 1,
-            category: i % 2 === 0 ? 'trigger' : 'transform'
+          client.callTool({ name: 'search_nodes', arguments: {
+            query: i % 2 === 0 ? 'webhook' : 'http',
+            limit: 1
           } })
         );
       }
@@ -290,12 +294,14 @@ describe('MCP Error Handling', () => {
   });
 
   describe('Invalid JSON Handling', () => {
+    // v2.26.0: validate_node_operation consolidated into validate_node
     it('should handle invalid JSON in tool parameters', async () => {
       try {
         // Config should be an object, not a string
-        await client.callTool({ name: 'validate_node_operation', arguments: {
+        await client.callTool({ name: 'validate_node', arguments: {
           nodeType: 'nodes-base.httpRequest',
-          config: 'invalid json string' as any
+          config: 'invalid json string' as any,
+          mode: 'full'
         } });
         expect.fail('Should have thrown an error');
       } catch (error: any) {
@@ -318,13 +324,13 @@ describe('MCP Error Handling', () => {
   describe('Timeout Scenarios', () => {
     it('should handle rapid sequential requests', async () => {
       const start = Date.now();
-      
+
       for (let i = 0; i < 20; i++) {
-        await client.callTool({ name: 'get_database_statistics', arguments: {} });
+        await client.callTool({ name: 'tools_documentation', arguments: {} });
       }
 
       const duration = Date.now() - start;
-      
+
       // Should complete reasonably quickly (under 5 seconds)
       expect(duration).toBeLessThan(5000);
     });
@@ -355,7 +361,7 @@ describe('MCP Error Handling', () => {
 
       for (const nodeType of largeNodes) {
         promises.push(
-          client.callTool({ name: 'get_node_info', arguments: { nodeType } })
+          client.callTool({ name: 'get_node', arguments: { nodeType } })
             .catch(() => null) // Some might not exist
         );
       }
@@ -400,7 +406,7 @@ describe('MCP Error Handling', () => {
     it('should continue working after errors', async () => {
       // Cause an error
       try {
-        await client.callTool({ name: 'get_node_info', arguments: {
+        await client.callTool({ name: 'get_node', arguments: {
           nodeType: 'invalid'
         } });
       } catch (error) {
@@ -408,25 +414,25 @@ describe('MCP Error Handling', () => {
       }
 
       // Should still work
-      const response = await client.callTool({ name: 'list_nodes', arguments: { limit: 1 } });
+      const response = await client.callTool({ name: 'search_nodes', arguments: { query: 'webhook', limit: 1 } });
       expect(response).toBeDefined();
     });
 
     it('should handle mixed success and failure', async () => {
       const promises = [
-        client.callTool({ name: 'list_nodes', arguments: { limit: 5 } }),
-        client.callTool({ name: 'get_node_info', arguments: { nodeType: 'invalid' } }).catch(e => ({ error: e })),
-        client.callTool({ name: 'get_database_statistics', arguments: {} }),
+        client.callTool({ name: 'search_nodes', arguments: { query: 'webhook', limit: 5 } }),
+        client.callTool({ name: 'get_node', arguments: { nodeType: 'invalid' } }).catch(e => ({ error: e })),
+        client.callTool({ name: 'tools_documentation', arguments: {} }),
         client.callTool({ name: 'search_nodes', arguments: { query: '' } }).catch(e => ({ error: e })),
-        client.callTool({ name: 'list_ai_tools', arguments: {} })
+        client.callTool({ name: 'get_node', arguments: { nodeType: 'nodes-base.httpRequest' } })
       ];
 
       const results = await Promise.all(promises);
-      
+
       // Some should succeed, some should fail
       const successes = results.filter(r => !('error' in r));
       const failures = results.filter(r => 'error' in r);
-      
+
       expect(successes.length).toBeGreaterThan(0);
       expect(failures.length).toBeGreaterThan(0);
     });
@@ -434,14 +440,14 @@ describe('MCP Error Handling', () => {
 
   describe('Edge Cases', () => {
     it('should handle empty responses gracefully', async () => {
-      const response = await client.callTool({ name: 'list_nodes', arguments: {
-        category: 'nonexistent_category'
+      const response = await client.callTool({ name: 'search_nodes', arguments: {
+        query: 'xyznonexistentnode12345'
       } });
 
       const result = JSON.parse((response as any).content[0].text);
-      expect(result).toHaveProperty('nodes');
-      expect(Array.isArray(result.nodes)).toBe(true);
-      expect(result.nodes).toHaveLength(0);
+      expect(result).toHaveProperty('results');
+      expect(Array.isArray(result.results)).toBe(true);
+      expect(result.results).toHaveLength(0);
     });
 
     it('should handle special characters in parameters', async () => {
@@ -467,14 +473,15 @@ describe('MCP Error Handling', () => {
 
     it('should handle null and undefined gracefully', async () => {
       // Most tools should handle missing optional params
-      const response = await client.callTool({ name: 'list_nodes', arguments: {
+      const response = await client.callTool({ name: 'search_nodes', arguments: {
+        query: 'webhook',
         limit: undefined as any,
-        category: null as any
+        mode: null as any
       } });
 
       const result = JSON.parse((response as any).content[0].text);
-      expect(result).toHaveProperty('nodes');
-      expect(Array.isArray(result.nodes)).toBe(true);
+      expect(result).toHaveProperty('results');
+      expect(Array.isArray(result.results)).toBe(true);
     });
   });
 
@@ -482,7 +489,7 @@ describe('MCP Error Handling', () => {
     it('should provide helpful error messages', async () => {
       try {
         // Use a truly invalid node type
-        await client.callTool({ name: 'get_node_info', arguments: {
+        await client.callTool({ name: 'get_node', arguments: {
           nodeType: 'invalid-node-type-that-does-not-exist'
         } });
         expect.fail('Should have thrown an error');
@@ -506,13 +513,15 @@ describe('MCP Error Handling', () => {
       }
     });
 
+    // v2.26.0: validate_node_operation consolidated into validate_node
     it('should provide context for validation errors', async () => {
-      const response = await client.callTool({ name: 'validate_node_operation', arguments: {
+      const response = await client.callTool({ name: 'validate_node', arguments: {
         nodeType: 'nodes-base.httpRequest',
         config: {
           // Missing required fields
           method: 'INVALID_METHOD'
-        }
+        },
+        mode: 'full'
       } });
 
       const validation = JSON.parse((response as any).content[0].text);