snow-flow 4.5.52 → 4.5.54

package/CLAUDE.md

@@ -6,14 +6,26 @@
 
 **❌ INFINITE LOOP (PROHIBITED):**
 ```
-Task("Create configurable workspace")  
-Task("Create configurable workspace")  
-Task("Create configurable workspace")  // ← CAUSES INFINITE LOOP!
+Task("UI Builder Tools Tester", "Test UI Builder tools");
+Task("UI Builder Tools Tester", "Test UI Builder tools");  // ← DUPLICATE AGENT TYPE!
+Task("Workspace Tools Tester", "Test workspace tools");
+Task("Workspace Tools Tester", "Test workspace tools");  // ← CAUSES INFINITE LOOP!
+
+// This pattern causes MCP server spam:
+// • Task(UI Builder Tools Tester) → snow_validate_uib_page_structure (repeated 100x)
+// • Task(Workspace Tools Tester) → snow_execute_script_with_output (repeated 100x)
 ```
 
 **✅ CORRECT (Single Agent):**
-```  
-Task("workspace-specialist", "Create ONE Configurable Agent Workspace named 'IT Support Hub' using snow_create_workspace with UX App architecture. Verify creation and store sys_id in Memory.")
+```
+// UNIQUE agent names prevent loops:
+Task("workspace-architect", "Create ONE UX workspace for IT support using snow_create_complete_workspace. Store all sys_ids in Memory.");
+Task("ui-specialist", "Design UI components AFTER workspace-architect completes. Use Memory to get workspace sys_ids.");
+Task("testing-validator", "Test workspace functionality AFTER ui-specialist completes. No duplicate testing!");
+
+// NEVER use generic names like:
+// Task("Tester", ...) - TOO GENERIC, CAUSES LOOPS!
+// Task("UI Builder Tools Tester", ...) - EXACTLY what caused the infinite loop!
 ```
 
 **🎯 Anti-Loop Rules:**

package/dist/cli.js

@@ -643,6 +643,31 @@ function buildQueenAgentPrompt(objective, taskAnalysis, options, isAuthenticated
         options.sharedMemory || options.progressMonitoring;
     const prompt = `# 👑 Snow-Flow Queen Agent Orchestration
 
+## 🚨 CRITICAL: PREVENT INFINITE LOOPS - READ FIRST!
+
+**NEVER SPAWN DUPLICATE AGENTS!** This causes infinite loops that spam MCP servers and crash Codespaces!
+
+**❌ INFINITE LOOP PATTERN (PROHIBITED):**
+\`\`\`
+Task(\"UI Builder Tools Tester\", \"Test UI Builder tools\");
+Task(\"UI Builder Tools Tester\", \"Test UI Builder tools\");  // ← DUPLICATE AGENT TYPE!
+Task(\"Workspace Tools Tester\", \"Test workspace tools\");
+Task(\"Workspace Tools Tester\", \"Test workspace tools\");  // ← INFINITE LOOP!
+\`\`\`
+
+**✅ CORRECT PATTERN (REQUIRED):**
+\`\`\`
+Task(\"workspace-architect\", \"Create ONE UX workspace using snow_create_complete_workspace\");
+Task(\"ui-designer\", \"Design UI components AFTER workspace is created\");
+Task(\"validator\", \"Test AFTER both previous agents complete\");
+\`\`\`
+
+**GOLDEN RULES:**
+1. **ONE agent per task type maximum**
+2. **UNIQUE agent names** (not generic \"Tester\")
+3. **SEQUENTIAL spawning** - wait for completion
+4. **CHECK Memory** for existing agents first
+
 ## 🎯 Mission Brief
 You are the Queen Agent, master coordinator of the Snow-Flow hive-mind. Your mission is to orchestrate a swarm of specialized agents to complete the following ServiceNow development objective:
 
@@ -838,29 +863,68 @@ TodoWrite([
 ]);
 \`\`\`
 
-### 4. Agent Spawning Strategy
-Based on the task analysis, spawn ${taskAnalysis.estimatedAgentCount} agents in smart batches:
+### 4. Agent Spawning Strategy - 🚨 ANTI-LOOP PROTECTION 🚨
+
+**CRITICAL: NO DUPLICATE AGENTS! ONLY SPAWN EACH AGENT TYPE ONCE!**
 
-**Dynamic Agent Discovery & Spawning (Use Snow-Flow MCP Tools):**
-1. **Initialize Swarm**: \`swarm_init({ topology: 'hierarchical', maxAgents: ${parseInt(options.maxAgents)} })\`
-2. **Discover Agents Dynamically**: \`agent_discover({ task_analysis: ${JSON.stringify(taskAnalysis)}, required_capabilities: [], context: { max_agents: ${parseInt(options.maxAgents)}, include_new_types: true } })\`
-3. **Spawn Discovered Agents**: Use \`agent_spawn({ type: 'agent_type_from_discovery', name: 'Agent Name', capabilities: ['discovered_capabilities'] })\` for each discovered agent
-4. **Coordination**: \`task_orchestrate({ task: '${objective}', strategy: 'adaptive' })\`
+**✅ CORRECT (Single Agents Only):**
+1. **Initialize Swarm ONCE**: \`swarm_init({ topology: 'hierarchical', maxAgents: ${parseInt(options.maxAgents)} })\`
+2. **Spawn ${taskAnalysis.estimatedAgentCount} DIFFERENT agents**: 
+Spawn ONE agent of each required type based on the objective:
 
-**IMPORTANT**: Do NOT use hardcoded agent types like 'widget-creator', 'specialist' etc. Let \`agent_discover\` determine the optimal agent types for this specific task!
+**${taskAnalysis.taskType} requires these UNIQUE agents:**
+- **ONE researcher**: \`Task(\"researcher\", \"Research ServiceNow requirements for: ${objective}\")\`
+- **ONE ${taskAnalysis.primaryAgent}**: \`Task(\"${taskAnalysis.primaryAgent}\", \"Implement main solution for: ${objective}\")\`
+- **ONE tester**: \`Task(\"tester\", \"Test and validate solution for: ${objective}\")\`
 
-### 5. Memory Coordination Pattern
-All agents MUST use this simple memory coordination:
+**🚨 CRITICAL ANTI-LOOP RULES:**
+- **NEVER spawn multiple agents of the same type**
+- **NEVER spawn \"UI Builder Tools Tester\" multiple times**
+- **NEVER spawn \"Workspace Tools Tester\" multiple times**
+- **WAIT for agent completion** before spawning related agents
+- **CHECK Memory** for existing agents before spawning new ones
+
+**❌ PROHIBITED PATTERNS:**
+\`\`\`
+// DON'T DO THIS - CAUSES INFINITE LOOPS:
+Task(\"UI Builder Tools Tester\", \"Test UI Builder tools\");
+Task(\"UI Builder Tools Tester\", \"Test UI Builder tools\");  // ← DUPLICATE!
+Task(\"UI Builder Tools Tester\", \"Test UI Builder tools\");  // ← INFINITE LOOP!
+\`\`\`
+
+**✅ CORRECT PATTERNS:**
+\`\`\`
+// DO THIS - SINGLE AGENTS WITH SPECIFIC TASKS:
+Task(\"ui-builder-specialist\", \"Create specific UI Builder page for incident management\");
+Task(\"workspace-architect\", \"Design UX workspace structure for IT support team\");
+Task(\"testing-specialist\", \"Validate workspace functionality and report results\");
+\`\`\`
+
+### 5. Memory Coordination Pattern with Loop Detection
+All agents MUST use this memory coordination WITH loop prevention:
 
 \`\`\`javascript
-// Agent initialization
+// STEP 1: Check if agent type already exists (PREVENT LOOPS!)
+const existingAgents = Memory.get('active_agents') || [];
+const agentType = 'ui-builder-specialist';
+
+if (existingAgents.includes(agentType)) {
+  console.log('Agent type already active - SKIPPING to prevent infinite loop');
+  return; // DON'T spawn duplicate agents!
+}
+
+// STEP 2: Register agent as active
 const agentId = \`agent_\${agentType}_\${sessionId}\`;
+existingAgents.push(agentType);
+Memory.store('active_agents', JSON.stringify(existingAgents));
 
-// Agent stores progress
+// STEP 3: Agent stores progress
 Memory.store(\`\${agentId}_progress\`, JSON.stringify({
+  agent_type: agentType,
   status: "working",
   current_task: "description of current work",
   completion_percentage: 45,
+  spawned_at: new Date().toISOString(),
   last_update: new Date().toISOString()
 }));
 

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

@@ -140,10 +140,10 @@ class ServiceNowFlowWorkspaceMobileMCP {
                     }
                 },
                 // 🏗️ COMPLETE UX WORKSPACE CREATION (6-Step Workflow)
-                // STEP 1: Experience Record (sys_ux_experience)
+                // STEP 1: Experience Record (sys_ux_experience) - REQUIRES NOW EXPERIENCE FRAMEWORK
                 {
                     name: 'snow_create_ux_experience',
-                    description: 'STEP 1: Create UX Experience Record (sys_ux_experience) - The top-level container for the workspace. This is the first step in the 6-step workspace creation process.',
+                    description: 'STEP 1: Create UX Experience Record (sys_ux_experience) - The top-level container for the workspace. ⚠️ REQUIRES: Now Experience Framework (UXF) enabled. ALTERNATIVE: Use traditional form/list configurations if UXF unavailable.',
                     inputSchema: {
                         type: 'object',
                         properties: {
@@ -357,10 +357,10 @@ class ServiceNowFlowWorkspaceMobileMCP {
                 // UI BUILDER TOOLS - COMPLETE NOW EXPERIENCE FRAMEWORK INTEGRATION
                 // Official ServiceNow sys_ux_* APIs for conversational UI Builder development
                 // ==========================================
-                // UI Builder Page Management (sys_ux_page)
+                // UI Builder Page Management (sys_ux_page) - REQUIRES UI BUILDER PLUGIN
                 {
                     name: 'snow_create_uib_page',
-                    description: 'Creates a new UI Builder page in the Now Experience Framework using official ServiceNow sys_ux_page API. Enables conversational page creation with full UXF integration.',
+                    description: 'Creates a new UI Builder page in the Now Experience Framework using official ServiceNow sys_ux_page API. ⚠️ REQUIRES: UI Builder plugin + ui_builder_admin role. ALTERNATIVE: Use Service Portal pages if plugin unavailable.',
                     inputSchema: {
                         type: 'object',
                         properties: {
@@ -815,33 +815,33 @@ class ServiceNowFlowWorkspaceMobileMCP {
                     case 'snow_import_flow_from_xml':
                         result = await this.importFlowFromXml(args);
                         break;
-                    // 🏗️ UX WORKSPACE CREATION (6-Step Workflow)
+                    // 🏗️ UX WORKSPACE CREATION (SAFE EXECUTION)
                     case 'snow_create_ux_experience':
-                        result = await this.snow_create_ux_experience(args);
+                        result = await this.safeToolExecution('snow_create_ux_experience', () => this.snow_create_ux_experience(args), 'now_experience_framework');
                         break;
                     case 'snow_create_ux_app_config':
-                        result = await this.snow_create_ux_app_config(args);
+                        result = await this.safeToolExecution('snow_create_ux_app_config', () => this.snow_create_ux_app_config(args), 'now_experience_framework');
                         break;
                     case 'snow_create_ux_page_macroponent':
-                        result = await this.snow_create_ux_page_macroponent(args);
+                        result = await this.safeToolExecution('snow_create_ux_page_macroponent', () => this.snow_create_ux_page_macroponent(args), 'now_experience_framework');
                         break;
                     case 'snow_create_ux_page_registry':
-                        result = await this.snow_create_ux_page_registry(args);
+                        result = await this.safeToolExecution('snow_create_ux_page_registry', () => this.snow_create_ux_page_registry(args), 'now_experience_framework');
                         break;
                     case 'snow_create_ux_app_route':
-                        result = await this.snow_create_ux_app_route(args);
+                        result = await this.safeToolExecution('snow_create_ux_app_route', () => this.snow_create_ux_app_route(args), 'now_experience_framework');
                         break;
                     case 'snow_update_ux_app_config_landing_page':
-                        result = await this.snow_update_ux_app_config_landing_page(args);
+                        result = await this.safeToolExecution('snow_update_ux_app_config_landing_page', () => this.snow_update_ux_app_config_landing_page(args), 'now_experience_framework');
                         break;
                     case 'snow_create_complete_workspace':
-                        result = await this.snow_create_complete_workspace(args);
+                        result = await this.safeToolExecution('snow_create_complete_workspace', () => this.snow_create_complete_workspace(args), 'now_experience_framework');
                         break;
                     case 'snow_create_configurable_agent_workspace':
-                        result = await this.snow_create_configurable_agent_workspace(args);
+                        result = await this.safeToolExecution('snow_create_configurable_agent_workspace', () => this.snow_create_configurable_agent_workspace(args), 'agent_workspace');
                         break;
                     case 'snow_discover_all_workspaces':
-                        result = await this.discoverAllWorkspaces(args);
+                        result = await this.safeToolExecution('snow_discover_all_workspaces', () => this.discoverAllWorkspaces(args), 'now_experience_framework');
                         break;
                     case 'snow_validate_workspace_configuration':
                         result = await this.validateWorkspaceConfiguration(args);
@@ -859,31 +859,31 @@ class ServiceNowFlowWorkspaceMobileMCP {
                     case 'snow_configure_offline_sync':
                         result = await this.configureOfflineSync(args);
                         break;
-                    // UI Builder Page Management
+                    // UI Builder Page Management (SAFE EXECUTION)
                     case 'snow_create_uib_page':
-                        result = await this.createUIBPage(args);
+                        result = await this.safeToolExecution('snow_create_uib_page', () => this.createUIBPage(args), 'ui_builder');
                         break;
                     case 'snow_update_uib_page':
-                        result = await this.updateUIBPage(args);
+                        result = await this.safeToolExecution('snow_update_uib_page', () => this.updateUIBPage(args), 'ui_builder');
                         break;
                     case 'snow_delete_uib_page':
-                        result = await this.deleteUIBPage(args);
+                        result = await this.safeToolExecution('snow_delete_uib_page', () => this.deleteUIBPage(args), 'ui_builder');
                         break;
                     case 'snow_discover_uib_pages':
-                        result = await this.discoverUIBPages(args);
+                        result = await this.safeToolExecution('snow_discover_uib_pages', () => this.discoverUIBPages(args), 'ui_builder');
                         break;
-                    // UI Builder Component Management
+                    // UI Builder Component Management (SAFE EXECUTION)
                     case 'snow_create_uib_component':
-                        result = await this.createUIBComponent(args);
+                        result = await this.safeToolExecution('snow_create_uib_component', () => this.createUIBComponent(args), 'ui_builder');
                         break;
                     case 'snow_update_uib_component':
-                        result = await this.updateUIBComponent(args);
+                        result = await this.safeToolExecution('snow_update_uib_component', () => this.updateUIBComponent(args), 'ui_builder');
                         break;
                     case 'snow_discover_uib_components':
-                        result = await this.discoverUIBComponents(args);
+                        result = await this.safeToolExecution('snow_discover_uib_components', () => this.discoverUIBComponents(args), 'ui_builder');
                         break;
                     case 'snow_clone_uib_component':
-                        result = await this.cloneUIBComponent(args);
+                        result = await this.safeToolExecution('snow_clone_uib_component', () => this.cloneUIBComponent(args), 'ui_builder');
                         break;
                     // UI Builder Data Broker Management
                     case 'snow_create_uib_data_broker':
@@ -1809,10 +1809,12 @@ ${configList}${layoutsText}${offlineText}
         }
     }
     /**
-     * Discover UI Builder Pages
+     * Discover UI Builder Pages - ENHANCED with mandatory feedback
      */
     async discoverUIBPages(args) {
         try {
+            // MANDATORY: Always log start of operation
+            this.logger.info(`🔍 Starting UI Builder pages discovery...`);
             this.logger.info('🔍 Discovering UI Builder pages...');
             const conditions = [];
             if (args.active_only)
@@ -1853,7 +1855,19 @@ ${configList}${layoutsText}${offlineText}
         }
         catch (error) {
             this.logger.error('Failed to discover UI Builder pages:', error);
-            throw error;
+            // NEVER throw - always return error object for MCP
+            return {
+                success: false,
+                error: `UI Builder pages discovery failed: ${error}`,
+                suggestion: 'UI Builder plugin not installed or insufficient permissions (need ui_builder_admin role)',
+                plugin_required: 'UI Builder',
+                table_attempted: 'sys_ux_page',
+                operation_type: 'DISCOVERY',
+                debug_info: {
+                    error_type: error instanceof Error ? error.constructor.name : 'Unknown',
+                    error_message: String(error)
+                }
+            };
         }
     }
     /**
@@ -1869,9 +1883,27 @@ ${configList}${layoutsText}${offlineText}
                 version: args.version || '1.0.0',
                 active: true
             };
+            // PRE-CHECK: Verify UI Builder is available
+            const uiBuilderCheck = await this.client.searchRecords('sys_ux_lib_source_script', '', 1);
+            if (!uiBuilderCheck.success) {
+                return {
+                    success: false,
+                    error: 'UI Builder plugin not available - sys_ux_lib_source_script table not accessible',
+                    suggestion: 'Install UI Builder plugin from ServiceNow Store. Requires ui_builder_admin role.',
+                    plugin_required: 'UI Builder',
+                    table_tested: 'sys_ux_lib_source_script',
+                    alternative: 'Use Service Portal widgets instead of UI Builder components'
+                };
+            }
             const sourceResponse = await this.client.createRecord('sys_ux_lib_source_script', sourceData);
             if (!sourceResponse.success) {
-                throw new Error(`Failed to create component source: ${sourceResponse.error}`);
+                return {
+                    success: false,
+                    error: `Failed to create component source: ${sourceResponse.error}`,
+                    suggestion: 'Check UI Builder permissions and source script syntax',
+                    operation_attempted: 'CREATE sys_ux_lib_source_script',
+                    source_data_attempted: sourceData
+                };
             }
             // Then create the component definition
             const componentData = {
@@ -1891,8 +1923,18 @@ ${configList}${layoutsText}${offlineText}
             const componentResponse = await this.client.createRecord('sys_ux_lib_component', componentData);
             if (!componentResponse.success) {
                 // Cleanup source script on failure
-                await this.client.deleteRecord('sys_ux_lib_source_script', sourceResponse.data.sys_id);
-                throw new Error(`Failed to create component: ${componentResponse.error}`);
+                const sourceId = sourceResponse.data?.sys_id || sourceResponse.data?.result?.sys_id;
+                if (sourceId) {
+                    await this.client.deleteRecord('sys_ux_lib_source_script', sourceId);
+                }
+                return {
+                    success: false,
+                    error: `Failed to create UI Builder component: ${componentResponse.error}`,
+                    suggestion: 'Check UI Builder permissions, component definition syntax, and plugin availability',
+                    operation_attempted: 'CREATE sys_ux_lib_component',
+                    component_data_attempted: componentData,
+                    cleanup_performed: !!sourceId
+                };
             }
             this.logger.info('✅ UI Builder component created successfully');
             return {
@@ -1957,10 +1999,12 @@ ${configList}${layoutsText}${offlineText}
         }
     }
     /**
-     * Discover UI Builder Components
+     * Discover UI Builder Components - ENHANCED with mandatory feedback
      */
     async discoverUIBComponents(args) {
         try {
+            // MANDATORY: Always log start of operation
+            this.logger.info(`🔍 Starting UI Builder components discovery...`);
             this.logger.info('🔍 Discovering UI Builder components...');
             const conditions = [];
             if (args.category)
@@ -2004,7 +2048,19 @@ ${configList}${layoutsText}${offlineText}
         }
         catch (error) {
             this.logger.error('Failed to discover UI Builder components:', error);
-            throw error;
+            // NEVER throw - always return error object for MCP
+            return {
+                success: false,
+                error: `UI Builder components discovery failed: ${error}`,
+                suggestion: 'UI Builder plugin not installed or insufficient permissions (need ui_builder_admin role)',
+                plugin_required: 'UI Builder',
+                table_attempted: 'sys_ux_lib_component',
+                operation_type: 'DISCOVERY',
+                debug_info: {
+                    error_type: error instanceof Error ? error.constructor.name : 'Unknown',
+                    error_message: String(error)
+                }
+            };
         }
     }
     /**
@@ -3425,6 +3481,113 @@ ${configList}${layoutsText}${offlineText}
     /**
      * Validate workspace configuration (fix from user feedback)
      */
+    /**
+     * COMPREHENSIVE PLUGIN DETECTION SYSTEM
+     * Checks all required plugins before tool execution
+     */
+    async checkPluginAvailabilityForTool(toolType) {
+        try {
+            switch (toolType) {
+                case 'ui_builder':
+                    const uiBuilderCheck = await this.client.searchRecords('sys_ux_page', '', 1);
+                    if (!uiBuilderCheck.success) {
+                        return {
+                            available: false,
+                            error: 'UI Builder plugin not installed or not accessible',
+                            suggestion: 'Install UI Builder plugin from ServiceNow Store. Requires ui_builder_admin + ui_builder_user roles.',
+                            alternative: 'Use Service Portal widgets for custom UI development instead'
+                        };
+                    }
+                    break;
+                case 'now_experience_framework':
+                    const uxfCheck = await this.client.searchRecords('sys_ux_experience', '', 1);
+                    if (!uxfCheck.success) {
+                        return {
+                            available: false,
+                            error: 'Now Experience Framework (UXF) not available',
+                            suggestion: 'Enable Now Experience Framework in ServiceNow instance. May require additional licensing.',
+                            alternative: 'Use traditional ServiceNow interface development instead'
+                        };
+                    }
+                    break;
+                case 'agent_workspace':
+                    const agentWorkspaceCheck = await this.client.searchRecords('sys_ux_screen_type', '', 1);
+                    if (!agentWorkspaceCheck.success) {
+                        return {
+                            available: false,
+                            error: 'Agent Workspace plugin not installed',
+                            suggestion: 'Install Agent Workspace plugin from ServiceNow Store. Requires workspace_admin role.',
+                            alternative: 'Use traditional forms and lists for agent interfaces'
+                        };
+                    }
+                    break;
+                case 'mobile_publishing':
+                    const mobileCheck = await this.client.searchRecords('sys_push_notif_msg', '', 1);
+                    if (!mobileCheck.success) {
+                        return {
+                            available: false,
+                            error: 'Mobile Publishing plugin not available',
+                            suggestion: 'Install Mobile Publishing plugin from ServiceNow Store. Requires additional licensing and mobile_admin role.',
+                            alternative: 'Use responsive Service Portal pages for mobile interfaces'
+                        };
+                    }
+                    break;
+            }
+            return { available: true };
+        }
+        catch (error) {
+            return {
+                available: false,
+                error: `Plugin check failed: ${error}`,
+                suggestion: 'Check ServiceNow connectivity and basic table access permissions'
+            };
+        }
+    }
+    /**
+     * SAFE TOOL EXECUTION WRAPPER
+     * Ensures all tools return proper feedback instead of throwing
+     */
+    async safeToolExecution(toolName, operation, pluginType) {
+        try {
+            this.logger.info(`🛠️ Executing tool: ${toolName}`);
+            // Step 1: Check plugin availability
+            const pluginCheck = await this.checkPluginAvailabilityForTool(pluginType);
+            if (!pluginCheck.available) {
+                this.logger.warn(`⚠️ Plugin check failed for ${toolName}`);
+                return {
+                    success: false,
+                    tool_name: toolName,
+                    plugin_type: pluginType,
+                    ...pluginCheck
+                };
+            }
+            // Step 2: Execute operation
+            const result = await operation();
+            this.logger.info(`✅ Tool ${toolName} executed successfully`);
+            return {
+                ...result,
+                tool_name: toolName,
+                plugin_verified: true,
+                execution_timestamp: new Date().toISOString()
+            };
+        }
+        catch (error) {
+            this.logger.error(`❌ Tool ${toolName} failed with exception:`, error);
+            // NEVER throw - always return error object
+            return {
+                success: false,
+                tool_name: toolName,
+                error: `Tool execution failed: ${error}`,
+                suggestion: 'Check ServiceNow connectivity, permissions, and plugin installation',
+                execution_type: 'EXCEPTION_CAUGHT',
+                debug_info: {
+                    error_type: error instanceof Error ? error.constructor.name : 'Unknown',
+                    error_message: String(error),
+                    stack_trace: error instanceof Error ? error.stack : undefined
+                }
+            };
+        }
+    }
     validateWorkspaceConfig(config) {
         const errors = [];
         // Check required fields

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "snow-flow",
-  "version": "4.5.52",
+  "version": "4.5.54",
   "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",