langflow-mcp-server 3.1.0 → 4.11.0

package/dist/mcp/server.js

@@ -16,39 +16,41 @@ class LangflowMCPServer {
         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.`);
+        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.`);
+                }
             }
-        }
-        catch (error) {
-            if (error instanceof TypeError) {
-                throw new Error(`Invalid LANGFLOW_BASE_URL format: ${baseUrl}`);
+            catch (error) {
+                if (error instanceof TypeError) {
+                    throw new Error(`Invalid LANGFLOW_BASE_URL format: ${baseUrl}`);
+                }
+                throw error;
             }
-            throw error;
-        }
-        if (apiKey.length < 10) {
-            throw new Error('LANGFLOW_API_KEY appears to be invalid (too short)');
+            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');
         let serverVersion = 'dev';
         try {
@@ -87,7 +89,8 @@ class LangflowMCPServer {
             'access_token', 'refresh_token', 'authorization',
             'x-api-key', 'x-store-api-key', 'set-cookie',
             'bearer', 'session', 'session_id', 'cookie',
-            'private_key', 'secret', 'credentials', 'api-key'
+            'private_key', 'secret', 'credentials', 'api-key',
+            'file_content', 'file', 'content', 'payload', 'data'
         ]);
         if (depth > MAX_DEPTH) {
             return { __error: 'max depth exceeded' };
@@ -163,6 +166,10 @@ class LangflowMCPServer {
         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 ${Math.round(estimatedSize)} bytes (estimated) exceeds maximum allowed size of ${maxSizeBytes} bytes (10MB)`);
@@ -226,7 +233,7 @@ class LangflowMCPServer {
         });
         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) {
@@ -278,7 +285,8 @@ class LangflowMCPServer {
                     }
                     case 'run_flow': {
                         const validated = validation_1.RunFlowSchema.parse(args);
-                        const result = await this.client.runFlow(validated.flow_id_or_name, validated.input_request, validated.stream);
+                        const { context: nestedContext, ...inputRequest } = validated.input_request;
+                        const result = await this.client.runFlow(validated.flow_id_or_name, inputRequest, validated.stream, validated.context ?? nestedContext);
                         return this.formatSuccessResponse(result);
                     }
                     case 'trigger_webhook': {
@@ -448,7 +456,7 @@ class LangflowMCPServer {
                             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');
@@ -476,7 +484,7 @@ class LangflowMCPServer {
                             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');
@@ -493,7 +501,7 @@ class LangflowMCPServer {
                     case 'get_profile_picture': {
                         const validated = validation_1.GetProfilePictureSchema.parse(args);
                         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');
@@ -633,11 +641,6 @@ class LangflowMCPServer {
                         const result = await this.client.buildVertices(flow_id, request);
                         return this.formatSuccessResponse(result);
                     }
-                    case 'get_vertex': {
-                        const validated = validation_1.GetVertexSchema.parse(args);
-                        const result = await this.client.getVertex(validated);
-                        return this.formatSuccessResponse(result);
-                    }
                     case 'stream_vertex_build': {
                         const validated = validation_1.StreamVertexBuildSchema.parse(args);
                         const result = await this.client.streamVertexBuild(validated);
@@ -658,11 +661,6 @@ class LangflowMCPServer {
                         const result = await this.client.getCurrentUser();
                         return this.formatSuccessResponse(result);
                     }
-                    case 'get_user': {
-                        const validated = validation_1.GetUserSchema.parse(args);
-                        const result = await this.client.getUser(validated.user_id);
-                        return this.formatSuccessResponse(result);
-                    }
                     case 'update_user': {
                         const validated = validation_1.UpdateUserSchema.parse(args);
                         const { user_id, ...updates } = validated;
@@ -692,11 +690,6 @@ class LangflowMCPServer {
                         await this.client.deleteApiKey(validated.api_key_id);
                         return this.formatSuccessResponse({ success: true, message: 'API key deleted successfully' });
                     }
-                    case 'list_custom_components': {
-                        validation_1.ListCustomComponentsSchema.parse(args);
-                        const result = await this.client.listCustomComponents();
-                        return this.formatSuccessResponse(result);
-                    }
                     case 'create_custom_component': {
                         const validated = validation_1.CreateCustomComponentSchema.parse(args);
                         const result = await this.client.createCustomComponent(validated);
@@ -777,6 +770,712 @@ class LangflowMCPServer {
                         const result = await this.client.getLogs(validated.stream);
                         return this.formatSuccessResponse(result);
                     }
+                    case 'replace_flow': {
+                        const validated = validation_1.ReplaceFlowSchema.parse(args);
+                        const { flow_id, ...body } = validated;
+                        const result = await this.client.replaceFlow(flow_id, body);
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'expand_flows': {
+                        const validated = validation_1.ExpandFlowsSchema.parse(args);
+                        const result = await this.client.expandFlows(validated.body);
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'get_flow_events': {
+                        const validated = validation_1.GetFlowEventsSchema.parse(args);
+                        const result = await this.client.getFlowEvents(validated.flow_id, validated.since !== undefined ? { since: validated.since } : undefined);
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'create_flow_event': {
+                        const validated = validation_1.CreateFlowEventSchema.parse(args);
+                        const { flow_id, ...body } = validated;
+                        const result = await this.client.createFlowEvent(flow_id, body);
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'list_flow_versions': {
+                        const validated = validation_1.ListFlowVersionsSchema.parse(args);
+                        const { flow_id, ...params } = validated;
+                        const result = await this.client.listFlowVersions(flow_id, params);
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'create_flow_version': {
+                        const validated = validation_1.CreateFlowVersionSchema.parse(args);
+                        const result = await this.client.createFlowVersion(validated.flow_id, validated.body);
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'get_flow_version': {
+                        const validated = validation_1.GetFlowVersionSchema.parse(args);
+                        const result = await this.client.getFlowVersion(validated.flow_id, validated.version_id);
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'delete_flow_version': {
+                        const validated = validation_1.DeleteFlowVersionSchema.parse(args);
+                        await this.client.deleteFlowVersion(validated.flow_id, validated.version_id);
+                        return this.formatSuccessResponse({
+                            success: true,
+                            message: 'Flow version deleted successfully'
+                        });
+                    }
+                    case 'activate_flow_version': {
+                        const validated = validation_1.ActivateFlowVersionSchema.parse(args);
+                        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 'detect_variables': {
+                        const validated = validation_1.DetectVariablesSchema.parse(args);
+                        const result = await this.client.detectVariables({ flow_version_ids: validated.flow_version_ids });
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'save_store_api_key': {
+                        const validated = validation_1.SaveStoreApiKeySchema.parse(args);
+                        const result = await this.client.saveStoreApiKey(validated.api_key);
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'update_custom_component': {
+                        const validated = validation_1.UpdateCustomComponentSchema.parse(args);
+                        const result = await this.client.updateCustomComponentCode(validated);
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'create_store_component': {
+                        const validated = validation_1.CreateStoreComponentSchema.parse(args);
+                        const result = await this.client.createStoreComponent({
+                            description: null,
+                            tags: null,
+                            is_component: null,
+                            ...validated
+                        });
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'like_store_component': {
+                        const validated = validation_1.LikeStoreComponentSchema.parse(args);
+                        const result = await this.client.likeStoreComponent(validated.component_id);
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'create_response': {
+                        const validated = validation_1.CreateResponseSchema.parse(args);
+                        const result = await this.client.createResponse(validated);
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'get_session': {
+                        validation_1.GetSessionSchema.parse(args);
+                        const result = await this.client.getSession();
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'create_user': {
+                        const validated = validation_1.CreateUserSchema.parse(args);
+                        const result = await this.client.createUser(validated);
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'get_webhook_events': {
+                        const validated = validation_1.GetWebhookEventsSchema.parse(args);
+                        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 'get_health_check': {
+                        validation_1.GetHealthCheckSchema.parse(args);
+                        const result = await this.client.getHealthCheck();
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'list_files_v2': {
+                        validation_1.ListFilesV2Schema.parse(args);
+                        const result = await this.client.listFilesV2();
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'upload_file_v2': {
+                        const validated = validation_1.UploadFileV2Schema.parse(args);
+                        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_file_v2': {
+                        const validated = validation_1.GetFileV2Schema.parse(args);
+                        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_file_v2': {
+                        const validated = validation_1.RenameFileV2Schema.parse(args);
+                        const result = await this.client.renameFileV2(validated.file_id, validated.name);
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'delete_file_v2': {
+                        const validated = validation_1.DeleteFileV2Schema.parse(args);
+                        const result = await this.client.deleteFileV2(validated.file_id);
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'delete_all_files_v2': {
+                        validation_1.DeleteAllFilesV2Schema.parse(args);
+                        const result = await this.client.deleteAllFilesV2();
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'batch_download_files_v2': {
+                        const validated = validation_1.BatchDownloadFilesV2Schema.parse(args);
+                        const result = await this.client.batchDownloadFilesV2(validated.file_ids);
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'batch_delete_files_v2': {
+                        const validated = validation_1.BatchDeleteFilesV2Schema.parse(args);
+                        const result = await this.client.batchDeleteFilesV2(validated.file_ids);
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'list_knowledge_bases_detailed': {
+                        validation_1.ListKnowledgeBasesDetailedSchema.parse(args);
+                        const result = await this.client.listKnowledgeBasesDetailed();
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'create_knowledge_base': {
+                        const validated = validation_1.CreateKnowledgeBaseSchema.parse(args);
+                        const result = await this.client.createKnowledgeBase(validated);
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'preview_knowledge_base_chunks': {
+                        const validated = validation_1.PreviewKnowledgeBaseChunksSchema.parse(args);
+                        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 'list_knowledge_base_chunks': {
+                        const validated = validation_1.ListKnowledgeBaseChunksSchema.parse(args);
+                        const { kb_name, ...params } = validated;
+                        const result = await this.client.listKnowledgeBaseChunks(kb_name, params);
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'ingest_knowledge_base': {
+                        const validated = validation_1.IngestKnowledgeBaseSchema.parse(args);
+                        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 'cancel_knowledge_base_ingest': {
+                        const validated = validation_1.CancelKnowledgeBaseIngestSchema.parse(args);
+                        const result = await this.client.cancelKnowledgeBaseIngest(validated.kb_name);
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'update_monitor_message': {
+                        const validated = validation_1.UpdateMonitorMessageSchema.parse(args);
+                        const { message_id, ...body } = validated;
+                        const result = await this.client.updateMonitorMessage(message_id, body);
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'delete_monitor_session_messages': {
+                        const validated = validation_1.DeleteMonitorSessionMessagesSchema.parse(args);
+                        const result = await this.client.deleteMonitorSessionMessages(validated.session_id);
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'delete_monitor_sessions': {
+                        const validated = validation_1.DeleteMonitorSessionsSchema.parse(args);
+                        const result = await this.client.deleteMonitorSessions(validated.session_ids);
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'get_shared_messages': {
+                        const validated = validation_1.GetSharedMessagesSchema.parse(args);
+                        const result = await this.client.getSharedMessages(validated);
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'get_shared_sessions': {
+                        const validated = validation_1.GetSharedSessionsSchema.parse(args);
+                        const result = await this.client.getSharedSessions(validated.source_flow_id);
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'update_shared_message': {
+                        const validated = validation_1.UpdateSharedMessageSchema.parse(args);
+                        const { 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 validated = validation_1.MigrateSharedSessionSchema.parse(args);
+                        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 validated = validation_1.DeleteSharedSessionSchema.parse(args);
+                        const result = await this.client.deleteSharedSession(validated.session_id, validated.source_flow_id);
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'list_traces': {
+                        const validated = validation_1.ListTracesSchema.parse(args);
+                        const result = await this.client.listTraces(validated);
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'delete_traces': {
+                        const validated = validation_1.DeleteTracesSchema.parse(args);
+                        const result = await this.client.deleteTraces(validated.flow_id);
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'get_trace': {
+                        const validated = validation_1.GetTraceSchema.parse(args);
+                        const result = await this.client.getTrace(validated.trace_id);
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'delete_trace': {
+                        const validated = validation_1.DeleteTraceSchema.parse(args);
+                        await this.client.deleteTrace(validated.trace_id);
+                        return this.formatSuccessResponse({
+                            success: true,
+                            message: 'Trace deleted successfully'
+                        });
+                    }
+                    case 'list_models': {
+                        const validated = validation_1.ListModelsSchema.parse(args);
+                        const result = await this.client.listModels(validated);
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'list_model_providers': {
+                        validation_1.ListModelProvidersSchema.parse(args);
+                        const result = await this.client.listModelProviders();
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'list_enabled_providers': {
+                        const validated = validation_1.ListEnabledProvidersSchema.parse(args);
+                        const result = await this.client.listEnabledProviders(validated.providers ? { providers: validated.providers } : undefined);
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'list_enabled_models': {
+                        const validated = validation_1.ListEnabledModelsSchema.parse(args);
+                        const result = await this.client.listEnabledModels(validated.model_names ? { model_names: validated.model_names } : undefined);
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'set_enabled_models': {
+                        const validated = validation_1.SetEnabledModelsSchema.parse(args);
+                        const result = await this.client.setEnabledModels(validated.models);
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'get_default_model': {
+                        const validated = validation_1.GetDefaultModelSchema.parse(args);
+                        const result = await this.client.getDefaultModel({ model_type: validated.model_type });
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'set_default_model': {
+                        const validated = validation_1.SetDefaultModelSchema.parse(args);
+                        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_model': {
+                        const validated = validation_1.DeleteDefaultModelSchema.parse(args);
+                        const result = await this.client.deleteDefaultModel({ model_type: validated.model_type });
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'get_provider_variable_mapping': {
+                        validation_1.GetProviderVariableMappingSchema.parse(args);
+                        const result = await this.client.getProviderVariableMapping();
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'validate_model_provider': {
+                        const validated = validation_1.ValidateModelProviderSchema.parse(args);
+                        const result = await this.client.validateModelProvider({
+                            provider: validated.provider,
+                            variables: validated.variables
+                        });
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'get_language_model_options': {
+                        validation_1.GetLanguageModelOptionsSchema.parse(args);
+                        const result = await this.client.getLanguageModelOptions();
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'get_embedding_model_options': {
+                        validation_1.GetEmbeddingModelOptionsSchema.parse(args);
+                        const result = await this.client.getEmbeddingModelOptions();
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'agentic_assist': {
+                        const validated = validation_1.AgenticAssistSchema.parse(args);
+                        const result = await this.client.agenticAssist(validated);
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'agentic_check_config': {
+                        validation_1.AgenticCheckConfigSchema.parse(args);
+                        const result = await this.client.agenticCheckConfig();
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'agentic_execute': {
+                        const validated = validation_1.AgenticExecuteSchema.parse(args);
+                        const { flow_name, ...body } = validated;
+                        const result = await this.client.agenticExecute(flow_name, body);
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'get_workflow_result': {
+                        const validated = validation_1.GetWorkflowResultSchema.parse(args);
+                        const result = await this.client.getWorkflowResult(validated.job_id ? { job_id: validated.job_id } : undefined);
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'run_workflow': {
+                        const validated = validation_1.RunWorkflowSchema.parse(args);
+                        const result = await this.client.runWorkflow(validated);
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'stop_workflow': {
+                        const validated = validation_1.StopWorkflowSchema.parse(args);
+                        const result = await this.client.stopWorkflow(validated.job_id);
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'list_mcp_servers': {
+                        const validated = validation_1.ListMcpServersSchema.parse(args);
+                        const result = await this.client.listMcpServers(validated.action_count !== undefined ? { action_count: validated.action_count } : undefined);
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'get_mcp_server': {
+                        const validated = validation_1.GetMcpServerSchema.parse(args);
+                        const result = await this.client.getMcpServer(validated.server_name);
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'create_mcp_server': {
+                        const validated = validation_1.CreateMcpServerSchema.parse(args);
+                        const result = await this.client.createMcpServer(validated.server_name, validated.config);
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'update_mcp_server': {
+                        const validated = validation_1.UpdateMcpServerSchema.parse(args);
+                        const result = await this.client.updateMcpServer(validated.server_name, validated.config);
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'delete_mcp_server': {
+                        const validated = validation_1.DeleteMcpServerSchema.parse(args);
+                        const result = await this.client.deleteMcpServer(validated.server_name);
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'get_mcp_project_config': {
+                        const validated = validation_1.GetMcpProjectConfigSchema.parse(args);
+                        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_mcp_project_config': {
+                        const validated = validation_1.UpdateMcpProjectConfigSchema.parse(args);
+                        const result = await this.client.updateMcpProjectConfig(validated.project_id, {
+                            settings: validated.settings,
+                            auth_settings: validated.auth_settings
+                        });
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'get_mcp_project_installed': {
+                        const validated = validation_1.GetMcpProjectInstalledSchema.parse(args);
+                        const result = await this.client.getMcpProjectInstalled(validated.project_id);
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'install_mcp_project': {
+                        const validated = validation_1.InstallMcpProjectSchema.parse(args);
+                        const result = await this.client.installMcpProject(validated.project_id, {
+                            client: validated.client,
+                            transport: validated.transport
+                        });
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'get_mcp_project_composer_url': {
+                        const validated = validation_1.GetMcpProjectComposerUrlSchema.parse(args);
+                        const result = await this.client.getMcpProjectComposerUrl(validated.project_id);
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'list_authz_roles': {
+                        const validated = validation_1.ListAuthzRolesSchema.parse(args);
+                        const result = await this.client.listAuthzRoles(validated);
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'get_authz_role': {
+                        const validated = validation_1.GetAuthzRoleSchema.parse(args);
+                        const result = await this.client.getAuthzRole(validated.role_id);
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'create_authz_role': {
+                        const validated = validation_1.CreateAuthzRoleSchema.parse(args);
+                        const result = await this.client.createAuthzRole(validated);
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'update_authz_role': {
+                        const validated = validation_1.UpdateAuthzRoleSchema.parse(args);
+                        const { role_id, ...body } = validated;
+                        const result = await this.client.updateAuthzRole(role_id, body);
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'delete_authz_role': {
+                        const validated = validation_1.DeleteAuthzRoleSchema.parse(args);
+                        await this.client.deleteAuthzRole(validated.role_id);
+                        return this.formatSuccessResponse({
+                            success: true,
+                            message: 'Role deleted successfully'
+                        });
+                    }
+                    case 'list_authz_role_assignments': {
+                        const validated = validation_1.ListAuthzRoleAssignmentsSchema.parse(args);
+                        const result = await this.client.listAuthzRoleAssignments(validated);
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'create_authz_role_assignment': {
+                        const validated = validation_1.CreateAuthzRoleAssignmentSchema.parse(args);
+                        const result = await this.client.createAuthzRoleAssignment(validated);
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'delete_authz_role_assignment': {
+                        const validated = validation_1.DeleteAuthzRoleAssignmentSchema.parse(args);
+                        await this.client.deleteAuthzRoleAssignment(validated.assignment_id);
+                        return this.formatSuccessResponse({
+                            success: true,
+                            message: 'Role assignment deleted successfully'
+                        });
+                    }
+                    case 'list_authz_teams': {
+                        const validated = validation_1.ListAuthzTeamsSchema.parse(args);
+                        const result = await this.client.listAuthzTeams(validated);
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'get_authz_team': {
+                        const validated = validation_1.GetAuthzTeamSchema.parse(args);
+                        const result = await this.client.getAuthzTeam(validated.team_id);
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'create_authz_team': {
+                        const validated = validation_1.CreateAuthzTeamSchema.parse(args);
+                        const result = await this.client.createAuthzTeam(validated);
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'update_authz_team': {
+                        const validated = validation_1.UpdateAuthzTeamSchema.parse(args);
+                        const { team_id, ...body } = validated;
+                        const result = await this.client.updateAuthzTeam(team_id, body);
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'delete_authz_team': {
+                        const validated = validation_1.DeleteAuthzTeamSchema.parse(args);
+                        await this.client.deleteAuthzTeam(validated.team_id);
+                        return this.formatSuccessResponse({
+                            success: true,
+                            message: 'Team deleted successfully'
+                        });
+                    }
+                    case 'list_authz_team_members': {
+                        const validated = validation_1.ListAuthzTeamMembersSchema.parse(args);
+                        const { team_id, ...params } = validated;
+                        const result = await this.client.listAuthzTeamMembers(team_id, params);
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'add_authz_team_member': {
+                        const validated = validation_1.AddAuthzTeamMemberSchema.parse(args);
+                        const { team_id, ...body } = validated;
+                        const result = await this.client.addAuthzTeamMember(team_id, body);
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'remove_authz_team_member': {
+                        const validated = validation_1.RemoveAuthzTeamMemberSchema.parse(args);
+                        await this.client.removeAuthzTeamMember(validated.team_id, validated.user_id);
+                        return this.formatSuccessResponse({
+                            success: true,
+                            message: 'Team member removed successfully'
+                        });
+                    }
+                    case 'list_authz_shares': {
+                        const validated = validation_1.ListAuthzSharesSchema.parse(args);
+                        const result = await this.client.listAuthzShares(validated);
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'get_authz_share': {
+                        const validated = validation_1.GetAuthzShareSchema.parse(args);
+                        const result = await this.client.getAuthzShare(validated.share_id);
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'create_authz_share': {
+                        const validated = validation_1.CreateAuthzShareSchema.parse(args);
+                        const result = await this.client.createAuthzShare(validated);
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'update_authz_share': {
+                        const validated = validation_1.UpdateAuthzShareSchema.parse(args);
+                        const result = await this.client.updateAuthzShare(validated.share_id, {
+                            permission_level: validated.permission_level
+                        });
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'delete_authz_share': {
+                        const validated = validation_1.DeleteAuthzShareSchema.parse(args);
+                        await this.client.deleteAuthzShare(validated.share_id);
+                        return this.formatSuccessResponse({
+                            success: true,
+                            message: 'Share deleted successfully'
+                        });
+                    }
+                    case 'get_authz_audit': {
+                        const validated = validation_1.GetAuthzAuditSchema.parse(args);
+                        const result = await this.client.getAuthzAudit(validated);
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'get_my_permissions': {
+                        const validated = validation_1.GetMyPermissionsSchema.parse(args);
+                        const result = await this.client.getMyPermissions(validated);
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'create_memory_base': {
+                        const validated = validation_1.CreateMemoryBaseSchema.parse(args);
+                        const result = await this.client.createMemoryBase(validated);
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'list_memory_bases': {
+                        const validated = validation_1.ListMemoryBasesSchema.parse(args);
+                        const result = await this.client.listMemoryBases(validated);
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'get_memory_base': {
+                        const validated = validation_1.GetMemoryBaseSchema.parse(args);
+                        const result = await this.client.getMemoryBase(validated.memory_base_id);
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'list_memory_base_sessions': {
+                        const validated = validation_1.ListMemoryBaseSessionsSchema.parse(args);
+                        const { memory_base_id, ...params } = validated;
+                        const result = await this.client.listMemoryBaseSessions(memory_base_id, params);
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'list_memory_base_messages': {
+                        const validated = validation_1.ListMemoryBaseMessagesSchema.parse(args);
+                        const { memory_base_id, ...params } = validated;
+                        const result = await this.client.listMemoryBaseMessages(memory_base_id, params);
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'update_memory_base': {
+                        const validated = validation_1.UpdateMemoryBaseSchema.parse(args);
+                        const { memory_base_id, ...body } = validated;
+                        const result = await this.client.updateMemoryBase(memory_base_id, body);
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'delete_memory_base': {
+                        const validated = validation_1.DeleteMemoryBaseSchema.parse(args);
+                        await this.client.deleteMemoryBase(validated.memory_base_id);
+                        return this.formatSuccessResponse({
+                            success: true,
+                            message: 'Memory base deleted successfully'
+                        });
+                    }
+                    case 'flush_memory_base': {
+                        const validated = validation_1.FlushMemoryBaseSchema.parse(args);
+                        const result = await this.client.flushMemoryBase(validated.memory_base_id, {
+                            session_id: validated.session_id
+                        });
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'check_memory_base_mismatch': {
+                        const validated = validation_1.CheckMemoryBaseMismatchSchema.parse(args);
+                        const result = await this.client.checkMemoryBaseMismatch(validated.memory_base_id);
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'regenerate_memory_base': {
+                        const validated = validation_1.RegenerateMemoryBaseSchema.parse(args);
+                        const result = await this.client.regenerateMemoryBase(validated.memory_base_id);
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'test_knowledge_base_connection': {
+                        const validated = validation_1.TestKnowledgeBaseConnectionSchema.parse(args);
+                        const result = await this.client.testKnowledgeBaseConnection(validated);
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'list_knowledge_base_connectors': {
+                        validation_1.ListKnowledgeBaseConnectorsSchema.parse(args);
+                        const result = await this.client.listKnowledgeBaseConnectors();
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'ingest_knowledge_base_folder': {
+                        const validated = validation_1.IngestKnowledgeBaseFolderSchema.parse(args);
+                        const { kb_name, ...body } = validated;
+                        const result = await this.client.ingestKnowledgeBaseFolder(kb_name, body);
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'ingest_knowledge_base_connector': {
+                        const validated = validation_1.IngestKnowledgeBaseConnectorSchema.parse(args);
+                        const { kb_name, ...body } = validated;
+                        const result = await this.client.ingestKnowledgeBaseConnector(kb_name, body);
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'get_knowledge_base_metadata_keys': {
+                        const validated = validation_1.GetKnowledgeBaseMetadataKeysSchema.parse(args);
+                        const result = await this.client.getKnowledgeBaseMetadataKeys(validated.kb_name);
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'list_knowledge_base_runs': {
+                        const validated = validation_1.ListKnowledgeBaseRunsSchema.parse(args);
+                        const { kb_name, ...params } = validated;
+                        const result = await this.client.listKnowledgeBaseRuns(kb_name, params);
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'get_knowledge_base_run': {
+                        const validated = validation_1.GetKnowledgeBaseRunSchema.parse(args);
+                        const result = await this.client.getKnowledgeBaseRun(validated.kb_name, validated.run_id);
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'reload_extension_bundle': {
+                        const validated = validation_1.ReloadExtensionBundleSchema.parse(args);
+                        const result = await this.client.reloadExtensionBundle(validated.extension_id, validated.bundle_name);
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'get_extension_events': {
+                        const validated = validation_1.GetExtensionEventsSchema.parse(args);
+                        const result = await this.client.getExtensionEvents(validated);
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'get_agentic_file': {
+                        const validated = validation_1.GetAgenticFileSchema.parse(args);
+                        const result = await this.client.getAgenticFile(validated);
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'reset_agentic_session': {
+                        const validated = validation_1.ResetAgenticSessionSchema.parse(args);
+                        const result = await this.client.resetAgenticSession(validated);
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'get_flow_note_translations': {
+                        const validated = validation_1.GetFlowNoteTranslationsSchema.parse(args);
+                        const result = await this.client.getFlowNoteTranslations(validated.flow_id);
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'get_job_queue_metrics': {
+                        validation_1.GetJobQueueMetricsSchema.parse(args);
+                        const result = await this.client.getJobQueueMetrics();
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'list_a2a_agents': {
+                        validation_1.ListA2aAgentsSchema.parse(args);
+                        const result = await this.client.listA2aAgents();
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'get_a2a_agent_card': {
+                        const validated = validation_1.GetA2aAgentCardSchema.parse(args);
+                        const result = await this.client.getA2aAgentCard(validated.flow_id);
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'invoke_a2a_jsonrpc': {
+                        const validated = validation_1.InvokeA2aJsonrpcSchema.parse(args);
+                        const { flow_id, ...body } = validated;
+                        const result = await this.client.invokeA2aJsonrpc(flow_id, body);
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'list_pending_workflows': {
+                        const validated = validation_1.ListPendingWorkflowsSchema.parse(args);
+                        const result = await this.client.listPendingWorkflows(validated.flow_id ? { flow_id: validated.flow_id } : undefined);
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'get_workflow_events': {
+                        const validated = validation_1.GetWorkflowEventsSchema.parse(args);
+                        const result = await this.client.getWorkflowEvents(validated.job_id);
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'resume_workflow': {
+                        const validated = validation_1.ResumeWorkflowSchema.parse(args);
+                        const { job_id, ...body } = validated;
+                        const result = await this.client.resumeWorkflow(job_id, body);
+                        return this.formatSuccessResponse(result);
+                    }
+                    case 'run_public_workflow': {
+                        const validated = validation_1.RunPublicWorkflowSchema.parse(args);
+                        const result = await this.client.runPublicWorkflow(validated);
+                        return this.formatSuccessResponse(result);
+                    }
                     default:
                         throw new Error(`Unknown tool: ${name}`);
                 }