snow-flow 4.5.48 → 4.5.50

package/dist/mcp/servicenow-flow-workspace-mobile-mcp.js

@@ -263,6 +263,35 @@ class ServiceNowFlowWorkspaceMobileMCP {
                         required: ['workspace_sys_id', 'workspace_type']
                     }
                 },
+                // COMPREHENSIVE TOOL HEALTH CHECKING
+                {
+                    name: 'snow_test_all_workspace_tools',
+                    description: 'Test all workspace and UI Builder tools to check availability, permissions, and functionality. Provides comprehensive status report with detailed feedback.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            include_ui_builder: { type: 'boolean', default: true, description: 'Test UI Builder tools' },
+                            include_workspace: { type: 'boolean', default: true, description: 'Test workspace creation tools' },
+                            include_mobile: { type: 'boolean', default: true, description: 'Test mobile tools' },
+                            include_flow: { type: 'boolean', default: true, description: 'Test flow tools' },
+                            detailed_errors: { type: 'boolean', default: true, description: 'Include detailed error information' }
+                        }
+                    }
+                },
+                {
+                    name: 'snow_check_plugin_availability',
+                    description: 'Check availability and licensing status of all ServiceNow plugins required for workspace and UI Builder functionality.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            check_ui_builder: { type: 'boolean', default: true, description: 'Check UI Builder plugin' },
+                            check_uxf: { type: 'boolean', default: true, description: 'Check Now Experience Framework' },
+                            check_agent_workspace: { type: 'boolean', default: true, description: 'Check Agent Workspace plugin' },
+                            check_mobile: { type: 'boolean', default: true, description: 'Check Mobile Publishing' },
+                            include_recommendations: { type: 'boolean', default: true, description: 'Include setup recommendations' }
+                        }
+                    }
+                },
                 // Mobile Tools
                 {
                     name: 'snow_configure_mobile_app',
@@ -822,6 +851,12 @@ class ServiceNowFlowWorkspaceMobileMCP {
                     case 'snow_validate_workspace_configuration':
                         result = await this.validateWorkspaceConfiguration(args);
                         break;
+                    case 'snow_test_all_workspace_tools':
+                        result = await this.testAllWorkspaceTools(args);
+                        break;
+                    case 'snow_check_plugin_availability':
+                        result = await this.checkPluginAvailability(args);
+                        break;
                     // Mobile
                     case 'snow_configure_mobile_app':
                         result = await this.configureMobileApp(args);
@@ -1377,20 +1412,40 @@ ${executionList}
                 }
                 throw new Error(`Failed to configure mobile app: ${response.error}`);
             }
+            // VERIFICATION: Confirm mobile app was configured
+            const sys_id = response.data.result.sys_id;
+            const verification = await this.client.getRecord('sys_mobile_application_config', sys_id);
+            if (!verification.success) {
+                return {
+                    success: false,
+                    error: 'Mobile app configuration reported success but record not found in sys_mobile_application_config table',
+                    suggestion: 'Mobile app configuration may have been rolled back due to validation errors',
+                    verification_failed: true
+                };
+            }
+            this.logger.info(`✅ Mobile app configured and verified: ${sys_id}`);
             return {
-                content: [{
-                        type: 'text',
-                        text: `✅ Mobile App configured!
-
-📱 **${args.app_name}**
-🆔 sys_id: ${response.data.sys_id}
-🔐 Authentication: ${args.authentication || 'oauth'}
-📦 Modules: ${args.enabled_modules ? args.enabled_modules.length : 0}
-💾 Offline Tables: ${args.offline_tables ? args.offline_tables.length : 0}
-🔔 Push Notifications: ${args.push_enabled !== false ? 'Enabled' : 'Disabled'}
-
-✨ Mobile app configuration saved!`
-                    }]
+                success: true,
+                verified: true,
+                mobile_app_sys_id: sys_id,
+                app_name: args.app_name,
+                authentication: args.authentication || 'oauth',
+                modules_count: args.enabled_modules ? args.enabled_modules.length : 0,
+                offline_tables_count: args.offline_tables ? args.offline_tables.length : 0,
+                push_enabled: args.push_enabled !== false,
+                created_at: new Date().toISOString(),
+                message: `✅ Mobile app '${args.app_name}' configured and verified successfully`,
+                detailed_confirmation: {
+                    operation: 'CONFIGURE Mobile App',
+                    sys_id: sys_id,
+                    app_name: args.app_name,
+                    authentication_method: args.authentication || 'oauth',
+                    enabled_modules: args.enabled_modules || [],
+                    offline_tables: args.offline_tables || [],
+                    push_notifications: args.push_enabled !== false,
+                    verified_in_table: 'sys_mobile_application_config',
+                    verification_timestamp: new Date().toISOString()
+                }
             };
         }
         catch (error) {
@@ -1423,20 +1478,39 @@ ${executionList}
             if (!response.success) {
                 throw new Error(`Failed to create mobile layout: ${response.error}`);
             }
+            // VERIFICATION: Confirm mobile layout was created
+            const sys_id = response.data.result.sys_id;
+            const verification = await this.client.getRecord('sys_mobile_layout', sys_id);
+            if (!verification.success) {
+                return {
+                    success: false,
+                    error: 'Mobile layout creation reported success but record not found in sys_mobile_layout table',
+                    suggestion: 'Mobile layout creation may have been rolled back due to validation errors',
+                    verification_failed: true
+                };
+            }
+            this.logger.info(`✅ Mobile layout created and verified: ${sys_id}`);
             return {
-                content: [{
-                        type: 'text',
-                        text: `✅ Mobile Layout created!
-
-📱 **${args.name}**
-🆔 sys_id: ${response.data.sys_id}
-📋 Table: ${args.table}
-📊 Type: ${args.type}
-📝 Fields: ${args.fields ? args.fields.length : 'Default'}
-🔗 Related Lists: ${args.related_lists ? args.related_lists.length : 0}
-
-✨ Mobile layout configured!`
-                    }]
+                success: true,
+                verified: true,
+                mobile_layout_sys_id: sys_id,
+                layout_name: args.name,
+                layout_table: args.table,
+                layout_type: args.type,
+                fields_count: args.fields ? args.fields.length : 0,
+                related_lists_count: args.related_lists ? args.related_lists.length : 0,
+                created_at: new Date().toISOString(),
+                message: `✅ Mobile layout '${args.name}' created and verified successfully`,
+                detailed_confirmation: {
+                    operation: 'CREATE Mobile Layout',
+                    sys_id: sys_id,
+                    name: args.name,
+                    table: args.table,
+                    type: args.type,
+                    fields: args.fields || [],
+                    verified_in_table: 'sys_mobile_layout',
+                    verification_timestamp: new Date().toISOString()
+                }
             };
         }
         catch (error) {
@@ -1802,9 +1876,30 @@ ${configList}${layoutsText}${offlineText}
             const query = conditions.join('^');
             const pagesResponse = await this.client.searchRecords('sys_ux_page', query, args.limit || 50);
             if (!pagesResponse.success) {
-                throw new Error(`Failed to discover UI Builder pages: ${pagesResponse.error}`);
+                return {
+                    success: false,
+                    error: `Failed to discover UI Builder pages: ${pagesResponse.error}`,
+                    suggestion: 'UI Builder plugin may not be installed. Check ServiceNow Store for UI Builder plugin.',
+                    plugin_required: 'UI Builder',
+                    table_tested: 'sys_ux_page'
+                };
+            }
+            const pages = pagesResponse.data.result || [];
+            // Handle no results case
+            if (pages.length === 0) {
+                return {
+                    success: true,
+                    pages: [],
+                    count: 0,
+                    message: '📝 No UI Builder pages found',
+                    explanation: 'This could mean: 1) No pages exist yet, 2) UI Builder plugin not installed, 3) Insufficient permissions to view pages',
+                    suggestions: [
+                        'Create your first UI Builder page using snow_create_uib_page',
+                        'Check if UI Builder plugin is installed and activated',
+                        'Verify you have ui_builder_user or ui_builder_admin roles'
+                    ]
+                };
             }
-            const pages = pagesResponse.data.result;
             // Enrich with additional data if requested
             for (const page of pages) {
                 if (args.include_routing) {
@@ -1823,8 +1918,18 @@ ${configList}${layoutsText}${offlineText}
             this.logger.info(`✅ Found ${pages.length} UI Builder pages`);
             return {
                 success: true,
+                verified: true,
                 pages: pages,
-                count: pages.length
+                count: pages.length,
+                query_used: query || 'No filter',
+                message: `✅ Successfully discovered ${pages.length} UI Builder pages`,
+                detailed_confirmation: {
+                    operation: 'DISCOVER UI Builder Pages',
+                    table_searched: 'sys_ux_page',
+                    results_count: pages.length,
+                    query_conditions: conditions.join(', ') || 'No conditions',
+                    search_timestamp: new Date().toISOString()
+                }
             };
         }
         catch (error) {
@@ -1870,12 +1975,34 @@ ${configList}${layoutsText}${offlineText}
                 await this.client.deleteRecord('sys_ux_lib_source_script', sourceResponse.data.sys_id);
                 throw new Error(`Failed to create component: ${componentResponse.error}`);
             }
-            this.logger.info('✅ UI Builder component created successfully');
+            // VERIFICATION: Confirm both records were created
+            const componentVerification = await this.client.getRecord('sys_ux_lib_component', componentResponse.data.result.sys_id);
+            const sourceVerification = await this.client.getRecord('sys_ux_lib_source_script', sourceResponse.data.result.sys_id);
+            if (!componentVerification.success || !sourceVerification.success) {
+                return {
+                    success: false,
+                    error: 'Component creation reported success but records not found in tables',
+                    suggestion: 'Component creation may have been rolled back due to validation errors',
+                    verification_failed: true
+                };
+            }
+            this.logger.info(`✅ UI Builder component created and verified: ${componentResponse.data.result.sys_id}`);
             return {
                 success: true,
-                component: componentResponse.data,
-                source_script: sourceResponse.data,
-                message: `Custom UI Builder component '${args.name}' created successfully`
+                verified: true,
+                component_sys_id: componentResponse.data.result.sys_id,
+                source_script_sys_id: sourceResponse.data.result.sys_id,
+                component_name: args.name,
+                category: args.category || 'custom',
+                created_at: new Date().toISOString(),
+                message: `✅ Custom UI Builder component '${args.name}' created and verified successfully`,
+                detailed_confirmation: {
+                    operation: 'CREATE UI Builder Component',
+                    component_sys_id: componentResponse.data.result.sys_id,
+                    source_script_sys_id: sourceResponse.data.result.sys_id,
+                    verified_in_tables: ['sys_ux_lib_component', 'sys_ux_lib_source_script'],
+                    verification_timestamp: new Date().toISOString()
+                }
             };
         }
         catch (error) {
@@ -1954,9 +2081,31 @@ ${configList}${layoutsText}${offlineText}
             const query = conditions.join('^');
             const componentsResponse = await this.client.searchRecords('sys_ux_lib_component', query, args.limit || 100);
             if (!componentsResponse.success) {
-                throw new Error(`Failed to discover components: ${componentsResponse.error}`);
+                return {
+                    success: false,
+                    error: `Failed to discover UI Builder components: ${componentsResponse.error}`,
+                    suggestion: 'UI Builder plugin may not be installed. Check ServiceNow Store for UI Builder plugin.',
+                    plugin_required: 'UI Builder',
+                    table_tested: 'sys_ux_lib_component'
+                };
+            }
+            const components = componentsResponse.data.result || [];
+            // Handle no results case
+            if (components.length === 0) {
+                return {
+                    success: true,
+                    components: [],
+                    count: 0,
+                    message: '📝 No UI Builder components found',
+                    explanation: 'This could mean: 1) No custom components exist, 2) UI Builder plugin not installed, 3) Insufficient permissions',
+                    query_used: query || 'No filter',
+                    suggestions: [
+                        'Create your first custom component using snow_create_uib_component',
+                        'Check built-in components by removing custom_only filter',
+                        'Verify UI Builder plugin is installed and you have proper permissions'
+                    ]
+                };
             }
-            const components = componentsResponse.data.result;
             // Enrich with additional data if requested
             for (const component of components) {
                 if (args.include_source && component.source_script) {
@@ -1974,8 +2123,24 @@ ${configList}${layoutsText}${offlineText}
             this.logger.info(`✅ Found ${components.length} UI Builder components`);
             return {
                 success: true,
+                verified: true,
                 components: components,
-                count: components.length
+                count: components.length,
+                query_used: query || 'No filter',
+                categories_found: [...new Set(components.map(c => c.category))],
+                message: `✅ Successfully discovered ${components.length} UI Builder components`,
+                detailed_confirmation: {
+                    operation: 'DISCOVER UI Builder Components',
+                    table_searched: 'sys_ux_lib_component',
+                    results_count: components.length,
+                    query_conditions: conditions.join(', ') || 'No conditions',
+                    enrichment_options: {
+                        source_included: !!args.include_source,
+                        usage_stats_included: !!args.include_usage_stats,
+                        dependencies_included: !!args.include_dependencies
+                    },
+                    search_timestamp: new Date().toISOString()
+                }
             };
         }
         catch (error) {
@@ -2061,11 +2226,35 @@ ${configList}${layoutsText}${offlineText}
             if (!response.success) {
                 throw new Error(`Failed to create data broker: ${response.error}`);
             }
-            this.logger.info('✅ UI Builder data broker created successfully');
+            // VERIFICATION: Confirm data broker was created
+            const sys_id = response.data.result.sys_id;
+            const verification = await this.client.getRecord('sys_ux_data_broker', sys_id);
+            if (!verification.success) {
+                return {
+                    success: false,
+                    error: 'Data broker creation reported success but record not found in sys_ux_data_broker table',
+                    suggestion: 'Data broker creation may have been rolled back due to validation errors',
+                    verification_failed: true
+                };
+            }
+            this.logger.info(`✅ UI Builder data broker created and verified: ${sys_id}`);
             return {
                 success: true,
-                data_broker: response.data,
-                message: `Data broker '${args.name}' created for ${args.type} type`
+                verified: true,
+                data_broker_sys_id: sys_id,
+                broker_name: args.name,
+                broker_type: args.type || 'table',
+                target_table: args.table || 'N/A',
+                created_at: new Date().toISOString(),
+                message: `✅ Data broker '${args.name}' created and verified successfully`,
+                detailed_confirmation: {
+                    operation: 'CREATE UI Builder Data Broker',
+                    sys_id: sys_id,
+                    name: args.name,
+                    type: args.type || 'table',
+                    verified_in_table: 'sys_ux_data_broker',
+                    verification_timestamp: new Date().toISOString()
+                }
             };
         }
         catch (error) {
@@ -2098,11 +2287,32 @@ ${configList}${layoutsText}${offlineText}
             if (!response.success) {
                 throw new Error(`Failed to configure data broker: ${response.error}`);
             }
-            this.logger.info('✅ UI Builder data broker configured successfully');
+            // VERIFICATION: Confirm data broker configuration was updated
+            const verification = await this.client.getRecord('sys_ux_data_broker', args.broker_id);
+            if (!verification.success) {
+                return {
+                    success: false,
+                    error: 'Data broker configuration reported success but record not found in sys_ux_data_broker table',
+                    suggestion: 'Data broker may not exist or you may lack permissions to access it',
+                    broker_id: args.broker_id,
+                    verification_failed: true
+                };
+            }
+            this.logger.info(`✅ UI Builder data broker configured and verified: ${args.broker_id}`);
             return {
                 success: true,
-                data_broker: response.data,
-                message: 'Data broker configuration updated successfully'
+                verified: true,
+                data_broker_sys_id: args.broker_id,
+                updates_applied: Object.keys(updates),
+                configured_at: new Date().toISOString(),
+                message: `✅ Data broker configuration updated and verified successfully`,
+                detailed_confirmation: {
+                    operation: 'CONFIGURE UI Builder Data Broker',
+                    sys_id: args.broker_id,
+                    updates_applied: updates,
+                    verified_in_table: 'sys_ux_data_broker',
+                    verification_timestamp: new Date().toISOString()
+                }
             };
         }
         catch (error) {
@@ -2323,11 +2533,36 @@ ${configList}${layoutsText}${offlineText}
             if (!response.success) {
                 throw new Error(`Failed to create client script: ${response.error}`);
             }
-            this.logger.info('✅ UI Builder client script created successfully');
+            // VERIFICATION: Confirm client script was created
+            const sys_id = response.data.result.sys_id;
+            const verification = await this.client.getRecord('sys_ux_client_script', sys_id);
+            if (!verification.success) {
+                return {
+                    success: false,
+                    error: 'Client script creation reported success but record not found in sys_ux_client_script table',
+                    suggestion: 'Client script creation may have been rolled back due to script validation errors',
+                    verification_failed: true
+                };
+            }
+            this.logger.info(`✅ UI Builder client script created and verified: ${sys_id}`);
             return {
                 success: true,
-                script: response.data,
-                message: `Client script '${args.name}' created for ${args.type} trigger`
+                verified: true,
+                client_script_sys_id: sys_id,
+                script_name: args.name,
+                script_type: args.type,
+                page_id: args.page_id,
+                created_at: new Date().toISOString(),
+                message: `✅ Client script '${args.name}' created and verified successfully`,
+                detailed_confirmation: {
+                    operation: 'CREATE UI Builder Client Script',
+                    sys_id: sys_id,
+                    name: args.name,
+                    type: args.type,
+                    page_reference: args.page_id,
+                    verified_in_table: 'sys_ux_client_script',
+                    verification_timestamp: new Date().toISOString()
+                }
             };
         }
         catch (error) {
@@ -2389,11 +2624,37 @@ ${configList}${layoutsText}${offlineText}
             if (!response.success) {
                 throw new Error(`Failed to create event: ${response.error}`);
             }
-            this.logger.info('✅ UI Builder event created successfully');
+            // VERIFICATION: Confirm event was created
+            const sys_id = response.data.result.sys_id;
+            const verification = await this.client.getRecord('sys_ux_event', sys_id);
+            if (!verification.success) {
+                return {
+                    success: false,
+                    error: 'Event creation reported success but record not found in sys_ux_event table',
+                    suggestion: 'Event creation may have been rolled back due to validation errors',
+                    verification_failed: true
+                };
+            }
+            this.logger.info(`✅ UI Builder event created and verified: ${sys_id}`);
             return {
                 success: true,
-                event: response.data,
-                message: `Custom event '${args.name}' created ${args.global_event ? '(global)' : '(scoped)'}`
+                verified: true,
+                event_sys_id: sys_id,
+                event_name: args.name,
+                event_scope: args.global_event ? 'Global' : 'Component Scoped',
+                component_scope: args.component_scope || 'Not specified',
+                created_at: new Date().toISOString(),
+                message: `✅ Custom event '${args.name}' created and verified successfully`,
+                detailed_confirmation: {
+                    operation: 'CREATE UI Builder Event',
+                    sys_id: sys_id,
+                    name: args.name,
+                    global_event: args.global_event || false,
+                    bubbles: args.bubbles !== false,
+                    cancelable: args.cancelable !== false,
+                    verified_in_table: 'sys_ux_event',
+                    verification_timestamp: new Date().toISOString()
+                }
             };
         }
         catch (error) {
@@ -2673,18 +2934,55 @@ ${configList}${layoutsText}${offlineText}
                 };
             }
             const result = await this.client.createRecord('sys_ux_experience', experienceData);
+            // ENHANCED FEEDBACK SYSTEM
             if (result.success && result.data && result.data.result && result.data.result.sys_id) {
-                this.logger.info(`✅ UX Experience created with sys_id: ${result.data.result.sys_id}`);
+                const sys_id = result.data.result.sys_id;
+                // VERIFICATION: Confirm record actually exists
+                const verification = await this.client.getRecord('sys_ux_experience', sys_id);
+                if (!verification.success) {
+                    return {
+                        success: false,
+                        error: `UX Experience creation reported success but record not found in sys_ux_experience table`,
+                        suggestion: 'Record creation may have failed silently or been rolled back due to permissions',
+                        reported_sys_id: sys_id,
+                        verification_failed: true
+                    };
+                }
+                this.logger.info(`✅ UX Experience created and verified with sys_id: ${sys_id}`);
                 return {
                     success: true,
-                    experience_sys_id: result.data.result.sys_id,
-                    message: `Experience '${args.name}' created successfully`,
-                    next_step: "Create App Configuration using this experience_sys_id"
+                    verified: true,
+                    experience_sys_id: sys_id,
+                    experience_name: args.name,
+                    shell_macroponent: shellSysId ? 'Linked to app shell' : 'No shell linked',
+                    created_at: new Date().toISOString(),
+                    table: 'sys_ux_experience',
+                    message: `✅ UX Experience '${args.name}' created and verified successfully`,
+                    detailed_confirmation: {
+                        operation: 'CREATE UX Experience',
+                        sys_id: sys_id,
+                        name: args.name,
+                        active: true,
+                        verified_in_table: 'sys_ux_experience',
+                        verification_timestamp: new Date().toISOString()
+                    },
+                    next_step: `Create App Configuration using experience_sys_id: ${sys_id}`
                 };
             }
             else {
                 const error = (result.data && result.data.error) || (result.error) || 'Unknown error creating experience';
-                throw new Error(`Failed to create experience: ${error}`);
+                return {
+                    success: false,
+                    error: `Failed to create UX Experience: ${error}`,
+                    suggestion: this.getErrorSuggestion(error),
+                    operation_attempted: 'CREATE sys_ux_experience',
+                    debug_info: {
+                        result_success: result.success,
+                        has_data: !!(result.data),
+                        has_result: !!(result.data && result.data.result),
+                        has_sys_id: !!(result.data && result.data.result && result.data.result.sys_id)
+                    }
+                };
             }
         }
         catch (error) {
@@ -2726,17 +3024,43 @@ ${configList}${layoutsText}${offlineText}
             };
             const result = await this.client.createRecord('sys_ux_app_config', configData);
             if (result.success && result.data && result.data.result && result.data.result.sys_id) {
-                this.logger.info(`✅ UX App Config created with sys_id: ${result.data.result.sys_id}`);
+                const sys_id = result.data.result.sys_id;
+                // VERIFICATION: Confirm app config was created
+                const verification = await this.client.getRecord('sys_ux_app_config', sys_id);
+                if (!verification.success) {
+                    return {
+                        success: false,
+                        error: 'App config creation reported success but record not found in sys_ux_app_config table',
+                        verification_failed: true
+                    };
+                }
+                this.logger.info(`✅ UX App Config created and verified: ${sys_id}`);
                 return {
                     success: true,
-                    app_config_sys_id: result.data.result.sys_id,
-                    message: `App Configuration '${args.name}' created successfully`,
-                    next_step: "Create Page Macroponent using this app_config_sys_id"
+                    verified: true,
+                    app_config_sys_id: sys_id,
+                    config_name: args.name,
+                    linked_experience: args.experience_sys_id,
+                    created_at: new Date().toISOString(),
+                    message: `✅ App Configuration '${args.name}' created and verified successfully`,
+                    detailed_confirmation: {
+                        operation: 'CREATE UX App Config',
+                        sys_id: sys_id,
+                        name: args.name,
+                        experience_assoc: args.experience_sys_id,
+                        verified_in_table: 'sys_ux_app_config',
+                        verification_timestamp: new Date().toISOString()
+                    },
+                    next_step: `Create Page Macroponent using app_config_sys_id: ${sys_id}`
                 };
             }
             else {
                 const error = (result.data && result.data.error) || (result.error) || 'Unknown error creating app config';
-                throw new Error(`Failed to create app config: ${error}`);
+                return {
+                    success: false,
+                    error: `Failed to create app config: ${error}`,
+                    suggestion: this.getErrorSuggestion(error)
+                };
             }
         }
         catch (error) {
@@ -3292,6 +3616,216 @@ ${configList}${layoutsText}${offlineText}
             throw error;
         }
     }
+    /**
+     * COMPREHENSIVE TOOL HEALTH TESTING
+     * Tests all workspace tools and provides detailed status report
+     */
+    async testAllWorkspaceTools(args) {
+        try {
+            this.logger.info('🛠️ Starting comprehensive tool health test...');
+            const testResults = {
+                test_timestamp: new Date().toISOString(),
+                tools_tested: 0,
+                tools_working: 0,
+                tools_failing: 0,
+                tools_unclear: 0,
+                detailed_results: [],
+                plugin_status: {},
+                recommendations: []
+            };
+            // Test critical plugins first
+            const pluginTests = [
+                { name: 'UI Builder', table: 'sys_ux_page', description: 'UI Builder functionality' },
+                { name: 'Now Experience Framework', table: 'sys_ux_experience', description: 'UX Workspace creation' },
+                { name: 'Agent Workspace', table: 'sys_ux_app_route', description: 'Configurable Agent Workspaces' },
+                { name: 'Mobile Publishing', table: 'sys_push_notif_msg', description: 'Mobile app management' },
+                { name: 'Flow Designer', table: 'sys_hub_flow', description: 'Flow automation' }
+            ];
+            for (const plugin of pluginTests) {
+                const pluginTest = await this.client.searchRecords(plugin.table, '', 1);
+                testResults.plugin_status[plugin.name] = {
+                    available: pluginTest.success,
+                    table: plugin.table,
+                    description: plugin.description,
+                    status: pluginTest.success ? '✅ Available' : '❌ Not Available'
+                };
+            }
+            // Test individual tools
+            const toolTests = [
+                // UX Experience tools
+                {
+                    name: 'snow_create_ux_experience',
+                    test: () => this.snow_create_ux_experience({ name: 'Health Test Experience' }),
+                    category: 'UX Experience',
+                    expects_sys_id: true
+                },
+                // UI Builder tools  
+                {
+                    name: 'snow_discover_uib_pages',
+                    test: () => this.discoverUIBuilderPages({}),
+                    category: 'UI Builder',
+                    expects_sys_id: false
+                },
+                // Mobile tools
+                {
+                    name: 'snow_configure_mobile_app',
+                    test: () => this.configureMobileApp({ app_name: 'Health Test App' }),
+                    category: 'Mobile',
+                    expects_sys_id: true
+                }
+            ];
+            for (const toolTest of toolTests) {
+                try {
+                    testResults.tools_tested++;
+                    const testStart = Date.now();
+                    const result = await toolTest.test();
+                    const testDuration = Date.now() - testStart;
+                    let status = '❌ FAILED';
+                    let feedback = 'No response';
+                    if (result && result.success === true) {
+                        if (toolTest.expects_sys_id && result.sys_id) {
+                            status = '✅ WORKING';
+                            feedback = `Created record with sys_id: ${result.sys_id}`;
+                            testResults.tools_working++;
+                        }
+                        else if (!toolTest.expects_sys_id) {
+                            status = '✅ WORKING';
+                            feedback = 'Operation completed successfully';
+                            testResults.tools_working++;
+                        }
+                        else {
+                            status = '⚠️ UNCLEAR';
+                            feedback = 'Success reported but no sys_id returned';
+                            testResults.tools_unclear++;
+                        }
+                    }
+                    else if (result && result.success === false) {
+                        status = '❌ FAILED';
+                        feedback = result.error || 'Unknown error';
+                        testResults.tools_failing++;
+                    }
+                    else {
+                        status = '⚠️ UNCLEAR';
+                        feedback = 'No clear success/failure indication';
+                        testResults.tools_unclear++;
+                    }
+                    testResults.detailed_results.push({
+                        tool: toolTest.name,
+                        category: toolTest.category,
+                        status: status,
+                        feedback: feedback,
+                        execution_time_ms: testDuration,
+                        expects_sys_id: toolTest.expects_sys_id,
+                        actual_result: result
+                    });
+                }
+                catch (error) {
+                    testResults.tools_tested++;
+                    testResults.tools_failing++;
+                    testResults.detailed_results.push({
+                        tool: toolTest.name,
+                        category: toolTest.category,
+                        status: '❌ FAILED',
+                        feedback: `Exception: ${error}`,
+                        execution_time_ms: 0,
+                        error_type: 'EXCEPTION'
+                    });
+                }
+            }
+            // Generate recommendations
+            if (testResults.tools_working === 0) {
+                testResults.recommendations.push('No tools are working - check authentication and instance setup');
+            }
+            if (testResults.tools_unclear > 0) {
+                testResults.recommendations.push('Some tools have unclear status - implement better response validation');
+            }
+            this.logger.info(`✅ Tool health test completed: ${testResults.tools_working}/${testResults.tools_tested} working`);
+            return {
+                success: true,
+                test_summary: testResults,
+                message: `Tool health test completed: ${testResults.tools_working}/${testResults.tools_tested} tools working properly`,
+                detailed_report: testResults.detailed_results
+            };
+        }
+        catch (error) {
+            this.logger.error('Failed to test workspace tools:', error);
+            throw error;
+        }
+    }
+    /**
+     * CHECK PLUGIN AVAILABILITY
+     * Comprehensive plugin and licensing status check
+     */
+    async checkPluginAvailability(args) {
+        try {
+            this.logger.info('🔌 Checking ServiceNow plugin availability...');
+            const pluginChecks = [];
+            if (args.check_ui_builder) {
+                const uiBuilderCheck = await this.client.searchRecords('sys_ux_page', '', 1);
+                pluginChecks.push({
+                    name: 'UI Builder',
+                    table: 'sys_ux_page',
+                    available: uiBuilderCheck.success,
+                    error: uiBuilderCheck.success ? null : uiBuilderCheck.error,
+                    status: uiBuilderCheck.success ? '✅ Available' : '❌ Not Available',
+                    recommendation: uiBuilderCheck.success ? 'UI Builder tools should work' : 'Install UI Builder plugin from ServiceNow Store'
+                });
+            }
+            if (args.check_uxf) {
+                const uxfCheck = await this.client.searchRecords('sys_ux_experience', '', 1);
+                pluginChecks.push({
+                    name: 'Now Experience Framework',
+                    table: 'sys_ux_experience',
+                    available: uxfCheck.success,
+                    error: uxfCheck.success ? null : uxfCheck.error,
+                    status: uxfCheck.success ? '✅ Available' : '❌ Not Available',
+                    recommendation: uxfCheck.success ? 'UX workspace creation should work' : 'Enable Now Experience Framework in instance'
+                });
+            }
+            if (args.check_agent_workspace) {
+                const agentCheck = await this.client.searchRecords('sys_ux_screen_type', '', 1);
+                pluginChecks.push({
+                    name: 'Agent Workspace',
+                    table: 'sys_ux_screen_type',
+                    available: agentCheck.success,
+                    error: agentCheck.success ? null : agentCheck.error,
+                    status: agentCheck.success ? '✅ Available' : '❌ Not Available',
+                    recommendation: agentCheck.success ? 'Agent workspace tools should work' : 'Install Agent Workspace plugin'
+                });
+            }
+            if (args.check_mobile) {
+                const mobileCheck = await this.client.searchRecords('sys_push_notif_msg', '', 1);
+                pluginChecks.push({
+                    name: 'Mobile Publishing',
+                    table: 'sys_push_notif_msg',
+                    available: mobileCheck.success,
+                    error: mobileCheck.success ? null : mobileCheck.error,
+                    status: mobileCheck.success ? '✅ Available' : '❌ Not Available',
+                    recommendation: mobileCheck.success ? 'Mobile tools should work' : 'Install Mobile Publishing plugin (requires additional licensing)'
+                });
+            }
+            const availableCount = pluginChecks.filter(p => p.available).length;
+            const totalCount = pluginChecks.length;
+            this.logger.info(`✅ Plugin check completed: ${availableCount}/${totalCount} plugins available`);
+            return {
+                success: true,
+                plugin_summary: {
+                    total_checked: totalCount,
+                    available: availableCount,
+                    unavailable: totalCount - availableCount,
+                    percentage: Math.round((availableCount / totalCount) * 100)
+                },
+                plugins: pluginChecks,
+                message: `Plugin availability check: ${availableCount}/${totalCount} plugins available`,
+                overall_status: availableCount === totalCount ? 'All plugins available' :
+                    availableCount > 0 ? 'Partial plugin availability' : 'No plugins available'
+            };
+        }
+        catch (error) {
+            this.logger.error('Failed to check plugin availability:', error);
+            throw error;
+        }
+    }
     /**
      * CONFIGURABLE AGENT WORKSPACE: Create using UX App architecture
      */
@@ -3398,6 +3932,141 @@ ${configList}${layoutsText}${offlineText}
             .replace(/^-|-$/g, '') // Trim leading/trailing hyphens
             .substring(0, 80); // Max 80 chars (ServiceNow field limit)
     }
+    /**
+     * ENHANCED RESPONSE VALIDATION SYSTEM
+     * Provides comprehensive feedback for all tool operations
+     */
+    async validateAndConfirmOperation(operationType, result, details) {
+        try {
+            // Standard validation for ServiceNow API responses
+            if (!result || typeof result !== 'object') {
+                return {
+                    success: false,
+                    error: `No response received from ServiceNow API for ${operationType}`,
+                    suggestion: 'Check ServiceNow instance connectivity and authentication',
+                    validation_result: 'NO_RESPONSE'
+                };
+            }
+            // Check for API success/failure
+            if (result.success === false) {
+                return {
+                    success: false,
+                    error: result.error || `${operationType} operation failed`,
+                    suggestion: this.getErrorSuggestion(result.error || ''),
+                    validation_result: 'API_FAILURE'
+                };
+            }
+            // Validate response data structure
+            if (result.success && (!result.data || !result.data.result)) {
+                return {
+                    success: false,
+                    error: `${operationType} succeeded but returned invalid data structure`,
+                    suggestion: 'Check ServiceNow table permissions and field access',
+                    validation_result: 'INVALID_DATA_STRUCTURE'
+                };
+            }
+            // Extract sys_id for verification
+            const sys_id = result.data?.result?.sys_id;
+            if (result.success && !sys_id) {
+                return {
+                    success: false,
+                    error: `${operationType} succeeded but no sys_id returned`,
+                    suggestion: 'Record may have been created but sys_id is not accessible',
+                    validation_result: 'MISSING_SYS_ID'
+                };
+            }
+            // VERIFICATION STEP: Confirm record actually exists
+            if (sys_id && details.table) {
+                const verification = await this.client.getRecord(details.table, sys_id);
+                if (!verification.success) {
+                    return {
+                        success: false,
+                        error: `${operationType} reported success but record not found in ${details.table}`,
+                        suggestion: 'Record creation may have failed silently or been rolled back',
+                        validation_result: 'RECORD_NOT_FOUND',
+                        reported_sys_id: sys_id
+                    };
+                }
+                // SUCCESS with verification!
+                return {
+                    success: true,
+                    sys_id: sys_id,
+                    verified: true,
+                    operation_type: operationType,
+                    table: details.table,
+                    message: `${operationType} completed successfully`,
+                    confirmation: `Record verified in ${details.table} with sys_id: ${sys_id}`,
+                    validation_result: 'VERIFIED_SUCCESS'
+                };
+            }
+            // Success without verification (no sys_id or table)
+            return {
+                success: true,
+                operation_type: operationType,
+                message: `${operationType} completed`,
+                validation_result: 'SUCCESS_NO_VERIFICATION'
+            };
+        }
+        catch (error) {
+            this.logger.error('Validation error:', error);
+            return {
+                success: false,
+                error: `Validation failed for ${operationType}: ${error}`,
+                suggestion: 'Check ServiceNow connectivity and permissions',
+                validation_result: 'VALIDATION_ERROR'
+            };
+        }
+    }
+    /**
+     * Get actionable suggestions based on error type
+     */
+    getErrorSuggestion(error) {
+        const errorLower = error.toLowerCase();
+        if (errorLower.includes('403') || errorLower.includes('forbidden')) {
+            return 'Check user permissions. May need ui_builder_admin or workspace_admin roles.';
+        }
+        if (errorLower.includes('404') || errorLower.includes('not found')) {
+            return 'Table/endpoint not available. Check if required plugin is installed and activated.';
+        }
+        if (errorLower.includes('400') || errorLower.includes('bad request')) {
+            return 'Invalid parameters or missing required fields. Check API documentation.';
+        }
+        if (errorLower.includes('401') || errorLower.includes('unauthorized')) {
+            return 'Authentication issue. Run snow-flow auth login to re-authenticate.';
+        }
+        if (errorLower.includes('plugin') || errorLower.includes('license')) {
+            return 'Required plugin not installed. Check ServiceNow Store for required plugins.';
+        }
+        return 'Check ServiceNow system logs for detailed error information.';
+    }
+    /**
+     * Enhanced tool execution wrapper with comprehensive feedback
+     */
+    async executeWithFeedback(operationType, operation, details) {
+        try {
+            this.logger.info(`🔄 Executing ${operationType}...`);
+            const startTime = Date.now();
+            const result = await operation();
+            const executionTime = Date.now() - startTime;
+            const validation = await this.validateAndConfirmOperation(operationType, result, details);
+            return {
+                ...validation,
+                execution_time_ms: executionTime,
+                timestamp: new Date().toISOString()
+            };
+        }
+        catch (error) {
+            this.logger.error(`❌ ${operationType} failed:`, error);
+            return {
+                success: false,
+                operation_type: operationType,
+                error: error instanceof Error ? error.message : String(error),
+                suggestion: this.getErrorSuggestion(String(error)),
+                validation_result: 'EXECUTION_ERROR',
+                timestamp: new Date().toISOString()
+            };
+        }
+    }
     /**
      * Validate workspace configuration (fix from user feedback)
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "snow-flow",
-  "version": "4.5.48",
+  "version": "4.5.50",
   "description": "Conversational ServiceNow development platform using Claude Code. Multi-agent orchestration with 20+ MCP servers providing 245+ ServiceNow tools including complete UX + Agent Workspace creation with official APIs.",
   "main": "dist/index.js",
   "type": "commonjs",