<?xml version="1.0" encoding="UTF-8"?>
<!-- This software is in the public domain under CC0 1.0 Universal plus a 
     Grant of Patent License.

     To the extent possible under law, the author(s) have dedicated all
     copyright and related and neighboring rights to this software to the
     public domain worldwide. This software is distributed without any warranty.

     You should have received a copy of the CC0 Public Domain Dedication
     along with this software (see the LICENSE.md file). If not, see
     <https://creativecommons.org/publicdomain/zero/1.0/>. -->

<services xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:noNamespaceSchemaLocation="http://moqui.org/xsd/service-definition-3.xsd">

    <!-- MCP Services using Moqui's built-in JSON-RPC support -->
    
    
    <service verb="mcp" noun="Initialize" authenticate="true" allow-remote="true" transaction-timeout="30">
        <description>Handle MCP initialize request using Moqui authentication</description>
        <in-parameters>
            <parameter name="sessionId" required="false"/>
            <parameter name="protocolVersion" required="true"/>
            <parameter name="capabilities" type="Map"/>
            <parameter name="clientInfo" type="Map"/>
        </in-parameters>
        <out-parameters>
            <parameter name="result" type="Map"/>
        </out-parameters>
        <actions>
            <script><![CDATA[
                import org.moqui.context.ExecutionContext
                import org.moqui.impl.context.UserFacadeImpl.UserInfo
                
                ExecutionContext ec = context.ec
                
                // Permissions are handled by Moqui's artifact authorization system
                // Users must be in appropriate groups (McpUser, MCP_BUSINESS) with access to McpServices artifact group
                
                // Disable authz to prevent automatic Visit updates during MCP operations
                ec.artifactExecution.disableAuthz()
                
                // Get Visit (session) created by servlet and validate access
                def visit = ec.entity.find("moqui.server.Visit")
                    .condition("visitId", sessionId)
                    .one()
                
                if (!visit) {
                    throw new Exception("Invalid session: ${sessionId}")
                }
                
                if (visit.userId != ec.user.userId) {
                    throw new Exception("Access denied for session: ${sessionId}")
                }
                
                // Update Visit with MCP initialization data
                UserInfo adminUserInfo = null
                try {
                    adminUserInfo = ec.user.pushUser("ADMIN")
                    def metadata = [:]
                    try {
                        metadata = groovy.json.JsonSlurper().parseText(visit.initialRequest ?: "{}") as Map
                    } catch (Exception e) {
                        ec.logger.debug("Failed to parse Visit metadata: ${e.message}")
                    }
                    
                    metadata.mcpInitialized = true
                    metadata.mcpProtocolVersion = protocolVersion
                    metadata.mcpCapabilities = capabilities
                    metadata.mcpClientInfo = clientInfo
                    metadata.mcpInitializedAt = System.currentTimeMillis()
                    
                    // Session metadata stored in memory only - no Visit updates to prevent lock contention
                    ec.logger.info("SESSIONID: ${sessionId} - metadata stored in memory")
                } finally {
                    if (adminUserInfo != null) {
                        ec.user.popUser()
                    }
                }
                
                // Validate protocol version - support common MCP versions with version negotiation
                def supportedVersions = ["2025-11-25", "2025-06-18", "2024-11-05", "2024-10-07", "2023-06-05"]
                if (!supportedVersions.contains(protocolVersion)) {
                    throw new Exception("Unsupported protocol version: ${protocolVersion}. Supported versions: ${supportedVersions.join(', ')}")
                }
                
                // Get current user context (if authenticated)
                def userId = ec.user.userId
                def userAccountId = userId ? userId : null
                
                // Build server capabilities - don't fetch actual tools/resources during init
                // Tools and resources will be discovered via separate list requests per MCP spec
                def serverCapabilities = [
                    tools: [listChanged: true],
                    resources: [subscribe: true, listChanged: true],
                    logging: [:]
                ]
                
                // Build server info
                def serverInfo = [
                    name: "Moqui MCP Server",
                    version: "2.0.1"
                ]
                
                result = [
                    protocolVersion: "2025-06-18",
                    capabilities: serverCapabilities,
                    serverInfo: serverInfo,
                    instructions: "This server provides access to Moqui ERP through MCP. For common business queries: Use screen_PopCommerce_screen_PopCommerceAdmin.Catalog for product catalog, screen_PopCommerce_screen_PopCommerceAdmin_Order.FindOrder for order status, screen_PopCommerce_screen_PopCommerceRoot.Customer for customer management, and screen_PopCommerce_screen_PopCommerceAdmin.QuickSearch for general searches. All screens support parameterized queries for filtering results."
                ]
                
                ec.logger.info("MCP Initialize for user ${userId} (session ${sessionId}): capabilities negotiated")
            ]]></script>
        </actions>
    </service>

    <service verb="mcp" noun="ToolsCall" authenticate="true" allow-remote="true" transaction-timeout="300">
        <description>Handle MCP tools/call request with direct Moqui service execution</description>
        <in-parameters>
            <parameter name="sessionId" required="false"/>
            <parameter name="name" required="true"/>
            <parameter name="arguments" type="Map"/>
        </in-parameters>
        <out-parameters>
            <parameter name="result" type="Map"/>
        </out-parameters>
        <actions>
            <script><![CDATA[
                import org.moqui.context.ExecutionContext
                import org.moqui.impl.context.UserFacadeImpl.UserInfo
                import groovy.json.JsonBuilder
                
                ExecutionContext ec = context.ec
                
                // Start timing for execution metrics
                def startTime = System.currentTimeMillis()
                
                // Handle stubbed MCP protocol methods by routing to actual Moqui services
                def protocolMethodMappings = [
                    "tools/list": "McpServices.list#Tools",
                    "tools/call": "McpServices.mcp#ToolsCall", 
                    "resources/list": "McpServices.mcp#ResourcesList",
                    "resources/read": "McpServices.mcp#ResourcesRead",
                    "resources/subscribe": "McpServices.mcp#ResourcesSubscribe",
                    "resources/unsubscribe": "McpServices.mcp#ResourcesUnsubscribe",
                    "prompts/list": "McpServices.mcp#PromptsList",
                    "prompts/get": "McpServices.mcp#PromptsGet",
                    "ping": "McpServices.mcp#Ping"
                ]
                
                if (protocolMethodMappings.containsKey(name)) {
                    ec.logger.info("MCP ToolsCall: Routing protocol method ${name} to ${protocolMethodMappings[name]}")
                    def targetServiceName = protocolMethodMappings[name]
                    
                    // Special handling for tools/call to avoid infinite recursion
                    if (name == "tools/call") {
                        // Extract the actual tool name and arguments from arguments
                        def actualToolName = arguments?.name
                        def actualArguments = arguments?.arguments
                        
                        if (!actualToolName) {
                            throw new Exception("tools/call requires 'name' parameter in arguments")
                        }
                        
                        // Ensure sessionId is always passed through in arguments
                        if (actualArguments instanceof Map) {
                            actualArguments.sessionId = sessionId
                        } else {
                            actualArguments = [sessionId: sessionId]
                        }
                        
                        // Route to the actual tool service, not recursive ToolsCall
                        def actualTargetServiceName = protocolMethodMappings[actualToolName]
                        if (actualTargetServiceName) {
                            ec.logger.info("MCP ToolsCall: Routing tools/call with name '${actualToolName}' to ${actualTargetServiceName}")
                            return ec.service.sync().name(actualTargetServiceName)
                                .parameters(actualArguments ?: [:])
                                .call()
                        } else {
                            throw new Exception("Unknown tool name: ${actualToolName}")
                        }
                    } else {
                        // For other protocol methods, call the target service with provided arguments
                        def serviceResult = ec.service.sync().name(targetServiceName)
                            .parameters(arguments ?: [:])
                            .call()
                        
                        def executionTime = (System.currentTimeMillis() - startTime) / 1000.0
                        
                        // Convert result to MCP format
                        def content = []
                        if (serviceResult?.result) {
                            content << [
                                type: "text",
                                text: new groovy.json.JsonBuilder(serviceResult.result).toString()
                            ]
                        }
                        
                        result.result = [
                            content: content,
                            isError: false
                        ]
                        return
                    }
                }
                
                // Check if this is a screen-based tool or a service-based tool
                def isScreenTool = name.startsWith("screen_")
                
                if (isScreenTool) {
                    // Decode screen path from tool name (Clean Encoding with subscreen support)
                    def toolNameSuffix = name.substring(7)  // Remove "screen_" prefix
                    
                    def screenPath
                    def subscreenName = null
                    
                    // Check if this is a subscreen (contains dot after the initial prefix)
                    if (toolNameSuffix.contains('.')) {
                        // Split on dot to separate parent screen path from subscreen name
                        def lastDotIndex = toolNameSuffix.lastIndexOf('.')
                        def parentPath = toolNameSuffix.substring(0, lastDotIndex)
                        subscreenName = toolNameSuffix.substring(lastDotIndex + 1)
                        
                        // Restore parent path: _ -> /, prepend component://, append .xml
                        screenPath = "component://" + parentPath.replace('_', '/') + ".xml"
                        ec.logger.info("Decoded subscreen path for tool ${name}: parent=${screenPath}, subscreen=${subscreenName}")
                    } else {
                        // Regular screen path: _ -> /, prepend component://, append .xml
                        screenPath = "component://" + toolNameSuffix.replace('_', '/') + ".xml"
                        ec.logger.info("Decoded screen path for tool ${name}: ${screenPath}")
}
                    
                    // Now call the screen tool with proper user context
                    def screenParams = arguments ?: [:]
                    // Use requested render mode from arguments, default to text for LLM-friendly output
                    def renderMode = screenParams.remove('renderMode') ?: "text"
                    def serviceCallParams = [screenPath: screenPath, parameters: screenParams, renderMode: renderMode, sessionId: sessionId]
                    if (subscreenName) {
                        serviceCallParams.subscreenName = subscreenName
                    }
                    serviceResult = ec.service.sync().name("McpServices.execute#ScreenAsMcpTool")
                        .parameters(serviceCallParams)
                        .call()
                        
                def executionTime = (System.currentTimeMillis() - startTime) / 1000.0
                    
                    // Convert result to MCP format
                    def content = []
                    
                    if (serviceResult?.result) {
                        // Handle screen execution result which has content array
                        if (serviceResult.result.content && serviceResult.result.content instanceof List) {
                            // Use the content array directly from the screen execution result
                            content.addAll(serviceResult.result.content)
                        } else if (serviceResult.result.type == "text" && serviceResult.result.text) {
                            content << [
                                type: "text", 
                                text: serviceResult.result.text
                            ]
                        } else {
                            content << [
                                type: "html", 
                                text: serviceResult.result.text ?: serviceResult.result.toString() ?: "Screen executed successfully"
                            ]
                        }
                    }
                    
                    // Extract content from ScreenAsMcpTool result, don't nest it
                    result = serviceResult?.result ?: [
                        content: content,
                        isError: false
                    ]
                    return
                }
                
                // For service tools, validate service exists
                if (!ec.service.isServiceDefined(name)) {
                    throw new Exception("Tool not found: ${name}")
                }
                
                // Capture original user for permission context
                def originalUsername = ec.user.username
                UserInfo adminUserInfo = null
                
                try {
                    // Execute service with elevated privileges for system access
                    // but maintain audit context with actual user
                    def serviceResult
                    adminUserInfo = null
                    try {
                        serviceResult = ec.service.sync().name(name).parameters(arguments ?: [:]).call()
                } finally {
                    if (adminUserInfo != null) {
                        ec.user.popUser()
                    }
                    ec.artifactExecution.enableAuthz()
                }
                    def executionTime = (System.currentTimeMillis() - startTime) / 1000.0
                    
                    // Convert result to MCP format
                    def content = []
                    if (serviceResult) {
                        content << [
                            type: "text",
                            text: new JsonBuilder(serviceResult).toString()
                        ]
                    }
                    
                    result.result = [
                        content: content,
                        isError: false
                    ]
                } catch (Exception e2) {
                    def executionTime = (System.currentTimeMillis() - startTime) / 1000.0
                    
                    result = [
                        content: [
                            [
                                type: "text",
                                text: "Error executing tool ${name}: ${e.message}"
                            ]
                        ],
                        isError: true
                    ]
                    
                    ec.logger.error("MCP tool execution error", e)
                } finally {
                    // Always restore original user context
                    if (adminUserInfo != null) {
                        ec.user.popUser()
                    }
                    
                    // Send a simple notification about tool execution
                    try {
                        def servlet = ec.web.getServletContext().getAttribute("enhancedMcpServlet")
                        ec.logger.info("TOOLS CALL: Got servlet reference: ${servlet != null}, sessionId: ${sessionId}")
                        if (servlet && sessionId) {
                            def notification = [
                                method: "notifications/tool_execution",
                                params: [
                                    toolName: name,
                                    executionTime: (System.currentTimeMillis() - startTime) / 1000.0,
                                    success: !result?.result?.isError,
                                    timestamp: System.currentTimeMillis()
                                ]
                            ]
                            servlet.queueNotification(sessionId, notification)
                            ec.logger.info("Queued tool execution notification for session ${sessionId}")
                        }
                    } catch (Exception e) {
                        ec.logger.warn("Failed to send tool execution notification: ${e.message}")
                    }
                }
            ]]></script>
        </actions>
    </service>

    <service verb="mcp" noun="ResourcesList" authenticate="false" allow-remote="true" transaction-timeout="60">
        <description>Handle MCP resources/list request with Moqui entity discovery</description>
        <in-parameters>
            <parameter name="sessionId"/>
            <parameter name="cursor"/>
        </in-parameters>
        <out-parameters>
            <parameter name="result" type="Map"/>
        </out-parameters>
        <actions>
            <script><![CDATA[
                import org.moqui.context.ExecutionContext
                import org.moqui.impl.context.UserFacadeImpl.UserInfo
                
                ExecutionContext ec = context.ec
                
                // Build list of available entities as resources
                def resources = []
                
                UserInfo adminUserInfo = null
                    
                // Store original user context before switching to ADMIN
                def originalUsername = ec.user.username
                def originalUserId = ec.user.userId
                def userGroups = ec.user.getUserGroupIdSet().collect { it }
                
                // Use curated list of commonly used entities instead of discovering all entities
                def availableResources = []
                
                ec.logger.debug("MCP ResourcesList: Starting permissions-based entity discovery ${userGroups}")
                
                // Get user's accessible entities using Moqui's optimized ArtifactAuthzCheckView
                def userAccessibleEntities = null as Set<String>
                adminUserInfo = null
                try {
                    adminUserInfo = ec.user.pushUser("ADMIN")
                    def aacvList = ec.entity.find("moqui.security.ArtifactAuthzCheckView")
                        .condition("userGroupId", userGroups)
                        .condition("artifactTypeEnumId", "AT_ENTITY")
                        .useCache(true)
                        .disableAuthz()
                        .list()
                    userAccessibleEntities = aacvList.collect { it.artifactName } as Set<String>
                } finally {
                    if (adminUserInfo != null) {
                        ec.user.popUser()
                    }
                }
                
                // Helper function to check if user has permission to an entity
                def userHasEntityPermission = { entityName ->
                    // Use pre-computed accessible entities set for O(1) lookup
                    return userAccessibleEntities != null && userAccessibleEntities.contains(entityName.toString())
                }
                
                // Add all permitted entities including ViewEntities for LLM convenience
                def allEntityNames = ec.entity.getAllEntityNames()
                def allViewNames = [] as Set<String>
                
                // Get ViewEntities by checking entity definitions for view entities
                def entityInfoList = ec.entity.getAllEntityInfo(0, true) // includeViewEntities=true
                for (entityInfo in entityInfoList) {
                    if (entityInfo.isViewEntity) {
                        allViewNames.add(entityInfo.entityName)
                    }
                }
                
                // Combine real entities and ViewEntities
                def allAccessibleEntities = allEntityNames + allViewNames
                
                for (entityName in allAccessibleEntities) {
                    if (userHasEntityPermission(entityName)) {
                        def description = "Moqui entity: ${entityName}"
                        if (entityName.contains("View")) {
                            description = "Moqui ViewEntity: ${entityName} (pre-joined data for LLM convenience)"
                        }
                        
                        ec.logger.debug("MCP ResourcesList: Adding entity: ${entityName}")
                        availableResources << [
                            uri: "entity://${entityName}",
                            name: entityName,
                            description: description,
                            mimeType: "application/json"
                        ]
                    }
                }
                
                result = [resources: availableResources]
            ]]></script>
        </actions>
    </service>

    <service verb="mcp" noun="ResourcesRead" authenticate="true" allow-remote="true" transaction-timeout="120">
        <description>Handle MCP resources/read request with Moqui entity queries</description>
        <in-parameters>
            <parameter name="sessionId"/>
            <parameter name="uri" required="true"/>
        </in-parameters>
        <out-parameters>
            <parameter name="result" type="Map"/>
        </out-parameters>
        <actions>
            <script><![CDATA[
                import org.moqui.context.ExecutionContext
                import groovy.json.JsonBuilder
                
                ExecutionContext ec = context.ec
                
                // Parse entity URI (format: entity://EntityName)
                if (!uri.startsWith("entity://")) {
                    throw new Exception("Invalid resource URI: ${uri}")
                }
                
                def entityName = uri.substring(9) // Remove "entity://" prefix
                
                // Validate entity exists
                if (!ec.entity.isEntityDefined(entityName)) {
                    throw new Exception("Entity not found: ${entityName}")
                }
                
                // Permission checking is handled by Moqui's artifact authorization system through artifact groups
                
try {
                 // Try to get entity definition - handle both real entities and view entities
                      def entityDef = null
                      try {
                          // First try getAllEntityInfo for detailed info
                          def entityInfoList = ec.entity.getAllEntityInfo(-1, true) // all entities, include view entities
                          entityDef = entityInfoList.find { it.entityName == entityName }
                          
                          if (!entityDef) {
                              // If not found in detailed list, try basic entity check
                              if (ec.entity.isEntityDefined(entityName)) {
                                  // Create minimal entity definition for basic query
                                  entityDef = [
                                      entityName: entityName,
                                      packageName: entityName.split('\\.')[0],
                                      description: "Entity: ${entityName}",
                                      isViewEntity: entityName.contains('View'),
                                      allFieldInfoList: []
                                  ]
                              }
                          }
                         
                          ec.logger.warn("ResourcesRead: Error getting entity info for ${entityName}: ${e.message}")
                          // Fallback: try basic entity check
                          if (ec.entity.isEntityDefined(entityName)) {
                              entityDef = [
                                  entityName: entityName,
                                  packageName: entityName.split('\\.')[0],
                                  description: "Entity: ${entityName}",
                                  isViewEntity: entityName.contains('View'),
                                  allFieldInfoList: []
                              ]
                          }
                      
                      if (!entityDef) {
                          throw new Exception("Entity not found: ${entityName}")
                      }
                      
                      ec.logger.info("ResourcesRead: Found entity ${entityName}, isViewEntity=${entityDef.isViewEntity}")
                     
                     // Query entity data (limited to prevent large responses)
                     def entityList = ec.entity.find(entityName)
                         .limit(100)
                         .list()
                     
                     def executionTime = (System.currentTimeMillis() - startTime) / 1000.0
                     
                     // SIZE PROTECTION: Check response size before returning
                     def jsonOutput = new JsonBuilder([
                         entityName: entityName,
                         description: entityDef.description ?: "",
                         packageName: entityDef.packageName,
                         recordCount: entityList.size(),
                         fields: fieldInfo,
                         data: entityList
                     ]).toString()
                     
                     def maxResponseSize = 1024 * 1024  // 1MB limit
                     if (jsonOutput.length() > maxResponseSize) {
                         ec.logger.warn("ResourcesRead: Response too large for ${entityName}: ${jsonOutput.length()} bytes (limit: ${maxResponseSize} bytes)")
                         
                         // Create truncated response with fewer records
                         def truncatedList = entityList.take(10)  // Keep only first 10 records
                         def truncatedOutput = new JsonBuilder([
                             entityName: entityName,
                             description: entityDef.description ?: "",
                             packageName: entityDef.packageName,
                             recordCount: entityList.size(),
                             fields: fieldInfo,
                             data: truncatedList,
                             truncated: true,
                             originalSize: entityList.size(),
                             truncatedSize: truncatedList.size(),
                             message: "Response truncated due to size limits. Original data has ${entityList.size()} records, showing first ${truncatedList.size()}."
                         ]).toString()
                         
                         contents = [
                             [
                                 uri: uri,
                                 mimeType: "application/json",
                                 text: truncatedOutput
                             ]
                         ]
                     } else {
                         // Normal response
                         contents = [
                             [
                                 uri: uri,
                                 mimeType: "application/json",
                                 text: jsonOutput
                             ]
                         ]
                     }
                     
                 } catch (Exception e) {
                      def executionTime = (System.currentTimeMillis() - startTime) / 1000.0
                      ec.logger.warn("Error reading resource ${uri}: ${e.message}")
                      result = [error: "Error reading resource ${uri}: ${e.message}"]
                  }
            ]]></script>
        </actions>
    </service>

    <service verb="mcp" noun="Ping" authenticate="true" allow-remote="true" transaction-timeout="10">
        <description>Handle MCP ping request for health check</description>
        <in-parameters>
            <parameter name="sessionId"/>
            <parameter name="cursor"/>
        </in-parameters>
        <out-parameters>
            <parameter name="result" type="Map"/>
        </out-parameters>
        <actions>
          <script><![CDATA[
                import org.moqui.impl.context.UserFacadeImpl.UserInfo
                
                // Get current user information
                def currentUser = ec.user.username
                def currentUserId = ec.user.userId
                
                // Try to get visit information if sessionId is provided
                def visitInfo = null
                if (sessionId) {
                    try {
                        ec.artifactExecution.disableAuthz()
                        def adminUserInfo = ec.user.pushUser("ADMIN")
                        try {
                            def visit = ec.entity.find("moqui.server.Visit")
                                .condition("visitId", sessionId)
                                .one()
                            
                            if (visit) {
                                visitInfo = [
                                    visitId: visit.visitId,
                                    userId: visit.userId,
                                    fromDate: visit.fromDate,
                                    lastUpdatedStamp: visit.lastUpdatedStamp
                                ]
                            }
                        } finally {
                            ec.user.popUser()
                        }
                        ec.artifactExecution.enableAuthz()
                    } catch (Exception e) {
                        // Log but don't fail the ping
                        ec.logger.warn("Error getting visit info for sessionId ${sessionId}: ${e.message}")
                    }
                }
                
                result = [
                    timestamp: ec.user.getNowTimestamp(),
                    status: "healthy",
                    version: "2.0.2",
                    sessionId: sessionId,
                    currentUser: currentUser,
                    currentUserId: currentUserId,
                    visitInfo: visitInfo,
                    architecture: "Visit-based sessions"
                ]
            ]]></script>
        </actions>
    </service>

    <!-- Debug Service -->
    
    <service verb="debug" noun="ComponentStatus" authenticate="false" allow-remote="true">
        <description>Debug service to verify component is loaded and working</description>
        <in-parameters/>
        <out-parameters>
            <parameter name="status" type="Map"/>
        </out-parameters>
        <actions>
            <script><![CDATA[
                import org.moqui.context.ExecutionContext
                import org.moqui.impl.context.UserFacadeImpl.UserInfo
                
                ExecutionContext ec = context.ec
                
                def status = [
                    componentLoaded: true,
                    componentName: "mo-mcp",
                    timestamp: ec.user.getNowTimestamp(),
                    user: ec.user.username,
                    userId: ec.user.userId,
                    serviceNames: ec.service.getKnownServiceNames().findAll { it.contains("Mcp") },
                    entityNames: ec.entity.getAllEntityNames().findAll { it.contains("ArtifactHit") }
                ]
                
                ec.logger.info("=== MCP COMPONENT DEBUG ===")
                ec.logger.info("Component status: ${status}")
                ec.logger.info("All service names count: ${ec.service.getKnownServiceNames().size()}")
                ec.logger.info("All entity names count: ${ec.entity.getAllEntityNames().size()}")
                ec.logger.info("=== END MCP COMPONENT DEBUG ===")
                
                result.status = status
            ]]></script>
        </actions>
    </service>

    <!-- Helper Functions -->
    
    <service verb="validate" noun="Origin" authenticate="false" allow-remote="false">
        <description>Validate Origin header for DNS rebinding protection</description>
        <in-parameters>
            <parameter name="origin" required="true"/>
        </in-parameters>
        <out-parameters>
            <parameter name="isValid" type="boolean"/>
        </out-parameters>
        <actions>
            <script><![CDATA[
                import org.moqui.context.ExecutionContext
                import org.moqui.impl.context.UserFacadeImpl.UserInfo
                
                ExecutionContext ec = context.ec
                
                // Allow localhost origins
                if (origin?.startsWith("http://localhost:") || origin?.startsWith("https://localhost:")) {
                    isValid = true
                    return
                }
                
                // Allow 127.0.0.1 origins
                if (origin?.startsWith("http://127.0.0.1:") || origin?.startsWith("https://127.0.0.1:")) {
                    isValid = true
                    return
                }
                
                // Allow same-origin requests (check against current host)
                def currentHost = ec.web?.request?.getServerName()
                def currentScheme = ec.web?.request?.getScheme()
                def currentPort = ec.web?.request?.getServerPort()
                
                def expectedOrigin = "${currentScheme}://${currentHost}"
                if ((currentScheme == "http" && currentPort != 80) || (currentScheme == "https" && currentPort != 443)) {
                    expectedOrigin += ":${currentPort}"
                }
                
                if (origin == expectedOrigin) {
                    isValid = true
                    return
                }
                
                // Check for configured allowed origins (could be from system properties)
                def allowedOrigins = ec.getFactory().getConfiguration().getStringList("moqui.mcp.allowed_origins", [])
                if (allowedOrigins.contains(origin)) {
                    isValid = true
                    return
                }
                
                isValid = false
            ]]></script>
        </actions>
    </service>
    
    <service verb="convert" noun="MoquiTypeToJsonSchemaType" authenticate="false">
        <description>Convert Moqui data types to JSON Schema types</description>
        <in-parameters>
            <parameter name="moquiType" required="true"/>
        </in-parameters>
        <out-parameters>
            <parameter name="jsonSchemaType"/>
        </out-parameters>
        <actions>
            <script><![CDATA[
                // Simple type mapping - can be expanded as needed
                def typeMap = [
                    "text-short": "string",
                    "text-medium": "string", 
                    "text-long": "string",
                    "text-very-long": "string",
                    "id": "string",
                    "id-long": "string",
                    "number-integer": "integer",
                    "number-decimal": "number",
                    "number-float": "number",
                    "date": "string",
                    "date-time": "string",
                    "date-time-nano": "string",
                    "boolean": "boolean",
                    "text-indicator": "boolean"
                ]
                
                jsonSchemaType = typeMap[moquiType] ?: "string"
            ]]></script>
        </actions>
    </service>

    <service verb="execute" noun="ScreenAsMcpTool" authenticate="true" allow-remote="true" transaction-timeout="120">
        <description>Execute a screen as an MCP tool</description>
        <in-parameters>
            <parameter name="screenPath" required="true"/>
            <parameter name="parameters" type="Map"><description>Parameters to pass to the screen</description></parameter>
            <parameter name="renderMode" default="html"><description>Render mode: text, html, xml, vuet, qvt</description></parameter>
            <parameter name="sessionId"><description>Session ID for user context restoration</description></parameter>
            <parameter name="subscreenName"><description>Optional subscreen name for dot notation paths</description></parameter>
        </in-parameters>
        <out-parameters>
            <parameter name="result" type="Map"/>
        </out-parameters>
        <actions>
            <script><![CDATA[
import org.moqui.context.ExecutionContext
import groovy.json.JsonBuilder

ExecutionContext ec = context.ec

def startTime = System.currentTimeMillis()
    // Note: Screen validation will happen during render
    // if (!ec.screen.isScreenDefined(screenPath)) {
    //     throw new Exception("Screen not found: ${screenPath}")
    // }
    
    // Set parameters in context
    if (parameters) {
        ec.context.putAll(parameters)
    }
    
    // Try to render screen content for LLM consumption
    def output = null
    def screenUrl = "http://localhost:8080/${screenPath}"
    def isError = false
    
    try {
        ec.logger.info("MCP Screen Execution: Attempting to render screen ${screenPath} using ScreenTest with proper root screen")
        
        // For ScreenTest to work properly, we need to use the correct root screen
        // The screenPath should be relative to the appropriate root screen
        def testScreenPath = screenPath
        def rootScreen = "component://webroot/screen/webroot.xml"
        
        // Initialize standalone flag outside the if block
        def targetScreenDef = null
        def isStandalone = false
        
            def pathAfterComponent = screenPath.substring(12).replace('.xml','') // Remove "component://"
            def pathParts = pathAfterComponent.split("/")
                // If the screen path is already a full component:// path, we need to handle it differently
        if (screenPath.startsWith("component://")) {
            // For component:// paths, we need to use the component's root screen, not webroot
            // Extract the component name and use its root screen
            if (pathParts.length >= 2) {
                def componentName = pathParts[0]
                def remainingPath = pathParts[1..-1].join("/")
                
                // Check if the target screen itself is standalone FIRST
                try {
                    targetScreenDef = ec.screen.getScreenDefinition(screenPath)
                    ec.logger.info("MCP Screen Execution: Target screen def for ${screenPath}: ${targetScreenDef?.getClass()?.getSimpleName()}")
                    if (targetScreenDef?.screenNode) {
                        def standaloneAttr = targetScreenDef.screenNode.attribute('standalone')
                        ec.logger.info("MCP Screen Execution: Target screen ${screenPath} standalone attribute: '${standaloneAttr}'")
                        isStandalone = standaloneAttr == "true"
                    } else {
                        ec.logger.warn("MCP Screen Execution: Target screen ${screenPath} has no screenNode")
                    }
                    ec.logger.info("MCP Screen Execution: Target screen ${screenPath} standalone=${isStandalone}")
                    
                    if (isStandalone) {
                        // For standalone screens, try to render with minimal context or fall back to URL
                        ec.logger.info("MCP Screen Execution: Standalone screen detected, will try direct rendering")
                        rootScreen = screenPath
                        testScreenPath = ""  // Empty path for standalone screens
                        // We'll handle standalone screens specially below
                    }
                } catch (Exception e) {
                    ec.logger.warn("MCP Screen Execution: Error checking target screen ${screenPath}: ${e.message}")
                    ec.logger.error("MCP Screen Execution: Full exception", e)
                }
                
                // Only look for component root if target is not standalone
                if (!isStandalone) {
                    // For component://webroot/screen/... paths, always use webroot as root
                    if (pathAfterComponent.startsWith("webroot/screen/")) {
                        // This is a webroot screen, use webroot as root and the rest as path
                        rootScreen = "component://webroot/screen/webroot.xml"
                        testScreenPath = pathAfterComponent.substring("webroot/screen/".length())
                        // Remove any leading "webroot/" from the path since we're already using webroot as root
                        if (testScreenPath.startsWith("webroot/")) {
                            testScreenPath = testScreenPath.substring("webroot/".length())
                        }
                        ec.logger.info("MCP Screen Execution: Using webroot root for webroot screen: ${rootScreen} with path: ${testScreenPath}")
                    } else {
                        // For other component screens, check if this is a direct screen path (not a subscreen path)
                        def pathSegments = remainingPath.split("/")
                        def isDirectScreenPath = false
                        
                        // Try to check if the full path is a valid screen
                        try {
                            def directScreenDef = ec.screen.getScreenDefinition(screenPath)
                            if (directScreenDef) {
                                isDirectScreenPath = true
                                ec.logger.info("MCP Screen Execution: Found direct screen path: ${screenPath}")
                            }
                        } catch (Exception e) {
                            ec.logger.debug("MCP Screen Execution: Direct screen check failed for ${screenPath}: ${e.message}")
                        }
                        
                        if (isDirectScreenPath) {
                            // For direct screen paths, use the screen itself as root
                            rootScreen = screenPath
                            testScreenPath = ""
                            ec.logger.info("MCP Screen Execution: Using direct screen as root: ${rootScreen}")
                        } else {
                            // Try to find the actual root screen for this component
                            def componentRootScreen = null
                            def possibleRootScreens = [
                                "${componentName}.xml",
                                "${componentName}Admin.xml",
                                "${componentName}Root.xml"
                            ]
                            
                            for (rootScreenName in possibleRootScreens) {
                                def candidateRoot = "component://${componentName}/screen/${rootScreenName}"
                                try {
                                    def testDef = ec.screen.getScreenDefinition(candidateRoot)
                                    if (testDef) {
                                        componentRootScreen = candidateRoot
                                        ec.logger.info("MCP Screen Execution: Found component root screen: ${componentRootScreen}")
                                        break
                                    }
                                } catch (Exception e) {
                                    ec.logger.debug("MCP Screen Execution: Root screen ${candidateRoot} not found: ${e.message}")
                                }
                            }
                            
                            if (componentRootScreen) {
                                rootScreen = componentRootScreen
                                testScreenPath = remainingPath
                                ec.logger.info("MCP Screen Execution: Using component root ${rootScreen} for path ${testScreenPath}")
                            } else {
                                // For mantle and other components, try using the component's screen directory as root
                                // This is a better fallback than webroot
                                def componentScreenRoot = "component://${componentName}/screen/"
                                if (pathAfterComponent.startsWith("${componentName}/screen/")) {
                                    // Extract the screen file name from the path
                                    def screenFileName = pathAfterComponent.substring("${componentName}/screen/".length())
                                    rootScreen = screenPath  // Use the full path as root
                                    testScreenPath = ""     // Empty path for direct screen access
                                    ec.logger.info("MCP Screen Execution: Using component screen as direct root: ${rootScreen}")
                                } else {
                                    // Final fallback: try webroot
                                    rootScreen = "component://webroot/screen/webroot.xml"
                                    testScreenPath = pathAfterComponent
                                    ec.logger.warn("MCP Screen Execution: Could not find component root for ${componentName}, using webroot fallback: ${testScreenPath}")
                                }
                            }
                        }
                    }
                }
            } else {
                // Fallback for malformed component paths
                testScreenPath = pathAfterComponent
                ec.logger.warn("MCP Screen Execution: Malformed component path, using fallback: ${testScreenPath}")
            }
        }
        
        // Handle subscreen if specified
        if (subscreenName) {
            ec.logger.info("MCP Screen Execution: Handling subscreen ${subscreenName} for parent ${screenPath}")
            
            // For subscreens, we need to modify the render path to include the subscreen
            // The pathParts array already contains the full path, so we need to add the subscreen name
            def subscreenPathParts = pathParts + subscreenName.split('_')
            ec.logger.info("MCP Screen Execution: Full subscreen path parts: ${subscreenPathParts}")
            
            // User context should already be correct from MCP servlet restoration
            // CustomScreenTestImpl will capture current user context automatically
            ec.logger.info("MCP Screen Execution: Current user context - userId: ${ec.user.userId}, username: ${ec.user.username}")
            
            // Regular screen rendering with current user context - use our custom ScreenTestImpl
            def screenTest = new org.moqui.mcp.CustomScreenTestImpl(ec.ecfi)
                .rootScreen(rootScreen)
                .renderMode(renderMode ? renderMode : "html")
                .auth(ec.user.username) // Propagate current user to the test renderer
            
            ec.logger.info("MCP Screen Execution: ScreenTest object created for subscreen: ${screenTest?.getClass()?.getSimpleName()}")
                
            if (screenTest) {
                def renderParams = parameters ?: [:]
                
                // Add current user info to render context to maintain authentication
                renderParams.userId = ec.user.userId
                renderParams.username = ec.user.username
                
                // Set user context in ScreenTest to maintain authentication
                // Note: ScreenTestImpl may not have direct userAccountId property, 
                // the user context should be inherited from the current ExecutionContext
                ec.logger.info("MCP Screen Execution: Current user context - userId: ${ec.user.userId}, username: ${ec.user.username}")
                ec.logger.info("SUBSCREEN PATH PARTS ${subscreenPathParts}")
                
            // Regular screen rendering with timeout for subscreen
                
            try {
                ec.logger.info("TESTRENDER ${subscreenName.replaceAll('_','/')} ${renderParams}")
                // For subscreens, the path should be relative to the parent screen that's already set as root
                // Since we're using the parent screen as root, we only need the subscreen name part
                def testRender = screenTest.render(subscreenName.replaceAll('_','/'), renderParams, "POST")
                output = testRender.getOutput()
                def outputLength = output?.length() ?: 0
                ec.logger.info("MCP Screen Execution: Successfully rendered screen ${screenPath}, output length: ${output?.length() ?: 0}")
            } catch (java.util.concurrent.TimeoutException e) {
                throw new Exception("Screen rendering timed out after 30 seconds for ${screenPath}")
            }
        } else {
            throw new Exception("ScreenTest object is null")
        }
        }
    } catch (Exception e) {
        isError = true
        ec.logger.warn("MCP Screen Execution: Could not render screen ${screenPath}, exposing error details: ${e.message}")
        ec.logger.warn("MCP Screen Execution: Exception details: ${e.getClass()?.getSimpleName()}: ${e.getMessage()}")
        ec.logger.error("MCP Screen Execution: Full exception for ${screenPath}", e)
        
        // Expose detailed error information instead of URL fallback
        def errorDetails = []
        errorDetails << "SCREEN RENDERING ERROR"
        errorDetails << "======================"
        errorDetails << "Screen Path: ${screenPath}"
        errorDetails << "Error Type: ${e.getClass()?.getSimpleName()}"
        errorDetails << "Error Message: ${e.getMessage()}"
        errorDetails << ""
        
        // Add stack trace for debugging (limited depth for readability)
        if (e.getStackTrace()) {
            errorDetails << "Stack Trace (top 10 frames):"
            e.getStackTrace().take(10).eachWithIndex { stackTrace, index ->
                errorDetails << "  ${index + 1}. ${stackTrace.toString()}"
            }
            if (e.getStackTrace().size() > 10) {
                errorDetails << "  ... and ${e.getStackTrace().size() - 10} more frames"
            }
        }
        
        // Add cause information if available
        def cause = e.getCause()
        if (cause) {
            errorDetails << ""
            errorDetails << "Root Cause: ${cause.getClass()?.getSimpleName()}: ${cause.getMessage()}"
        }
        
        // Add context information
        errorDetails << ""
        errorDetails << "Context Information:"
        errorDetails << "- User: ${ec.user.username} (${ec.user.userId})"
        errorDetails << "- Render Mode: ${renderMode}"
        errorDetails << "- Parameters: ${parameters ?: 'none'}"
        errorDetails << "- Execution Time: ${((System.currentTimeMillis() - startTime) / 1000.0)}s"
        
        // Add troubleshooting suggestions
        errorDetails << ""
        errorDetails << "Troubleshooting Suggestions:"
        errorDetails << "1. Check if the screen path is correct and the screen exists"
        errorDetails << "2. Verify user has permission to access this screen"
        errorDetails << "3. Check if all required parameters are provided"
        errorDetails << "4. Verify screen dependencies and data access"
        errorDetails << "5. Check server logs for more detailed error information"
        
        output = errorDetails.join("\n")
    }
    
    // Helper function to convert web paths to MCP tool names
    def convertWebPathToMcpTool = { path ->
        try {
            // Handle simple catalog paths (dropdown menu items)
            if (path == "Category" || path.startsWith("Category/")) {
                return "screen_SimpleScreens_screen_SimpleScreens_Catalog_Category"
            } else if (path == "Feature" || path.startsWith("Feature/")) {
                return "screen_SimpleScreens_screen_SimpleScreens_Catalog_Feature"
            } else if (path == "FeatureGroup" || path.startsWith("FeatureGroup/")) {
                return "screen_SimpleScreens_screen_SimpleScreens_Catalog_FeatureGroup"
            } else if (path == "Product" || path.startsWith("Product/")) {
                return "screen_SimpleScreens_screen_SimpleScreens_Catalog_Product"
            } else if (path.startsWith("Search")) {
                return "screen_SimpleScreens_screen_SimpleScreens_Search"
            }
            
            // Handle full catalog paths
            if (path.startsWith("Product/FindProduct")) {
                return "screen_SimpleScreens_screen_SimpleScreens_Catalog_Product"
            } else if (path.startsWith("Category/FindCategory")) {
                return "screen_SimpleScreens_screen_SimpleScreens_Catalog_Category"  
            } else if (path.startsWith("Feature/FindFeature")) {
                return "screen_SimpleScreens_screen_SimpleScreens_Catalog_Feature"
            } else if (path.startsWith("FeatureGroup/FindFeatureGroup")) {
                return "screen_SimpleScreens_screen_SimpleScreens_Catalog_FeatureGroup"
            }
            
            // Handle PopCommerce Admin paths
            if (path.startsWith("PopcAdmin/")) {
                def cleanPath = path.replace("PopcAdmin/", "PopCommerceAdmin/")
                def toolName = "screen_PopCommerce_screen_" + cleanPath.replace("/", "_")
                return toolName
            }
            
            // Handle SimpleScreens paths
            if (path.startsWith("apps/")) {
                def cleanPath = path.replace("apps/", "")
                def toolName = "screen_SimpleScreens_screen_SimpleScreens_" + cleanPath.replace("/", "_")
                return toolName
            }
            
            return null
        } catch (Exception e) {
            ec.logger.debug("Error converting web path ${path} to MCP tool: ${e.message}")
            return null
        }
    }
    
    def executionTime = (System.currentTimeMillis() - startTime) / 1000.0
    
    // Convert web URLs to MCP tool suggestions to keep users in MCP ecosystem
    def processedOutput = output
    if (output && !isError) {
        try {
            // Convert common web URLs to MCP tool suggestions
            processedOutput = output.replaceAll(/http:\/\/localhost:8080\/([^\s"'>]+)/) { match ->
                def path = match[1]
                def toolName = convertWebPathToMcpTool(path)
                if (toolName) {
                    return "MCP_TOOL:${toolName}"
                } else {
                    return match[0] // Keep original if no MCP tool found
                }
            }
            
            ec.logger.info("MCP Screen Execution: Converted web URLs to MCP tool suggestions for ${screenPath}")
        } catch (Exception e) {
            ec.logger.warn("MCP Screen Execution: Error converting URLs to MCP tools: ${e.message}")
            // Keep original output if conversion fails
        }
    }
    
    // Return screen result directly as content array (standard MCP flow)
    def content = []
    
    // Add execution status as first content item
    content << [
        type: "text",
        text: "Screen execution completed for ${screenPath} in ${executionTime}s"
    ]
    
    // Add screen HTML as main content
    content << [
        type: "html",
        text: processedOutput,
        screenPath: screenPath,
        screenUrl: screenUrl,
        executionTime: executionTime,
        isError: isError
    ]
    
    result = [
        content: content,
        isError: false
    ]
    
    ec.logger.info("MCP Screen Execution: Returned result directly for screen ${screenPath} in ${executionTime}s")
            ]]></script>
        </actions>
    </service>

    <service verb="mcp" noun="ResourcesTemplatesList" authenticate="false" allow-remote="true" transaction-timeout="30">
        <description>Handle MCP resources/templates/list request</description>
        <in-parameters>
            <parameter name="sessionId"/>
        </in-parameters>
        <out-parameters>
            <parameter name="result" type="Map"/>
        </out-parameters>
        <actions>
            <script><![CDATA[
                import org.moqui.context.ExecutionContext
                
                ExecutionContext ec = context.ec
                
                // For now, return empty templates list - can be extended later
                def templates = []
                
                result = [resourceTemplates: templates]
            ]]></script>
        </actions>
    </service>
    
    <service verb="mcp" noun="ResourcesSubscribe" authenticate="false" allow-remote="true" transaction-timeout="30">
        <description>Handle MCP resources/subscribe request</description>
        <in-parameters>
            <parameter name="sessionId"/>
            <parameter name="uri" required="true"><description>Resource URI to subscribe to</description></parameter>
        </in-parameters>
        <out-parameters>
            <parameter name="result" type="Map"/>
        </out-parameters>
        <actions>
            <script><![CDATA[
                import org.moqui.context.ExecutionContext
                
                ExecutionContext ec = context.ec
                
                ec.logger.info("Resource subscription requested for URI: ${uri}, sessionId: ${sessionId}")
                
                // For now, just return success - actual subscription tracking could be added
                result = [subscribed: true, uri: uri]
            ]]></script>
        </actions>
    </service>
    
    <service verb="mcp" noun="ResourcesUnsubscribe" authenticate="false" allow-remote="true" transaction-timeout="30">
        <description>Handle MCP resources/unsubscribe request</description>
        <in-parameters>
            <parameter name="sessionId"/>
            <parameter name="uri" required="true"><description>Resource URI to unsubscribe from</description></parameter>
        </in-parameters>
        <out-parameters>
            <parameter name="result" type="Map"/>
        </out-parameters>
        <actions>
            <script><![CDATA[
                import org.moqui.context.ExecutionContext
                
                ExecutionContext ec = context.ec
                
                ec.logger.info("Resource unsubscription requested for URI: ${uri}, sessionId: ${sessionId}")
                
                // For now, just return success - actual subscription tracking could be added
                result = [unsubscribed: true, uri: uri]
            ]]></script>
        </actions>
    </service>
    
    <service verb="mcp" noun="PromptsList" authenticate="false" allow-remote="true" transaction-timeout="30">
        <description>Handle MCP prompts/list request</description>
        <in-parameters>
            <parameter name="sessionId"/>
        </in-parameters>
        <out-parameters>
            <parameter name="result" type="Map"/>
        </out-parameters>
        <actions>
            <script><![CDATA[
                import org.moqui.context.ExecutionContext
                
                ExecutionContext ec = context.ec
                
                // For now, return empty prompts list - can be extended later
                def prompts = []
                
                result = [prompts: prompts]
            ]]></script>
        </actions>
    </service>
    
    <service verb="mcp" noun="PromptsGet" authenticate="false" allow-remote="true" transaction-timeout="30">
        <description>Handle MCP prompts/get request</description>
        <in-parameters>
            <parameter name="sessionId"/>
            <parameter name="name" required="true"><description>Prompt name to retrieve</description></parameter>
        </in-parameters>
        <out-parameters>
            <parameter name="result" type="Map"/>
        </out-parameters>
        <actions>
            <script><![CDATA[
                import org.moqui.context.ExecutionContext
                
                ExecutionContext ec = context.ec
                
                ec.logger.info("Prompt requested: ${name}, sessionId: ${sessionId}")
                
                // For now, return not found - can be extended later
                result = [error: "Prompt not found: ${name}"]
            ]]></script>
        </actions>
    </service>
    
    <service verb="mcp" noun="RootsList" authenticate="false" allow-remote="true" transaction-timeout="30">
        <description>Handle MCP roots/list request</description>
        <in-parameters>
            <parameter name="sessionId"/>
        </in-parameters>
        <out-parameters>
            <parameter name="result" type="Map"/>
        </out-parameters>
        <actions>
            <script><![CDATA[
                import org.moqui.context.ExecutionContext
                
                ExecutionContext ec = context.ec
                
                // For now, return empty roots list - can be extended later
                def roots = []
                
                result = [roots: roots]
            ]]></script>
        </actions>
    </service>
    
    <service verb="mcp" noun="SamplingCreateMessage" authenticate="false" allow-remote="true" transaction-timeout="30">
        <description>Handle MCP sampling/createMessage request</description>
        <in-parameters>
            <parameter name="sessionId"/>
            <parameter name="messages" type="List"><description>List of messages to sample</description></parameter>
            <parameter name="maxTokens" type="Integer"><description>Maximum tokens to generate</description></parameter>
            <parameter name="temperature" type="BigDecimal"><description>Sampling temperature</description></parameter>
        </in-parameters>
        <out-parameters>
            <parameter name="result" type="Map"/>
        </out-parameters>
        <actions>
            <script><![CDATA[
                import org.moqui.context.ExecutionContext
                
                ExecutionContext ec = context.ec
                
                ec.logger.info("Sampling createMessage requested for sessionId: ${sessionId}")
                
                // For now, return not implemented - can be extended with actual LLM integration
                result = [error: "Sampling not implemented"]
            ]]></script>
        </actions>
    </service>
    
    <service verb="mcp" noun="ElicitationCreate" authenticate="false" allow-remote="true" transaction-timeout="30">
        <description>Handle MCP elicitation/create request</description>
        <in-parameters>
            <parameter name="sessionId"/>
            <parameter name="prompt"><description>Prompt for elicitation</description></parameter>
            <parameter name="context"><description>Context for elicitation</description></parameter>
        </in-parameters>
        <out-parameters>
            <parameter name="result" type="Map"/>
        </out-parameters>
        <actions>
            <script><![CDATA[
                import org.moqui.context.ExecutionContext
                
                ExecutionContext ec = context.ec
                
                ec.logger.info("Elicitation create requested for sessionId: ${sessionId}")
                
                // For now, return not implemented - can be extended later
                result = [error: "Elicitation not implemented"]
            ]]></script>
        </actions>
    </service>

    <service verb="list" noun="Tools" authenticate="false" allow-remote="true" transaction-timeout="60">
        <description>Compact tool discovery using ArtifactAuthzCheckView with clean recursion</description>
        <in-parameters>
            <parameter name="sessionId"/>
            <parameter name="cursor"/>
        </in-parameters>
        <out-parameters>
            <parameter name="result" type="Map"/>
        </out-parameters>
        <actions>
            <script><![CDATA[
                import org.moqui.context.ExecutionContext
                
                ExecutionContext ec = context.ec
                def startTime = System.currentTimeMillis()
                
                // Get user context
                def originalUsername = ec.user.username
                def originalUserId = ec.user.userId  
                def userGroups = ec.user.getUserGroupIdSet().collect { it }
                
                def tools = []
                adminUserInfo = null
                
                try {
                    adminUserInfo = ec.user.pushUser("ADMIN")
                    
                    def allScreens = [] as Set<String>
                       
                    // Get screens accessible to user's groups
                    def aacvList = ec.entity.find("moqui.security.ArtifactAuthzCheckView")
                        .condition("artifactTypeEnumId", "AT_XML_SCREEN")
                        .condition("userGroupId", "in", userGroups)
                        .useCache(true)
                        .disableAuthz()
                        .list()
                    allScreens = aacvList.collect { it.artifactName } as Set<String>
                    
                    // Helper function to convert screen path to MCP tool name
                    def screenPathToToolName = { screenPath ->
                        // Clean Encoding: strip component:// and .xml, replace / with _
                        def cleanPath = screenPath
                        if (cleanPath.startsWith("component://")) cleanPath = cleanPath.substring(12)
                        if (cleanPath.endsWith(".xml")) cleanPath = cleanPath.substring(0, cleanPath.length() - 4)
                        
                        // Extract just the screen name from the path (last part after /)
                        def screenName = cleanPath.split('/')[-1]
                        
                        return "screen_" + screenName
                    }
                    
                    // Helper function to convert screen path to MCP tool name with subscreen support
                    def screenPathToToolNameWithSubscreens = { screenPath, parentScreenPath = null ->
                        // If we have a parent screen path, this is a subscreen - use dot notation
                        if (parentScreenPath) {
                            def parentCleanPath = parentScreenPath
                            if (parentCleanPath.startsWith("component://")) parentCleanPath = parentCleanPath.substring(12)
                            if (parentCleanPath.endsWith(".xml")) parentCleanPath = parentCleanPath.substring(0, parentCleanPath.length() - 4)
                            
                            // Extract just the parent screen name (last part after /)
                            def parentScreenName = parentCleanPath.split('/')[-1]
                            
                            // Extract subscreen name from the full screen path
                            def subscreenName = screenPath.split("/")[-1]
                            if (subscreenName.endsWith(".xml")) subscreenName = subscreenName.substring(0, subscreenName.length() - 4)
                            
                            return "screen_" + parentScreenName + "." + subscreenName
                        }
                        
                        // Regular screen path conversion for main screens
                        return screenPathToToolName(screenPath)
                    }
                    
                    // Helper function to recursively process screens and create tools
                    def processScreenWithSubscreens 
                    processScreenWithSubscreens = { screenPath, parentScreenPath = null, processedScreens = null, toolsAccumulator = null, parentToolName = null, level = 1 ->
                        ec.logger.debug("list#Tools: Processing screen ${screenPath} (parent: ${parentScreenPath}, parentToolName: ${parentToolName}, level: ${level})")
                        
                        // Initialize processedScreens and toolsAccumulator if null
                        if (processedScreens == null) processedScreens = [] as Set<String>
                        if (toolsAccumulator == null) toolsAccumulator = []
                        
                        // Create a unique key for this specific access path (screen + parent)
                        def accessPathKey = screenPath + "|" + (parentScreenPath ?: "ROOT")
                        
                        if (processedScreens.contains(accessPathKey)) {
                            ec.logger.debug("list#Tools: Already processed ${screenPath} from parent ${parentScreenPath}, skipping")
                            return
                        }
                        
                        processedScreens.add(accessPathKey)
                        
                        try {
                            // Skip problematic patterns early
                            if (screenPath.contains("/error/") || screenPath.contains("/system/")) {
                                ec.logger.debug("list#Tools: Skipping system screen ${screenPath}")
                                return
                            }
                            
                            // Determine if this is a subscreen
                            def isSubscreen = parentScreenPath != null
                            
                            // Try to get screen definition
                            def screenDefinition = null
                            def title = screenPath.split("/")[-1].replace('.xml', '')
                            def description = "Moqui screen: ${screenPath}"
                            
                            try {
                                screenDefinition = ec.screen.getScreenDefinition(screenPath)
                                if (screenDefinition?.screenNode?.attribute('default-menu-title')) {
                                    title = screenDefinition.screenNode.attribute('default-menu-title')
                                    description = "Moqui screen: ${screenPath} (${title})"
                                }
                            } catch (Exception e) {
                                ec.logger.debug("list#Tools: No screen definition for ${screenPath}, using basic info")
                            }
                            
                            // Get screen parameters from transitions
                            def parameters = [:]
                            try {
                                def screenInfo = ec.screen.getScreenInfo(screenPath)
                                if (screenInfo?.transitionInfoByName) {
                                    for (transitionEntry in screenInfo.transitionInfoByName) {
                                        def transitionInfo = transitionEntry.value
                                        if (transitionInfo?.ti) {
                                            transitionInfo.ti.getPathParameterList()?.each { param ->
                                                parameters[param] = [
                                                    type: "string",
                                                    description: "Path parameter for transition: ${param}"
                                                ]
                                            }
                                            transitionInfo.ti.getRequestParameterList()?.each { param ->
                                                parameters[param.name] = [
                                                    type: "string",
                                                    description: "Request parameter: ${param.name}"
                                                ]
                                            }
                                        }
                                    }
                                }
                            } catch (Exception e) {
                                ec.logger.debug("Could not extract parameters from screen ${screenPath}: ${e.message}")
                            }
                            
                            // Create tool with proper naming
                            def toolName
                            if (isSubscreen && parentToolName) {
                                // Use the passed hierarchical parent tool name and append current subscreen name
                                def subscreenName = screenPath.split("/")[-1]
                                if (subscreenName.endsWith(".xml")) subscreenName = subscreenName.substring(0, subscreenName.length() - 4)
                                
                                // For level 1 subscreens, use dot notation
                                // For level 2+, replace the last dot with underscore and add the new subscreen name
                                if (level == 2) {
                                    toolName = parentToolName + "." + subscreenName
                                } else {
                                    // Replace last dot with underscore and append new subscreen name
                                    toolName = parentToolName + "_" + subscreenName // .replaceAll('\\.[^.]*$', '_' + subscreenName)
                                }
                                ec.logger.debug("list#Tools: Creating subscreen tool ${toolName} for ${screenPath} (parentToolName: ${parentToolName}, level: ${level})")
                            } else if (isSubscreen && parentScreenPath) {
                                toolName = parentToolName + screenPathToToolNameWithSubscreens(screenPath, parentScreenPath)
                                ec.logger.debug("list#Tools: Creating subscreen tool ${toolName} for ${screenPath} (parent: ${parentScreenPath})")
                            } else {
                                toolName = parentToolName + screenPathToToolName(screenPath)
                                ec.logger.debug("list#Tools: Creating main screen tool ${toolName} for ${screenPath}")
                            }
                            
                            def tool = [
                                name: toolName,
                                title: title,
                                description: title,  // Use title as description instead of redundant path
                                inputSchema: [
                                    type: "object",
                                    properties: parameters,
                                    required: []
                                ]
                            ]
                            
                            ec.logger.debug("list#Tools: Adding accessible screen tool ${toolName} for ${screenPath}")
                            toolsAccumulator << tool
                            
                            // Recursively process subscreens
                            try {
                                def screenInfoList = ec.screen.getScreenInfoList(screenPath, 1)
                                def screenInfo = screenInfoList?.first()
                                if (screenInfo?.subscreenInfoByName) {
                                    ec.logger.debug("list#Tools: Found ${screenInfo.subscreenInfoByName.size()} subscreens for ${screenPath}: ${screenInfo.subscreenInfoByName.keySet()}")
                                    for (subScreenEntry in screenInfo.subscreenInfoByName) {
                                        def subScreenInfo = subScreenEntry.value
                                        def subScreenPathList = subScreenInfo?.screenPath
                                        ec.logger.debug("list#Tools: Processing subscreen ${subScreenEntry.key}, subScreenInfo.screenPath: ${subScreenInfo.screenPath}")
                                        
                                        // Get the actual subscreen location from screenInfo (should have correct cross-component paths)
                                        def actualSubScreenPath = null
                                        
                                        if (subScreenInfo?.screenPath) {
                                            // Try to get actual screen location from subScreenInfo
                                            try {
                                                // Check if subScreenInfo has a method to get actual screen location
                                                if (subScreenInfo.hasProperty('sd')) {
                                                    // Try to get location from screen definition
                                                    def screenDef = subScreenInfo.sd
                                                    if (screenDef?.hasProperty('screenLocation')) {
                                                        actualSubScreenPath = screenDef.screenLocation
                                                        ec.logger.debug("list#Tools: Found screenLocation from sd for ${subScreenEntry.key}: ${actualSubScreenPath}")
                                                    } else if (screenDef?.hasProperty('location')) {
                                                        actualSubScreenPath = screenDef.location
                                                        ec.logger.debug("list#Tools: Found location from sd for ${subScreenEntry.key}: ${actualSubScreenPath}")
                                                    }
                                                }
                                                
                                                // Fallback to checking if screenPath contains XML path
                                                if (!actualSubScreenPath) {
                                                    if (subScreenInfo.screenPath instanceof List) {
                                                        // This is a list of all subscreens/transitions, not a path
                                                        // Don't treat it as a path - use other methods to find location
                                                        ec.logger.debug("list#Tools: screenPath is a list, not using for path resolution for ${subScreenEntry.key}")
                                                    } else {
                                                        actualSubScreenPath = subScreenInfo.screenPath.toString()
                                                    }
                                                }
                                                            
                                            } catch (Exception e) {
                                                ec.logger.debug("list#Tools: Error getting screen location from subScreenInfo for ${subScreenEntry.key}: ${e.message}")
                                            }
                                        }
                                        
                                        // Fallback: try XML parsing if screenInfo doesn't have the path
                                        if (!actualSubScreenPath) {
                                            try {
                                                def parentScreenDef = ec.screen.getScreenDefinition(screenPath)
                                                if (parentScreenDef?.screenNode) {
                                                    def subscreensNode = parentScreenDef.screenNode.first("subscreens")
                                                    if (subscreensNode) {
                                                        def subscreenItems = []
                                                        try {
                                                            subscreenItems = subscreensNode."subscreens-item"
                                                        } catch (Exception e) {
                                                            def allChildren = subscreensNode.children()
                                                            subscreenItems = allChildren.findAll { 
                                                                it.name() == "subscreens-item" 
                                                            }
                                                        }
                                                        
                                                        def subscreenItem = null
                                                        for (item in subscreenItems) {
                                                            if (item.hasAttribute('name') && item.attribute('name') == subScreenEntry.key) {
                                                                subscreenItem = item
                                                                break
                                                            }
                                                        }
                                                        if (subscreenItem?.hasAttribute('location')) {
                                                            actualSubScreenPath = subscreenItem.attribute('location')
                                                            ec.logger.debug("list#Tools: Found XML location for ${subScreenEntry.key}: ${actualSubScreenPath}")
                                                        }
                                                    }
                                                }
                                            } catch (Exception e) {
                                                ec.logger.info("Could not get subscreen location from XML for ${subScreenEntry.key}: ${e.message}")
                                            }
                                        }
                                        
                                        // Final fallback: construct from screenPath if we couldn't get the actual location
                                        if (!actualSubScreenPath) {
                                            def subscreenName = subScreenEntry.key
                                            def currentScreenPath = screenPath
                                            def lastSlash = currentScreenPath.lastIndexOf('/')
                                            if (lastSlash > 0) {
                                                def basePath = currentScreenPath.substring(0, lastSlash + 1)
                                                actualSubScreenPath = basePath + subscreenName + ".xml"
                                                ec.logger.debug("list#Tools: Constructed fallback path for ${subScreenEntry.key}: ${actualSubScreenPath}")
                                            }
                                        }
                                        
                                        if (actualSubScreenPath) {
                                            ec.logger.debug("list#Tools: Adding subscreen ${actualSubScreenPath} ${screenPath} ${toolName} ${level+1}")
                                            processScreenWithSubscreens(actualSubScreenPath, screenPath, processedScreens, toolsAccumulator, toolName, level + 1)
                                        } else if (!actualSubScreenPath) {
                                            // For screens without explicit location, try automatic discovery
                                            def lastSlash = screenPath.lastIndexOf('/')
                                            if (lastSlash > 0) {
                                                def basePath = screenPath.substring(0, lastSlash + 1)
                                                def autoSubScreenPath = basePath + subScreenEntry.key + ".xml"
                                                ec.logger.debug("list#Tools: Constructed fallback path for ${subScreenEntry.key}: ${actualSubScreenPath}")
                                                processScreenWithSubscreens(autoSubScreenPath, screenPath, processedScreens, toolsAccumulator, toolName, level + 1)
                                            }
                                        }
                                    }
                                }
                            } catch (Exception e) {
                                ec.logger.debug("Could not get subscreens for ${screenPath}: ${e.message}")
                            }
                            
                        } catch (Exception e) {
                            ec.logger.warn("Error processing screen ${screenPath}: ${e.message}")
                        }
                    }
                    
                    // Process all accessible screens recursively
                    def processedScreens = [] as Set<String>
                    ec.logger.info("list#Tools: Starting recursive processing from ${allScreens.size()} base screens")
                    for (screenPath in allScreens) {
                        def parentToolPath = 'screen_' + screenPath.split('/')[-3..-3].join('_').replace('.xml', '') + '_'
                        ec.logger.debug("TOPSCREEN: ${parentToolPath}")
                        processScreenWithSubscreens(screenPath, null, processedScreens, tools, parentToolPath, 0)
                    }
                    ec.logger.info("list#Tools: Recursive processing found ${tools.size()} total tools")
                    
                    // Add standard MCP protocol methods that clients can discover
                    def standardMcpMethods = [
                        [
                            name: "tools/list",
                            title: "List Available Tools",
                            description: "Get a list of all available MCP tools including Moqui services and screens",
                            inputSchema: [
                                type: "object",
                                properties: [
                                    cursor: [
                                        type: "string",
                                        description: "Pagination cursor for large tool lists"
                                    ]
                                ],
                                required: []
                            ]
                        ],
                        [
                            name: "tools/call",
                            title: "Execute Tool",
                            description: "Execute a specific MCP tool by name with parameters",
                            inputSchema: [
                                type: "object",
                                properties: [
                                    name: [
                                        type: "string",
                                        description: "Name of the tool to execute"
                                    ],
                                    arguments: [
                                        type: "object",
                                        description: "Parameters to pass to the tool"
                                    ]
                                ],
                                required: ["name"]
                            ]
                        ],
                        [
                            name: "resources/list",
                            title: "List Resources",
                            description: "Get a list of available MCP resources (Moqui entities)",
                            inputSchema: [
                                type: "object",
                                properties: [
                                    cursor: [
                                        type: "string",
                                        description: "Pagination cursor for large resource lists"
                                    ]
                                ],
                                required: []
                            ]
                        ],
                        [
                            name: "resources/read",
                            title: "Read Resource",
                            description: "Read data from a specific MCP resource (Moqui entity)",
                            inputSchema: [
                                type: "object",
                                properties: [
                                    uri: [
                                        type: "string",
                                        description: "Resource URI to read (format: entity://EntityName)"
                                    ]
                                ],
                                required: ["uri"]
                            ]
                        ],
                        [
                            name: "ping",
                            title: "Ping Server",
                            description: "Test connectivity to the MCP server and get session info",
                            inputSchema: [
                                type: "object",
                                properties: [:],
                                required: []
                            ]
                        ]
                    ]
                    
                    tools.addAll(0, standardMcpMethods)  // Add at beginning so they appear on first page
                    ec.logger.debug("list#Tools: Added ${standardMcpMethods.size()} standard MCP protocol methods")
                    
                } finally {
                    if (adminUserInfo != null) {
                        ec.user.popUser()
                    }
                }
                
                // Pagination (same as original)
                def pageSize = 50
                def startIndex = cursor ? Integer.parseInt(cursor) : 0
                def endIndex = Math.min(startIndex + pageSize, tools.size())
                def paginatedTools = tools.subList(startIndex, endIndex)
                
                result = [tools: paginatedTools]
                if (endIndex < tools.size()) {
                    result.nextCursor = String.valueOf(endIndex)
                }
                
                ec.logger.info("list#Tools: Found ${tools.size()} tools for user ${originalUsername}")
            ]]></script>
        </actions>
    </service>

    <!-- NOTE: handle#McpRequest service removed - functionality moved to screen/webapp.xml for unified handling -->

</services>