langflow-mcp-server 3.1.0 → 4.11.0

package/dist/mcp/server-consolidated.js

@@ -16,35 +16,37 @@ class LangflowMCPServerConsolidated {
         this.client = null;
         const baseUrl = process.env.LANGFLOW_BASE_URL;
         const apiKey = process.env.LANGFLOW_API_KEY;
-        if (!baseUrl || !apiKey) {
-            throw new Error('LANGFLOW_BASE_URL and LANGFLOW_API_KEY must be set in environment');
-        }
-        try {
-            const url = new URL(baseUrl);
-            if (!['http:', 'https:'].includes(url.protocol)) {
-                throw new Error(`Invalid protocol: ${url.protocol}. Only http: and https: are allowed.`);
-            }
-        }
-        catch (error) {
-            if (error instanceof TypeError) {
-                throw new Error(`Invalid LANGFLOW_BASE_URL format: ${baseUrl}`);
+        if (baseUrl && apiKey) {
+            try {
+                const url = new URL(baseUrl);
+                if (!['http:', 'https:'].includes(url.protocol)) {
+                    throw new Error(`Invalid protocol: ${url.protocol}. Only http: and https: are allowed.`);
+                }
             }
-            throw error;
-        }
-        if (apiKey.length < 10) {
-            throw new Error('LANGFLOW_API_KEY appears to be invalid (too short)');
+            catch (error) {
+                if (error instanceof TypeError) {
+                    throw new Error(`Invalid LANGFLOW_BASE_URL format: ${baseUrl}`);
+                }
+                throw error;
+            }
+            if (apiKey.length < 10) {
+                throw new Error('LANGFLOW_API_KEY appears to be invalid (too short)');
+            }
+            const DEFAULT_TIMEOUT = 30000;
+            const MIN_TIMEOUT = 1000;
+            const MAX_TIMEOUT = 300000;
+            const timeoutStr = process.env.LANGFLOW_TIMEOUT || String(DEFAULT_TIMEOUT);
+            let timeout = parseInt(timeoutStr, 10);
+            if (isNaN(timeout) || timeout < MIN_TIMEOUT || timeout > MAX_TIMEOUT) {
+                logger_1.logger.warn(`Invalid LANGFLOW_TIMEOUT: ${timeoutStr}, using default: ${DEFAULT_TIMEOUT}`);
+                timeout = DEFAULT_TIMEOUT;
+            }
+            const config = { baseUrl, apiKey, timeout };
+            this.client = new langflow_client_1.LangflowClient(config);
         }
-        const DEFAULT_TIMEOUT = 30000;
-        const MIN_TIMEOUT = 1000;
-        const MAX_TIMEOUT = 300000;
-        const timeoutStr = process.env.LANGFLOW_TIMEOUT || String(DEFAULT_TIMEOUT);
-        let timeout = parseInt(timeoutStr, 10);
-        if (isNaN(timeout) || timeout < MIN_TIMEOUT || timeout > MAX_TIMEOUT) {
-            logger_1.logger.warn(`Invalid LANGFLOW_TIMEOUT: ${timeoutStr}, using default: ${DEFAULT_TIMEOUT}`);
-            timeout = DEFAULT_TIMEOUT;
+        else {
+            logger_1.logger.warn('LANGFLOW_BASE_URL or LANGFLOW_API_KEY not set. Server will start but tools will return errors until configured.');
         }
-        const config = { baseUrl, apiKey, timeout };
-        this.client = new langflow_client_1.LangflowClient(config);
         logger_1.logger.info('Initializing Langflow MCP server (consolidated tools)');
         let serverVersion = 'dev';
         try {
@@ -150,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)`);
@@ -206,7 +212,7 @@ class LangflowMCPServerConsolidated {
         });
         this.server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
             if (!this.client) {
-                throw new Error('Langflow client not initialized');
+                throw new Error('Langflow client not initialized. Set LANGFLOW_BASE_URL and LANGFLOW_API_KEY environment variables.');
             }
             const { name, arguments: rawArgs } = request.params;
             if (rawArgs !== undefined && rawArgs !== null) {
@@ -247,6 +253,32 @@ 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 '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}`);
                 }
@@ -310,14 +342,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': {
@@ -368,10 +413,6 @@ class LangflowMCPServerConsolidated {
                 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);
@@ -479,6 +520,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) {
@@ -505,6 +550,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) {
@@ -528,7 +633,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 });
@@ -545,7 +650,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 });
@@ -597,6 +702,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) {
@@ -609,10 +756,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);
@@ -626,6 +769,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) {
@@ -662,6 +810,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) {
@@ -671,10 +823,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);
@@ -704,6 +852,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) {
@@ -753,7 +920,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 });
@@ -762,6 +929,508 @@ 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);
+            }
+        }
+    }
+    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();
+                return this.formatSuccessResponse(result);
+            }
+            case 'enabled_providers': {
+                const result = await this.client.listEnabledProviders(validated.providers ? { providers: validated.providers } : undefined);
+                return this.formatSuccessResponse(result);
+            }
+            case 'enabled_models': {
+                const result = await this.client.listEnabledModels(validated.model_names ? { model_names: validated.model_names } : 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();
+                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();
+                return this.formatSuccessResponse(result);
+            }
+            case 'options_embedding': {
+                const result = await this.client.getEmbeddingModelOptions();
+                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 '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 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(validated.flow_id ? { flow_id: validated.flow_id } : undefined);
+                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() {