@qikdev/mcp 6.6.8 → 6.6.10

package/build/src/index.js

@@ -56,7 +56,8 @@ const QIK_ACCESS_TOKEN = process.env.QIK_ACCESS_TOKEN;
 export class QikMCPServer {
     server;
     axiosInstance;
-    glossary = {};
+    glossary = {}; // Full glossary with readOnly fields (for queries)
+    aiGlossary = {}; // AI glossary without readOnly fields (for creates/updates)
     userSession = null;
     lastGlossaryUpdate = 0;
     GLOSSARY_CACHE_TTL = 5 * 60 * 1000; // 5 minutes
@@ -145,29 +146,25 @@ export class QikMCPServer {
             return; // Use cached version
         }
         try {
-            const response = await this.axiosInstance.get('/glossary');
-            const newGlossary = (response.data || []).reduce(function (memo, definition) {
-                // Use the key property from the definition as the glossary key
+            // Load AI-friendly glossary (which excludes readOnly fields)
+            const aiGlossaryResponse = await this.axiosInstance.get('/glossary/ai');
+            // Process AI-friendly glossary
+            const newAiGlossary = (aiGlossaryResponse.data || []).reduce(function (memo, definition) {
                 if (definition.key) {
                     memo[definition.key] = definition;
                 }
                 return memo;
             }, {});
-            // Validate glossary structure
-            if (typeof newGlossary === 'object' && newGlossary !== null) {
-                this.glossary = newGlossary;
-                this.lastGlossaryUpdate = now;
-                this.log(`Loaded ${Object.keys(this.glossary).length} content types from glossary`);
-                // Log available content types for debugging
-                const contentTypes = Object.keys(this.glossary).sort();
-                this.log(`Available content types: ${contentTypes.join(', ')}`);
-            }
-            else {
-                this.log('Invalid glossary response structure - keeping existing glossary');
-            }
+            this.aiGlossary = newAiGlossary;
+            this.glossary = newAiGlossary; // Use AI glossary as the main glossary
+            this.lastGlossaryUpdate = now;
+            this.log(`Loaded ${Object.keys(this.glossary).length} content types from AI glossary`);
+            // Log available content types for debugging
+            const contentTypes = Object.keys(this.glossary).sort();
+            this.log(`Available content types: ${contentTypes.join(', ')}`);
         }
         catch (error) {
-            this.log(`Failed to load glossary: ${this.formatError(error)}`);
+            this.log(`Failed to load AI glossary: ${this.formatError(error)}`);
             // Don't clear existing glossary on error - keep what we have
             if (Object.keys(this.glossary).length === 0) {
                 this.log('No cached glossary available - some operations may fail');
@@ -210,261 +207,6 @@ export class QikMCPServer {
     getMinimumArrayLength(field) {
         return this.isFieldArray(field) ? (field.minimum || 0) : 0;
     }
-    /**
-     * Analyzes field placement rules directly from glossary structure
-     * This is the authoritative source for field placement decisions
-     */
-    analyzeFieldPlacementFromGlossary(contentType) {
-        const typeInfo = this.glossary[contentType];
-        if (!typeInfo) {
-            throw new Error(`Content type ${contentType} not found in glossary`);
-        }
-        // Check if this is a custom definition (has definesType)
-        const isCustomDefinition = !!typeInfo.definesType;
-        const baseType = typeInfo.definesType || null;
-        // Extract fields from the glossary structure
-        const fields = typeInfo.fields || [];
-        const definedFields = typeInfo.definedFields || [];
-        // Create widget mapping for enhanced validation
-        const widgetFields = new Map();
-        // Process fields for widget information
-        const processFieldsForWidgets = (fieldList) => {
-            for (const field of fieldList) {
-                if (field.widget) {
-                    widgetFields.set(field.key, field.widget);
-                }
-                // Process nested fields in groups
-                if (field.fields && Array.isArray(field.fields)) {
-                    processFieldsForWidgets(field.fields);
-                }
-            }
-        };
-        processFieldsForWidgets(fields);
-        processFieldsForWidgets(definedFields);
-        return {
-            rootLevelFields: new Set(fields.map(f => f.key)),
-            dataObjectFields: new Set(definedFields.map((f) => f.key)),
-            baseType,
-            isCustomDefinition,
-            allFields: fields,
-            allDefinedFields: definedFields,
-            widgetFields
-        };
-    }
-    /**
-     * Validates field placement based on glossary structure
-     */
-    validateFieldPlacementFromGlossary(args, contentType) {
-        const analysis = this.analyzeFieldPlacementFromGlossary(contentType);
-        const errors = [];
-        const warnings = [];
-        // Check for fields in data object that should be at root level
-        if (args.data && typeof args.data === 'object') {
-            for (const [key, value] of Object.entries(args.data)) {
-                if (analysis.rootLevelFields.has(key)) {
-                    errors.push(`Field "${key}" is defined in glossary "fields" array and must be at ROOT LEVEL, not in data object`);
-                }
-                // Widget validation for data object fields
-                if (analysis.widgetFields.has(key)) {
-                    const widgetValidation = this.validateWidgetValue(key, value, analysis.widgetFields.get(key));
-                    if (!widgetValidation.valid) {
-                        errors.push(...widgetValidation.errors);
-                    }
-                    if (widgetValidation.warnings.length > 0) {
-                        warnings.push(...widgetValidation.warnings);
-                    }
-                }
-            }
-        }
-        // Check for fields at root level that should be in data object
-        for (const [key, value] of Object.entries(args)) {
-            if (key !== 'type' && key !== 'title' && key !== 'meta' && key !== 'data' &&
-                key !== 'reference' && key !== 'referenceType' && key !== 'body' && key !== 'organisation') {
-                if (analysis.dataObjectFields.has(key)) {
-                    errors.push(`Field "${key}" is defined in glossary "definedFields" array and must be in DATA OBJECT, not at root level`);
-                }
-                // Widget validation for root level fields
-                if (analysis.widgetFields.has(key)) {
-                    const widgetValidation = this.validateWidgetValue(key, value, analysis.widgetFields.get(key));
-                    if (!widgetValidation.valid) {
-                        errors.push(...widgetValidation.errors);
-                    }
-                    if (widgetValidation.warnings.length > 0) {
-                        warnings.push(...widgetValidation.warnings);
-                    }
-                }
-            }
-        }
-        return { valid: errors.length === 0, errors, warnings, analysis };
-    }
-    /**
-     * Automatically restructures payload based on glossary field placement rules
-     */
-    restructurePayloadFromGlossary(args, contentType) {
-        const analysis = this.analyzeFieldPlacementFromGlossary(contentType);
-        const payload = {};
-        // Always include title if provided
-        if (args.title)
-            payload.title = args.title;
-        // Handle meta separately (always root level)
-        if (args.meta)
-            payload.meta = args.meta;
-        // Handle standard root-level fields
-        const standardRootFields = ['reference', 'referenceType', 'body', 'organisation'];
-        for (const fieldKey of standardRootFields) {
-            if (args[fieldKey] !== undefined) {
-                payload[fieldKey] = args[fieldKey];
-            }
-        }
-        // Process provided data and separate into correct locations
-        const rootData = {};
-        const dataObjectData = {};
-        if (args.data && typeof args.data === 'object') {
-            for (const [key, value] of Object.entries(args.data)) {
-                if (analysis.rootLevelFields.has(key)) {
-                    rootData[key] = value; // Move to root level
-                }
-                else {
-                    dataObjectData[key] = value; // Keep in data object
-                }
-            }
-        }
-        // Add any root-level fields that were incorrectly placed at top level
-        for (const [key, value] of Object.entries(args)) {
-            if (key !== 'type' && key !== 'title' && key !== 'meta' && key !== 'data' &&
-                !standardRootFields.includes(key)) {
-                if (analysis.dataObjectFields.has(key)) {
-                    dataObjectData[key] = value; // Move to data object
-                }
-                else if (analysis.rootLevelFields.has(key)) {
-                    rootData[key] = value; // Keep at root level
-                }
-            }
-        }
-        // Add root level fields to payload
-        Object.assign(payload, rootData);
-        // Add data object if there are any data fields
-        if (Object.keys(dataObjectData).length > 0) {
-            payload.data = dataObjectData;
-        }
-        return payload;
-    }
-    /**
-     * Generates comprehensive error message based on glossary structure with widget guidance
-     */
-    generateFieldPlacementErrorFromGlossary(contentType, errors, warnings = []) {
-        const analysis = this.analyzeFieldPlacementFromGlossary(contentType);
-        const rootFieldsList = Array.from(analysis.rootLevelFields).join(', ');
-        const dataFieldsList = Array.from(analysis.dataObjectFields).join(', ');
-        let errorMessage = `🚫 **FIELD PLACEMENT ERRORS for ${contentType.toUpperCase()}**
-
-${errors.join('\n')}`;
-        if (warnings.length > 0) {
-            errorMessage += `\n\n⚠️ **WARNINGS:**\n${warnings.join('\n')}`;
-        }
-        errorMessage += `\n\n**ACCORDING TO GLOSSARY DEFINITION:**
-${analysis.isCustomDefinition ? `- Extends: ${analysis.baseType}` : '- Primitive type'}
-- Total fields in "fields" array: ${analysis.allFields.length}
-- Total fields in "definedFields" array: ${analysis.allDefinedFields.length}`;
-        // Add widget information if present
-        if (analysis.widgetFields.size > 0) {
-            errorMessage += `\n- Widget types detected: ${analysis.widgetFields.size} fields with specific widgets`;
-            const widgetInfo = [];
-            for (const [fieldKey, widgetType] of analysis.widgetFields.entries()) {
-                if (widgetType === 'dateobject') {
-                    widgetInfo.push(`  • ${fieldKey}: dateobject widget (requires {hour, minute, day, month, year} format)`);
-                }
-                else {
-                    widgetInfo.push(`  • ${fieldKey}: ${widgetType} widget`);
-                }
-            }
-            if (widgetInfo.length > 0) {
-                errorMessage += `\n${widgetInfo.join('\n')}`;
-            }
-        }
-        errorMessage += `\n\n**ROOT LEVEL FIELDS (from glossary "fields" array):**
-${rootFieldsList || 'none defined'}
-
-**DATA OBJECT FIELDS (from glossary "definedFields" array):**
-${dataFieldsList || 'none defined'}
-
-**CORRECT STRUCTURE:**
-\`\`\`json
-{
-  "type": "${contentType}",
-  "title": "Your Title Here",`;
-        // Add sample root level fields with widget-aware examples
-        const rootFields = Array.from(analysis.rootLevelFields).filter(f => f !== 'title' && f !== '_id' && f !== 'meta');
-        if (rootFields.length > 0) {
-            rootFields.slice(0, 2).forEach(fieldKey => {
-                const widgetType = analysis.widgetFields.get(fieldKey);
-                let exampleValue = '"value"';
-                if (widgetType === 'dateobject') {
-                    exampleValue = '{"hour": 14, "minute": 30, "day": 15, "month": 1, "year": 2025}';
-                }
-                else if (widgetType === 'date') {
-                    exampleValue = '"2025-01-15"';
-                }
-                else if (widgetType === 'time') {
-                    exampleValue = '"14:30"';
-                }
-                else if (widgetType === 'datetime') {
-                    exampleValue = '"2025-01-15T14:30:00Z"';
-                }
-                errorMessage += `\n  "${fieldKey}": ${exampleValue},`;
-            });
-        }
-        errorMessage += `\n  "meta": { "scopes": ["scope-id-here"] }`;
-        // Add data object with widget-aware examples
-        if (analysis.dataObjectFields.size > 0) {
-            errorMessage += `,\n  "data": {`;
-            const dataFields = Array.from(analysis.dataObjectFields).slice(0, 3);
-            dataFields.forEach((fieldKey, index) => {
-                const widgetType = analysis.widgetFields.get(fieldKey);
-                let exampleValue = '"value"';
-                if (widgetType === 'dateobject') {
-                    exampleValue = '{"hour": 9, "minute": 0, "day": 22, "month": 3, "year": 2024}';
-                }
-                else if (widgetType === 'date') {
-                    exampleValue = '"2024-03-22"';
-                }
-                else if (widgetType === 'time') {
-                    exampleValue = '"09:00"';
-                }
-                else if (widgetType === 'datetime') {
-                    exampleValue = '"2024-03-22T09:00:00Z"';
-                }
-                const comma = index < dataFields.length - 1 ? ',' : '';
-                errorMessage += `\n    "${fieldKey}": ${exampleValue}${comma}`;
-            });
-            errorMessage += `\n  }`;
-        }
-        errorMessage += `\n}
-\`\`\`
-
-**FIELD PLACEMENT RULE:**
-- Fields in glossary "fields" array → ROOT LEVEL
-- Fields in glossary "definedFields" array → DATA OBJECT`;
-        // Add widget-specific guidance
-        if (analysis.widgetFields.size > 0) {
-            errorMessage += `\n\n**WIDGET-SPECIFIC GUIDANCE:**\n`;
-            for (const [fieldKey, widgetType] of analysis.widgetFields.entries()) {
-                if (widgetType === 'dateobject') {
-                    errorMessage += `- **${fieldKey}** (dateobject): Use format {"hour": 14, "minute": 30, "day": 15, "month": 1, "year": 2025}\n`;
-                }
-                else if (widgetType === 'date') {
-                    errorMessage += `- **${fieldKey}** (date): Use ISO date format "2025-01-15"\n`;
-                }
-                else if (widgetType === 'time') {
-                    errorMessage += `- **${fieldKey}** (time): Use time format "14:30"\n`;
-                }
-                else if (widgetType === 'datetime') {
-                    errorMessage += `- **${fieldKey}** (datetime): Use ISO datetime format "2025-01-15T14:30:00Z"\n`;
-                }
-            }
-        }
-        return errorMessage;
-    }
     /**
      * Validates widget-specific field values
      */
@@ -727,57 +469,83 @@ ${dataFieldsList || 'none defined'}
                 return 'string';
         }
     }
+    /**
+     * Generates completely dynamic properties based on the loaded glossary
+     * This creates schema properties for ALL fields from ALL content types
+     */
     generateDynamicContentProperties() {
-        // Generate dynamic properties that show field structure for common content types
         const properties = {};
-        // Add common root-level fields that appear across content types
-        const commonRootFields = ['reference', 'referenceType', 'body', 'organisation'];
-        for (const fieldKey of commonRootFields) {
-            properties[fieldKey] = {
-                type: 'string',
-                description: `${fieldKey} field (ALWAYS goes at ROOT LEVEL, never in data object)`,
-            };
+        // Collect all unique fields from all content types in the glossary
+        const allRootFields = new Set();
+        const allDataFields = new Set();
+        const fieldSchemas = new Map();
+        // Process each content type in the glossary
+        for (const [contentTypeKey, contentType] of Object.entries(this.glossary)) {
+            if (!contentType || typeof contentType !== 'object')
+                continue;
+            // Get fields from the content type (these go at root level)
+            const fields = contentType.fields || [];
+            for (const field of fields) {
+                if (field.key && field.key !== '_id') { // Skip internal ID field
+                    allRootFields.add(field.key);
+                    // Generate schema for this field
+                    if (!fieldSchemas.has(field.key)) {
+                        fieldSchemas.set(field.key, this.generateFieldSchema(field));
+                    }
+                }
+            }
+            // Get definedFields from the content type (these go in data object)
+            const definedFields = contentType.definedFields || [];
+            for (const field of definedFields) {
+                if (field.key) {
+                    allDataFields.add(field.key);
+                    // Generate schema for this field
+                    if (!fieldSchemas.has(field.key)) {
+                        fieldSchemas.set(field.key, this.generateFieldSchema(field));
+                    }
+                }
+            }
+        }
+        // Add all root-level fields as properties
+        for (const fieldKey of allRootFields) {
+            if (fieldKey !== 'title' && fieldKey !== 'meta') { // These are handled separately
+                const schema = fieldSchemas.get(fieldKey);
+                if (schema) {
+                    properties[fieldKey] = {
+                        ...schema,
+                        description: `${schema.description || fieldKey} (ROOT LEVEL field from glossary)`
+                    };
+                }
+            }
+        }
+        // Create comprehensive data object with all possible data fields
+        const dataProperties = {};
+        for (const fieldKey of allDataFields) {
+            const schema = fieldSchemas.get(fieldKey);
+            if (schema) {
+                dataProperties[fieldKey] = {
+                    ...schema,
+                    description: `${schema.description || fieldKey} (DATA OBJECT field from glossary)`
+                };
+            }
         }
-        // Add a data object for definedFields with clear explanation
+        // Add the data object with dynamic properties
         properties.data = {
             type: 'object',
-            description: `CRITICAL FIELD PLACEMENT RULE: 
+            description: `DYNAMIC FIELD PLACEMENT (based on glossary):
       
-**ROOT LEVEL FIELDS (never put these in data object):**
-- title, reference, referenceType, body, organisation, meta
-- These are "fields" in the glossary definition
+**ROOT LEVEL FIELDS (from glossary "fields" array):**
+${Array.from(allRootFields).sort().join(', ')}
 
-**DATA OBJECT FIELDS (always put these in data object):**
-- Custom fields defined as "definedFields" in the glossary
-- Content-type specific fields like wasAnyoneHurt, customField1, etc.
+**DATA OBJECT FIELDS (from glossary "definedFields" array):**
+${Array.from(allDataFields).sort().join(', ')}
 
-**WRONG EXAMPLE:**
-{
-  "data": {
-    "title": "My Title",  // ❌ WRONG - title goes at root level
-    "plural": "My Items", // ❌ WRONG - plural goes at root level
-    "customField": "value"
-  }
-}
+**FIELD PLACEMENT RULE:**
+- Fields in glossary "fields" array → ROOT LEVEL
+- Fields in glossary "definedFields" array → DATA OBJECT
 
-**CORRECT EXAMPLE:**
-{
-  "title": "My Title",     // ✅ CORRECT - at root level
-  "data": {
-    "customField": "value" // ✅ CORRECT - custom fields in data object
-  }
-}`,
-            properties: {
-                wasAnyoneHurt: {
-                    type: 'string',
-                    description: 'For incident reports - whether anyone was hurt (this is a definedField, so it goes in data object)',
-                    enum: ['yes', 'no']
-                },
-                whatTimeDidItHappen: {
-                    type: 'string',
-                    description: 'For incident reports - when the incident occurred (this is a definedField, so it goes in data object)'
-                }
-            }
+The MCP server automatically determines correct placement based on the glossary definition for each content type.`,
+            properties: dataProperties
         };
         return properties;
     }
@@ -1033,6 +801,50 @@ ${dataFieldsList || 'none defined'}
                 }]
         };
     }
+    /**
+     * Filters out readOnly fields from payload for create/update operations
+     */
+    filterReadOnlyFields(payload, contentType) {
+        const typeInfo = this.getContentTypeInfo(contentType);
+        if (!typeInfo) {
+            return payload; // If we can't get type info, return payload as-is
+        }
+        const filteredPayload = { ...payload };
+        // Get fields from the content type - handle both QikField and QikAIField structures
+        let fields = [];
+        if (typeInfo.fields) {
+            fields = typeInfo.fields;
+        }
+        // Filter out readOnly fields from root level
+        for (const field of fields) {
+            if (field.readOnly && field.key && filteredPayload[field.key] !== undefined) {
+                this.log(`Filtering out readOnly field: ${field.key}`);
+                delete filteredPayload[field.key];
+            }
+        }
+        // Filter out readOnly fields from data object
+        if (filteredPayload.data && typeof filteredPayload.data === 'object') {
+            for (const field of fields) {
+                if (field.readOnly) {
+                    // Handle both QikAIField (with path) and QikField (with key) structures
+                    let dataFieldKey = null;
+                    if (field.path && field.path.startsWith('data.')) {
+                        // QikAIField structure
+                        dataFieldKey = field.path.replace('data.', '');
+                    }
+                    else if (field.key) {
+                        // QikField structure - assume it's a data field if it's readOnly and not at root
+                        dataFieldKey = field.key;
+                    }
+                    if (dataFieldKey && filteredPayload.data[dataFieldKey] !== undefined) {
+                        this.log(`Filtering out readOnly data field: ${dataFieldKey}`);
+                        delete filteredPayload.data[dataFieldKey];
+                    }
+                }
+            }
+        }
+        return filteredPayload;
+    }
     generateEnhancedFilterSchema() {
         return {
             type: 'object',
@@ -2532,24 +2344,12 @@ ${JSON.stringify({
                 isError: true,
             };
         }
-        // Use the new glossary-driven field placement validation
         try {
-            const fieldValidation = this.validateFieldPlacementFromGlossary(args, args.type);
-            // If there are field placement errors, return detailed guidance
-            if (!fieldValidation.valid) {
-                return {
-                    content: [{
-                            type: 'text',
-                            text: this.generateFieldPlacementErrorFromGlossary(args.type, fieldValidation.errors),
-                        }],
-                    isError: true,
-                };
-            }
-            // Automatically restructure the payload based on glossary rules
-            const payload = this.restructurePayloadFromGlossary(args, args.type);
+            // Create payload from args and filter out readOnly fields
+            let payload = { ...args };
+            payload = this.filterReadOnlyFields(payload, args.type);
             // Handle scope inheritance for comment types
-            const analysis = fieldValidation.analysis;
-            const isCommentType = analysis.baseType === 'comment' || args.type === 'comment' || args.type.includes('Comment');
+            const isCommentType = args.type === 'comment' || args.type.includes('Comment');
             if (isCommentType && payload.reference && (!payload.meta?.scopes || payload.meta.scopes.length === 0)) {
                 try {
                     // Fetch the referenced item to get its scopes
@@ -2572,26 +2372,22 @@ ${JSON.stringify({
                         type: 'text',
                         text: `✅ **SUCCESSFULLY CREATED ${args.type.toUpperCase()} CONTENT**
 
-The content was created using glossary-driven field placement:
-- Root level fields: ${Object.keys(payload).filter(k => k !== 'data' && k !== 'meta').join(', ')}
-- Data object fields: ${payload.data ? Object.keys(payload.data).join(', ') : 'none'}
-- Meta fields: ${payload.meta ? Object.keys(payload.meta).join(', ') : 'none'}
-
-**Field Placement Analysis:**
-- Content type: ${analysis.isCustomDefinition ? `Custom definition extending ${analysis.baseType}` : 'Primitive type'}
-- Root level fields from glossary: ${Array.from(analysis.rootLevelFields).join(', ')}
-- Data object fields from glossary: ${Array.from(analysis.dataObjectFields).join(', ')}
-
 **Created Content:**
 ${JSON.stringify(response.data, null, 2)}`,
                     }],
             };
         }
         catch (error) {
+            // Pass through server errors directly - they contain the authoritative validation messages
             return {
                 content: [{
                         type: 'text',
-                        text: `Failed to create ${args.type}: ${this.formatError(error)}`,
+                        text: `Failed to create ${args.type}: ${this.formatError(error)}
+
+💡 **Field Placement Guidance:**
+- **Root Level**: title, reference, referenceType, body, organisation, meta
+- **Data Object**: Custom fields defined in content type's "definedFields" array
+- Use \`qik_get_content_definition\` to see the exact field structure for this content type`,
                     }],
                 isError: true,
             };
@@ -2599,12 +2395,27 @@ ${JSON.stringify(response.data, null, 2)}`,
     }
     async updateContent(args) {
         try {
+            let updateData = { ...args.data };
+            // Get the content type for the item being updated
+            let contentType = null;
+            try {
+                const existingContent = await this.axiosInstance.get(`/content/${args.id}`);
+                if (existingContent.data && existingContent.data.meta && existingContent.data.meta.type) {
+                    contentType = existingContent.data.meta.type;
+                }
+            }
+            catch (error) {
+                this.log(`Could not fetch existing content to determine type for readOnly filtering: ${this.formatError(error)}`);
+            }
             const method = args.replace ? 'put' : 'patch';
-            const response = await this.axiosInstance[method](`/content/${args.id}`, args.data);
+            const response = await this.axiosInstance[method](`/content/${args.id}`, updateData);
             return {
                 content: [{
                         type: 'text',
-                        text: JSON.stringify(response.data, null, 2),
+                        text: `✅ **SUCCESSFULLY UPDATED CONTENT**
+
+**Updated Content:**
+${JSON.stringify(response.data, null, 2)}`,
                     }],
             };
         }
@@ -3329,62 +3140,47 @@ No examples found for category: "${args.category}"
                     isError: true,
                 };
             }
-            // Use both the documentation helper and glossary-driven validation
+            // Simplified validation using documentation helper only
             const docValidation = QikDocumentationHelper.validateFieldPlacement(args.contentType, args.payload);
-            const glossaryValidation = this.validateFieldPlacementFromGlossary(args.payload, args.contentType);
             let result = `✅ **FIELD PLACEMENT VALIDATION: ${args.contentType.toUpperCase()}**\n\n`;
-            if (glossaryValidation.valid && docValidation.valid) {
+            if (docValidation.valid) {
                 result += `🎉 **VALIDATION PASSED**\n\n`;
                 result += `Your payload has correct field placement!\n\n`;
-                const analysis = glossaryValidation.analysis;
                 result += `**Field Analysis:**\n`;
                 result += `- Root level fields: ${Object.keys(args.payload).filter(k => k !== 'data' && k !== 'meta').join(', ') || 'none'}\n`;
                 result += `- Data object fields: ${args.payload.data ? Object.keys(args.payload.data).join(', ') : 'none'}\n`;
                 result += `- Meta fields: ${args.payload.meta ? Object.keys(args.payload.meta).join(', ') : 'none'}\n\n`;
-                result += `**Glossary Structure:**\n`;
-                result += `- Expected root fields: ${Array.from(analysis.rootLevelFields).join(', ') || 'none'}\n`;
-                result += `- Expected data fields: ${Array.from(analysis.dataObjectFields).join(', ') || 'none'}\n`;
             }
             else {
                 result += `❌ **VALIDATION FAILED**\n\n`;
-                const allErrors = [...(docValidation.errors || []), ...(glossaryValidation.errors || [])];
-                if (allErrors.length > 0) {
+                if (docValidation.errors && docValidation.errors.length > 0) {
                     result += `**Errors Found:**\n`;
-                    allErrors.forEach(error => {
+                    docValidation.errors.forEach(error => {
                         result += `- ${error}\n`;
                     });
                     result += '\n';
                 }
-                if (glossaryValidation.analysis) {
-                    const analysis = glossaryValidation.analysis;
-                    result += `**Correct Structure:**\n`;
-                    result += `\`\`\`json\n`;
-                    result += `{\n`;
-                    result += `  "type": "${args.contentType}",\n`;
-                    result += `  "title": "Your Title Here",\n`;
-                    const rootFields = Array.from(analysis.rootLevelFields).filter(f => f !== 'title' && f !== '_id' && f !== 'meta');
-                    if (rootFields.length > 0) {
-                        rootFields.slice(0, 2).forEach(field => {
-                            result += `  "${field}": "value",\n`;
-                        });
-                    }
-                    result += `  "meta": { "scopes": ["scope-id-here"] }`;
-                    if (analysis.dataObjectFields.size > 0) {
-                        result += `,\n  "data": {\n`;
-                        Array.from(analysis.dataObjectFields).slice(0, 3).forEach((field, index, arr) => {
-                            result += `    "${field}": "value"${index < arr.length - 1 ? ',' : ''}\n`;
-                        });
-                        result += `  }`;
-                    }
-                    result += `\n}\n\`\`\`\n`;
-                }
+                result += `**General Field Placement Rules:**\n`;
+                result += `- **Root Level**: title, reference, referenceType, body, organisation, meta\n`;
+                result += `- **Data Object**: Custom fields defined in content type's "definedFields" array\n`;
+                result += `- Use \`qik_get_content_definition\` to see the exact field structure for this content type\n\n`;
+                result += `**Correct Structure Example:**\n`;
+                result += `\`\`\`json\n`;
+                result += `{\n`;
+                result += `  "type": "${args.contentType}",\n`;
+                result += `  "title": "Your Title Here",\n`;
+                result += `  "meta": { "scopes": ["scope-id-here"] },\n`;
+                result += `  "data": {\n`;
+                result += `    "customField": "value"\n`;
+                result += `  }\n`;
+                result += `}\n\`\`\`\n`;
             }
             return {
                 content: [{
                         type: 'text',
                         text: result,
                     }],
-                isError: !glossaryValidation.valid || !docValidation.valid,
+                isError: !docValidation.valid,
             };
         }
         catch (error) {