langflow-mcp-server 3.1.1 → 4.12.2

package/dist/mcp/server-consolidated.js

@@ -73,7 +73,7 @@ class LangflowMCPServerConsolidated {
             'x-api-key', 'x-store-api-key', 'set-cookie',
             'bearer', 'session', 'session_id', 'cookie',
             'private_key', 'secret', 'credentials', 'api-key',
-            'file_content', 'file', 'content', 'payload', 'data'
+            'file_content', 'file', 'content', 'payload', 'data', 'auth_settings', 'input_value', 'instruction'
         ]);
         if (depth > MAX_DEPTH)
             return { __error: 'max depth exceeded' };
@@ -152,6 +152,10 @@ class LangflowMCPServerConsolidated {
         if (!base64Regex.test(fileContent)) {
             throw new Error('Invalid base64 format');
         }
+        if (fileContent.length % 4 !== 0 ||
+            Buffer.from(fileContent, 'base64').toString('base64') !== fileContent) {
+            throw new Error('Invalid base64 format');
+        }
         const estimatedSize = (fileContent.length * 3) / 4;
         if (estimatedSize > maxSizeBytes) {
             throw new Error(`File size exceeds maximum allowed size of ${maxSizeBytes} bytes (10MB)`);
@@ -249,6 +253,34 @@ class LangflowMCPServerConsolidated {
                         return await this.handleValidationTool(args);
                     case 'system':
                         return await this.handleSystemTool(args);
+                    case 'flow_version':
+                        return await this.handleFlowVersionTool(args);
+                    case 'file_v2':
+                        return await this.handleFileV2Tool(args);
+                    case 'model':
+                        return await this.handleModelTool(args);
+                    case 'agentic':
+                        return await this.handleAgenticTool(args);
+                    case 'workflow':
+                        return await this.handleWorkflowTool(args);
+                    case 'a2a':
+                        return await this.handleA2aTool(args);
+                    case 'governance':
+                        return await this.handleGovernanceTool(args);
+                    case 'mcp_server':
+                        return await this.handleMcpServerTool(args);
+                    case 'mcp_project':
+                        return await this.handleMcpProjectTool(args);
+                    case 'trace':
+                        return await this.handleTraceTool(args);
+                    case 'response':
+                        return await this.handleResponseTool(args);
+                    case 'authz':
+                        return await this.handleAuthzTool(args);
+                    case 'memory':
+                        return await this.handleMemoryTool(args);
+                    case 'extension':
+                        return await this.handleExtensionTool(args);
                     default:
                         throw new Error(`Unknown tool: ${name}`);
                 }
@@ -312,14 +344,27 @@ class LangflowMCPServerConsolidated {
                 const starters = await this.client.listStarterProjects();
                 return this.formatSuccessResponse(starters);
             }
+            case 'replace': {
+                const { action: _, flow_id, ...body } = validated;
+                const result = await this.client.replaceFlow(flow_id, body);
+                return this.formatSuccessResponse(result);
+            }
+            case 'expand': {
+                const result = await this.client.expandFlows(validated.body);
+                return this.formatSuccessResponse(result);
+            }
+            case 'note_translations': {
+                const result = await this.client.getFlowNoteTranslations(validated.flow_id);
+                return this.formatSuccessResponse(result);
+            }
         }
     }
     async handleFlowExecutionTool(args) {
         const validated = validation_consolidated_1.FlowExecutionToolSchema.parse(args);
         switch (validated.action) {
             case 'run': {
-                const { action: _, flow_id_or_name, stream, ...inputRequest } = validated;
-                const result = await this.client.runFlow(flow_id_or_name, inputRequest, stream);
+                const { action: _, flow_id_or_name, stream, context, ...inputRequest } = validated;
+                const result = await this.client.runFlow(flow_id_or_name, inputRequest, stream, context);
                 return this.formatSuccessResponse(result);
             }
             case 'run_advanced': {
@@ -357,23 +402,32 @@ class LangflowMCPServerConsolidated {
                 const result = await this.client.buildFlow(flow_id, { inputs, data, files }, params);
                 return this.formatSuccessResponse(result);
             }
+            case 'public_start': {
+                const { action: _, flow_id, inputs, files, ...params } = validated;
+                const result = await this.client.buildPublicFlow(flow_id, { inputs, files }, params);
+                return this.formatSuccessResponse(result);
+            }
             case 'status': {
                 const result = await this.client.getBuildStatus(validated.job_id, validated.event_delivery);
                 return this.formatSuccessResponse(result);
             }
+            case 'public_events': {
+                const result = await this.client.getPublicBuildEvents(validated.job_id, validated.event_delivery);
+                return this.formatSuccessResponse(result);
+            }
             case 'cancel': {
                 const result = await this.client.cancelBuild(validated.job_id);
                 return this.formatSuccessResponse(result);
             }
+            case 'public_cancel': {
+                const result = await this.client.cancelPublicBuild(validated.job_id);
+                return this.formatSuccessResponse(result);
+            }
             case 'vertices': {
                 const { action: _, flow_id, ...request } = validated;
                 const result = await this.client.buildVertices(flow_id, request);
                 return this.formatSuccessResponse(result);
             }
-            case 'get_vertex': {
-                const result = await this.client.getVertex({ flow_id: validated.flow_id, vertex_id: validated.vertex_id });
-                return this.formatSuccessResponse(result);
-            }
             case 'stream_vertex': {
                 const result = await this.client.streamVertexBuild({ flow_id: validated.flow_id, vertex_id: validated.vertex_id });
                 return this.formatSuccessResponse(result);
@@ -446,6 +500,11 @@ class LangflowMCPServerConsolidated {
                 const updated = await this.client.updateProject(project_id, updates);
                 return this.formatSuccessResponse(updated);
             }
+            case 'upsert': {
+                const { action: _, project_id, ...body } = validated;
+                const updated = await this.client.upsertProject(project_id, body);
+                return this.formatSuccessResponse(updated);
+            }
             case 'delete': {
                 await this.client.deleteProject(validated.project_id);
                 return this.formatSuccessResponse({ success: true, message: 'Project deleted successfully' });
@@ -481,6 +540,10 @@ class LangflowMCPServerConsolidated {
                 await this.client.deleteVariable(validated.variable_id);
                 return this.formatSuccessResponse({ success: true, message: 'Variable deleted successfully' });
             }
+            case 'detect': {
+                const result = await this.client.detectVariables({ flow_version_ids: validated.flow_version_ids });
+                return this.formatSuccessResponse(result);
+            }
         }
     }
     async handleKnowledgeBaseTool(args) {
@@ -507,6 +570,66 @@ class LangflowMCPServerConsolidated {
                 const result = await this.client.uploadKnowledgeBase(validated.kb_name, fileBuffer, validated.file_name);
                 return this.formatSuccessResponse(result);
             }
+            case 'create': {
+                const { action: _, ...body } = validated;
+                const result = await this.client.createKnowledgeBase(body);
+                return this.formatSuccessResponse(result);
+            }
+            case 'list_detailed': {
+                const result = await this.client.listKnowledgeBasesDetailed();
+                return this.formatSuccessResponse(result);
+            }
+            case 'list_chunks': {
+                const { action: _, kb_name, ...params } = validated;
+                const result = await this.client.listKnowledgeBaseChunks(kb_name, params);
+                return this.formatSuccessResponse(result);
+            }
+            case 'ingest': {
+                const fileBuffer = this.validateFileSize(validated.file_content);
+                const result = await this.client.ingestKnowledgeBase(validated.kb_name, [{ buffer: fileBuffer, filename: validated.file_name }], validated.params);
+                return this.formatSuccessResponse(result);
+            }
+            case 'preview_chunks': {
+                const fileBuffer = this.validateFileSize(validated.file_content);
+                const result = await this.client.previewKnowledgeBaseChunks([{ buffer: fileBuffer, filename: validated.file_name }], validated.params);
+                return this.formatSuccessResponse(result);
+            }
+            case 'cancel_ingest': {
+                const result = await this.client.cancelKnowledgeBaseIngest(validated.kb_name);
+                return this.formatSuccessResponse(result);
+            }
+            case 'test_connection': {
+                const { action: _, ...body } = validated;
+                const result = await this.client.testKnowledgeBaseConnection(body);
+                return this.formatSuccessResponse(result);
+            }
+            case 'list_connectors': {
+                const result = await this.client.listKnowledgeBaseConnectors();
+                return this.formatSuccessResponse(result);
+            }
+            case 'ingest_folder': {
+                const { action: _, kb_name, ...body } = validated;
+                const result = await this.client.ingestKnowledgeBaseFolder(kb_name, body);
+                return this.formatSuccessResponse(result);
+            }
+            case 'ingest_connector': {
+                const { action: _, kb_name, ...body } = validated;
+                const result = await this.client.ingestKnowledgeBaseConnector(kb_name, body);
+                return this.formatSuccessResponse(result);
+            }
+            case 'metadata_keys': {
+                const result = await this.client.getKnowledgeBaseMetadataKeys(validated.kb_name);
+                return this.formatSuccessResponse(result);
+            }
+            case 'list_runs': {
+                const { action: _, kb_name, ...params } = validated;
+                const result = await this.client.listKnowledgeBaseRuns(kb_name, params);
+                return this.formatSuccessResponse(result);
+            }
+            case 'get_run': {
+                const result = await this.client.getKnowledgeBaseRun(validated.kb_name, validated.run_id);
+                return this.formatSuccessResponse(result);
+            }
         }
     }
     async handleFileTool(args) {
@@ -530,7 +653,7 @@ class LangflowMCPServerConsolidated {
                     flow_id: validated.flow_id,
                     file_name: validated.file_name
                 });
-                if (!fileData)
+                if (!fileData || (fileData.byteLength ?? fileData.length) === 0)
                     throw new Error('No file data received from server');
                 const base64Data = Buffer.from(fileData).toString('base64');
                 return this.formatSuccessResponse({ file_name: validated.file_name, content: base64Data });
@@ -547,7 +670,7 @@ class LangflowMCPServerConsolidated {
                     flow_id: validated.flow_id,
                     file_name: validated.file_name
                 });
-                if (!imageData)
+                if (!imageData || (imageData.byteLength ?? imageData.length) === 0)
                     throw new Error('No image data received from server');
                 const base64Data = Buffer.from(imageData).toString('base64');
                 return this.formatSuccessResponse({ file_name: validated.file_name, content: base64Data });
@@ -599,6 +722,48 @@ class LangflowMCPServerConsolidated {
                 const result = await this.client.getMonitorTransactions({ flow_id: flow_id, ...params });
                 return this.formatSuccessResponse(result);
             }
+            case 'update_message': {
+                const { action: _, message_id, ...body } = validated;
+                const result = await this.client.updateMonitorMessage(message_id, body);
+                return this.formatSuccessResponse(result);
+            }
+            case 'delete_session_messages': {
+                const result = await this.client.deleteMonitorSessionMessages(validated.session_id);
+                return this.formatSuccessResponse(result);
+            }
+            case 'delete_sessions': {
+                const result = await this.client.deleteMonitorSessions(validated.session_ids);
+                return this.formatSuccessResponse(result);
+            }
+            case 'get_shared': {
+                const { action: _, ...params } = validated;
+                const result = await this.client.getSharedMessages(params);
+                return this.formatSuccessResponse(result);
+            }
+            case 'get_shared_sessions': {
+                const result = await this.client.getSharedSessions(validated.source_flow_id);
+                return this.formatSuccessResponse(result);
+            }
+            case 'update_shared': {
+                const { action: _, message_id, source_flow_id, ...body } = validated;
+                const result = await this.client.updateSharedMessage(message_id, source_flow_id, body);
+                return this.formatSuccessResponse(result);
+            }
+            case 'migrate_shared_session': {
+                const result = await this.client.migrateSharedSession(validated.session_id, {
+                    new_session_id: validated.new_session_id,
+                    source_flow_id: validated.source_flow_id
+                });
+                return this.formatSuccessResponse(result);
+            }
+            case 'delete_shared_session': {
+                const result = await this.client.deleteSharedSession(validated.session_id, validated.source_flow_id);
+                return this.formatSuccessResponse(result);
+            }
+            case 'job_queue': {
+                const result = await this.client.getJobQueueMetrics();
+                return this.formatSuccessResponse(result);
+            }
         }
     }
     async handleUserTool(args) {
@@ -611,10 +776,6 @@ class LangflowMCPServerConsolidated {
                 const result = await this.client.listUsers(params);
                 return this.formatSuccessResponse(result);
             }
-            case 'get': {
-                const result = await this.client.getUser(validated.user_id);
-                return this.formatSuccessResponse(result);
-            }
             case 'get_current': {
                 const result = await this.client.getCurrentUser();
                 return this.formatSuccessResponse(result);
@@ -628,6 +789,11 @@ class LangflowMCPServerConsolidated {
                 const result = await this.client.resetUserPassword(validated.user_id, validated.new_password);
                 return this.formatSuccessResponse(result);
             }
+            case 'create': {
+                const { action: _, ...body } = validated;
+                const result = await this.client.createUser(body);
+                return this.formatSuccessResponse(result);
+            }
         }
     }
     async handleAuthTool(args) {
@@ -664,6 +830,10 @@ class LangflowMCPServerConsolidated {
                 await this.client.deleteApiKey(validated.api_key_id);
                 return this.formatSuccessResponse({ success: true, message: 'API key deleted successfully' });
             }
+            case 'save_store_key': {
+                const result = await this.client.saveStoreApiKey(validated.api_key);
+                return this.formatSuccessResponse(result);
+            }
         }
     }
     async handleStoreTool(args) {
@@ -673,10 +843,6 @@ class LangflowMCPServerConsolidated {
                 const components = await this.client.listComponents();
                 return this.formatSuccessResponse(components);
             }
-            case 'list_custom': {
-                const result = await this.client.listCustomComponents();
-                return this.formatSuccessResponse(result);
-            }
             case 'create_custom': {
                 const result = await this.client.createCustomComponent({ name: validated.name, code: validated.code });
                 return this.formatSuccessResponse(result);
@@ -706,6 +872,25 @@ class LangflowMCPServerConsolidated {
                 const likes = await this.client.getUserLikes();
                 return this.formatSuccessResponse(likes);
             }
+            case 'create_store': {
+                const { action: _, ...body } = validated;
+                const result = await this.client.createStoreComponent({
+                    description: null,
+                    tags: null,
+                    is_component: null,
+                    ...body
+                });
+                return this.formatSuccessResponse(result);
+            }
+            case 'like': {
+                const result = await this.client.likeStoreComponent(validated.component_id);
+                return this.formatSuccessResponse(result);
+            }
+            case 'update_custom': {
+                const { action: _, ...body } = validated;
+                const result = await this.client.updateCustomComponentCode(body);
+                return this.formatSuccessResponse(result);
+            }
         }
     }
     async handleRegistrationTool(args) {
@@ -755,7 +940,7 @@ class LangflowMCPServerConsolidated {
             }
             case 'get_picture': {
                 const pictureData = await this.client.getProfilePicture(validated.folder_name, validated.file_name);
-                if (!pictureData)
+                if (!pictureData || (pictureData.byteLength ?? pictureData.length) === 0)
                     throw new Error('No picture data received from server');
                 const base64Data = Buffer.from(pictureData).toString('base64');
                 return this.formatSuccessResponse({ file_name: validated.file_name, content: base64Data });
@@ -764,6 +949,571 @@ class LangflowMCPServerConsolidated {
                 const voices = await this.client.listElevenLabsVoices();
                 return this.formatSuccessResponse(voices);
             }
+            case 'session': {
+                const result = await this.client.getSession();
+                return this.formatSuccessResponse(result);
+            }
+            case 'webhook_events': {
+                const result = await this.client.getWebhookEvents(validated.flow_id_or_name, validated.user_id ? { user_id: validated.user_id } : undefined);
+                return this.formatSuccessResponse(result);
+            }
+            case 'health_check': {
+                const result = await this.client.getHealthCheck();
+                return this.formatSuccessResponse(result);
+            }
+            case 'healthz': {
+                const result = await this.client.getHealthz();
+                return this.formatSuccessResponse(result);
+            }
+        }
+    }
+    async handleFlowVersionTool(args) {
+        const validated = validation_consolidated_1.FlowVersionToolSchema.parse(args);
+        switch (validated.action) {
+            case 'list': {
+                const { action: _, flow_id, ...params } = validated;
+                const result = await this.client.listFlowVersions(flow_id, params);
+                return this.formatSuccessResponse(result);
+            }
+            case 'create': {
+                const result = await this.client.createFlowVersion(validated.flow_id, validated.body);
+                return this.formatSuccessResponse(result);
+            }
+            case 'get': {
+                const result = await this.client.getFlowVersion(validated.flow_id, validated.version_id);
+                return this.formatSuccessResponse(result);
+            }
+            case 'delete': {
+                await this.client.deleteFlowVersion(validated.flow_id, validated.version_id);
+                return this.formatSuccessResponse({ success: true, message: 'Flow version deleted successfully' });
+            }
+            case 'activate': {
+                const result = await this.client.activateFlowVersion(validated.flow_id, validated.version_id, validated.save_draft !== undefined ? { save_draft: validated.save_draft } : undefined);
+                return this.formatSuccessResponse(result);
+            }
+            case 'get_events': {
+                const result = await this.client.getFlowEvents(validated.flow_id, validated.since !== undefined ? { since: validated.since } : undefined);
+                return this.formatSuccessResponse(result);
+            }
+            case 'create_event': {
+                const { action: _, flow_id, ...body } = validated;
+                const result = await this.client.createFlowEvent(flow_id, body);
+                return this.formatSuccessResponse(result);
+            }
+        }
+    }
+    async handleFileV2Tool(args) {
+        const validated = validation_consolidated_1.FileV2ToolSchema.parse(args);
+        switch (validated.action) {
+            case 'list': {
+                const result = await this.client.listFilesV2();
+                return this.formatSuccessResponse(result);
+            }
+            case 'upload': {
+                const fileBuffer = this.validateFileSize(validated.file_content);
+                const params = {};
+                if (validated.append !== undefined)
+                    params.append = validated.append;
+                if (validated.ephemeral !== undefined)
+                    params.ephemeral = validated.ephemeral;
+                const result = await this.client.uploadFileV2(fileBuffer, validated.file_name, params);
+                return this.formatSuccessResponse(result);
+            }
+            case 'get': {
+                const result = await this.client.getFileV2(validated.file_id, validated.return_content !== undefined ? { return_content: validated.return_content } : undefined);
+                return this.formatSuccessResponse(result);
+            }
+            case 'rename': {
+                const result = await this.client.renameFileV2(validated.file_id, validated.name);
+                return this.formatSuccessResponse(result);
+            }
+            case 'delete': {
+                const result = await this.client.deleteFileV2(validated.file_id);
+                return this.formatSuccessResponse(result);
+            }
+            case 'delete_all': {
+                const result = await this.client.deleteAllFilesV2();
+                return this.formatSuccessResponse(result);
+            }
+            case 'batch_download': {
+                const result = await this.client.batchDownloadFilesV2(validated.file_ids);
+                return this.formatSuccessResponse(result);
+            }
+            case 'batch_delete': {
+                const result = await this.client.batchDeleteFilesV2(validated.file_ids);
+                return this.formatSuccessResponse(result);
+            }
+        }
+    }
+    async handleModelTool(args) {
+        const validated = validation_consolidated_1.ModelToolSchema.parse(args);
+        switch (validated.action) {
+            case 'list': {
+                const { action: _, ...params } = validated;
+                const result = await this.client.listModels(params);
+                return this.formatSuccessResponse(result);
+            }
+            case 'providers': {
+                const result = await this.client.listModelProviders(validated.purpose ? { purpose: validated.purpose } : undefined);
+                return this.formatSuccessResponse(result);
+            }
+            case 'provider_descriptors': {
+                const result = await this.client.listModelProviderDescriptors(validated.purpose ? { purpose: validated.purpose } : undefined);
+                return this.formatSuccessResponse(result);
+            }
+            case 'enabled_providers': {
+                const result = await this.client.listEnabledProviders(validated.providers || validated.purpose
+                    ? { providers: validated.providers, purpose: validated.purpose }
+                    : undefined);
+                return this.formatSuccessResponse(result);
+            }
+            case 'enabled_models': {
+                const result = await this.client.listEnabledModels(validated.model_names || validated.purpose
+                    ? { model_names: validated.model_names, purpose: validated.purpose }
+                    : undefined);
+                return this.formatSuccessResponse(result);
+            }
+            case 'set_enabled': {
+                const result = await this.client.setEnabledModels(validated.models);
+                return this.formatSuccessResponse(result);
+            }
+            case 'get_default': {
+                const result = await this.client.getDefaultModel({ model_type: validated.model_type });
+                return this.formatSuccessResponse(result);
+            }
+            case 'set_default': {
+                const result = await this.client.setDefaultModel({
+                    provider: validated.provider,
+                    model_name: validated.model_name,
+                    model_type: validated.model_type
+                });
+                return this.formatSuccessResponse(result);
+            }
+            case 'delete_default': {
+                const result = await this.client.deleteDefaultModel({ model_type: validated.model_type });
+                return this.formatSuccessResponse(result);
+            }
+            case 'provider_mapping': {
+                const result = await this.client.getProviderVariableMapping(validated.purpose ? { purpose: validated.purpose } : undefined);
+                return this.formatSuccessResponse(result);
+            }
+            case 'validate_provider': {
+                const result = await this.client.validateModelProvider({
+                    provider: validated.provider,
+                    variables: validated.variables
+                });
+                return this.formatSuccessResponse(result);
+            }
+            case 'options_language': {
+                const result = await this.client.getLanguageModelOptions(validated.purpose ? { purpose: validated.purpose } : undefined);
+                return this.formatSuccessResponse(result);
+            }
+            case 'options_embedding': {
+                const result = await this.client.getEmbeddingModelOptions(validated.purpose ? { purpose: validated.purpose } : undefined);
+                return this.formatSuccessResponse(result);
+            }
+        }
+    }
+    async handleAgenticTool(args) {
+        const validated = validation_consolidated_1.AgenticToolSchema.parse(args);
+        switch (validated.action) {
+            case 'assist': {
+                const { action: _, ...body } = validated;
+                const result = await this.client.agenticAssist(body);
+                return this.formatSuccessResponse(result);
+            }
+            case 'assist_stream': {
+                const { action: _, ...body } = validated;
+                const result = await this.client.agenticAssistStream(body);
+                return this.formatSuccessResponse(result);
+            }
+            case 'assist_run': {
+                const { action: _, ...body } = validated;
+                const result = await this.client.agenticAssistRun(body);
+                return this.formatSuccessResponse(result);
+            }
+            case 'check_config': {
+                const result = await this.client.agenticCheckConfig();
+                return this.formatSuccessResponse(result);
+            }
+            case 'execute': {
+                const { action: _, flow_name, ...body } = validated;
+                const result = await this.client.agenticExecute(flow_name, body);
+                return this.formatSuccessResponse(result);
+            }
+            case 'get_file': {
+                const result = await this.client.getAgenticFile({
+                    path: validated.path,
+                    download: validated.download
+                });
+                return this.formatSuccessResponse(result);
+            }
+            case 'reset_session': {
+                const result = await this.client.resetAgenticSession(validated.session_id !== undefined ? { session_id: validated.session_id } : undefined);
+                return this.formatSuccessResponse(result);
+            }
+        }
+    }
+    async handleGovernanceTool(args) {
+        const validated = validation_consolidated_1.GovernanceToolSchema.parse(args);
+        switch (validated.action) {
+            case 'get_model_provider_policy':
+                return this.formatSuccessResponse(await this.client.getModelProviderPolicy());
+            case 'replace_model_provider_policy': {
+                const { action: _, ...body } = validated;
+                return this.formatSuccessResponse(await this.client.replaceModelProviderPolicy(body));
+            }
+            case 'get_catalog_component_policy':
+                return this.formatSuccessResponse(await this.client.getCatalogComponentPolicy());
+            case 'replace_catalog_component_policy':
+                return this.formatSuccessResponse(await this.client.replaceCatalogComponentPolicy({ blocked: validated.blocked }));
+            case 'get_catalog_template_policy':
+                return this.formatSuccessResponse(await this.client.getCatalogTemplatePolicy());
+            case 'replace_catalog_template_policy':
+                return this.formatSuccessResponse(await this.client.replaceCatalogTemplatePolicy({ blocked: validated.blocked }));
+            case 'get_catalog_policy_usage':
+                return this.formatSuccessResponse(await this.client.getCatalogPolicyUsage());
+            case 'get_catalog_policy_usage_flows':
+                return this.formatSuccessResponse(await this.client.getCatalogPolicyUsageFlows({
+                    component: validated.component,
+                    limit: validated.limit
+                }));
+            case 'get_policy_bundle':
+                return this.formatSuccessResponse(await this.client.getPolicyBundle());
+            case 'replace_policy_bundle': {
+                const { action: _, ...body } = validated;
+                return this.formatSuccessResponse(await this.client.replacePolicyBundle(body));
+            }
+            case 'list_policy_bundle_history':
+                return this.formatSuccessResponse(await this.client.listPolicyBundleHistory({
+                    limit: validated.limit,
+                    before_revision: validated.before_revision
+                }));
+            case 'rollback_policy_bundle': {
+                const { action: _, revision, ...body } = validated;
+                return this.formatSuccessResponse(await this.client.rollbackPolicyBundle(revision, body));
+            }
+        }
+    }
+    async handleWorkflowTool(args) {
+        const validated = validation_consolidated_1.WorkflowToolSchema.parse(args);
+        switch (validated.action) {
+            case 'run': {
+                const { action: _, ...body } = validated;
+                const result = await this.client.runWorkflow(body);
+                return this.formatSuccessResponse(result);
+            }
+            case 'get_result': {
+                const result = await this.client.getWorkflowResult(validated.job_id ? { job_id: validated.job_id } : undefined);
+                return this.formatSuccessResponse(result);
+            }
+            case 'stop': {
+                const result = await this.client.stopWorkflow(validated.job_id);
+                return this.formatSuccessResponse(result);
+            }
+            case 'pending': {
+                const result = await this.client.listPendingWorkflows({ flow_id: validated.flow_id });
+                return this.formatSuccessResponse(result);
+            }
+            case 'events': {
+                const result = await this.client.getWorkflowEvents(validated.job_id);
+                return this.formatSuccessResponse(result);
+            }
+            case 'resume': {
+                const { action: _, job_id, ...body } = validated;
+                const result = await this.client.resumeWorkflow(job_id, body);
+                return this.formatSuccessResponse(result);
+            }
+            case 'run_public': {
+                const { action: _, ...body } = validated;
+                const result = await this.client.runPublicWorkflow(body);
+                return this.formatSuccessResponse(result);
+            }
+        }
+    }
+    async handleA2aTool(args) {
+        const validated = validation_consolidated_1.A2aToolSchema.parse(args);
+        switch (validated.action) {
+            case 'list_agents': {
+                const result = await this.client.listA2aAgents();
+                return this.formatSuccessResponse(result);
+            }
+            case 'agent_card': {
+                const result = await this.client.getA2aAgentCard(validated.flow_id);
+                return this.formatSuccessResponse(result);
+            }
+            case 'jsonrpc': {
+                const { action: _, flow_id, ...body } = validated;
+                const result = await this.client.invokeA2aJsonrpc(flow_id, body);
+                return this.formatSuccessResponse(result);
+            }
+        }
+    }
+    async handleMcpServerTool(args) {
+        const validated = validation_consolidated_1.McpServerToolSchema.parse(args);
+        switch (validated.action) {
+            case 'list': {
+                const result = await this.client.listMcpServers(validated.action_count !== undefined ? { action_count: validated.action_count } : undefined);
+                return this.formatSuccessResponse(result);
+            }
+            case 'get': {
+                const result = await this.client.getMcpServer(validated.server_name);
+                return this.formatSuccessResponse(result);
+            }
+            case 'create': {
+                const result = await this.client.createMcpServer(validated.server_name, validated.config);
+                return this.formatSuccessResponse(result);
+            }
+            case 'update': {
+                const result = await this.client.updateMcpServer(validated.server_name, validated.config);
+                return this.formatSuccessResponse(result);
+            }
+            case 'delete': {
+                const result = await this.client.deleteMcpServer(validated.server_name);
+                return this.formatSuccessResponse(result);
+            }
+        }
+    }
+    async handleMcpProjectTool(args) {
+        const validated = validation_consolidated_1.McpProjectToolSchema.parse(args);
+        switch (validated.action) {
+            case 'get_config': {
+                const result = await this.client.getMcpProjectConfig(validated.project_id, validated.mcp_enabled !== undefined ? { mcp_enabled: validated.mcp_enabled } : undefined);
+                return this.formatSuccessResponse(result);
+            }
+            case 'update_config': {
+                const result = await this.client.updateMcpProjectConfig(validated.project_id, {
+                    settings: validated.settings,
+                    auth_settings: validated.auth_settings
+                });
+                return this.formatSuccessResponse(result);
+            }
+            case 'get_installed': {
+                const result = await this.client.getMcpProjectInstalled(validated.project_id);
+                return this.formatSuccessResponse(result);
+            }
+            case 'install': {
+                const result = await this.client.installMcpProject(validated.project_id, {
+                    client: validated.client,
+                    transport: validated.transport
+                });
+                return this.formatSuccessResponse(result);
+            }
+            case 'get_composer_url': {
+                const result = await this.client.getMcpProjectComposerUrl(validated.project_id);
+                return this.formatSuccessResponse(result);
+            }
+        }
+    }
+    async handleTraceTool(args) {
+        const validated = validation_consolidated_1.TraceToolSchema.parse(args);
+        switch (validated.action) {
+            case 'list': {
+                const { action: _, ...params } = validated;
+                const result = await this.client.listTraces(params);
+                return this.formatSuccessResponse(result);
+            }
+            case 'get': {
+                const result = await this.client.getTrace(validated.trace_id);
+                return this.formatSuccessResponse(result);
+            }
+            case 'delete': {
+                await this.client.deleteTrace(validated.trace_id);
+                return this.formatSuccessResponse({ success: true, message: 'Trace deleted successfully' });
+            }
+            case 'delete_by_flow': {
+                const result = await this.client.deleteTraces(validated.flow_id);
+                return this.formatSuccessResponse(result);
+            }
+        }
+    }
+    async handleResponseTool(args) {
+        const validated = validation_consolidated_1.ResponseToolSchema.parse(args);
+        switch (validated.action) {
+            case 'create': {
+                const { action: _, ...body } = validated;
+                const result = await this.client.createResponse(body);
+                return this.formatSuccessResponse(result);
+            }
+        }
+    }
+    async handleAuthzTool(args) {
+        const validated = validation_consolidated_1.AuthzToolSchema.parse(args);
+        switch (validated.action) {
+            case 'list_roles': {
+                const { action: _, ...params } = validated;
+                const result = await this.client.listAuthzRoles(params);
+                return this.formatSuccessResponse(result);
+            }
+            case 'get_role': {
+                const result = await this.client.getAuthzRole(validated.role_id);
+                return this.formatSuccessResponse(result);
+            }
+            case 'create_role': {
+                const { action: _, ...body } = validated;
+                const result = await this.client.createAuthzRole(body);
+                return this.formatSuccessResponse(result);
+            }
+            case 'update_role': {
+                const { action: _, role_id, ...body } = validated;
+                const result = await this.client.updateAuthzRole(role_id, body);
+                return this.formatSuccessResponse(result);
+            }
+            case 'delete_role': {
+                await this.client.deleteAuthzRole(validated.role_id);
+                return this.formatSuccessResponse({ success: true, message: 'Role deleted successfully' });
+            }
+            case 'list_role_assignments': {
+                const { action: _, ...params } = validated;
+                const result = await this.client.listAuthzRoleAssignments(params);
+                return this.formatSuccessResponse(result);
+            }
+            case 'create_role_assignment': {
+                const { action: _, ...body } = validated;
+                const result = await this.client.createAuthzRoleAssignment(body);
+                return this.formatSuccessResponse(result);
+            }
+            case 'delete_role_assignment': {
+                await this.client.deleteAuthzRoleAssignment(validated.assignment_id);
+                return this.formatSuccessResponse({ success: true, message: 'Role assignment deleted successfully' });
+            }
+            case 'list_teams': {
+                const { action: _, ...params } = validated;
+                const result = await this.client.listAuthzTeams(params);
+                return this.formatSuccessResponse(result);
+            }
+            case 'get_team': {
+                const result = await this.client.getAuthzTeam(validated.team_id);
+                return this.formatSuccessResponse(result);
+            }
+            case 'create_team': {
+                const { action: _, ...body } = validated;
+                const result = await this.client.createAuthzTeam(body);
+                return this.formatSuccessResponse(result);
+            }
+            case 'update_team': {
+                const { action: _, team_id, ...body } = validated;
+                const result = await this.client.updateAuthzTeam(team_id, body);
+                return this.formatSuccessResponse(result);
+            }
+            case 'delete_team': {
+                await this.client.deleteAuthzTeam(validated.team_id);
+                return this.formatSuccessResponse({ success: true, message: 'Team deleted successfully' });
+            }
+            case 'list_team_members': {
+                const { action: _, team_id, ...params } = validated;
+                const result = await this.client.listAuthzTeamMembers(team_id, params);
+                return this.formatSuccessResponse(result);
+            }
+            case 'add_team_member': {
+                const { action: _, team_id, ...body } = validated;
+                const result = await this.client.addAuthzTeamMember(team_id, body);
+                return this.formatSuccessResponse(result);
+            }
+            case 'remove_team_member': {
+                await this.client.removeAuthzTeamMember(validated.team_id, validated.user_id);
+                return this.formatSuccessResponse({ success: true, message: 'Team member removed successfully' });
+            }
+            case 'list_shares': {
+                const { action: _, ...params } = validated;
+                const result = await this.client.listAuthzShares(params);
+                return this.formatSuccessResponse(result);
+            }
+            case 'get_share': {
+                const result = await this.client.getAuthzShare(validated.share_id);
+                return this.formatSuccessResponse(result);
+            }
+            case 'create_share': {
+                const { action: _, ...body } = validated;
+                const result = await this.client.createAuthzShare(body);
+                return this.formatSuccessResponse(result);
+            }
+            case 'update_share': {
+                const result = await this.client.updateAuthzShare(validated.share_id, {
+                    permission_level: validated.permission_level
+                });
+                return this.formatSuccessResponse(result);
+            }
+            case 'delete_share': {
+                await this.client.deleteAuthzShare(validated.share_id);
+                return this.formatSuccessResponse({ success: true, message: 'Share deleted successfully' });
+            }
+            case 'audit': {
+                const { action: _, audit_action, ...rest } = validated;
+                const params = { ...rest, ...(audit_action !== undefined ? { action: audit_action } : {}) };
+                const result = await this.client.getAuthzAudit(params);
+                return this.formatSuccessResponse(result);
+            }
+            case 'my_permissions': {
+                const { action: _, ...body } = validated;
+                const result = await this.client.getMyPermissions(body);
+                return this.formatSuccessResponse(result);
+            }
+        }
+    }
+    async handleMemoryTool(args) {
+        const validated = validation_consolidated_1.MemoryToolSchema.parse(args);
+        switch (validated.action) {
+            case 'create': {
+                const { action: _, ...body } = validated;
+                const result = await this.client.createMemoryBase(body);
+                return this.formatSuccessResponse(result);
+            }
+            case 'list': {
+                const { action: _, ...params } = validated;
+                const result = await this.client.listMemoryBases(params);
+                return this.formatSuccessResponse(result);
+            }
+            case 'get': {
+                const result = await this.client.getMemoryBase(validated.memory_base_id);
+                return this.formatSuccessResponse(result);
+            }
+            case 'list_sessions': {
+                const { action: _, memory_base_id, ...params } = validated;
+                const result = await this.client.listMemoryBaseSessions(memory_base_id, params);
+                return this.formatSuccessResponse(result);
+            }
+            case 'list_messages': {
+                const { action: _, memory_base_id, ...params } = validated;
+                const result = await this.client.listMemoryBaseMessages(memory_base_id, params);
+                return this.formatSuccessResponse(result);
+            }
+            case 'update': {
+                const { action: _, memory_base_id, ...body } = validated;
+                const result = await this.client.updateMemoryBase(memory_base_id, body);
+                return this.formatSuccessResponse(result);
+            }
+            case 'delete': {
+                await this.client.deleteMemoryBase(validated.memory_base_id);
+                return this.formatSuccessResponse({ success: true, message: 'Memory base deleted successfully' });
+            }
+            case 'flush': {
+                const result = await this.client.flushMemoryBase(validated.memory_base_id, {
+                    session_id: validated.session_id
+                });
+                return this.formatSuccessResponse(result);
+            }
+            case 'mismatch': {
+                const result = await this.client.checkMemoryBaseMismatch(validated.memory_base_id);
+                return this.formatSuccessResponse(result);
+            }
+            case 'regenerate': {
+                const result = await this.client.regenerateMemoryBase(validated.memory_base_id);
+                return this.formatSuccessResponse(result);
+            }
+        }
+    }
+    async handleExtensionTool(args) {
+        const validated = validation_consolidated_1.ExtensionToolSchema.parse(args);
+        switch (validated.action) {
+            case 'reload': {
+                const result = await this.client.reloadExtensionBundle(validated.extension_id, validated.bundle_name);
+                return this.formatSuccessResponse(result);
+            }
+            case 'events': {
+                const result = await this.client.getExtensionEvents(validated.since !== undefined ? { since: validated.since } : undefined);
+                return this.formatSuccessResponse(result);
+            }
         }
     }
     async run() {
@@ -771,6 +1521,9 @@ class LangflowMCPServerConsolidated {
         await this.server.connect(transport);
         logger_1.logger.info('Langflow MCP server (consolidated) running on stdio');
     }
+    async connectTransport(transport) {
+        await this.server.connect(transport);
+    }
     async shutdown() {
         logger_1.logger.info('Shutting down Langflow MCP server');
         await this.server.close();