@qikdev/mcp 6.6.10 → 6.6.11

package/build/src/index.js

@@ -1,80 +1,37 @@
 #!/usr/bin/env node
 /**
- * Qik Platform MCP Server - Enhanced Version with Comprehensive Documentation
+ * Simplified Qik Platform MCP Server
  *
- * This MCP server provides comprehensive integration with the Qik platform,
- * enabling AI assistants to interact with Qik's content management system,
- * user management, forms, files, and more.
- *
- * Key Features:
- * - Glossary-driven architecture for dynamic content type discovery
- * - Smart validation based on content type definitions
- * - Context-aware error handling and suggestions
- * - Dynamic tool schema generation
- * - Comprehensive API coverage
- * - Intelligent request building and field validation
- * - Advanced disambiguation logic for definitions vs instances
- * - Workflow system documentation and automation
- * - Comprehensive scope and permission management
- *
- * IMPORTANT QIK CONCEPTS:
- *
- * 1. DEFINITIONS vs INSTANCES:
- *    - Definitions: Templates that define structure (e.g., "workflow definition", "content type definition")
- *    - Instances: Actual content items created from definitions (e.g., "workflow card", "article instance")
- *    - When user says "create a workflow" they usually mean create a workflow DEFINITION
- *    - When user says "add Jim to workflow X" they mean create a workflow CARD instance
- *
- * 2. WORKFLOW SYSTEM:
- *    - Workflow Definitions: Define the structure with columns, steps, automation
- *    - Workflow Cards: Individual items that move through the workflow
- *    - Columns: Represent stages in the workflow (e.g., "To Do", "In Progress", "Done")
- *    - Steps: Specific positions within columns where cards can be placed
- *    - Automation: Entry/exit/success/fail functions that run when cards move
- *
- * 3. SCOPE SYSTEM:
- *    - Hierarchical permission structure (like folders)
- *    - Every content item must belong to at least one scope
- *    - Users need appropriate permissions within scopes to perform actions
- *    - Scopes can inherit permissions from parent scopes
- *
- * 4. CONTENT TYPE SYSTEM:
- *    - Base types: Core Qik types (article, profile, event, etc.)
- *    - Extended types: Custom types that extend base types with additional fields
- *    - Fields vs DefinedFields: Fields go at root level, definedFields go in data object
+ * A simple translation layer between AI models and the Qik API.
+ * Focuses on core functionality with interactive error handling.
  */
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { CallToolRequestSchema, ListToolsRequestSchema, ErrorCode, McpError, } from "@modelcontextprotocol/sdk/types.js";
 import axios from 'axios';
-import FormData from 'form-data';
 import { ConfigManager } from './config.js';
-import { QikDocumentationHelper, QIK_DOCUMENTATION } from './documentation.js';
 // Environment variables
 const QIK_API_URL = process.env.QIK_API_URL || 'https://api.qik.dev';
 const QIK_ACCESS_TOKEN = process.env.QIK_ACCESS_TOKEN;
 export class QikMCPServer {
     server;
     axiosInstance;
-    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
-    serverName = 'Qik'; // Default fallback
+    glossary = {};
+    serverName = 'Qik';
     constructor() {
         if (!QIK_ACCESS_TOKEN) {
             throw new Error('QIK_ACCESS_TOKEN environment variable is required. Run "qik-mcp-server setup" to configure.');
         }
         this.server = new Server({
             name: "qik-mcp-server",
-            version: "2.0.0",
+            version: "3.0.0",
         }, {
             capabilities: {
                 tools: {},
             },
         });
-        // Configure axios instance with Qik API settings
+        // Configure axios instance
         this.axiosInstance = axios.create({
             baseURL: QIK_API_URL,
             headers: {
@@ -93,19 +50,14 @@ export class QikMCPServer {
         });
     }
     log(message) {
-        // Only log in development or when explicitly enabled
         if (process.env.NODE_ENV !== 'production' || process.env.QIK_MCP_DEBUG === 'true') {
-            // Use stderr to avoid interfering with MCP JSON protocol on stdout
             process.stderr.write(`[Qik MCP] ${message}\n`);
         }
     }
     async initializeServer() {
         try {
-            // Load server name from config first
             await this.loadServerName();
-            // Load user session
             await this.loadUserSession();
-            // Then load glossary
             await this.loadGlossary();
             this.log(`Initialized with ${Object.keys(this.glossary).length} content types`);
         }
@@ -119,15 +71,10 @@ export class QikMCPServer {
             const config = await configManager.loadConfig();
             if (config && config.serverName) {
                 this.serverName = config.serverName;
-                this.log(`Loaded server name: ${this.serverName}`);
-            }
-            else {
-                this.log(`No server name found in config, using default: ${this.serverName}`);
             }
         }
         catch (error) {
-            this.log(`Failed to load server name from config: ${this.formatError(error)}`);
-            // Keep default fallback value
+            this.log(`Failed to load server name: ${this.formatError(error)}`);
         }
     }
     async loadUserSession() {
@@ -140,35 +87,19 @@ export class QikMCPServer {
             this.log(`Failed to load user session: ${this.formatError(error)}`);
         }
     }
-    async loadGlossary(force = false) {
-        const now = Date.now();
-        if (!force && this.lastGlossaryUpdate && (now - this.lastGlossaryUpdate) < this.GLOSSARY_CACHE_TTL) {
-            return; // Use cached version
-        }
+    async loadGlossary() {
         try {
-            // 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) {
+            const response = await this.axiosInstance.get('/glossary/ai');
+            this.glossary = (response.data || []).reduce((memo, definition) => {
                 if (definition.key) {
                     memo[definition.key] = definition;
                 }
                 return memo;
             }, {});
-            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(', ')}`);
+            this.log(`Loaded ${Object.keys(this.glossary).length} content types`);
         }
         catch (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');
-            }
+            this.log(`Failed to load glossary: ${this.formatError(error)}`);
         }
     }
     formatError(error) {
@@ -183,472 +114,54 @@ export class QikMCPServer {
         }
         return error.message || String(error);
     }
-    getContentTypeInfo(type) {
-        return this.glossary[type] || null;
-    }
-    validateContentType(type) {
-        const info = this.getContentTypeInfo(type);
-        if (!info) {
-            const availableTypes = Object.keys(this.glossary).join(', ');
-            return {
-                valid: false,
-                error: `Content type '${type}' not found. Available types: ${availableTypes}`
-            };
-        }
-        return { valid: true, info };
-    }
-    // Enhanced glossary-driven field analysis methods
-    isFieldRequired(field) {
-        return field.minimum !== undefined && field.minimum > 0;
-    }
-    isFieldArray(field) {
-        return field.maximum === 0;
-    }
-    getMinimumArrayLength(field) {
-        return this.isFieldArray(field) ? (field.minimum || 0) : 0;
-    }
-    /**
-     * Validates widget-specific field values
-     */
-    validateWidgetValue(fieldKey, value, widgetType) {
-        const errors = [];
-        const warnings = [];
-        switch (widgetType) {
-            case 'dateobject':
-                return this.validateDateObjectWidget(fieldKey, value);
-            case 'date':
-                if (typeof value === 'string') {
-                    const dateRegex = /^\d{4}-\d{2}-\d{2}$/;
-                    if (!dateRegex.test(value)) {
-                        errors.push(`Field "${fieldKey}" with date widget must use ISO date format (YYYY-MM-DD), got: ${value}`);
-                    }
-                }
-                else {
-                    errors.push(`Field "${fieldKey}" with date widget must be a string in ISO date format (YYYY-MM-DD)`);
-                }
-                break;
-            case 'time':
-                if (typeof value === 'string') {
-                    const timeRegex = /^\d{2}:\d{2}(:\d{2})?$/;
-                    if (!timeRegex.test(value)) {
-                        errors.push(`Field "${fieldKey}" with time widget must use time format (HH:MM or HH:MM:SS), got: ${value}`);
-                    }
-                }
-                else {
-                    errors.push(`Field "${fieldKey}" with time widget must be a string in time format (HH:MM)`);
-                }
-                break;
-            case 'datetime':
-                if (typeof value === 'string') {
-                    try {
-                        new Date(value);
-                    }
-                    catch (e) {
-                        errors.push(`Field "${fieldKey}" with datetime widget must be a valid ISO datetime string, got: ${value}`);
-                    }
-                }
-                else {
-                    errors.push(`Field "${fieldKey}" with datetime widget must be a string in ISO datetime format`);
-                }
-                break;
-            default:
-                // No specific validation for other widget types
-                break;
-        }
-        return { valid: errors.length === 0, errors, warnings };
-    }
-    /**
-     * Validates dateobject widget values
-     */
-    validateDateObjectWidget(fieldKey, value) {
-        const errors = [];
-        const warnings = [];
-        if (!value || typeof value !== 'object') {
-            errors.push(`Field "${fieldKey}" with dateobject widget must be an object with hour, minute, day, month, year properties`);
-            return { valid: false, errors, warnings };
-        }
-        const requiredProps = ['hour', 'minute', 'day', 'month', 'year'];
-        const missingProps = requiredProps.filter(prop => value[prop] === undefined || value[prop] === null);
-        if (missingProps.length > 0) {
-            errors.push(`Field "${fieldKey}" dateobject is missing required properties: ${missingProps.join(', ')}`);
-        }
-        // Validate ranges
-        if (typeof value.hour === 'number') {
-            if (value.hour < 0 || value.hour > 23) {
-                errors.push(`Field "${fieldKey}" dateobject hour must be between 0-23, got: ${value.hour}`);
-            }
-        }
-        else if (value.hour !== undefined) {
-            errors.push(`Field "${fieldKey}" dateobject hour must be a number`);
-        }
-        if (typeof value.minute === 'number') {
-            if (value.minute < 0 || value.minute > 59) {
-                errors.push(`Field "${fieldKey}" dateobject minute must be between 0-59, got: ${value.minute}`);
-            }
-        }
-        else if (value.minute !== undefined) {
-            errors.push(`Field "${fieldKey}" dateobject minute must be a number`);
-        }
-        if (typeof value.day === 'number') {
-            if (value.day < 1 || value.day > 31) {
-                errors.push(`Field "${fieldKey}" dateobject day must be between 1-31, got: ${value.day}`);
-            }
-        }
-        else if (value.day !== undefined) {
-            errors.push(`Field "${fieldKey}" dateobject day must be a number`);
-        }
-        if (typeof value.month === 'number') {
-            if (value.month < 1 || value.month > 12) {
-                errors.push(`Field "${fieldKey}" dateobject month must be between 1-12, got: ${value.month}`);
-            }
-        }
-        else if (value.month !== undefined) {
-            errors.push(`Field "${fieldKey}" dateobject month must be a number`);
-        }
-        if (typeof value.year === 'number') {
-            if (value.year < 1900 || value.year > 2100) {
-                warnings.push(`Field "${fieldKey}" dateobject year ${value.year} seems unusual (expected 1900-2100)`);
-            }
-        }
-        else if (value.year !== undefined) {
-            errors.push(`Field "${fieldKey}" dateobject year must be a number`);
-        }
-        return { valid: errors.length === 0, errors, warnings };
-    }
-    generateFieldPath(field, isDefinedField, groupPath = '') {
-        let basePath = isDefinedField ? 'data' : '';
-        if (groupPath) {
-            basePath = basePath ? `${basePath}.${groupPath}` : groupPath;
-        }
-        return basePath ? `${basePath}.${field.key}` : field.key;
-    }
-    processGroupFields(fields, parentPath = '', isDefinedField = false) {
-        const processedFields = [];
-        for (const field of fields) {
-            if (field.type === 'group' && field.fields) {
-                if (field.asObject) {
-                    // Group creates nested object structure
-                    const groupPath = parentPath ? `${parentPath}.${field.key}` : field.key;
-                    processedFields.push(...this.processGroupFields(field.fields, groupPath, isDefinedField));
-                }
-                else {
-                    // Group is just for organization, fields remain at same level
-                    processedFields.push(...this.processGroupFields(field.fields, parentPath, isDefinedField));
-                }
-            }
-            else {
-                const fieldPath = this.generateFieldPath(field, isDefinedField, parentPath);
-                processedFields.push({
-                    field,
-                    path: fieldPath,
-                    isRequired: this.isFieldRequired(field),
-                    isArray: this.isFieldArray(field)
-                });
-            }
-        }
-        return processedFields;
-    }
-    analyzeContentTypeFields(contentType) {
-        let fields = [];
-        let definedFields = [];
-        // Extract fields from different possible structures
-        if (contentType.fields) {
-            fields = contentType.fields;
-            definedFields = contentType.definedFields || [];
-        }
-        else if (contentType.definition) {
-            fields = contentType.definition.fields || [];
-            definedFields = contentType.definition.definedFields || [];
-        }
-        else if (contentType.type) {
-            fields = contentType.type.fields || [];
-            definedFields = contentType.type.definedFields || [];
-        }
-        const topLevelFields = this.processGroupFields(fields, '', false);
-        const dataFields = this.processGroupFields(definedFields, '', true);
-        const allFields = [...topLevelFields, ...dataFields];
-        const allRequiredFields = allFields.filter(f => f.isRequired);
-        return {
-            topLevelFields,
-            dataFields,
-            allRequiredFields
-        };
-    }
-    validateFieldData(data, fields, contentType) {
-        const errors = [];
-        for (const field of fields) {
-            const value = data[field.key];
-            // Check required fields
-            if (field.minimum && field.minimum > 0 && (!value || (Array.isArray(value) && value.length === 0))) {
-                errors.push(`Field '${field.key}' (${field.title}) is required for ${contentType}`);
-            }
-            // Type validation
-            if (value !== undefined && value !== null) {
-                switch (field.type) {
-                    case 'string':
-                        if (typeof value !== 'string') {
-                            errors.push(`Field '${field.key}' must be a string, got ${typeof value}`);
-                        }
-                        break;
-                    case 'number':
-                    case 'integer':
-                        if (typeof value !== 'number') {
-                            errors.push(`Field '${field.key}' must be a number, got ${typeof value}`);
-                        }
-                        break;
-                    case 'boolean':
-                        if (typeof value !== 'boolean') {
-                            errors.push(`Field '${field.key}' must be a boolean, got ${typeof value}`);
-                        }
-                        break;
-                    case 'array':
-                        if (!Array.isArray(value)) {
-                            errors.push(`Field '${field.key}' must be an array, got ${typeof value}`);
-                        }
-                        break;
-                    case 'reference':
-                        if (field.referenceType && typeof value === 'string') {
-                            // Basic validation - could be enhanced to check if referenced item exists
-                        }
-                        else if (Array.isArray(value) && field.maximum !== 1) {
-                            // Array of references
-                        }
-                        else {
-                            errors.push(`Field '${field.key}' must be a valid reference to ${field.referenceType || 'content'}`);
-                        }
-                        break;
-                }
-            }
-        }
-        return { valid: errors.length === 0, errors };
-    }
-    generateFieldSchema(field) {
-        const schema = {
-            type: this.mapFieldTypeToJsonSchema(field.type),
-            description: field.description || field.title,
-        };
-        if (field.options && field.options.length > 0) {
-            schema.enum = field.options.map(opt => opt.value);
-        }
-        if (field.type === 'array' && field.fields) {
-            schema.items = {
-                type: 'object',
-                properties: this.generateFieldsSchema(field.fields),
-            };
-        }
-        if (field.type === 'reference') {
-            schema.description += field.referenceType ? ` (references ${field.referenceType})` : ' (content reference)';
-        }
-        return schema;
-    }
-    generateFieldsSchema(fields) {
-        const properties = {};
-        for (const field of fields) {
-            properties[field.key] = this.generateFieldSchema(field);
-        }
-        return properties;
-    }
-    mapFieldTypeToJsonSchema(fieldType) {
-        switch (fieldType) {
-            case 'string':
-            case 'email':
-            case 'url':
-            case 'date':
-                return 'string';
-            case 'number':
-            case 'integer':
-                return 'number';
-            case 'boolean':
-                return 'boolean';
-            case 'array':
-                return 'array';
-            case 'group':
-            case 'reference':
-                return 'object';
-            default:
-                return 'string';
-        }
-    }
-    /**
-     * Generates completely dynamic properties based on the loaded glossary
-     * This creates schema properties for ALL fields from ALL content types
-     */
-    generateDynamicContentProperties() {
-        const properties = {};
-        // 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)`
-                };
+    async promptUserForScopes() {
+        try {
+            const response = await this.axiosInstance.get('/scope/tree');
+            const scopes = this.extractAvailableScopes(response.data);
+            if (scopes.length === 0) {
+                throw new Error('No scopes available for content creation');
             }
-        }
-        // Add the data object with dynamic properties
-        properties.data = {
-            type: 'object',
-            description: `DYNAMIC FIELD PLACEMENT (based on glossary):
-      
-**ROOT LEVEL FIELDS (from glossary "fields" array):**
-${Array.from(allRootFields).sort().join(', ')}
+            return {
+                content: [{
+                        type: 'text',
+                        text: `🔐 **SCOPE SELECTION REQUIRED**
 
-**DATA OBJECT FIELDS (from glossary "definedFields" array):**
-${Array.from(allDataFields).sort().join(', ')}
+To create content, you need to specify which scope(s) to create it in.
 
-**FIELD PLACEMENT RULE:**
-- Fields in glossary "fields" array → ROOT LEVEL
-- Fields in glossary "definedFields" array → DATA OBJECT
+**Available Scopes:**
+${scopes.map(s => `- **${s.id}**: ${s.title} (${s.path})`).join('\n')}
 
-The MCP server automatically determines correct placement based on the glossary definition for each content type.`,
-            properties: dataProperties
-        };
-        return properties;
-    }
-    findContentTypesByDescription(description) {
-        const normalizedDescription = description.toLowerCase().trim();
-        const matches = [];
-        // Direct match first (check if the description exactly matches a key)
-        if (this.glossary[normalizedDescription]) {
-            return [normalizedDescription];
-        }
-        // Search through glossary for matches
-        for (const [key, contentType] of Object.entries(this.glossary)) {
-            if (!contentType || typeof contentType !== 'object')
-                continue;
-            // Get title and plural - the glossary structure from the screenshot shows these are direct properties
-            let title = '';
-            let plural = '';
-            // Based on the screenshot, the structure is directly on the contentType object
-            if (contentType.title) {
-                title = (contentType.title || '').toLowerCase();
-                plural = (contentType.plural || '').toLowerCase();
-            }
-            // Fallback to nested structures if they exist
-            else if (contentType.definition) {
-                title = (contentType.definition.title || '').toLowerCase();
-                plural = (contentType.definition.plural || '').toLowerCase();
-            }
-            else if (contentType.type) {
-                title = (contentType.type.title || '').toLowerCase();
-                plural = (contentType.type.plural || '').toLowerCase();
-            }
-            // Exact title/plural match (e.g., "incident report" matches "Incident Report")
-            if (title === normalizedDescription || plural === normalizedDescription) {
-                matches.push(key);
-                continue;
-            }
-            // Partial word matches - check if all words in description are found in title
-            const descriptionWords = normalizedDescription.split(/\s+/);
-            const titleWords = title.split(/\s+/);
-            if (descriptionWords.length > 0 && descriptionWords.every(word => titleWords.some(titleWord => titleWord.includes(word) || word.includes(titleWord)))) {
-                matches.push(key);
-                continue;
-            }
-            // Also check against the key itself for partial matches
-            const keyLower = key.toLowerCase();
-            if (descriptionWords.every(word => keyLower.includes(word))) {
-                matches.push(key);
-                continue;
-            }
-            // Specific common term matches
-            if (normalizedDescription.includes('incident') && (title.includes('incident') || keyLower.includes('incident'))) {
-                matches.push(key);
-            }
-            else if (normalizedDescription.includes('report') && (title.includes('report') || keyLower.includes('report'))) {
-                matches.push(key);
-            }
-            else if (normalizedDescription.includes('event') && (title.includes('event') || keyLower.includes('event'))) {
-                matches.push(key);
-            }
-            else if (normalizedDescription.includes('comment') && (title.includes('comment') || keyLower.includes('comment'))) {
-                matches.push(key);
-            }
-            else if (normalizedDescription.includes('issue') && (title.includes('issue') || keyLower.includes('issue'))) {
-                matches.push(key);
-            }
-            else if (normalizedDescription.includes('ticket') && (title.includes('ticket') || keyLower.includes('ticket'))) {
-                matches.push(key);
-            }
-            else if (normalizedDescription.includes('case') && (title.includes('case') || keyLower.includes('case'))) {
-                matches.push(key);
-            }
-        }
-        return matches;
-    }
-    findContentTypeByDescription(description) {
-        const matches = this.findContentTypesByDescription(description);
-        return matches.length === 1 ? matches[0] : null;
-    }
-    async getAvailableScopes() {
-        try {
-            const response = await this.axiosInstance.get('/scope/tree');
-            return response.data;
+Please retry your request with the scope ID(s) you want to use in the meta.scopes field.
+
+**Example:**
+\`\`\`json
+{
+  "meta": {
+    "scopes": ["${scopes[0].id}"]
+  }
+}
+\`\`\``,
+                    }],
+                isError: true,
+            };
         }
         catch (error) {
-            this.log(`Failed to get scopes: ${this.formatError(error)}`);
-            return null;
+            throw new Error(`Failed to get available scopes: ${this.formatError(error)}`);
         }
     }
-    extractScopesWithPermissions(scopeTree, permission = 'create') {
+    extractAvailableScopes(scopeTree) {
         const scopes = [];
         const traverse = (node, path = '') => {
             if (!node)
                 return;
             const currentPath = path ? `${path} > ${node.title || node.name || node._id}` : (node.title || node.name || node._id);
-            // Check if user has create permission for this scope
-            if (node.permissions && node.permissions[permission]) {
+            if (node.permissions && node.permissions.create) {
                 scopes.push({
                     id: node._id,
                     title: node.title || node.name || node._id,
                     path: currentPath
                 });
             }
-            // Traverse children
             if (node.children && Array.isArray(node.children)) {
                 for (const child of node.children) {
                     traverse(child, currentPath);
@@ -665,856 +178,94 @@ The MCP server automatically determines correct placement based on the glossary
         }
         return scopes;
     }
-    // Enhanced filter helper functions
-    validateFilter(filter) {
-        const errors = [];
-        if (!filter || typeof filter !== 'object') {
-            return { valid: true, errors: [] }; // Empty filter is valid
-        }
-        // Check if it's a filter group or condition
-        if (filter.operator) {
-            // Filter group validation
-            if (!['and', 'or', 'nor'].includes(filter.operator)) {
-                errors.push(`Invalid operator '${filter.operator}'. Must be 'and', 'or', or 'nor'.`);
-            }
-            if (!Array.isArray(filter.filters)) {
-                errors.push('Filter group must have a "filters" array.');
-            }
-            else {
-                // Recursively validate nested filters
-                for (const nestedFilter of filter.filters) {
-                    const nestedValidation = this.validateFilter(nestedFilter);
-                    errors.push(...nestedValidation.errors);
-                }
-            }
-        }
-        else if (filter.key && filter.comparator) {
-            // Filter condition validation
-            const validComparators = [
-                'dateanniversary', 'anniversarybetween', 'anniversarynext', 'anniversarypast',
-                'datenext', 'datenotbetween', 'datenotnext', 'datebefore', 'dateafter',
-                'datetoday', 'datenottoday', 'datebeforetoday', 'dateaftertoday',
-                'datebeforenow', 'dateafternow', 'datepast', 'datenotpast',
-                'datesameday', 'datesamemonth', 'datesameweek', 'datesameyear',
-                'datebetween', 'datemonth',
-                'equal', 'notequal', 'in', 'notin', 'startswith', 'doesnotstartwith',
-                'endswith', 'doesnotendwith', 'contains', 'excludes',
-                'greater', 'lesser', 'greaterequal', 'lesserequal',
-                'notgreater', 'notlesser', 'notgreaterequal', 'notlesserequal',
-                'between', 'notbetween',
-                'valuesgreater', 'valueslesser', 'valuesgreaterequal', 'valueslesserequal',
-                'empty', 'notempty'
-            ];
-            if (!validComparators.includes(filter.comparator)) {
-                errors.push(`Invalid comparator '${filter.comparator}'.`);
-            }
-            // Validate required values for specific comparators
-            const requiresValue = ['equal', 'notequal', 'greater', 'lesser', 'greaterequal', 'lesserequal', 'contains', 'excludes', 'startswith', 'endswith', 'datebefore', 'dateafter', 'dateanniversary'];
-            const requiresValues = ['in', 'notin'];
-            const requiresValue2 = ['between', 'notbetween', 'anniversarybetween', 'anniversarynext', 'anniversarypast', 'datenext', 'datepast'];
-            if (requiresValue.includes(filter.comparator) && filter.value === undefined) {
-                errors.push(`Comparator '${filter.comparator}' requires a 'value' parameter.`);
-            }
-            if (requiresValues.includes(filter.comparator) && (!filter.values || !Array.isArray(filter.values))) {
-                errors.push(`Comparator '${filter.comparator}' requires a 'values' array parameter.`);
-            }
-            if (requiresValue2.includes(filter.comparator) && filter.value2 === undefined) {
-                errors.push(`Comparator '${filter.comparator}' requires both 'value' and 'value2' parameters.`);
-            }
-        }
-        else {
-            errors.push('Filter must be either a filter group (with operator and filters) or a condition (with key and comparator).');
-        }
-        return { valid: errors.length === 0, errors };
-    }
-    createBirthdayFilter(timeframe, amount, unit = 'days') {
-        return {
-            operator: 'and',
-            filters: [{
-                    key: 'dob',
-                    comparator: timeframe === 'next' ? 'anniversarynext' : 'anniversarypast',
-                    value: amount,
-                    value2: unit
-                }]
-        };
-    }
-    createDateRangeFilter(field, startDate, endDate) {
-        return {
-            operator: 'and',
-            filters: [{
-                    key: field,
-                    comparator: 'datebetween',
-                    value: startDate,
-                    value2: endDate
-                }]
-        };
-    }
-    createGenderFilter(gender) {
-        return {
-            key: 'gender',
-            comparator: 'equal',
-            value: gender
-        };
-    }
-    createAgeRangeFilter(minAge, maxAge) {
-        const currentYear = new Date().getFullYear();
-        return {
-            operator: 'and',
-            filters: [{
-                    key: 'dobYear',
-                    comparator: 'between',
-                    value: currentYear - maxAge,
-                    value2: currentYear - minAge
-                }]
-        };
-    }
-    createThisMonthBirthdayFilter() {
-        const now = new Date();
-        const currentMonth = now.getMonth() + 1; // JavaScript months are 0-indexed
-        return {
-            operator: 'and',
-            filters: [{
-                    key: 'dobMonth',
-                    comparator: 'equal',
-                    value: currentMonth
-                }]
-        };
-    }
-    createRecentContentFilter(days = 30) {
-        return {
-            operator: 'and',
-            filters: [{
-                    key: 'meta.created',
-                    comparator: 'datepast',
-                    value: days,
-                    value2: 'days'
-                }]
-        };
-    }
-    createScopeFilter(scopeIds) {
-        return {
-            operator: 'and',
-            filters: [{
-                    key: 'meta.scopes',
-                    comparator: 'in',
-                    values: scopeIds
-                }]
-        };
-    }
-    /**
-     * 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',
-            description: `Advanced filter criteria using Qik's powerful filter syntax. Supports hierarchical filters with 'and', 'or', 'nor' operators and 40+ comparators for dates, strings, numbers, and arrays.
-
-EXAMPLES:
-
-1. Birthdays in next 10 days:
-{
-  "operator": "and",
-  "filters": [{
-    "key": "dob",
-    "comparator": "anniversarynext", 
-    "value": 10,
-    "value2": "days"
-  }]
-}
-
-2. Male profiles born this month:
-{
-  "operator": "and",
-  "filters": [
-    {"key": "gender", "comparator": "equal", "value": "male"},
-    {"key": "dobMonth", "comparator": "equal", "value": 8}
-  ]
-}
-
-3. Content created in last 30 days:
-{
-  "operator": "and", 
-  "filters": [{
-    "key": "meta.created",
-    "comparator": "datepast",
-    "value": 30,
-    "value2": "days"
-  }]
-}
-
-4. Complex query with OR logic:
-{
-  "operator": "or",
-  "filters": [
-    {"key": "firstName", "comparator": "startswith", "value": "John"},
-    {"key": "lastName", "comparator": "contains", "value": "Smith"}
-  ]
-}`,
-            properties: {
-                operator: {
-                    type: 'string',
-                    enum: ['and', 'or', 'nor'],
-                    description: 'Logical operator: "and" (all must match), "or" (any can match), "nor" (none can match)'
-                },
-                filters: {
-                    type: 'array',
-                    description: 'Array of filter conditions or nested filter groups',
-                    items: {
-                        oneOf: [
-                            {
-                                type: 'object',
-                                description: 'Filter condition',
-                                properties: {
-                                    key: {
-                                        type: 'string',
-                                        description: 'Field path to filter on (e.g., "firstName", "meta.created", "data.customField")'
-                                    },
-                                    comparator: {
-                                        type: 'string',
-                                        enum: [
-                                            // Date/Anniversary comparators
-                                            'dateanniversary', 'anniversarybetween', 'anniversarynext', 'anniversarypast',
-                                            'datenext', 'datenotbetween', 'datenotnext', 'datebefore', 'dateafter',
-                                            'datetoday', 'datenottoday', 'datebeforetoday', 'dateaftertoday',
-                                            'datebeforenow', 'dateafternow', 'datepast', 'datenotpast',
-                                            'datesameday', 'datesamemonth', 'datesameweek', 'datesameyear',
-                                            'datebetween', 'datemonth',
-                                            // String comparators
-                                            'equal', 'notequal', 'in', 'notin', 'startswith', 'doesnotstartwith',
-                                            'endswith', 'doesnotendwith', 'contains', 'excludes',
-                                            // Numeric comparators
-                                            'greater', 'lesser', 'greaterequal', 'lesserequal',
-                                            'notgreater', 'notlesser', 'notgreaterequal', 'notlesserequal',
-                                            'between', 'notbetween',
-                                            // Array/value comparators
-                                            'valuesgreater', 'valueslesser', 'valuesgreaterequal', 'valueslesserequal',
-                                            'empty', 'notempty'
-                                        ],
-                                        description: 'Comparison operator - see documentation for full list and usage'
-                                    },
-                                    value: {
-                                        description: 'Primary comparison value (type depends on comparator)'
-                                    },
-                                    value2: {
-                                        description: 'Secondary value for range comparators (between, anniversarynext, etc.)'
-                                    },
-                                    values: {
-                                        type: 'array',
-                                        description: 'Array of values for "in" and "notin" comparators'
-                                    }
-                                },
-                                required: ['key', 'comparator']
-                            },
-                            {
-                                type: 'object',
-                                description: 'Nested filter group',
-                                properties: {
-                                    operator: { type: 'string', enum: ['and', 'or', 'nor'] },
-                                    filters: { type: 'array' }
-                                },
-                                required: ['operator', 'filters']
-                            }
-                        ]
-                    }
-                }
+    async handleApiError(error, operation, args) {
+        if (error.response?.status === 400) {
+            const errorData = error.response.data;
+            // Handle missing scopes
+            if (errorData.message && errorData.message.includes('scope')) {
+                return await this.promptUserForScopes();
             }
-        };
-    }
-    /**
-     * Enhanced intelligent content creation with advanced disambiguation logic
-     *
-     * This method provides sophisticated analysis of user intent to distinguish between:
-     * - Creating workflow DEFINITIONS vs workflow CARD instances
-     * - Creating content type DEFINITIONS vs content INSTANCES
-     * - Understanding context clues like "add person to workflow" vs "create new workflow"
-     */
-    async intelligentContentCreation(description, additionalData) {
-        // STEP 1: Advanced Intent Analysis with Disambiguation Logic
-        const intentAnalysis = this.analyzeUserIntent(description, additionalData);
-        // Handle workflow-specific disambiguation
-        if (intentAnalysis.isWorkflowRelated) {
-            return await this.handleWorkflowDisambiguation(description, additionalData, intentAnalysis);
-        }
-        // STEP 2: Standard content type matching
-        const contentTypeMatches = this.findContentTypesByDescription(description);
-        if (contentTypeMatches.length === 0) {
-            return await this.handleNoContentTypeMatches(description);
-        }
-        if (contentTypeMatches.length > 1) {
-            return await this.handleMultipleContentTypeMatches(description, contentTypeMatches);
-        }
-        // STEP 3: Single match found - provide comprehensive guidance
-        const contentType = contentTypeMatches[0];
-        return await this.handleSingleContentTypeMatch(contentType, description, additionalData);
-    }
-    /**
-     * Analyzes user intent to distinguish between different types of content creation
-     */
-    analyzeUserIntent(description, additionalData) {
-        const normalizedDesc = description.toLowerCase().trim();
-        const contextClues = [];
-        // Workflow-related keywords
-        const workflowKeywords = ['workflow', 'kanban', 'board', 'column', 'step', 'process', 'pipeline'];
-        const isWorkflowRelated = workflowKeywords.some(keyword => normalizedDesc.includes(keyword));
-        // Definition creation indicators
-        const definitionIndicators = [
-            'create a new', 'create new', 'make a new', 'design a', 'set up a', 'build a',
-            'define a', 'establish a', 'configure a'
-        ];
-        const isDefinitionCreation = definitionIndicators.some(indicator => normalizedDesc.includes(indicator));
-        // Instance creation indicators
-        const instanceIndicators = [
-            'add', 'assign', 'put', 'move', 'place', 'insert', 'include'
-        ];
-        const isInstanceCreation = instanceIndicators.some(indicator => normalizedDesc.includes(indicator));
-        // Person assignment indicators
-        const personIndicators = [
-            'add person', 'assign person', 'add user', 'assign user', 'add someone', 'assign someone',
-            'add jim', 'add john', 'add sarah', 'put person', 'move person'
-        ];
-        const isPersonAssignment = personIndicators.some(indicator => normalizedDesc.includes(indicator));
-        // Collect context clues
-        if (isWorkflowRelated)
-            contextClues.push('workflow-related');
-        if (isDefinitionCreation)
-            contextClues.push('definition-creation');
-        if (isInstanceCreation)
-            contextClues.push('instance-creation');
-        if (isPersonAssignment)
-            contextClues.push('person-assignment');
-        // Calculate confidence based on clarity of intent
-        let confidence = 0.5; // Base confidence
-        if (isDefinitionCreation && !isInstanceCreation)
-            confidence = 0.9;
-        if (isInstanceCreation && !isDefinitionCreation)
-            confidence = 0.9;
-        if (isPersonAssignment)
-            confidence = 0.95;
-        return {
-            isWorkflowRelated,
-            isDefinitionCreation,
-            isInstanceCreation,
-            isPersonAssignment,
-            confidence,
-            contextClues
-        };
-    }
-    /**
-     * Handles workflow-specific disambiguation with comprehensive guidance
-     */
-    async handleWorkflowDisambiguation(description, additionalData, intentAnalysis) {
-        const normalizedDesc = description.toLowerCase().trim();
-        // Check if user wants to create a workflow DEFINITION
-        if (intentAnalysis.isDefinitionCreation ||
-            normalizedDesc.includes('create a workflow') ||
-            normalizedDesc.includes('new workflow') ||
-            normalizedDesc.includes('design workflow')) {
+            // Handle validation errors - let user know what went wrong
             return {
                 content: [{
                         type: 'text',
-                        text: `🔧 **WORKFLOW DEFINITION CREATION**
-
-You want to create a new workflow definition (template). This defines the structure, columns, steps, and automation rules.
+                        text: `❌ **VALIDATION ERROR**
 
-**WORKFLOW DEFINITION STRUCTURE:**
+The API rejected your request for ${operation}:
 
-A workflow definition includes:
-- **Columns**: Stages like "To Do", "In Progress", "Review", "Done"
-- **Steps**: Specific positions within columns where cards can be placed
-- **Automation**: Functions that run when cards enter/exit steps
-- **Due Date Behavior**: How due dates are calculated and managed
-- **Completion Criteria**: Rules that determine when workflow is complete
-
-**EXAMPLE WORKFLOW DEFINITION:**
-\`\`\`json
-{
-  "type": "definition",
-  "title": "New Student Induction Workflow",
-  "definesType": "workflowcard",
-  "workflow": [
-    {
-      "title": "Enrollment",
-      "description": "Initial enrollment and documentation",
-      "steps": [
-        {
-          "title": "Application Received",
-          "type": "step",
-          "description": "Student application has been received",
-          "duration": 1440,
-          "assignees": [],
-          "entryFunction": "// Code to run when card enters this step",
-          "exitFunction": "// Code to run when card exits this step"
-        }
-      ]
-    },
-    {
-      "title": "Processing",
-      "description": "Review and approval process",
-      "steps": [
-        {
-          "title": "Document Review",
-          "type": "step",
-          "description": "Review all submitted documents"
-        }
-      ]
-    }
-  ]
-}
-\`\`\`
+**Error Details:**
+${JSON.stringify(errorData, null, 2)}
 
-To create this workflow definition, use:
-\`qik_create_content\` with type: "definition" and the workflow structure in the data field.
+**Your Request:**
+${JSON.stringify(args, null, 2)}
 
-Would you like me to help you create a specific workflow definition?`,
+**Suggestions:**
+- Check that all required fields are provided
+- Verify field names match the content type definition
+- Ensure scope IDs are valid and you have permissions
+- Use \`qik_get_content_definition\` to see the exact field structure`,
                     }],
+                isError: true,
             };
         }
-        // Check if user wants to add someone to an existing workflow (create workflow CARD)
-        if (intentAnalysis.isPersonAssignment ||
-            normalizedDesc.includes('add') && normalizedDesc.includes('to workflow') ||
-            normalizedDesc.includes('assign') && normalizedDesc.includes('workflow')) {
+        if (error.response?.status === 403) {
             return {
                 content: [{
                         type: 'text',
-                        text: `👤 **WORKFLOW CARD CREATION (Person Assignment)**
-
-You want to add a person to an existing workflow by creating a workflow card instance.
-
-**WORKFLOW CARD vs WORKFLOW DEFINITION:**
-- **Workflow Definition**: The template/structure (columns, steps, rules)
-- **Workflow Card**: Individual items that move through the workflow
+                        text: `🚫 **PERMISSION DENIED**
 
-**TO ADD SOMEONE TO A WORKFLOW:**
+You don't have permission to perform ${operation}.
 
-1. **Find the workflow definition ID** first using:
-   \`qik_list_content\` with type: "definition" and search for your workflow name
-
-2. **Create a workflow card** using:
-   \`qik_create_content\` with type: "workflowcard"
-
-**EXAMPLE WORKFLOW CARD:**
-\`\`\`json
-{
-  "type": "workflowcard",
-  "title": "John Smith - Student Induction",
-  "reference": "PROFILE_ID_HERE",
-  "referenceType": "profile",
-  "data": {
-    "workflowDefinition": "WORKFLOW_DEFINITION_ID_HERE",
-    "currentStep": "application-received",
-    "assignedTo": ["USER_ID_HERE"],
-    "dueDate": "2024-01-15T09:00:00.000Z"
-  }
-}
-\`\`\`
+**Possible causes:**
+- Your access token doesn't have the required permissions
+- The scope you're trying to access is restricted
+- The content type requires special permissions
 
-**NEED MORE HELP?**
-- What's the name of the workflow you want to add someone to?
-- Who do you want to add to the workflow?
-- Do you have the workflow definition ID?`,
+**Next steps:**
+- Check your token permissions with your administrator
+- Try using \`qik_get_scopes\` to see available scopes
+- Verify you have create/update permissions for this content type`,
                     }],
+                isError: true,
             };
         }
-        // General workflow guidance
-        return {
-            content: [{
-                    type: 'text',
-                    text: `🔄 **WORKFLOW SYSTEM GUIDANCE**
-
-I detected you're working with workflows. Please clarify your intent:
-
-**OPTION 1: Create Workflow Definition (Template)**
-- "Create a new workflow"
-- "Design a student onboarding workflow"
-- "Set up a project management workflow"
-→ Creates the structure, columns, steps, and rules
-
-**OPTION 2: Add Person to Existing Workflow**
-- "Add Jim to the student workflow"
-- "Assign Sarah to project workflow"
-- "Put John in the onboarding process"
-→ Creates a workflow card instance for a person
-
-**WORKFLOW CONCEPTS:**
-- **Definition**: The template (like a Kanban board layout)
-- **Card**: Individual items moving through the workflow
-- **Columns**: Stages (To Do, In Progress, Done)
-- **Steps**: Specific positions within columns
-- **Automation**: Code that runs when cards move
-
-**AVAILABLE WORKFLOW CONTENT TYPES:**
-- \`definition\`: For creating workflow templates
-- \`workflowcard\`: For individual workflow instances
-- \`object\`: For custom workflow-related objects
-
-Please specify: Are you creating a new workflow template, or adding someone to an existing workflow?`,
-                }],
-        };
-    }
-    /**
-     * Handles cases where no content types match the description
-     */
-    async handleNoContentTypeMatches(description) {
-        const availableTypes = Object.entries(this.glossary).map(([key, type]) => {
-            let title = 'Unknown';
-            let plural = 'Unknown';
-            if (type && typeof type === 'object') {
-                if (type.definition) {
-                    title = type.definition.title || title;
-                    plural = type.definition.plural || plural;
-                }
-                else if (type.type) {
-                    title = type.type.title || title;
-                    plural = type.type.plural || plural;
-                }
-                else if (type.title) {
-                    title = type.title || title;
-                    plural = type.plural || plural;
-                }
-            }
-            return { key, title, plural };
-        });
-        // Group types by category for better organization
-        const categorizedTypes = this.categorizeContentTypes(availableTypes);
+        // Generic error handling
         return {
             content: [{
                     type: 'text',
-                    text: `❌ **NO MATCHING CONTENT TYPE FOUND**
+                    text: `❌ **API ERROR**
 
-I couldn't find a content type for "${description}".
+Failed to ${operation}:
 
-**AVAILABLE CONTENT TYPES BY CATEGORY:**
+**Error:** ${this.formatError(error)}
 
-${categorizedTypes}
+**Your Request:**
+${JSON.stringify(args, null, 2)}
 
-**SUGGESTIONS:**
-- Try using more specific terms (e.g., "incident report" instead of "report")
-- Check if you meant to create a workflow definition or workflow card
-- Use the exact content type key from the list above
-
-**NEED HELP?**
-- Use \`qik_get_glossary\` to see all available types with descriptions
-- Use \`qik_get_content_definition\` with a specific type to see its fields`,
+**Troubleshooting:**
+- Check your internet connection
+- Verify your access token is valid
+- Try the request again in a few moments`,
                 }],
             isError: true,
         };
     }
-    /**
-     * Categorizes content types for better organization in help text
-     */
-    categorizeContentTypes(types) {
-        const categories = {
-            'Core Content': [],
-            'People & Profiles': [],
-            'Workflows & Processes': [],
-            'Communication': [],
-            'Media & Files': [],
-            'System & Admin': [],
-            'Other': []
-        };
-        for (const type of types) {
-            const key = type.key.toLowerCase();
-            const title = type.title.toLowerCase();
-            if (key.includes('profile') || key.includes('person') || key.includes('user')) {
-                categories['People & Profiles'].push(type);
-            }
-            else if (key.includes('workflow') || key.includes('definition') || key.includes('process')) {
-                categories['Workflows & Processes'].push(type);
-            }
-            else if (key.includes('comment') || key.includes('message') || key.includes('notification') || key.includes('email')) {
-                categories['Communication'].push(type);
-            }
-            else if (key.includes('file') || key.includes('image') || key.includes('video') || key.includes('audio')) {
-                categories['Media & Files'].push(type);
-            }
-            else if (key.includes('scope') || key.includes('role') || key.includes('policy') || key.includes('variable')) {
-                categories['System & Admin'].push(type);
-            }
-            else if (['article', 'event', 'object'].includes(key)) {
-                categories['Core Content'].push(type);
-            }
-            else {
-                categories['Other'].push(type);
-            }
-        }
-        let result = '';
-        for (const [category, categoryTypes] of Object.entries(categories)) {
-            if (categoryTypes.length > 0) {
-                result += `\n**${category}:**\n`;
-                result += categoryTypes.map(t => `- ${t.key}: ${t.title} (${t.plural})`).join('\n');
-                result += '\n';
-            }
-        }
-        return result;
-    }
-    /**
-     * Handles cases where multiple content types match
-     */
-    async handleMultipleContentTypeMatches(description, contentTypeMatches) {
-        const matchDetails = contentTypeMatches.map(key => {
-            const type = this.glossary[key];
-            let title = 'Unknown';
-            let plural = 'Unknown';
-            let baseType = '';
-            if (type && typeof type === 'object') {
-                if (type.definition) {
-                    title = type.definition.title || title;
-                    plural = type.definition.plural || plural;
-                    baseType = type.definition.definesType || '';
-                }
-                else if (type.type) {
-                    title = type.type.title || title;
-                    plural = type.type.plural || plural;
-                }
-                else if (type.title) {
-                    title = type.title || title;
-                    plural = type.plural || plural;
-                    baseType = type.definesType || '';
-                }
-            }
-            return { key, title, plural, baseType };
-        });
-        return {
-            content: [{
-                    type: 'text',
-                    text: `🔍 **MULTIPLE CONTENT TYPES FOUND**
-
-I found multiple content types that match "${description}". Please clarify which one you'd like to create:
-
-${matchDetails.map(t => {
-                        let description = `- **${t.key}**: ${t.title} (${t.plural})`;
-                        if (t.baseType) {
-                            description += ` - extends ${t.baseType}`;
-                        }
-                        return description;
-                    }).join('\n')}
-
-**TO PROCEED:**
-1. Choose the exact content type key from above
-2. Use \`qik_create_content\` with your chosen type
-3. Or use \`qik_get_content_definition\` to see field details first
-
-**NEED MORE INFO?**
-Use \`qik_get_content_definition\` with any of the type keys above to see their specific fields and requirements.`,
-                }],
-            isError: true,
-        };
-    }
-    /**
-     * Handles single content type match with comprehensive guidance
-     */
-    async handleSingleContentTypeMatch(contentType, description, additionalData) {
-        const typeInfo = this.getContentTypeInfo(contentType);
-        if (!typeInfo) {
-            return {
-                content: [{
-                        type: 'text',
-                        text: `❌ Found content type "${contentType}" but couldn't load its definition.`,
-                    }],
-                isError: true,
-            };
-        }
-        // Extract comprehensive type information
-        const typeAnalysis = this.analyzeContentTypeStructure(typeInfo);
-        let guidance = `✅ **CONTENT TYPE FOUND: ${contentType.toUpperCase()}**\n\n`;
-        guidance += `**Type**: ${typeAnalysis.title}\n`;
-        guidance += `**Description**: ${typeAnalysis.description || 'No description available'}\n`;
-        if (typeAnalysis.baseType) {
-            guidance += `**Extends**: ${typeAnalysis.baseType}\n`;
-        }
-        guidance += `\n**FIELD STRUCTURE:**\n`;
-        if (typeAnalysis.requiredFields.length > 0) {
-            guidance += `\n**Required Fields:**\n`;
-            guidance += typeAnalysis.requiredFields.map(f => `- **${f.key}** (${f.title}): ${f.description || 'No description'}`).join('\n');
-        }
-        if (typeAnalysis.optionalFields.length > 0) {
-            guidance += `\n\n**Optional Fields:**\n`;
-            guidance += typeAnalysis.optionalFields.map(f => `- **${f.key}** (${f.title}): ${f.description || 'No description'}`).join('\n');
-        }
-        // Handle creation if data provided
-        if (additionalData && typeof additionalData === 'object' && additionalData.title) {
-            return await this.handleContentCreationWithData(contentType, additionalData, typeAnalysis);
-        }
-        // Provide creation guidance
-        guidance += await this.generateCreationGuidance(contentType, typeAnalysis);
-        return {
-            content: [{
-                    type: 'text',
-                    text: guidance,
-                }],
-        };
-    }
-    /**
-     * Analyzes content type structure for comprehensive information
-     */
-    analyzeContentTypeStructure(typeInfo) {
-        let fields = [];
-        let title = 'Unknown';
-        let description = '';
-        let baseType = '';
-        if (typeInfo.definition) {
-            fields = typeInfo.definition.fields || [];
-            title = typeInfo.definition.title || title;
-            description = typeInfo.definition.description || '';
-            baseType = typeInfo.definition.definesType || '';
-        }
-        else if (typeInfo.type) {
-            fields = typeInfo.type.fields || [];
-            title = typeInfo.type.title || title;
-            description = typeInfo.type.description || '';
-        }
-        else if (typeInfo.fields) {
-            fields = typeInfo.fields || [];
-            title = typeInfo.title || title;
-            description = typeInfo.description || '';
-            baseType = typeInfo.definesType || '';
-        }
-        const requiredFields = fields.filter((f) => f.minimum && f.minimum > 0);
-        const optionalFields = fields.filter((f) => !f.minimum || f.minimum === 0);
-        return {
-            title,
-            description,
-            baseType,
-            fields,
-            requiredFields,
-            optionalFields,
-            fieldCount: fields.length
-        };
-    }
-    /**
-     * Handles content creation when data is provided
-     */
-    async handleContentCreationWithData(contentType, additionalData, typeAnalysis) {
-        // Check if scopes are provided
-        if (!additionalData.meta || !additionalData.meta.scopes || !Array.isArray(additionalData.meta.scopes) || additionalData.meta.scopes.length === 0) {
-            const scopeTree = await this.getAvailableScopes();
-            if (scopeTree) {
-                const availableScopes = this.extractScopesWithPermissions(scopeTree, 'create');
-                if (availableScopes.length === 0) {
-                    return {
-                        content: [{
-                                type: 'text',
-                                text: `🚫 **PERMISSION DENIED**\n\nYou don't have permission to create content in any scopes. Please contact your administrator.`,
-                            }],
-                        isError: true,
-                    };
-                }
-                return {
-                    content: [{
-                            type: 'text',
-                            text: `📍 **SCOPE SELECTION REQUIRED**\n\nTo create "${additionalData.title}" as a ${typeAnalysis.title}, you need to specify which scope to create it in.\n\n**Available Scopes:**\n${availableScopes.map(s => `- **${s.id}**: ${s.path}`).join('\n')}\n\n**TO CREATE:**\nUse \`qik_create_content\` with:\n- type: "${contentType}"\n- title: "${additionalData.title}"\n- meta: { "scopes": ["scope_id_here"] }\n- data: { /* your field values */ }`,
-                        }],
-                };
-            }
-        }
-        // Proceed with creation
-        const title = additionalData.title || `New ${typeAnalysis.title}`;
-        const data = additionalData.data || {};
-        const meta = additionalData.meta || {};
-        return await this.createContent({
-            type: contentType,
-            title,
-            data,
-            meta,
-        });
-    }
-    /**
-     * Generates comprehensive creation guidance
-     */
-    async generateCreationGuidance(contentType, typeAnalysis) {
-        let guidance = `\n\n**CREATION GUIDANCE:**\n`;
-        // Get available scopes
-        const scopeTree = await this.getAvailableScopes();
-        let scopeGuidance = '';
-        if (scopeTree) {
-            const availableScopes = this.extractScopesWithPermissions(scopeTree, 'create');
-            if (availableScopes.length > 0) {
-                scopeGuidance = `\n**Available Scopes:**\n${availableScopes.map(s => `- **${s.id}**: ${s.path}`).join('\n')}\n`;
-            }
-        }
-        guidance += `\n**TO CREATE THIS CONTENT:**\n`;
-        guidance += `Use \`qik_create_content\` with:\n`;
-        guidance += `- **type**: "${contentType}"\n`;
-        guidance += `- **title**: "Your title here"\n`;
-        guidance += `- **meta**: { "scopes": ["scope_id_here"] } *(required)*\n`;
-        guidance += `- **data**: { /* field values based on structure above */ }\n`;
-        guidance += scopeGuidance;
-        // Add specific guidance for common types
-        if (contentType === 'definition') {
-            guidance += `\n**WORKFLOW DEFINITION EXAMPLE:**\n`;
-            guidance += `For workflow definitions, include the workflow structure in the data field with columns, steps, and automation rules.\n`;
-        }
-        if (contentType.includes('comment') || contentType.includes('Comment')) {
-            guidance += `\n**COMMENT CREATION:**\n`;
-            guidance += `Comments require a reference to the item being commented on. Include:\n`;
-            guidance += `- **reference**: ID of the item to comment on\n`;
-            guidance += `- **referenceType**: Type of the referenced item\n`;
-        }
-        return guidance;
-    }
-    generateToolDescription(baseDescription, emoji = '') {
-        const prefix = emoji ? `${emoji} ` : '';
-        return `${prefix}${baseDescription.replace(/Qik/g, this.serverName)}`;
-    }
     setupToolHandlers() {
         this.server.setRequestHandler(ListToolsRequestSchema, async () => {
-            // Ensure glossary is loaded
-            await this.loadGlossary();
             const tools = [
-                // Authentication & Session
+                // Core requirement 1: Authentication
                 {
                     name: 'qik_get_user_session',
-                    description: this.generateToolDescription('Get current user session information', '👤'),
+                    description: '👤 Get current user session information',
                     inputSchema: {
                         type: 'object',
                         properties: {},
                     },
                 },
-                // Content Type Discovery
+                // Core requirement 2: Glossary discovery
                 {
                     name: 'qik_get_glossary',
-                    description: this.generateToolDescription('Get all available content types and their definitions', '📚'),
+                    description: '📚 Get all available content types and their definitions',
                     inputSchema: {
                         type: 'object',
                         properties: {},
@@ -1522,34 +273,37 @@ Use \`qik_get_content_definition\` with any of the type keys above to see their
                 },
                 {
                     name: 'qik_get_content_definition',
-                    description: this.generateToolDescription('Get definition for a specific content type', '🔍'),
+                    description: '🔍 Get definition for a specific content type',
                     inputSchema: {
                         type: 'object',
                         properties: {
                             type: {
                                 type: 'string',
-                                description: 'Content type key (e.g., "article", "profile", "event")',
+                                description: 'Content type key',
                                 enum: Object.keys(this.glossary),
                             },
                         },
                         required: ['type'],
                     },
                 },
-                // Content Management
+                // Core requirement 3: Session management (covered by user session)
+                {
+                    name: 'qik_get_scopes',
+                    description: '🔐 Get available scopes/permissions tree',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {},
+                    },
+                },
+                // Core requirement 4: Basic CRUD tools
                 {
                     name: 'qik_get_content',
-                    description: this.generateToolDescription('Get content item by ID or slug', '📄'),
+                    description: '📄 Get content item by ID or slug',
                     inputSchema: {
                         type: 'object',
                         properties: {
-                            id: {
-                                type: 'string',
-                                description: 'Content ID',
-                            },
-                            slug: {
-                                type: 'string',
-                                description: 'Content slug (e.g., "article:my-post" or "car:pathfinder")',
-                            },
+                            id: { type: 'string', description: 'Content ID' },
+                            slug: { type: 'string', description: 'Content slug' },
                         },
                         oneOf: [
                             { required: ['id'] },
@@ -1559,27 +313,7 @@ Use \`qik_get_content_definition\` with any of the type keys above to see their
                 },
                 {
                     name: 'qik_list_content',
-                    description: this.generateToolDescription(`List content items with advanced filtering and search capabilities. Supports complex queries like birthdays, date ranges, and sophisticated business logic.
-
-**ENHANCED FILTER CAPABILITIES:**
-- 40+ comparators for dates, strings, numbers, and arrays
-- Hierarchical filters with 'and', 'or', 'nor' operators
-- Anniversary and birthday queries (anniversarynext, anniversarypast)
-- Date range filtering (datebetween, datepast, datenext)
-- String matching (contains, startswith, endswith, equal)
-- Numeric comparisons (greater, lesser, between)
-- Array operations (in, notin, valuesgreater)
-
-**COMMON USE CASES:**
-- Find birthdays in next 10 days: {"operator":"and","filters":[{"key":"dob","comparator":"anniversarynext","value":10,"value2":"days"}]}
-- Recent content: {"operator":"and","filters":[{"key":"meta.created","comparator":"datepast","value":30,"value2":"days"}]}
-- Gender filtering: {"operator":"and","filters":[{"key":"gender","comparator":"equal","value":"male"}]}
-- Complex queries with OR logic for multiple conditions
-
-**FIELD TARGETING:**
-- Use dot notation for nested fields: "meta.created", "data.customField"
-- Target specific profile fields: "firstName", "lastName", "emails"
-- Filter by metadata: "meta.scopes", "meta.tags", "meta.security"`, '📋'),
+                    description: '📋 List content items with filtering and search',
                     inputSchema: {
                         type: 'object',
                         properties: {
@@ -1588,121 +322,43 @@ Use \`qik_get_content_definition\` with any of the type keys above to see their
                                 description: 'Content type to list',
                                 enum: Object.keys(this.glossary),
                             },
-                            search: {
-                                type: 'string',
-                                description: 'Search keywords - searches within title, tags, and text areas',
-                            },
-                            filter: this.generateEnhancedFilterSchema(),
-                            sort: {
-                                type: 'object',
-                                description: 'Sorting configuration for results',
-                                properties: {
-                                    key: {
-                                        type: 'string',
-                                        description: 'Field to sort by (e.g., "title", "meta.created", "data.customField")'
-                                    },
-                                    direction: {
-                                        type: 'string',
-                                        enum: ['asc', 'desc'],
-                                        description: 'Sort direction: ascending or descending'
-                                    },
-                                    type: {
-                                        type: 'string',
-                                        enum: ['string', 'number', 'date'],
-                                        description: 'Data type for proper sorting behavior'
-                                    },
-                                },
-                            },
+                            search: { type: 'string', description: 'Search keywords' },
+                            filter: { type: 'object', description: 'Filter criteria' },
                             page: {
                                 type: 'object',
-                                description: 'Pagination settings',
                                 properties: {
-                                    size: {
-                                        type: 'number',
-                                        minimum: 1,
-                                        maximum: 100,
-                                        description: 'Number of items per page (1-100)'
-                                    },
-                                    index: {
-                                        type: 'number',
-                                        minimum: 1,
-                                        description: 'Page number to retrieve (starts at 1)'
-                                    },
+                                    size: { type: 'number', minimum: 1, maximum: 100 },
+                                    index: { type: 'number', minimum: 1 },
                                 },
                             },
-                            select: {
-                                type: 'array',
-                                items: { type: 'string' },
-                                description: 'Specific fields to include in response (e.g., ["title", "data.make", "meta.created"])',
-                            },
                         },
                         required: ['type'],
                     },
                 },
                 {
                     name: 'qik_create_content',
-                    description: this.generateToolDescription(`Create new content item with intelligent field structure handling.
-
-**FIELD STRUCTURE INTELLIGENCE:**
-- Automatically separates root-level fields from data object fields
-- Handles comment inheritance (comments inherit scopes from referenced items)
-- Validates field requirements based on content type definitions
-- Supports workflow definitions, workflow cards, and all content types
-
-**FIELD PLACEMENT RULES:**
-- **Root Level**: reference, referenceType, body, organisation, title, meta
-- **Data Object**: Custom fields defined in content type definitions (definedFields)
-- **Meta Object**: scopes (required), tags, security, personaAuthor, etc.
-
-**CONTENT TYPE EXAMPLES:**
-- **Comments**: Require reference + referenceType, inherit scopes automatically
-- **Workflow Definitions**: Use data object for workflow structure (columns, steps, automation)
-- **Workflow Cards**: Reference profiles, link to workflow definitions
-- **Profiles**: firstName, lastName at root, custom fields in data object
-- **Articles**: body at root level, custom article fields in data object
-
-**SCOPE INHERITANCE:**
-- Comments automatically inherit scopes from referenced items
-- Other content types require explicit scope assignment
-- Use qik_get_scopes to find available scopes with permissions
-
-**VALIDATION:**
-- Checks content type exists and user has access
-- Validates required fields based on content type definition
-- Ensures proper field placement (root vs data object)`, '✨'),
+                    description: '✨ Create new content item',
                     inputSchema: {
                         type: 'object',
                         properties: {
                             type: {
                                 type: 'string',
-                                description: 'Content type to create (use qik_get_glossary to see all available types)',
+                                description: 'Content type to create',
                                 enum: Object.keys(this.glossary),
                             },
-                            title: {
-                                type: 'string',
-                                description: 'Content title (required for all content types)',
-                            },
-                            // Generate dynamic properties based on content types
-                            ...this.generateDynamicContentProperties(),
+                            title: { type: 'string', description: 'Content title' },
+                            data: { type: 'object', description: 'Content data fields' },
                             meta: {
                                 type: 'object',
-                                description: 'Meta information (scopes required for most content types)',
+                                description: 'Meta information (scopes required)',
                                 properties: {
                                     scopes: {
                                         type: 'array',
                                         items: { type: 'string' },
-                                        description: 'Scope IDs where this content should be stored (REQUIRED - use qik_get_scopes to find available)',
-                                    },
-                                    tags: {
-                                        type: 'array',
-                                        items: { type: 'string' },
-                                        description: 'Tag IDs for categorization and search',
-                                    },
-                                    security: {
-                                        type: 'string',
-                                        enum: ['public', 'secure', 'private'],
-                                        description: 'Security level: public (everyone), secure (authenticated), private (restricted)',
+                                        description: 'Scope IDs where content should be created',
                                     },
+                                    tags: { type: 'array', items: { type: 'string' } },
+                                    security: { type: 'string', enum: ['public', 'secure', 'private'] },
                                 },
                             },
                         },
@@ -1711,341 +367,32 @@ Use \`qik_get_content_definition\` with any of the type keys above to see their
                 },
                 {
                     name: 'qik_update_content',
-                    description: this.generateToolDescription('Update existing content item', '✏️'),
+                    description: '✏️ Update existing content item',
                     inputSchema: {
                         type: 'object',
                         properties: {
-                            id: {
-                                type: 'string',
-                                description: 'Content ID to update',
-                            },
-                            data: {
-                                type: 'object',
-                                description: 'Data to update (partial update)',
-                            },
-                            replace: {
-                                type: 'boolean',
-                                description: 'Whether to replace entire content (PUT) or merge (PATCH)',
-                                default: false,
-                            },
+                            id: { type: 'string', description: 'Content ID to update' },
+                            data: { type: 'object', description: 'Data to update' },
                         },
                         required: ['id', 'data'],
                     },
                 },
                 {
                     name: 'qik_delete_content',
-                    description: this.generateToolDescription('Delete content item', '🗑️'),
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            id: {
-                                type: 'string',
-                                description: 'Content ID to delete',
-                            },
-                        },
-                        required: ['id'],
-                    },
-                },
-                // Profile Management
-                {
-                    name: 'qik_list_profiles',
-                    description: this.generateToolDescription('Search and list profiles/people', '👥'),
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            search: {
-                                type: 'string',
-                                description: 'Search by name or email',
-                            },
-                            filter: {
-                                type: 'object',
-                                description: 'Filter criteria',
-                            },
-                            page: {
-                                type: 'object',
-                                properties: {
-                                    size: { type: 'number', minimum: 1, maximum: 100 },
-                                    index: { type: 'number', minimum: 1 },
-                                },
-                            },
-                        },
-                    },
-                },
-                {
-                    name: 'qik_create_profile',
-                    description: this.generateToolDescription('Create new profile/person', '👤'),
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            firstName: {
-                                type: 'string',
-                                description: 'First name',
-                            },
-                            lastName: {
-                                type: 'string',
-                                description: 'Last name',
-                            },
-                            emails: {
-                                type: 'array',
-                                items: { type: 'string' },
-                                description: 'Email addresses',
-                            },
-                            phoneNumbers: {
-                                type: 'array',
-                                items: {
-                                    type: 'object',
-                                    properties: {
-                                        label: { type: 'string' },
-                                        countryCode: { type: 'string' },
-                                        number: { type: 'string' },
-                                    },
-                                },
-                                description: 'Phone numbers',
-                            },
-                            data: {
-                                type: 'object',
-                                description: 'Additional profile data',
-                            },
-                            meta: {
-                                type: 'object',
-                                description: 'Meta information (scopes, tags, etc.)',
-                            },
-                        },
-                        required: ['firstName', 'lastName'],
-                    },
-                },
-                {
-                    name: 'qik_get_profile_timeline',
-                    description: this.generateToolDescription('Get a profile timeline with chronological activity data - provides much richer information than basic profile details including recent actions, content created, events attended, workflow activities, and other activity logs', '📅'),
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            id: {
-                                type: 'string',
-                                description: 'Profile ID to get timeline for',
-                            },
-                        },
-                        required: ['id'],
-                    },
-                },
-                {
-                    name: 'qik_get_profile_info',
-                    description: this.generateToolDescription('Intelligently get profile information with disambiguation between basic details and activity timeline. Asks clarifying questions when the request is ambiguous to provide the most relevant information', '🤔'),
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            query: {
-                                type: 'string',
-                                description: 'Natural language query about a person (e.g., "Tell me about Jeff", "What has John been up to?", "Get Sarah\'s contact info")',
-                            },
-                            profileId: {
-                                type: 'string',
-                                description: 'Profile ID if known (optional - can search by name if not provided)',
-                            },
-                            profileName: {
-                                type: 'string',
-                                description: 'Person\'s name to search for if ID not provided (optional)',
-                            },
-                            includeTimeline: {
-                                type: 'boolean',
-                                description: 'Whether to include timeline/activity data (optional - will be determined from query if not specified)',
-                            },
-                        },
-                        required: ['query'],
-                    },
-                },
-                // Form Management
-                {
-                    name: 'qik_get_form',
-                    description: this.generateToolDescription('Get form definition', '📝'),
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            id: {
-                                type: 'string',
-                                description: 'Form ID',
-                            },
-                        },
-                        required: ['id'],
-                    },
-                },
-                {
-                    name: 'qik_submit_form',
-                    description: this.generateToolDescription('Submit form data', '📤'),
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            id: {
-                                type: 'string',
-                                description: 'Form ID',
-                            },
-                            data: {
-                                type: 'object',
-                                description: 'Form submission data',
-                            },
-                        },
-                        required: ['id', 'data'],
-                    },
-                },
-                // File Management
-                {
-                    name: 'qik_upload_file',
-                    description: this.generateToolDescription('Upload file to platform', '📁'),
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            title: {
-                                type: 'string',
-                                description: 'File title',
-                            },
-                            fileData: {
-                                type: 'string',
-                                description: 'Base64 encoded file data',
-                            },
-                            fileName: {
-                                type: 'string',
-                                description: 'Original file name',
-                            },
-                            mimeType: {
-                                type: 'string',
-                                description: 'File MIME type',
-                            },
-                            meta: {
-                                type: 'object',
-                                description: 'Meta information (scopes, tags, etc.)',
-                            },
-                        },
-                        required: ['title', 'fileData', 'fileName'],
-                    },
-                },
-                // Search & Discovery
-                {
-                    name: 'qik_search_content',
-                    description: this.generateToolDescription('Global content search across all types', '🔎'),
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            query: {
-                                type: 'string',
-                                description: 'Search query',
-                            },
-                            types: {
-                                type: 'array',
-                                items: {
-                                    type: 'string',
-                                    enum: Object.keys(this.glossary),
-                                },
-                                description: 'Content types to search in',
-                            },
-                            limit: {
-                                type: 'number',
-                                minimum: 1,
-                                maximum: 100,
-                                default: 20,
-                            },
-                        },
-                        required: ['query'],
-                    },
-                },
-                {
-                    name: 'qik_get_scopes',
-                    description: this.generateToolDescription('Get available scopes/permissions tree', '🔐'),
-                    inputSchema: {
-                        type: 'object',
-                        properties: {},
-                    },
-                },
-                // Utility Tools
-                {
-                    name: 'qik_get_smartlist',
-                    description: this.generateToolDescription('Execute a smartlist query', '📊'),
+                    description: '🗑️ Delete content item',
                     inputSchema: {
                         type: 'object',
                         properties: {
-                            id: {
-                                type: 'string',
-                                description: 'Smartlist ID',
-                            },
+                            id: { type: 'string', description: 'Content ID to delete' },
                         },
                         required: ['id'],
                     },
                 },
-                // Intelligent Content Creation with Advanced Disambiguation
-                {
-                    name: 'qik_create_content_intelligent',
-                    description: this.generateToolDescription(`Intelligently create content with advanced disambiguation logic. 
-
-**WORKFLOW DISAMBIGUATION:**
-- "create a workflow" → Creates workflow DEFINITION (template)
-- "add Jim to workflow X" → Creates workflow CARD (instance)
-- "design student onboarding workflow" → Creates workflow DEFINITION
-- "assign Sarah to project workflow" → Creates workflow CARD
-
-**CONTENT TYPE DISAMBIGUATION:**
-- Automatically detects intent between definitions vs instances
-- Provides comprehensive guidance for workflow systems
-- Categorizes content types for better organization
-- Handles scope permissions and requirements
-
-**EXAMPLES:**
-- "create an incident report" → Finds incident report content type
-- "make a new workflow" → Guides through workflow definition creation
-- "add person to existing workflow" → Guides through workflow card creation
-- "design a student induction process" → Creates workflow definition
-
-**WORKFLOW CONCEPTS EXPLAINED:**
-- **Workflow Definition**: Template with columns, steps, automation rules
-- **Workflow Card**: Individual items that move through the workflow
-- **Columns**: Stages like "To Do", "In Progress", "Done"
-- **Steps**: Specific positions within columns
-- **Automation**: Entry/exit/success/fail functions`, '🧠'),
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            description: {
-                                type: 'string',
-                                description: 'Natural language description of what to create. Examples: "create an incident report", "make a new workflow", "add Jim to student workflow", "design onboarding process"',
-                            },
-                            title: {
-                                type: 'string',
-                                description: 'Title for the content (optional - will be requested if needed)',
-                            },
-                            data: {
-                                type: 'object',
-                                description: 'Content data fields (optional - will be guided through structure)',
-                            },
-                            meta: {
-                                type: 'object',
-                                description: 'Meta information including scopes, tags, security level (will be guided through requirements)',
-                                properties: {
-                                    scopes: {
-                                        type: 'array',
-                                        items: { type: 'string' },
-                                        description: 'Scope IDs where content should be created'
-                                    },
-                                    tags: {
-                                        type: 'array',
-                                        items: { type: 'string' },
-                                        description: 'Tag IDs for categorization'
-                                    },
-                                    security: {
-                                        type: 'string',
-                                        enum: ['public', 'secure', 'private'],
-                                        description: 'Security level for the content'
-                                    }
-                                }
-                            },
-                        },
-                        required: ['description'],
-                    },
-                },
             ];
             return { tools };
         });
         this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
             try {
-                // Ensure glossary is fresh
-                await this.loadGlossary();
                 switch (request.params.name) {
                     case 'qik_get_user_session':
                         return await this.getUserSession();
@@ -2053,7 +400,9 @@ Use \`qik_get_content_definition\` with any of the type keys above to see their
                         return await this.getGlossary();
                     case 'qik_get_content_definition':
                         return await this.getContentDefinition(request.params.arguments);
-                    case 'qik_get_content':
+                    case 'qik_get_scopes':
+                        return await this.getScopes();
+                    case 'qik_get_content':
                         return await this.getContent(request.params.arguments);
                     case 'qik_list_content':
                         return await this.listContent(request.params.arguments);
@@ -2063,32 +412,6 @@ Use \`qik_get_content_definition\` with any of the type keys above to see their
                         return await this.updateContent(request.params.arguments);
                     case 'qik_delete_content':
                         return await this.deleteContent(request.params.arguments);
-                    case 'qik_list_profiles':
-                        return await this.listProfiles(request.params.arguments);
-                    case 'qik_create_profile':
-                        return await this.createProfile(request.params.arguments);
-                    case 'qik_get_form':
-                        return await this.getForm(request.params.arguments);
-                    case 'qik_submit_form':
-                        return await this.submitForm(request.params.arguments);
-                    case 'qik_upload_file':
-                        return await this.uploadFile(request.params.arguments);
-                    case 'qik_search_content':
-                        return await this.searchContent(request.params.arguments);
-                    case 'qik_get_scopes':
-                        return await this.getScopes();
-                    case 'qik_get_smartlist':
-                        return await this.getSmartlist(request.params.arguments);
-                    case 'qik_get_profile_timeline':
-                        return await this.getProfileTimeline(request.params.arguments);
-                    case 'qik_get_profile_info':
-                        return await this.getProfileInfo(request.params.arguments);
-                    case 'qik_create_content_intelligent':
-                        return await this.intelligentContentCreation(request.params.arguments.description, {
-                            title: request.params.arguments.title,
-                            data: request.params.arguments.data,
-                            meta: request.params.arguments.meta,
-                        });
                     default:
                         throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${request.params.name}`);
                 }
@@ -2096,34 +419,7 @@ Use \`qik_get_content_definition\` with any of the type keys above to see their
             catch (error) {
                 this.log(`Error in ${request.params.name}: ${this.formatError(error)}`);
                 if (axios.isAxiosError(error)) {
-                    const axiosError = error;
-                    if (axiosError.response?.status === 401) {
-                        return {
-                            content: [{
-                                    type: 'text',
-                                    text: 'Authentication failed. Please check your access token configuration.',
-                                }],
-                            isError: true,
-                        };
-                    }
-                    else if (axiosError.response?.status === 403) {
-                        return {
-                            content: [{
-                                    type: 'text',
-                                    text: 'Access denied. Your token may not have permission for this operation.',
-                                }],
-                            isError: true,
-                        };
-                    }
-                    else if (axiosError.response?.status === 429) {
-                        return {
-                            content: [{
-                                    type: 'text',
-                                    text: 'Rate limit exceeded. Please try again later.',
-                                }],
-                            isError: true,
-                        };
-                    }
+                    return await this.handleApiError(error, request.params.name, request.params.arguments);
                 }
                 return {
                     content: [{
@@ -2135,7 +431,7 @@ Use \`qik_get_content_definition\` with any of the type keys above to see their
             }
         });
     }
-    // Enhanced tool implementations
+    // Simplified tool implementations - let API handle validation
     async getUserSession() {
         if (!this.userSession) {
             await this.loadUserSession();
@@ -2148,102 +444,33 @@ Use \`qik_get_content_definition\` with any of the type keys above to see their
         };
     }
     async getGlossary() {
-        await this.loadGlossary(true); // Force refresh
-        // Create a clean list of all content types with their proper titles and descriptions
-        const contentTypes = Object.entries(this.glossary).map(([key, contentType]) => {
-            let title = 'Unknown';
-            let plural = 'Unknown';
-            let description = '';
-            let fieldCount = 0;
-            let baseType = null;
-            let fields = [];
-            if (contentType && typeof contentType === 'object') {
-                // Handle direct properties on contentType (most common structure)
-                if (contentType.title) {
-                    title = contentType.title;
-                    plural = contentType.plural || title + 's';
-                    description = contentType.description || '';
-                    fields = contentType.fields || [];
-                    baseType = contentType.definesType;
-                }
-                // Handle nested definition structure
-                else if (contentType.definition) {
-                    title = contentType.definition.title || title;
-                    plural = contentType.definition.plural || title + 's';
-                    description = contentType.definition.description || '';
-                    fields = contentType.definition.fields || [];
-                    baseType = contentType.definition.definesType;
-                }
-                // Handle nested type structure
-                else if (contentType.type) {
-                    title = contentType.type.title || title;
-                    plural = contentType.type.plural || title + 's';
-                    description = contentType.type.description || '';
-                    fields = contentType.type.fields || [];
-                }
-                fieldCount = fields.length;
-            }
-            return {
-                key,
-                title,
-                plural,
-                description,
-                fieldCount,
-                baseType,
-                isExtension: baseType && baseType !== key,
-                fields: fields.map(f => ({
-                    key: f.key,
-                    title: f.title,
-                    type: f.type,
-                    required: this.isFieldRequired(f),
-                    description: f.description || ''
-                }))
-            };
-        });
-        // Sort alphabetically by title for easy reading
-        const sortedTypes = contentTypes.sort((a, b) => a.title.localeCompare(b.title));
-        // Create a summary that clearly shows each type is unique
-        const typesList = sortedTypes.map(type => {
-            let typeDescription = `${type.key}: ${type.title}`;
-            if (type.isExtension && type.baseType) {
-                typeDescription += ` (extends ${type.baseType})`;
-            }
-            if (type.plural !== type.title + 's') {
-                typeDescription += ` - plural: ${type.plural}`;
-            }
-            if (type.fieldCount > 0) {
-                typeDescription += ` - ${type.fieldCount} fields`;
-            }
-            return typeDescription;
-        });
+        await this.loadGlossary();
+        const contentTypes = Object.entries(this.glossary).map(([key, type]) => ({
+            key,
+            title: type.title,
+            plural: type.plural,
+            description: type.description,
+            fieldCount: type.fields?.length || 0,
+        }));
         return {
             content: [{
                     type: 'text',
                     text: `Available Content Types (${contentTypes.length} total):
 
-${typesList.join('\n')}
-
-Each content type above is unique and can be used for content creation. Extended types (those that show "extends X") are specialized versions of base types with their own specific fields and purposes.
-
-For detailed field information about any content type, use qik_get_content_definition with the type key.
+${contentTypes.map(t => `${t.key}: ${t.title} (${t.fieldCount} fields)`).join('\n')}
 
 Full glossary data:
-${JSON.stringify({
-                        contentTypes: sortedTypes,
-                        totalTypes: contentTypes.length,
-                        extensionTypes: contentTypes.filter(t => t.isExtension).length,
-                        baseTypes: contentTypes.filter(t => !t.isExtension).length
-                    }, null, 2)}`,
+${JSON.stringify(this.glossary, null, 2)}`,
                 }],
         };
     }
     async getContentDefinition(args) {
-        const validation = this.validateContentType(args.type);
-        if (!validation.valid) {
+        if (!this.glossary[args.type]) {
+            const available = Object.keys(this.glossary).join(', ');
             return {
                 content: [{
                         type: 'text',
-                        text: validation.error,
+                        text: `Content type '${args.type}' not found. Available types: ${available}`,
                     }],
                 isError: true,
             };
@@ -2258,18 +485,32 @@ ${JSON.stringify({
             };
         }
         catch (error) {
+            if (axios.isAxiosError(error)) {
+                return await this.handleApiError(error, 'get content definition', args);
+            }
+            throw error;
+        }
+    }
+    async getScopes() {
+        try {
+            const response = await this.axiosInstance.get('/scope/tree');
             return {
                 content: [{
                         type: 'text',
-                        text: `Failed to fetch definition for '${args.type}': ${this.formatError(error)}`,
+                        text: JSON.stringify(response.data, null, 2),
                     }],
-                isError: true,
             };
         }
+        catch (error) {
+            if (axios.isAxiosError(error)) {
+                return await this.handleApiError(error, 'get scopes', {});
+            }
+            throw error;
+        }
     }
     async getContent(args) {
-        let response;
         try {
+            let response;
             if (args.id) {
                 response = await this.axiosInstance.get(`/content/${args.id}`);
             }
@@ -2287,23 +528,19 @@ ${JSON.stringify({
             };
         }
         catch (error) {
-            const identifier = args.id || args.slug;
-            return {
-                content: [{
-                        type: 'text',
-                        text: `Failed to fetch content '${identifier}': ${this.formatError(error)}`,
-                    }],
-                isError: true,
-            };
+            if (axios.isAxiosError(error)) {
+                return await this.handleApiError(error, 'get content', args);
+            }
+            throw error;
         }
     }
     async listContent(args) {
-        const validation = this.validateContentType(args.type);
-        if (!validation.valid) {
+        if (!this.glossary[args.type]) {
+            const available = Object.keys(this.glossary).join(', ');
             return {
                 content: [{
                         type: 'text',
-                        text: validation.error,
+                        text: `Content type '${args.type}' not found. Available types: ${available}`,
                     }],
                 isError: true,
             };
@@ -2312,9 +549,7 @@ ${JSON.stringify({
             const response = await this.axiosInstance.post(`/content/${args.type}/list`, {
                 search: args.search || '',
                 filter: args.filter || {},
-                sort: args.sort || { key: 'meta.created', direction: 'desc', type: 'date' },
                 page: args.page || { size: 20, index: 1 },
-                select: args.select || [],
             });
             return {
                 content: [{
@@ -2324,109 +559,58 @@ ${JSON.stringify({
             };
         }
         catch (error) {
-            return {
-                content: [{
-                        type: 'text',
-                        text: `Failed to list ${args.type} content: ${this.formatError(error)}`,
-                    }],
-                isError: true,
-            };
+            if (axios.isAxiosError(error)) {
+                return await this.handleApiError(error, 'list content', args);
+            }
+            throw error;
         }
     }
     async createContent(args) {
-        const validation = this.validateContentType(args.type);
-        if (!validation.valid) {
+        if (!this.glossary[args.type]) {
+            const available = Object.keys(this.glossary).join(', ');
             return {
                 content: [{
                         type: 'text',
-                        text: validation.error,
+                        text: `Content type '${args.type}' not found. Available types: ${available}`,
                     }],
                 isError: true,
             };
         }
         try {
-            // 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 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
-                    const referencedItem = await this.axiosInstance.get(`/content/${payload.reference}`);
-                    if (referencedItem.data && referencedItem.data.meta && referencedItem.data.meta.scopes) {
-                        if (!payload.meta)
-                            payload.meta = {};
-                        payload.meta.scopes = referencedItem.data.meta.scopes;
-                        this.log(`Inherited scopes from referenced item ${payload.reference}: ${payload.meta.scopes.join(', ')}`);
-                    }
-                }
-                catch (error) {
-                    this.log(`Failed to fetch referenced item ${payload.reference} for scope inheritance: ${this.formatError(error)}`);
-                    // Continue without scope inheritance if we can't fetch the referenced item
-                }
-            }
-            const response = await this.axiosInstance.post(`/content/${args.type}/create`, payload);
+            const response = await this.axiosInstance.post(`/content/${args.type}/create`, args);
             return {
                 content: [{
                         type: 'text',
-                        text: `✅ **SUCCESSFULLY CREATED ${args.type.toUpperCase()} CONTENT**
+                        text: `✅ Successfully created ${args.type}:
 
-**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)}
-
-💡 **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,
-            };
+            if (axios.isAxiosError(error)) {
+                return await this.handleApiError(error, 'create content', args);
+            }
+            throw error;
         }
     }
     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}`, updateData);
+            const response = await this.axiosInstance.patch(`/content/${args.id}`, args.data);
             return {
                 content: [{
                         type: 'text',
-                        text: `✅ **SUCCESSFULLY UPDATED CONTENT**
+                        text: `✅ Successfully updated content:
 
-**Updated Content:**
 ${JSON.stringify(response.data, null, 2)}`,
                     }],
             };
         }
         catch (error) {
-            return {
-                content: [{
-                        type: 'text',
-                        text: `Failed to update content ${args.id}: ${this.formatError(error)}`,
-                    }],
-                isError: true,
-            };
+            if (axios.isAxiosError(error)) {
+                return await this.handleApiError(error, 'update content', args);
+            }
+            throw error;
         }
     }
     async deleteContent(args) {
@@ -2435,771 +619,24 @@ ${JSON.stringify(response.data, null, 2)}`,
             return {
                 content: [{
                         type: 'text',
-                        text: `Content ${args.id} deleted successfully`,
-                    }],
-            };
-        }
-        catch (error) {
-            return {
-                content: [{
-                        type: 'text',
-                        text: `Failed to delete content ${args.id}: ${this.formatError(error)}`,
-                    }],
-                isError: true,
-            };
-        }
-    }
-    async listProfiles(args) {
-        try {
-            const response = await this.axiosInstance.post('/content/profile/list', {
-                search: args.search || '',
-                filter: args.filter || {},
-                page: args.page || { size: 20, index: 1 },
-            });
-            return {
-                content: [{
-                        type: 'text',
-                        text: JSON.stringify(response.data, null, 2),
-                    }],
-            };
-        }
-        catch (error) {
-            return {
-                content: [{
-                        type: 'text',
-                        text: `Failed to list profiles: ${this.formatError(error)}`,
-                    }],
-                isError: true,
-            };
-        }
-    }
-    async createProfile(args) {
-        const payload = {
-            firstName: args.firstName,
-            lastName: args.lastName,
-            emails: args.emails || [],
-            phoneNumbers: args.phoneNumbers || [],
-            data: args.data || {},
-            meta: args.meta || {},
-        };
-        try {
-            const response = await this.axiosInstance.post('/content/profile/create', payload);
-            return {
-                content: [{
-                        type: 'text',
-                        text: JSON.stringify(response.data, null, 2),
-                    }],
-            };
-        }
-        catch (error) {
-            return {
-                content: [{
-                        type: 'text',
-                        text: `Failed to create profile: ${this.formatError(error)}`,
-                    }],
-                isError: true,
-            };
-        }
-    }
-    async getProfileTimeline(args) {
-        try {
-            const response = await this.axiosInstance.get(`/profile/${args.id}/timeline`);
-            return {
-                content: [{
-                        type: 'text',
-                        text: `📅 **PROFILE TIMELINE FOR ${args.id}**
-
-This timeline provides chronological activity data including recent actions, content created, events attended, workflow activities, and other activity logs.
-
-**Timeline Data:**
-${JSON.stringify(response.data, null, 2)}`,
-                    }],
-            };
-        }
-        catch (error) {
-            return {
-                content: [{
-                        type: 'text',
-                        text: `Failed to get profile timeline for ${args.id}: ${this.formatError(error)}`,
-                    }],
-                isError: true,
-            };
-        }
-    }
-    async getProfileInfo(args) {
-        const normalizedQuery = args.query.toLowerCase().trim();
-        // Analyze the query to determine intent
-        const timelineKeywords = [
-            'activity', 'timeline', 'been up to', 'doing', 'recent', 'lately',
-            'actions', 'history', 'events', 'workflow', 'progress'
-        ];
-        const basicInfoKeywords = [
-            'contact', 'email', 'phone', 'details', 'information', 'about'
-        ];
-        const wantsTimeline = args.includeTimeline !== undefined
-            ? args.includeTimeline
-            : timelineKeywords.some(keyword => normalizedQuery.includes(keyword));
-        const wantsBasicInfo = basicInfoKeywords.some(keyword => normalizedQuery.includes(keyword));
-        // If the intent is ambiguous, ask for clarification
-        if (!wantsTimeline && !wantsBasicInfo && args.includeTimeline === undefined) {
-            const personName = args.profileName || (args.profileId ? `person (ID: ${args.profileId})` : 'this person');
-            return {
-                content: [{
-                        type: 'text',
-                        text: `🤔 **CLARIFICATION NEEDED**
-
-You asked: "${args.query}"
-
-I can provide different types of information about ${personName}:
-
-**OPTION 1: Basic Profile Details** 📋
-- Contact information (email, phone)
-- Basic demographic data
-- Profile fields and custom data
-→ Use: \`qik_get_content\` or \`qik_list_profiles\`
-
-**OPTION 2: Activity Timeline** 📅  
-- Recent actions and activities
-- Content they've created or been involved with
-- Workflow progress and events attended
-- Much richer, more colorful activity data
-→ Use: \`qik_get_profile_timeline\`
-
-**Which would be more helpful for your needs?**
-
-To get both, you can:
-1. First get basic profile info with \`qik_list_profiles\` (search by name)
-2. Then get timeline data with \`qik_get_profile_timeline\` (using the profile ID)`,
-                    }],
-            };
-        }
-        let profileId = args.profileId;
-        // If no profile ID provided, try to find the profile by name
-        if (!profileId && args.profileName) {
-            try {
-                const searchResponse = await this.axiosInstance.post('/content/profile/list', {
-                    search: args.profileName,
-                    page: { size: 5, index: 1 },
-                });
-                if (searchResponse.data.items && searchResponse.data.items.length > 0) {
-                    if (searchResponse.data.items.length === 1) {
-                        profileId = searchResponse.data.items[0]._id;
-                    }
-                    else {
-                        // Multiple matches found
-                        const matches = searchResponse.data.items.map((p) => `- **${p._id}**: ${p.firstName} ${p.lastName} (${p.emails?.[0] || 'no email'})`).join('\n');
-                        return {
-                            content: [{
-                                    type: 'text',
-                                    text: `🔍 **MULTIPLE PROFILES FOUND**
-
-Found ${searchResponse.data.items.length} profiles matching "${args.profileName}":
-
-${matches}
-
-Please specify which profile you want by using the profile ID with \`qik_get_profile_timeline\` or \`qik_get_content\`.`,
-                                }],
-                        };
-                    }
-                }
-                else {
-                    return {
-                        content: [{
-                                type: 'text',
-                                text: `❌ **PROFILE NOT FOUND**
-
-No profiles found matching "${args.profileName}". 
-
-Try:
-- Using \`qik_list_profiles\` with a broader search
-- Checking the spelling of the name
-- Using the exact profile ID if you have it`,
-                            }],
-                        isError: true,
-                    };
-                }
-            }
-            catch (error) {
-                return {
-                    content: [{
-                            type: 'text',
-                            text: `Failed to search for profile "${args.profileName}": ${this.formatError(error)}`,
-                        }],
-                    isError: true,
-                };
-            }
-        }
-        // Now we have a profile ID, get the appropriate information
-        if (wantsTimeline && profileId) {
-            return await this.getProfileTimeline({ id: profileId });
-        }
-        else if (profileId) {
-            // Get basic profile information
-            try {
-                const response = await this.axiosInstance.get(`/content/${profileId}`);
-                return {
-                    content: [{
-                            type: 'text',
-                            text: `👤 **PROFILE INFORMATION**
-
-**Basic Details:**
-${JSON.stringify(response.data, null, 2)}
-
-💡 **Want more activity details?** Use \`qik_get_profile_timeline\` with ID: ${profileId} to see their recent activities, workflow progress, and timeline data.`,
-                        }],
-                };
-            }
-            catch (error) {
-                return {
-                    content: [{
-                            type: 'text',
-                            text: `Failed to get profile information for ${profileId}: ${this.formatError(error)}`,
-                        }],
-                    isError: true,
-                };
-            }
-        }
-        else {
-            return {
-                content: [{
-                        type: 'text',
-                        text: `❌ **MISSING PROFILE IDENTIFIER**
-
-To get profile information, I need either:
-- **profileId**: The exact profile ID
-- **profileName**: The person's name to search for
-
-Please provide one of these and try again.`,
-                    }],
-                isError: true,
-            };
-        }
-    }
-    async getForm(args) {
-        try {
-            const response = await this.axiosInstance.get(`/form/${args.id}`);
-            return {
-                content: [{
-                        type: 'text',
-                        text: JSON.stringify(response.data, null, 2),
-                    }],
-            };
-        }
-        catch (error) {
-            return {
-                content: [{
-                        type: 'text',
-                        text: `Failed to get form ${args.id}: ${this.formatError(error)}`,
-                    }],
-                isError: true,
-            };
-        }
-    }
-    async submitForm(args) {
-        try {
-            const response = await this.axiosInstance.post(`/form/${args.id}`, args.data);
-            return {
-                content: [{
-                        type: 'text',
-                        text: JSON.stringify(response.data, null, 2),
-                    }],
-            };
-        }
-        catch (error) {
-            return {
-                content: [{
-                        type: 'text',
-                        text: `Failed to submit form ${args.id}: ${this.formatError(error)}`,
-                    }],
-                isError: true,
-            };
-        }
-    }
-    async uploadFile(args) {
-        try {
-            const formData = new FormData();
-            // Convert base64 to buffer
-            const fileBuffer = Buffer.from(args.fileData, 'base64');
-            formData.append('file', fileBuffer, args.fileName);
-            const jsonData = {
-                title: args.title,
-                meta: args.meta || {},
-            };
-            formData.append('json', JSON.stringify(jsonData));
-            const response = await this.axiosInstance.post('/file/upload', formData, {
-                headers: {
-                    ...formData.getHeaders(),
-                    'Authorization': `Bearer ${QIK_ACCESS_TOKEN}`,
-                },
-            });
-            return {
-                content: [{
-                        type: 'text',
-                        text: JSON.stringify(response.data, null, 2),
+                        text: `✅ Successfully deleted content ${args.id}`,
                     }],
             };
         }
         catch (error) {
-            return {
-                content: [{
-                        type: 'text',
-                        text: `Failed to upload file: ${this.formatError(error)}`,
-                    }],
-                isError: true,
-            };
-        }
-    }
-    async searchContent(args) {
-        const results = [];
-        const types = args.types || Object.keys(this.glossary);
-        // Limit to 5 types to avoid too many requests
-        for (const type of types.slice(0, 5)) {
-            try {
-                const response = await this.axiosInstance.post(`/content/${type}/list`, {
-                    search: args.query,
-                    page: { size: args.limit || 20, index: 1 },
-                });
-                if (response.data.items && response.data.items.length > 0) {
-                    results.push({
-                        type,
-                        items: response.data.items,
-                        total: response.data.total,
-                    });
-                }
+            if (axios.isAxiosError(error)) {
+                return await this.handleApiError(error, 'delete content', args);
             }
-            catch (error) {
-                // Skip types that error (might not exist or no permission)
-                continue;
-            }
-        }
-        return {
-            content: [{
-                    type: 'text',
-                    text: JSON.stringify(results, null, 2),
-                }],
-        };
-    }
-    async getScopes() {
-        try {
-            const response = await this.axiosInstance.get('/scope/tree');
-            return {
-                content: [{
-                        type: 'text',
-                        text: JSON.stringify(response.data, null, 2),
-                    }],
-            };
-        }
-        catch (error) {
-            return {
-                content: [{
-                        type: 'text',
-                        text: `Failed to get scopes: ${this.formatError(error)}`,
-                    }],
-                isError: true,
-            };
-        }
-    }
-    async getSmartlist(args) {
-        try {
-            const response = await this.axiosInstance.get(`/smartlist/${args.id}`);
-            return {
-                content: [{
-                        type: 'text',
-                        text: JSON.stringify(response.data, null, 2),
-                    }],
-            };
-        }
-        catch (error) {
-            return {
-                content: [{
-                        type: 'text',
-                        text: `Failed to get smartlist ${args.id}: ${this.formatError(error)}`,
-                    }],
-                isError: true,
-            };
-        }
-    }
-    // Documentation-focused tool implementations
-    async getDocumentation(args) {
-        try {
-            const documentation = QikDocumentationHelper.getTopicDocumentation(args.topic);
-            if (!documentation) {
-                return {
-                    content: [{
-                            type: 'text',
-                            text: `❌ **DOCUMENTATION NOT FOUND**
-
-No documentation found for topic: "${args.topic}"
-
-**Available topics:**
-- authentication (token types, methods, error codes)
-- endpoints (API endpoint documentation)
-- contentTypes (content type specific guidance)
-- filterSyntax (filter operators and comparators)
-- concepts (key concepts like field placement, scopes, workflows)
-- examples (code examples for common use cases)
-- troubleshooting (error resolution guides)
-
-**Example usage:**
-- \`qik_get_documentation\` with topic: "concepts.field_placement"
-- \`qik_get_documentation\` with topic: "authentication.tokenTypes"
-- \`qik_get_documentation\` with topic: "troubleshooting.field_placement_errors"`,
-                        }],
-                    isError: true,
-                };
-            }
-            let result = `📖 **DOCUMENTATION: ${args.topic.toUpperCase()}**\n\n`;
-            if (args.subtopic && documentation[args.subtopic]) {
-                result += `**Subtopic: ${args.subtopic}**\n\n`;
-                result += JSON.stringify(documentation[args.subtopic], null, 2);
-            }
-            else {
-                result += JSON.stringify(documentation, null, 2);
-            }
-            return {
-                content: [{
-                        type: 'text',
-                        text: result,
-                    }],
-            };
-        }
-        catch (error) {
-            return {
-                content: [{
-                        type: 'text',
-                        text: `Failed to get documentation for ${args.topic}: ${this.formatError(error)}`,
-                    }],
-                isError: true,
-            };
-        }
-    }
-    async searchDocumentation(args) {
-        try {
-            const results = QikDocumentationHelper.searchDocumentation(args.query);
-            const limit = args.limit || 10;
-            const limitedResults = results.slice(0, limit);
-            if (limitedResults.length === 0) {
-                return {
-                    content: [{
-                            type: 'text',
-                            text: `🔍 **NO DOCUMENTATION FOUND**
-
-No documentation found for query: "${args.query}"
-
-**Try searching for:**
-- "field placement" - for field structure guidance
-- "authentication" - for token and auth help
-- "filter" - for filtering and query syntax
-- "workflow" - for workflow system concepts
-- "birthday" - for anniversary/birthday queries
-- "scope" - for permission and scope guidance
-- "troubleshooting" - for error resolution
-
-**Available documentation sections:**
-- Authentication & Tokens
-- API Endpoints
-- Content Types
-- Filter Syntax
-- Core Concepts
-- Code Examples
-- Troubleshooting Guides`,
-                        }],
-                };
-            }
-            let result = `🔍 **DOCUMENTATION SEARCH RESULTS**\n\n`;
-            result += `Found ${limitedResults.length} results for "${args.query}":\n\n`;
-            limitedResults.forEach((item, index) => {
-                result += `**${index + 1}. ${item.path}** (${item.type})\n`;
-                if (typeof item.content === 'string') {
-                    const preview = item.content.length > 200
-                        ? item.content.substring(0, 200) + '...'
-                        : item.content;
-                    result += `${preview}\n\n`;
-                }
-                else {
-                    result += `${JSON.stringify(item.content).substring(0, 200)}...\n\n`;
-                }
-            });
-            result += `💡 **Need more specific help?** Use \`qik_get_documentation\` with a specific topic for detailed information.`;
-            return {
-                content: [{
-                        type: 'text',
-                        text: result,
-                    }],
-            };
-        }
-        catch (error) {
-            return {
-                content: [{
-                        type: 'text',
-                        text: `Failed to search documentation: ${this.formatError(error)}`,
-                    }],
-                isError: true,
-            };
-        }
-    }
-    async getTroubleshooting(args) {
-        try {
-            let troubleshootingInfo;
-            if (args.issueType) {
-                // Get specific issue type
-                troubleshootingInfo = QIK_DOCUMENTATION.troubleshooting[args.issueType];
-                if (troubleshootingInfo) {
-                    troubleshootingInfo = { issue: args.issueType, ...troubleshootingInfo };
-                }
-            }
-            else {
-                // Auto-detect issue type from error message
-                troubleshootingInfo = QikDocumentationHelper.getTroubleshootingInfo(args.errorMessage);
-            }
-            if (!troubleshootingInfo) {
-                return {
-                    content: [{
-                            type: 'text',
-                            text: `🔧 **NO SPECIFIC TROUBLESHOOTING FOUND**
-
-I couldn't find specific troubleshooting information for: "${args.errorMessage}"
-
-**Available troubleshooting categories:**
-- **field_placement_errors**: Field structure and placement issues
-- **authentication_failures**: Token and permission problems
-- **filter_syntax_errors**: Query and filter syntax issues
-- **scope_permission_issues**: Access and permission problems
-- **workflow_confusion**: Workflow definition vs card confusion
-- **date_handling_issues**: Date format and timezone problems
-- **performance_issues**: Slow queries and optimization
-
-**General troubleshooting steps:**
-1. Check the error message for specific field names or codes
-2. Verify your access token and permissions
-3. Ensure proper field placement (root vs data object)
-4. Validate filter syntax and comparators
-5. Check scope permissions and hierarchy
-
-**Need more help?** Try:
-- \`qik_search_documentation\` with keywords from your error
-- \`qik_get_documentation\` with topic: "troubleshooting"
-- \`qik_validate_field_placement\` for content creation issues`,
-                        }],
-                };
-            }
-            let result = `🔧 **TROUBLESHOOTING: ${troubleshootingInfo.issue.toUpperCase().replace(/_/g, ' ')}**\n\n`;
-            result += `**Your Error:** "${args.errorMessage}"\n\n`;
-            if (troubleshootingInfo.symptoms && troubleshootingInfo.symptoms.length > 0) {
-                result += `**Common Symptoms:**\n`;
-                result += troubleshootingInfo.symptoms.map((s) => `- ${s}`).join('\n');
-                result += '\n\n';
-            }
-            if (troubleshootingInfo.causes && troubleshootingInfo.causes.length > 0) {
-                result += `**Likely Causes:**\n`;
-                result += troubleshootingInfo.causes.map((c) => `- ${c}`).join('\n');
-                result += '\n\n';
-            }
-            if (troubleshootingInfo.solutions && troubleshootingInfo.solutions.length > 0) {
-                result += `**Solutions:**\n`;
-                result += troubleshootingInfo.solutions.map((s) => `- ${s}`).join('\n');
-                result += '\n\n';
-            }
-            if (troubleshootingInfo.prevention && troubleshootingInfo.prevention.length > 0) {
-                result += `**Prevention:**\n`;
-                result += troubleshootingInfo.prevention.map((p) => `- ${p}`).join('\n');
-                result += '\n\n';
-            }
-            if (troubleshootingInfo.relatedIssues && troubleshootingInfo.relatedIssues.length > 0) {
-                result += `**Related Issues:**\n`;
-                result += troubleshootingInfo.relatedIssues.map((r) => `- ${r}`).join('\n');
-            }
-            return {
-                content: [{
-                        type: 'text',
-                        text: result,
-                    }],
-            };
-        }
-        catch (error) {
-            return {
-                content: [{
-                        type: 'text',
-                        text: `Failed to get troubleshooting information: ${this.formatError(error)}`,
-                    }],
-                isError: true,
-            };
-        }
-    }
-    async getExamples(args) {
-        try {
-            if (args.category === 'all') {
-                let result = `💡 **ALL CODE EXAMPLES**\n\n`;
-                for (const [category, examples] of Object.entries(QIK_DOCUMENTATION.examples)) {
-                    result += `## ${category.toUpperCase()}\n\n`;
-                    for (const [exampleKey, example] of Object.entries(examples)) {
-                        const typedExample = example;
-                        result += `### ${typedExample.title}\n`;
-                        result += `${typedExample.description}\n\n`;
-                        result += `\`\`\`json\n${JSON.stringify(typedExample.code, null, 2)}\n\`\`\`\n\n`;
-                        result += `**Explanation:** ${typedExample.explanation}\n\n`;
-                        if (typedExample.variations && typedExample.variations.length > 0) {
-                            result += `**Variations:**\n`;
-                            typedExample.variations.forEach((variation) => {
-                                result += `- ${variation.description}\n`;
-                                result += `  \`\`\`json\n  ${JSON.stringify(variation.code, null, 2)}\n  \`\`\`\n`;
-                            });
-                            result += '\n';
-                        }
-                    }
-                }
-                return {
-                    content: [{
-                            type: 'text',
-                            text: result,
-                        }],
-                };
-            }
-            const examples = QikDocumentationHelper.getExamples(args.category, args.example);
-            if (!examples) {
-                return {
-                    content: [{
-                            type: 'text',
-                            text: `💡 **NO EXAMPLES FOUND**
-
-No examples found for category: "${args.category}"
-
-**Available example categories:**
-- **authentication**: Token usage and auth examples
-- **content_creation**: Creating different content types
-- **filtering**: Advanced filtering and search examples
-
-**Example usage:**
-- \`qik_get_examples\` with category: "authentication"
-- \`qik_get_examples\` with category: "filtering" and example: "birthday_search"
-- \`qik_get_examples\` with category: "all" (shows all examples)`,
-                        }],
-                    isError: true,
-                };
-            }
-            let result = `💡 **CODE EXAMPLES: ${args.category.toUpperCase()}**\n\n`;
-            if (args.example && examples[args.example]) {
-                // Show specific example
-                const example = examples[args.example];
-                result += `### ${example.title}\n`;
-                result += `${example.description}\n\n`;
-                result += `\`\`\`json\n${JSON.stringify(example.code, null, 2)}\n\`\`\`\n\n`;
-                result += `**Explanation:** ${example.explanation}\n\n`;
-                if (example.variations && example.variations.length > 0) {
-                    result += `**Variations:**\n`;
-                    example.variations.forEach((variation) => {
-                        result += `- ${variation.description}\n`;
-                        result += `  \`\`\`json\n  ${JSON.stringify(variation.code, null, 2)}\n  \`\`\`\n`;
-                    });
-                }
-            }
-            else {
-                // Show all examples in category
-                for (const [exampleKey, example] of Object.entries(examples)) {
-                    const typedExample = example;
-                    result += `### ${typedExample.title}\n`;
-                    result += `${typedExample.description}\n\n`;
-                    result += `\`\`\`json\n${JSON.stringify(typedExample.code, null, 2)}\n\`\`\`\n\n`;
-                    result += `**Explanation:** ${typedExample.explanation}\n\n`;
-                    if (typedExample.variations && typedExample.variations.length > 0) {
-                        result += `**Variations:**\n`;
-                        typedExample.variations.forEach((variation) => {
-                            result += `- ${variation.description}\n`;
-                            result += `  \`\`\`json\n  ${JSON.stringify(variation.code, null, 2)}\n  \`\`\`\n`;
-                        });
-                        result += '\n';
-                    }
-                }
-            }
-            return {
-                content: [{
-                        type: 'text',
-                        text: result,
-                    }],
-            };
-        }
-        catch (error) {
-            return {
-                content: [{
-                        type: 'text',
-                        text: `Failed to get examples: ${this.formatError(error)}`,
-                    }],
-                isError: true,
-            };
-        }
-    }
-    async validateFieldPlacement(args) {
-        try {
-            const validation = this.validateContentType(args.contentType);
-            if (!validation.valid) {
-                return {
-                    content: [{
-                            type: 'text',
-                            text: validation.error,
-                        }],
-                    isError: true,
-                };
-            }
-            // Simplified validation using documentation helper only
-            const docValidation = QikDocumentationHelper.validateFieldPlacement(args.contentType, args.payload);
-            let result = `✅ **FIELD PLACEMENT VALIDATION: ${args.contentType.toUpperCase()}**\n\n`;
-            if (docValidation.valid) {
-                result += `🎉 **VALIDATION PASSED**\n\n`;
-                result += `Your payload has correct field placement!\n\n`;
-                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`;
-            }
-            else {
-                result += `❌ **VALIDATION FAILED**\n\n`;
-                if (docValidation.errors && docValidation.errors.length > 0) {
-                    result += `**Errors Found:**\n`;
-                    docValidation.errors.forEach(error => {
-                        result += `- ${error}\n`;
-                    });
-                    result += '\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: !docValidation.valid,
-            };
-        }
-        catch (error) {
-            return {
-                content: [{
-                        type: 'text',
-                        text: `Failed to validate field placement: ${this.formatError(error)}`,
-                    }],
-                isError: true,
-            };
+            throw error;
         }
     }
     async run() {
         const transport = new StdioServerTransport();
         await this.server.connect(transport);
-        this.log('Qik MCP server running on stdio');
+        this.log('Simplified Qik MCP server running on stdio');
     }
 }
-// Only run the server if this file is executed directly (not imported)
+// Only run the server if this file is executed directly
 if (import.meta.url === `file://${process.argv[1]}`) {
     const server = new QikMCPServer();
     server.run().catch(console.error);