@resolveio/server-lib 22.3.221 → 22.3.222

package/src/methods/report-builder.ts

@@ -1,3300 +0,0 @@
-import SimpleSchema from 'simpl-schema';
-import { ReportBuilderReports } from '../collections/report-builder-report.collection';
-import { Users } from '../collections/user.collection';
-import { MethodManager } from '../managers/method.manager';
-import { recordOpenAIUsage } from '../managers/openai-usage-ledger.manager';
-import { PaginationOptions, PaginationOptionsSchema } from '../models/pagination.model';
-import { ReportBuilderCollectionJoin } from '../models/report-builder-report.model';
-import { ResolveIOServer } from '../resolveio-server-app';
-import { CodexClient, CodexConfig, CodexRunOptions, CodexThreadOptions } from '../services/codex-client';
-import { deepCopy, round, toTitleCase } from '../util/common';
-import { applyLinkFieldUnwinds, ensureLookupLocalKeyUnwinds, normalizeLookupField } from '../util/report-builder-unwinds';
-import { buildTree, getReportLookupSchemas, mongoCommand } from '../util/schema-report-builder';
-import { countChatTokens, countTokens } from '../util/tokenizer';
-import { executeAiAssistantMongoRead, AiAssistantMongoReadInput } from './ai-terminal';
-
-const DEFAULT_REPORT_BUILDER_CODEX_TIMEOUT_MS = 60000;
-
-let reportBuilderCodexClient: CodexClient | null = null;
-
-export function loadReportBuilderMethods(methodManager: MethodManager) {
-	methodManager.methods({
-		reportBuilderAiSuggest: {
-			check: new SimpleSchema({
-				payload: {
-					type: Object,
-					blackbox: true
-				}
-			}),
-			function: async function(payload: any) {
-				return await executeReportBuilderAi(payload || {}, this);
-			}
-		},
-		reportbuilderreportWithId: {
-			check: new SimpleSchema({
-				id: {
-					type: String
-				}
-			}),
-			function: function(id: string) {
-				return ReportBuilderReports.findOne({_id: id});
-			}
-		},
-		reportBuilderBuildTree: {
-			check: new SimpleSchema({
-				collection_root: {
-					type: String
-				},
-				collectionJoins: {
-					type: Array,
-					optional: true
-				},
-				'collectionJoins.$': {
-					type: Object
-				},
-				'collectionJoins.$.collection': {
-					type: String
-				},
-				'collectionJoins.$.alias': {
-					type: String,
-					optional: true
-				},
-				'collectionJoins.$.local_key': {
-					type: String,
-					optional: true
-				},
-				'collectionJoins.$.foreign_key': {
-					type: String,
-					optional: true
-				}
-			}),
-			function: function(collection_root: string, collectionJoins: any[] = []) {
-				let baseRootTree = buildCollectionTree(collection_root);
-
-				let collectionTrees: any[] = [
-					{
-						collection: collection_root,
-						alias: toTitleCase(collection_root.replace(/\_/g, ' ').replace(/-/g, ' ')),
-						lookup_as: '',
-						tree: deepCopy(baseRootTree)
-					}
-				];
-
-				let rootTree = baseRootTree;
-
-				(collectionJoins || []).forEach((join, joinIndex) => {
-					const joinLocalKey = join.local_key && join.local_key.trim().length ? join.local_key : '_id';
-					const joinForeignKey = join.foreign_key && join.foreign_key.trim().length ? join.foreign_key : '_id';
-
-					let joinAlias = buildJoinAlias(join, joinIndex);
-					let joinNode = buildJoinLookupNode(collection_root, {...join, local_key: joinLocalKey, foreign_key: joinForeignKey}, joinAlias);
-
-					let joinTree = buildCollectionTree(join.collection, joinNode);
-					joinNode.children = joinTree.children;
-					joinNode.is_join = true;
-
-					rootTree.children.push(joinNode);
-
-					collectionTrees.push({
-						collection: join.collection,
-						alias: joinAlias,
-						lookup_as: joinNode.lookup_as,
-						tree: deepCopy(joinTree)
-					});
-				});
-
-				return Promise.resolve({
-					isLeaf: false,
-					children: rootTree.children,
-					trees: collectionTrees
-				});
-			}
-		},
-		reportBuilderGetDistinctValue: {
-			check: new SimpleSchema({
-				treeLeaf: {
-					type: Object,
-					blackbox: true
-				}
-			}),
-			function: async function(treeLeaf) {
-				if (treeLeaf.fieldType === 'String') {
-					const fieldPath = (treeLeaf && typeof treeLeaf.fieldPath === 'string') ? treeLeaf.fieldPath : '';
-					if (fieldPath.includes('(Lookup') || treeLeaf.lookup_collection) {
-						return mongoCommand('distinct', treeLeaf.collection_name, fieldPath.replace(/^.+\(.+\) \(Lookup.*\)\.\$\./g, '').replace(/\.\$/g, ''));
-					}
-					else {
-						return mongoCommand('distinct', treeLeaf.collection_name, fieldPath.replace(/\.\$/g, ''));
-					}
-				}
-				else {
-					return [];
-				}
-			}
-		},
-		reportBuilderGetResults: {
-			bypassSession: true,
-			check: new SimpleSchema({
-				reportType: {
-					type: String
-				},
-				rootCollectionName: {
-					type: String
-				},
-				options: {
-					type: PaginationOptionsSchema
-				},
-				filters: {
-					type: Array,
-					optional: true
-				},
-				'filters.$': {
-					type: Object,
-					blackbox: true,
-					optional: true
-				},
-				filterArrays: {
-					type: Array,
-					optional: true
-				},
-				'filterArrays.$': {
-					type: Object,
-					blackbox: true,
-					optional: true
-				},
-				filterArrayFields: {
-					type: Array,
-					optional: true
-				},
-				'filterArrayFields.$': {
-					type: Object,
-					blackbox: true,
-					optional: true
-				},
-				selectedFields: {
-					type: Array,
-					optional: true
-				},
-				'selectedFields.$': {
-					type: Object,
-					optional: true,
-					blackbox: true
-				},
-				customFields: {
-					type: Array,
-					optional: true
-				},
-				'customFields.$': {
-					type: Object,
-					optional: true,
-					blackbox: true
-				},
-				groupsRow: {
-					type: Array
-				},
-				'groupsRow.$': {
-					type: Object,
-					blackbox: true
-				},
-				fieldsTotal: {
-					type: Array
-				},
-				'fieldsTotal.$': {
-					type: Object,
-					blackbox: true
-				},
-				fieldsLink: {
-					type: Array
-				},
-				'fieldsLink.$': {
-					type: Object,
-					blackbox: true
-				},
-				date_field: {
-					type: String,
-					optional: true
-				},
-				date_interval: {
-					type: String,
-					optional: true
-				},
-				displayType: {
-					type: String,
-					optional: true
-				}
-			}),
-			function: async function(reportType: string, rootCollectionName: string, rootOptions: PaginationOptions, filters: any[] = [], filterArrays: any[] = [], filterArrayFields: any[] = [], selectedFields: any[] = [], customFields: any[] = [], groupsRow: any[] = [], fieldsTotal: any[] = [], fieldsLink: any[] = [], date_field = '', date_interval = '', displayType = '') {
-				let modelCollection = ResolveIOServer.getMongoManager().collection(rootCollectionName);
-
-				if (!modelCollection) {
-					throw new Error('Error in Report builder get results: Invalid collection');
-				}
-				else {
-					filters = expandLayoutColumnFilters(filters, selectedFields);
-					filterArrays = expandLayoutColumnFilters(filterArrays, selectedFields);
-					const datePaths = collectRootDatePaths(rootCollectionName);
-					if (datePaths.size) {
-						coerceDateFilters(filters, datePaths);
-						coerceDateFilters(filterArrays, datePaths);
-					}
-					const reportBuilderTimezone = process.env.TZ_CLIENT || 'America/Chicago';
-
-					const lookupAliases = collectLookupAliases(selectedFields, filterArrayFields, groupsRow);
-					const {rootFilters, lookupFilters} = splitFiltersByLookup(filters, lookupAliases);
-
-					// Union-based join mode (no local/foreign key): build per-collection pipelines and union them
-					// Union-based join mode should only apply when a "joined" collection has no join keys.
-					// Standard lookups (with local/foreign keys) must use the aggregation $lookup pipeline below,
-					// otherwise we'd return unrelated docs from the foreign collection (and root fields like "well" go blank).
-					const additionalCollectionsMap = new Map<string, {collection: string, alias: string}>();
-					(selectedFields || [])
-						.filter(f =>
-							f &&
-							f.lookup_collection &&
-							(!f.lookup_local_key || !f.lookup_foreign_key)
-						)
-						.forEach(f => {
-							const alias = f.lookup_as || f.lookup_collection;
-							const key = `${f.lookup_collection}::${alias}`;
-							if (!additionalCollectionsMap.has(key)) {
-								additionalCollectionsMap.set(key, {collection: f.lookup_collection, alias});
-							}
-						});
-					const additionalCollections = Array.from(additionalCollectionsMap.values());
-
-					if (additionalCollections.length) {
-						let unionQuery: any[] = buildCollectionPipeline(rootCollectionName, '', selectedFields, filters.concat(rootFilters || []), filterArrays.concat(lookupFilters || []), true);
-
-						additionalCollections.forEach(cfg => {
-							unionQuery.push({
-								$unionWith: {
-									coll: cfg.collection,
-									pipeline: buildCollectionPipeline(cfg.collection, cfg.alias, selectedFields, filters.concat(rootFilters || []), filterArrays.concat(lookupFilters || []), false)
-								}
-							});
-						});
-
-						if (rootOptions.sort) {
-							const {sortSpec: sortToUse, addFields: layoutSortAdd} = buildLayoutSortSpec(rootOptions.sort, selectedFields);
-							if (Object.keys(layoutSortAdd).length) {
-								unionQuery.push({$addFields: layoutSortAdd});
-							}
-							appendSafeSort(unionQuery, sortToUse, selectedFields, customFields);
-						}
-
-						// Apply remapped filters on projected field ids after union
-						const remappedFilters = remapFiltersToIds(filters.concat(rootFilters || []), selectedFields);
-						const remappedArrayFilters = remapFiltersToIds(filterArrays.concat(lookupFilters || []), selectedFields);
-						const postMatchAnd: any[] = [];
-						if (remappedFilters.length) {
-							postMatchAnd.push(...remappedFilters);
-						}
-						if (remappedArrayFilters.length) {
-							postMatchAnd.push(...remappedArrayFilters);
-						}
-						if (postMatchAnd.length) {
-							unionQuery.push({$match: {$and: postMatchAnd}});
-						}
-
-						const readPreference = this.serverConfig['ROOT_URL'] !== 'http://localhost:4200' ? 'secondary' : 'primary';
-						let queryResult = {
-							count: 0,
-							results: [],
-							totals: {}
-						};
-
-						try {
-							queryResult = await executeReportBuilderQuery(modelCollection, unionQuery, rootOptions, fieldsTotal, selectedFields, customFields, readPreference);
-						}
-						catch (err) {
-							console.log(err);
-						}
-
-						let tmpRes = [{
-							count: queryResult.count,
-							results: queryResult.results,
-							totals: queryResult.totals
-						}];
-
-						return tmpRes;
-					}
-
-					// Query
-					let query = [];
-					
-					// Non-Lookup Match Filters
-					let initialQueryMatchCondition = {
-						$and: []
-					};
-
-					// selectedFields.filter(a => a.collection_name === rootCollectionName).forEach(field => {
-					// 	initialQueryMatchCondition['$and'].push({
-					// 		$and: [
-					// 			{[field.fieldPath.replace(/\.\$/g, '')]: {$exists: 1}},
-					// 			// {[field.fieldPath.replace(/\.\$/g, '')]: {$ne: ''}},
-					// 			{[field.fieldPath.replace(/\.\$/g, '')]: {$ne: null}},
-					// 		]
-					// 	});
-					// });
-
-					if (rootFilters.length) {
-						rootFilters.forEach(filter => initialQueryMatchCondition['$and'].push(filter));
-					}
-
-					// Add filter to query
-					// if (filters.filter(a => (!a['$or'] && !Object.keys(a).some(b => b.includes('(Lookup'))) || (a['$or'] && !a['$or'].some(b => Object.keys(b).some(c => c.includes('(Lookup)'))))).length || selectedFields.filter(a => !a.fieldPath.includes('(Lookup')).length) {
-					if (initialQueryMatchCondition['$and'].length) {
-						query.push({
-							$match: initialQueryMatchCondition
-						});
-					}
-
-					// Add count
-					query.push({ $addFields: { count: { $sum: 1} } });
-
-					let sizes = [];
-
-					filterArrayFields.filter(a => a.fieldPath).forEach(filterField => {
-						let fieldData = filterField.fieldPath.split('.$');
-
-						let fieldPath = '';
-
-						for (let i = 0; i < fieldData.length - 1; i++) {
-							fieldPath += fieldData[i];
-
-							if (filterField.lookup_collection || fieldPath.split('.$')[fieldPath.split('.$').length - 1].includes('(Lookup')) {
-								ensureLookupLocalKeyUnwinds({
-									query,
-									sizes,
-									lookupLocalKey: filterField.lookup_local_key || '',
-									lookupAs: filterField.lookup_as || ''
-								});
-
-								const lookupAs = filterField.lookup_as.replace(/\.\$/g, '');
-								if (!query.some(a => a.$lookup && a.$lookup.as === lookupAs)) {
-									query.push({$lookup: {
-										from: filterField.lookup_collection,
-										localField: normalizeLookupField(filterField.lookup_local_key),
-										foreignField: normalizeLookupField(filterField.lookup_foreign_key),
-										as: lookupAs
-									}});
-
-									const lookupSizeKey = filterField.lookup_as.replace(/\.\$\./g, '_').replace(/\./g, '_');
-									sizes.push(lookupSizeKey);
-									const lookupSourceExpr = '$' + lookupAs;
-									query.push({$addFields: {['size_' + lookupSizeKey]: {$size: {$cond: [{$isArray: lookupSourceExpr}, lookupSourceExpr, []]}}}});
-
-									const unwindPath = '$' + lookupAs;
-									query.push({'$unwind': {path: unwindPath, preserveNullAndEmptyArrays: true}});
-								}
-							}
-							else {
-								if (!query.some(a => a.$addFields && Object.keys(a.$addFields).includes('size_' + fieldPath.replace(/\./g, '_')))) {
-									sizes.push(fieldPath.replace(/\./g, '_'));
-									const sourceExpr = '$' + fieldPath;
-									query.push({$addFields: {['size_' + fieldPath.replace(/\./g, '_')]: {$size: {$cond: [{$isArray: sourceExpr}, sourceExpr, []]}}}});
-
-									const unwindPath = '$' + fieldPath;
-									query.push({'$unwind': {path: unwindPath, preserveNullAndEmptyArrays: true}});
-								}
-							}
-						}
-					});
-
-					// Groups - Lookups / Sizes / Unwinds
-					groupsRow.forEach(row => {
-						const rowField = (row && typeof row.field === 'string') ? row.field : '';
-						if (rowField.includes('$')) {
-							let fieldData = rowField.split('.$');
-
-							let fieldPath = '';
-
-							for (let i = 0; i < fieldData.length - 1; i++) {
-								fieldPath += fieldData[i];
-
-								const lastSegment = fieldPath.split('.$')[fieldPath.split('.$').length - 1];
-								const hasLookup = !!row.treeItem?.lookup_collection || (lastSegment || '').includes('(Lookup');
-
-								if (hasLookup && row.treeItem?.lookup_collection && row.treeItem?.lookup_as) {
-									ensureLookupLocalKeyUnwinds({
-										query,
-										sizes,
-										lookupLocalKey: row.treeItem.lookup_local_key || '',
-										lookupAs: row.treeItem.lookup_as || ''
-									});
-
-									const lookupAsRaw = row.treeItem.lookup_as || '';
-									const lookupAs = lookupAsRaw.replace(/\.\$/g, '');
-
-									if (!query.some(a => a.$lookup && a.$lookup.as === lookupAs)) {
-										query.push({$lookup: {
-											from: row.treeItem.lookup_collection,
-											localField: normalizeLookupField(row.treeItem.lookup_local_key || ''),
-											foreignField: normalizeLookupField(row.treeItem.lookup_foreign_key || ''),
-											as: lookupAs
-										}});
-
-										const sizeKey = lookupAsRaw.replace(/\.\$\./g, '_').replace(/\./g, '_');
-										sizes.push(sizeKey);
-										const sourceExpr = '$' + lookupAs;
-										query.push({$addFields: {['size_' + sizeKey]: {$size: {$cond: [{$isArray: sourceExpr}, sourceExpr, []]}}}});
-
-										const unwindPath = '$' + lookupAs;
-										query.push({'$unwind': {path: unwindPath, preserveNullAndEmptyArrays: true}});
-									}
-								}
-								else {
-									if (!query.some(a => a.$addFields && Object.keys(a.$addFields).includes('size_' + fieldPath.replace(/\.\$\./g, '.').replace(/\./g, '_')))) {
-										const sizeKey = fieldPath.replace(/\.\$\./g, '.').replace(/\./g, '_');
-										sizes.push(sizeKey);
-										const sourceExpr = '$' + fieldPath.replace(/\.\$\./g, '.');
-										query.push({$addFields: {['size_' + sizeKey]: {$size: {$cond: [{$isArray: sourceExpr}, sourceExpr, []]}}}});
-										const unwindPath = '$' + fieldPath.replace(/\.\$\./g, '.');
-										query.push({'$unwind': {path: unwindPath, preserveNullAndEmptyArrays: true}});
-									}
-								}
-
-								fieldPath += '.$';
-							}
-						}
-					});
-
-					applyLinkFieldUnwinds({
-						query,
-						sizes,
-						fieldsLink,
-						selectedFields,
-						filterArrayFields,
-						groupsRow
-					});
-
-					// Selected Fields - Lookups / Sizes / Unwinds
-					// NOTE: lookup-based unwinds are no longer needed for joins; union handled below
-
-					// Divide all number fields by sizes
-					let divFields = {$addFields: {}};
-
-					fieldsTotal.filter(a => a.type === 'sum').forEach(total => {
-						selectedFields.filter(a => a.fieldType === 'Number' || a.leafValueType === 'Count').forEach(field => {
-							const fieldPath = (field && typeof field.fieldPath === 'string') ? field.fieldPath : '';
-							if (!fieldPath && field.leafValueType !== 'Count') {
-								return;
-							}
-
-							let multFields = [];
-
-							if (!fieldPath.includes('.$')) {
-								sizes.forEach(size => {
-									multFields.push({$cond: { if: { $gt: ['$size_' + size, 0 ] }, then: '$size_' + size, else: 1 }});
-								});
-							}
-							else {
-								sizes.filter(a => !fieldPath.replace(/\.\$\./g, '_').replace(/\./g, '_').includes(a) && !filterArrayFields.filter(a => a.fieldPath).some(b => b.fieldPath.replace(/\.\$\./g, '_').replace(/\./g, '_').includes(a)) && !fieldsLink.some(b => b.field_first.replace(/\.\$\./g, '_').replace(/\./g, '_').includes(a) || b.field_second.replace(/\.\$\./g, '_').replace(/\./g, '_').includes(a))).forEach(size => {
-									multFields.push({$cond: { if: { $gt: ['$size_' + size, 0 ] }, then: '$size_' + size, else: 1 }});
-								});
-							}
-
-							if (multFields.length) {
-								if (field.leafValueType === 'Count') {
-									divFields.$addFields[total.id + '_' + field.id] = {
-										$divide: ['$count', {$multiply: multFields}]
-									};
-								}
-								else {
-									divFields.$addFields[total.id + '_' + field.id] = {
-										$divide: [buildArrayAwareNumericFieldExpr(fieldPath), {$multiply: multFields}]
-									};	
-								}
-							}
-							else {
-								if (field.leafValueType === 'Count') {
-									divFields.$addFields[total.id + '_' + field.id] = '$count';
-								}
-								else {
-									divFields.$addFields[total.id + '_' + field.id] = buildArrayAwareNumericFieldExpr(fieldPath);
-								}
-							}
-						});
-					});
-
-					selectedFields.filter(a => a.fieldType === 'Number' && a.leafValueType === 'Sum').forEach(field => {
-						const fieldPath = (field && typeof field.fieldPath === 'string') ? field.fieldPath : '';
-						if (!fieldPath) {
-							return;
-						}
-
-						let multFields = [];
-
-						sizes.filter(a => !fieldPath.replace(/\.\$\./g, '_').replace(/\./g, '_').includes(a) && !groupsRow.some(b => (b.field || '').replace(/\.\$\./g, '_').replace(/\./g, '_').includes(a)) && !filterArrayFields.filter(a => a.fieldPath).some(b => b.fieldPath.replace(/\.\$\./g, '_').replace(/\./g, '_').includes(a)) && !fieldsLink.some(b => b.field_first.replace(/\.\$\./g, '_').replace(/\./g, '_').includes(a) || b.field_second.replace(/\.\$\./g, '_').replace(/\./g, '_').includes(a))).forEach(size => {
-							multFields.push({$cond: { if: { $gt: ['$size_' + size, 0 ] }, then: '$size_' + size, else: 1 }});
-						});
-
-						if (multFields.length) {
-							divFields.$addFields[fieldPath.replace(/\.\$/g, '')] = {
-								$divide: [buildArrayAwareNumericFieldExpr(fieldPath), {$multiply: multFields}]
-							};
-						}
-					});
-
-					selectedFields.filter(a => a.leafValueType === 'Count').forEach(field => {
-						const fieldPath = (field && typeof field.fieldPath === 'string') ? field.fieldPath : '';
-						if (!fieldPath) {
-							return;
-						}
-
-						let multFields = [];
-						
-						sizes.filter(a => !fieldPath.replace(/\.\$\./g, '_').replace(/\./g, '_').includes(a) && !groupsRow.some(b => (b.field || '').replace(/\.\$\./g, '_').replace(/\./g, '_').includes(a)) && !filterArrayFields.filter(a => a.fieldPath).some(b => b.fieldPath.replace(/\.\$\./g, '_').replace(/\./g, '_').includes(a)) && !fieldsLink.some(b => b.field_first.replace(/\.\$\./g, '_').replace(/\./g, '_').includes(a) || b.field_second.replace(/\.\$\./g, '_').replace(/\./g, '_').includes(a))).forEach(size => {
-							multFields.push({$cond: { if: { $gt: ['$size_' + size, 0 ] }, then: '$size_' + size, else: 1 }});
-						});
-
-						if (multFields.length) {
-							divFields.$addFields['count_' + fieldPath.replace(/\.\$/g, '')] = {
-								$divide: ['$count', {$multiply: multFields}]
-							};
-						}
-						else {
-							if (reportType !== 'Dated' && sizes.filter(a => fieldPath.replace(/\.\$\./g, '_').includes(a)).length) {
-								sizes.filter(a => fieldPath.replace(/\.\$\./g, '_').includes(a)).forEach(size => {
-									divFields.$addFields['count_' + fieldPath.replace(/\.\$/g, '')] = '$size_' + size;
-								});
-							}
-							else {
-								divFields.$addFields['count_' + fieldPath.replace(/\.\$/g, '')] = '$count';
-							}
-						}
-					});
-
-					fieldsTotal.filter(a => a.type === 'avg').forEach(total => {
-						selectedFields.filter(a => a.fieldType === 'Number' || a.leafValueType === 'Count').forEach(field => {
-							const fieldPath = (field && typeof field.fieldPath === 'string') ? field.fieldPath : '';
-							if (!fieldPath && field.leafValueType !== 'Count') {
-								return;
-							}
-							divFields.$addFields[total.id + '_' + field.id] = buildArrayAwareNumericFieldExpr(fieldPath);
-						});
-					});
-
-					if (Object.keys(divFields.$addFields).length > 0) {
-						query.push(divFields);
-					}
-
-					fieldsLink.filter(a => a.field_first && a.field_second).forEach(link => {
-						query.push({$addFields: {[link.id]: {$cmp: ['$' + link.field_first.replace(/\.\$/g, ''), '$' + link.field_second.replace(/\.\$/g, '')]}}});
-						query.push({$match: {[link.id]: 0}});
-					});
-
-					customFields.forEach(cust => {
-						cust.operations.filter(a => a.operation && !a.fields.some(b => (b.field === null || b.field === '') && b.value === null)).forEach((operation, opIndex) => {
-							let custFieldGroup = {};
-
-							if (operation.operation === 'divide') {
-								let condCheck = [];
-								operation.fields.filter(a => a.field || a.value !== null).forEach(field => {
-									if (field.field) {
-										condCheck.push({$eq: ['$' + field.field.replace(/\.\$/g, ''), 0]});
-										condCheck.push({$eq: ['$' + field.field.replace(/\.\$/g, ''), null]});
-									}
-									else {
-										condCheck.push({$eq: [field.value, 0]});
-										condCheck.push({$eq: [field.value, null]});
-									}
-								});
-
-								if (opIndex > 0) {
-									condCheck.push({$eq: ['$' + cust.selFieldId, 0]});
-									condCheck.push({$eq: ['$' + cust.selFieldId, null]});
-								}
-
-								let tmpOperationFields = [];
-
-								if (opIndex > 0) {
-									tmpOperationFields.push('$' + cust.selFieldId);
-								}
-	
-								operation.fields.filter(a => a.field || a.value !== null).forEach(field => {
-									if (field.field) {
-										tmpOperationFields.push('$' + field.field.replace(/\.\$/g, ''));
-									}
-									else {
-										tmpOperationFields.push(field.value);
-									}
-								});
-
-								custFieldGroup[cust.selFieldId] = {
-									$cond: { if: { $or: condCheck }, then: 0, else: {['$' + operation.operation]: tmpOperationFields} }
-								};
-							}
-							else {
-								custFieldGroup[cust.selFieldId] = {
-									['$' + operation.operation]: []
-								};
-
-								if (opIndex > 0) {
-									custFieldGroup[cust.selFieldId]['$' + operation.operation].push({$cond: { if: { $eq: ['$' + cust.selFieldId, null] }, then: 0, else: '$' + cust.selFieldId}});
-								}
-
-								let condOr = [];
-
-								operation.fields.filter(a => a.field || a.value !== null).forEach(field => {
-									if (field.field) {
-										condOr.push({$eq: ['$' + field.field.replace(/\.\$/g, ''), null]});
-									}
-									else {
-										condOr.push({$eq: [field.value, null]});
-									}
-								});
-	
-								operation.fields.filter(a => a.field || a.value !== null).forEach(field => {
-									if (field.field) {
-										custFieldGroup[cust.selFieldId]['$' + operation.operation].push({$cond: { if: { $or: condOr }, then: 0, else: '$' + field.field.replace(/\.\$/g, '')}});
-									}
-									else {
-										custFieldGroup[cust.selFieldId]['$' + operation.operation].push({$cond: { if: { $or: condOr }, then: 0, else: field.value}});
-									}
-								});
-							}
-
-							query.push({$addFields: custFieldGroup});
-						});
-					});
-
-					fieldsTotal.forEach(total => {
-						customFields.forEach(field => {
-							query.push({$addFields:{[total.id + '_' + field.selFieldId]: '$' + field.selFieldId}});
-						});
-					});
-
-					// Filters - Lookups / Arrays
-					let queryMatchConditionLookup = {
-						$and: []
-					};
-
-					if (lookupFilters.length) {
-						lookupFilters.forEach(filter => queryMatchConditionLookup['$and'].push(filter));
-					}
-
-					filterArrays.forEach(filter => {
-						queryMatchConditionLookup['$and'].push(filter);
-					});
-
-					if (queryMatchConditionLookup.$and.length) {
-						query.push({$match: queryMatchConditionLookup});
-					}
-
-					// Group
-					let queryGroup = {
-						_id: {}
-					};
-
-					if (groupsRow.length || !displayType || displayType === 'grouped') {
-						if (!groupsRow.length) {
-							queryGroup._id = '$_id';
-						}
-						else {
-							if (rootOptions.sort) { 
-								let groupedSorts = {};
-								Object.keys(rootOptions.sort).forEach(sortField => {
-									let selField = selectedFields.find(a => a.id === sortField);
-	
-									if (selField) {
-										const sortPath = (selField && typeof selField.fieldPath === 'string') ? selField.fieldPath.replace(/\.\$/g, '') : '';
-										if (sortPath) {
-											groupedSorts[sortPath] = rootOptions.sort[sortField];
-										}
-									}
-								});
-								if (Object.keys(groupedSorts).length > 0) {
-									query.push({
-										$sort: groupedSorts
-									});
-								}
-							}
-						}
-
-							if (groupsRow.length && date_field && date_interval) {
-								const dateFieldPath = (typeof date_field === 'string') ? date_field.replace(/\.\$/g, '') : '';
-								if (dateFieldPath) {
-									const dateFieldExpr = '$' + dateFieldPath;
-									const utcHourExpr = {'$hour': {date: dateFieldExpr, timezone: 'UTC'}};
-									const utcMinuteExpr = {'$minute': {date: dateFieldExpr, timezone: 'UTC'}};
-									const utcSecondExpr = {'$second': {date: dateFieldExpr, timezone: 'UTC'}};
-									const utcDayExpr = {'$dayOfMonth': {date: dateFieldExpr, timezone: 'UTC'}};
-									const tzDayExpr = {'$dayOfMonth': {date: dateFieldExpr, timezone: reportBuilderTimezone}};
-									const useUtcForDateOnlyExpr = {
-										$and: [
-											{$eq: [utcHourExpr, 0]},
-											{$eq: [utcMinuteExpr, 0]},
-											{$eq: [utcSecondExpr, 0]},
-											{$ne: [utcDayExpr, tzDayExpr]}
-										]
-									};
-									const groupingTimezoneExpr = {$cond: [useUtcForDateOnlyExpr, 'UTC', reportBuilderTimezone]};
-
-									if (date_interval === 'Seconds') {
-										queryGroup._id['second'] = {'$second' : {'date': dateFieldExpr, 'timezone': groupingTimezoneExpr}};
-										queryGroup._id['minute'] = {'$minute' : {'date': dateFieldExpr, 'timezone': groupingTimezoneExpr}};
-										queryGroup._id['hour'] = {'$hour' : {'date': dateFieldExpr, 'timezone': groupingTimezoneExpr}};
-										queryGroup._id['day'] = {'$dayOfMonth' : {'date': dateFieldExpr, 'timezone': groupingTimezoneExpr}};
-										queryGroup._id['month'] = {'$month' : {'date': dateFieldExpr, 'timezone': groupingTimezoneExpr}};
-										queryGroup._id['year'] = {'$year' : {'date': dateFieldExpr, 'timezone': groupingTimezoneExpr}};
-									}
-									else if (date_interval === 'Minutes') {
-										queryGroup._id['minute'] = {'$minute' : {'date': dateFieldExpr, 'timezone': groupingTimezoneExpr}};
-										queryGroup._id['hour'] = {'$hour' : {'date': dateFieldExpr, 'timezone': groupingTimezoneExpr}};
-										queryGroup._id['day'] = {'$dayOfMonth' : {'date': dateFieldExpr, 'timezone': groupingTimezoneExpr}};
-										queryGroup._id['month'] = {'$month' : {'date': dateFieldExpr, 'timezone': groupingTimezoneExpr}};
-										queryGroup._id['year'] = {'$year' : {'date': dateFieldExpr, 'timezone': groupingTimezoneExpr}};
-									}
-									else if (date_interval === 'Hours') {
-										queryGroup._id['hour'] = {'$hour' : {'date': dateFieldExpr, 'timezone': groupingTimezoneExpr}};
-										queryGroup._id['day'] = {'$dayOfMonth' : {'date': dateFieldExpr, 'timezone': groupingTimezoneExpr}};
-										queryGroup._id['month'] = {'$month' : {'date': dateFieldExpr, 'timezone': groupingTimezoneExpr}};
-										queryGroup._id['year'] = {'$year' : {'date': dateFieldExpr, 'timezone': groupingTimezoneExpr}};
-									}
-									else if (date_interval === 'Daily') {
-										queryGroup._id['day'] = {'$dayOfMonth' : {'date': dateFieldExpr, 'timezone': groupingTimezoneExpr}};
-										queryGroup._id['month'] = {'$month' : {'date': dateFieldExpr, 'timezone': groupingTimezoneExpr}};
-										queryGroup._id['year'] = {'$year' : {'date': dateFieldExpr, 'timezone': groupingTimezoneExpr}};
-									}
-									else if (date_interval === 'Weekly') {
-										queryGroup._id['week'] = {'$isoWeek' : {'date': dateFieldExpr, 'timezone': groupingTimezoneExpr}};
-										queryGroup._id['year'] = {'$isoWeekYear' : {'date': dateFieldExpr, 'timezone': groupingTimezoneExpr}};
-									}
-									else if (date_interval === 'Monthly') {
-										queryGroup._id['month'] = {'$month' : {'date': dateFieldExpr, 'timezone': groupingTimezoneExpr}};
-										queryGroup._id['year'] = {'$year' : {'date': dateFieldExpr, 'timezone': groupingTimezoneExpr}};
-									}
-									else if (date_interval === 'Quarterly') {
-										queryGroup._id['month'] = {'$month' : {'date': dateFieldExpr, 'timezone': groupingTimezoneExpr}};
-										queryGroup._id['year'] = {'$year' : {'date': dateFieldExpr, 'timezone': groupingTimezoneExpr}};
-									}
-									else if (date_interval === 'Yearly') {
-										queryGroup._id['year'] = {'$year' : {'date': dateFieldExpr, 'timezone': groupingTimezoneExpr}};
-									}
-								}
-							}
-
-							groupsRow.forEach(row => {
-								const rowField = (row && typeof row.field === 'string') ? row.field : '';
-								if (!rowField || !row?.id) {
-									return;
-								}
-
-								queryGroup._id[row.id] = '$' + rowField.replace(/\.\$/g, '');
-							});
-	
-							selectedFields.forEach(field => {
-								const fieldPath = (field && typeof field.fieldPath === 'string') ? field.fieldPath : '';
-								if (!fieldPath) {
-									if (field.leafValueType === 'Count') {
-										queryGroup[field.id] = { '$sum': 1 };
-									}
-									return;
-								}
-
-								if (field.leafValueType === 'Average') {
-									queryGroup[field.id] = {'$avg': '$' + fieldPath.replace(/\.\$/g, '')};	
-								}
-								else if (field.leafValueType === 'Sum') {
-									queryGroup[field.id] = {'$sum': buildArrayAwareNumericFieldExpr(fieldPath)};	
-								}
-								else if (field.leafValueType === 'Count') {
-									queryGroup[field.id] = { '$sum': '$count_' + fieldPath.replace(/\.\$/g, '') };
-								}
-								else if (field.leafValueType === 'Minimum') {
-									queryGroup[field.id] = {'$min': '$' + fieldPath.replace(/\.\$/g, '')};	
-								}
-								else if (field.leafValueType === 'Maximum') {
-									queryGroup[field.id] = {'$max': '$' + fieldPath.replace(/\.\$/g, '')};	
-								}
-								else if (field.leafValueType === 'First') {
-									queryGroup[field.id] = {'$first': '$' + fieldPath.replace(/\.\$/g, '')};	
-								}
-								else if (field.leafValueType === 'Last') {
-									queryGroup[field.id] = {'$last': '$' + fieldPath.replace(/\.\$/g, '')};	
-								}
-								else if (field.leafValueType === 'Unique') {
-									queryGroup[field.id] = {'$addToSet': '$' + fieldPath.replace(/\.\$/g, '')};	
-								}
-								else {
-									queryGroup[field.id] = {'$push': {$ifNull: ['$' + fieldPath.replace(/\.\$/g, ''), null]}};
-								}
-							});
-
-						customFields.forEach(cust => {
-							if (cust.leafValueType === 'Average') {
-								queryGroup[cust.selFieldId] = {'$avg': '$' +  cust.selFieldId};	
-							}
-							else if (cust.leafValueType === 'Sum') {
-								queryGroup[cust.selFieldId] = {'$sum': '$' +  cust.selFieldId};	
-							}
-							else if (cust.leafValueType === 'Count') {
-								if (reportType === 'Dated') {
-									queryGroup[cust.selFieldId] = { '$sum': '$count_' +  cust.selFieldId };
-								}
-								else {
-									queryGroup[cust.selFieldId] = { '$push': '$count_' +  cust.selFieldId };
-								}
-							}
-							else if (cust.leafValueType === 'Minimum') {
-								queryGroup[cust.selFieldId] = {'$min': '$' +  cust.selFieldId};	
-							}
-							else if (cust.leafValueType === 'Maximum') {
-								queryGroup[cust.selFieldId] = {'$max': '$' +  cust.selFieldId};	
-							}
-							else if (cust.leafValueType === 'First') {
-								queryGroup[cust.selFieldId] = {'$first': '$' +  cust.selFieldId};	
-							}
-							else if (cust.leafValueType === 'Last') {
-								queryGroup[cust.selFieldId] = {'$last': '$' +  cust.selFieldId};	
-							}
-							else if (cust.leafValueType === 'Unique') {
-								queryGroup[cust.selFieldId] = {'$addToSet': '$' +  cust.selFieldId};	
-							}
-							else {
-								queryGroup[cust.selFieldId] = {'$push': {$ifNull: ['$' +  cust.selFieldId, null]}};
-							}
-						});
-
-						// Totals
-						if (fieldsTotal.length) {
-							fieldsTotal.forEach(total => {
-								selectedFields.filter(a => a.fieldType === 'Number' || a.leafValueType === 'Count').forEach(field => {
-									queryGroup[total.id + '_' + field.id] = {['$' + total.type] : '$' + total.id + '_' + field.id};
-								});
-
-								customFields.forEach(field => {
-									queryGroup[total.id + '_' + field.selFieldId] = {['$' + total.type]: '$' + total.id + '_' + field.selFieldId};
-								});
-							});
-						}
-
-						query.push({$group: queryGroup});
-					}
-					else {
-						//Projection
-						let queryProjection = {
-							_id: 1
-						};
-
-							selectedFields.forEach(field => {
-								const fieldPath = (field && typeof field.fieldPath === 'string') ? field.fieldPath : '';
-								if (!fieldPath && field.leafValueType !== 'Count') {
-									return;
-								}
-
-								if (field.leafValueType === 'Average') {
-									queryProjection[field.id] = buildArrayAwareAverageFieldExpr(fieldPath);
-								}
-								else if (field.leafValueType === 'Sum') {
-									queryProjection[field.id] = buildArrayAwareNumericFieldExpr(fieldPath);
-								}
-								else if (field.leafValueType === 'Count') {
-									queryProjection[field.id] = {$sum: 1};
-								}
-								else if (field.leafValueType === 'Minimum') {
-									queryProjection[field.id] = {$min: '$' + fieldPath.replace(/\.\$/g, '')};
-								}
-								else if (field.leafValueType === 'Maximum') {
-									queryProjection[field.id] = {$max: '$' + fieldPath.replace(/\.\$/g, '')};
-								}
-								else {
-									queryProjection[field.id] = '$' + fieldPath.replace(/\.\$/g, '');
-								}
-							});
-
-						customFields.forEach(cust => {
-							if (cust === 'Average') {
-								queryProjection[cust.selFieldId] = {$avg: '$' +  cust.selFieldId};
-							}
-							else if (cust === 'Sum') {
-								queryProjection[cust.selFieldId] = {$sum: '$' +  cust.selFieldId};
-							}
-							else if (cust === 'Count') {
-								queryProjection[cust.selFieldId] = {$sum: 1};
-							}
-							else if (cust === 'Minimum') {
-								queryProjection[cust.selFieldId] = {$min: '$' +  cust.selFieldId};
-							}
-							else if (cust === 'Maximum') {
-								queryProjection[cust.selFieldId] = {$max: '$' +  cust.selFieldId};
-							}
-							else {
-								queryProjection[cust.selFieldId] = '$' + cust.selFieldId;
-							}
-						});
-
-						//Totals
-							if (fieldsTotal.length && (reportType === 'List' || reportType === 'Dated')) {
-								fieldsTotal.forEach(total => {
-									selectedFields.filter(a => a.fieldType === 'Number' || a.leafValueType === 'Count').forEach(field => {
-										const totalFieldPath = total.id + '_' + field.id;
-										if (total.type === 'sum') {
-											queryProjection[totalFieldPath] = buildArrayAwareNumericFieldExpr(totalFieldPath);
-										}
-										else if (total.type === 'avg') {
-											queryProjection[totalFieldPath] = buildArrayAwareAverageFieldExpr(totalFieldPath);
-										}
-										else {
-											queryProjection[totalFieldPath] = {['$' + total.type]: '$' + totalFieldPath};
-										}
-									});
-
-								customFields.forEach(field => {
-									queryProjection[total.id + '_' + field.selFieldId] = {['$' + total.type]: '$' + total.id + '_' + field.selFieldId};
-								});
-							});
-						}
-
-						query.push({$project: queryProjection});
-					}
-
-					// SORT
-					if (rootOptions.sort) {
-						appendSafeSort(query, rootOptions.sort, selectedFields, customFields);
-					}
-
-					if (reportType === 'Group' && groupsRow.length > 1) {
-						for (let i = groupsRow.length - 1; i >= 1; i--) {
-							let projQuery = {_id: 1};
-
-							projQuery[groupsRow[i].id] = {
-								_id: {[groupsRow[i].id]: '$_id.' + groupsRow[i].id}
-							};
-
-							if (i === groupsRow.length - 1) {
-								selectedFields.forEach(field => {
-									projQuery[groupsRow[i].id][field.id] = '$' + field.id;
-								});
-
-								customFields.forEach(field => {
-									projQuery[groupsRow[i].id][field.selFieldId] = '$' + field.selFieldId;
-								});
-							}
-							else {
-								projQuery[groupsRow[i].id][groupsRow[i + 1].id] = '$' + groupsRow[i + 1].id;
-							}
-
-							fieldsTotal.forEach(totField => {
-								selectedFields.filter(b => b.fieldType === 'Number' || b.leafValueType === 'Count').forEach(selField => {
-									projQuery[totField.id + '_' + selField.id] = 1;
-									projQuery[groupsRow[i].id][totField.id + '_' + selField.id] = '$' + totField.id + '_' + selField.id;
-								});
-
-								customFields.forEach(field => {
-									projQuery[groupsRow[i].id][totField.id + '_' + field.selFieldId] = '$' + totField.id + '_' + field.selFieldId;
-								});
-							});
-
-							query.push({$project: projQuery});
-
-							let grQuery = {
-								_id: {}
-							};
-
-							for (let j = 0; j < i; j++) {
-								grQuery._id[groupsRow[j].id] = '$_id.' + groupsRow[j].id;
-							}
-
-							grQuery[groupsRow[i].id] = {
-								$push: '$' + groupsRow[i].id
-							};
-
-							fieldsTotal.forEach(totField => {
-								selectedFields.filter(b => b.fieldType === 'Number' || b.leafValueType === 'Count').forEach(selField => {
-									grQuery[totField.id + '_' + selField.id] = {['$' + totField.type]: '$' + totField.id + '_' + selField.id};
-								});
-
-								customFields.forEach(field => {
-									grQuery[totField.id + '_' + field.selFieldId] = {['$' + totField.type]: '$' + totField.id + '_' + field.selFieldId};
-								});
-							});
-
-							query.push({$group: grQuery});
-
-							if (rootOptions.sort) {
-								let sortKeys = Object.keys(rootOptions.sort);
-								let sort = {};
-
-								let groupString = '';
-								groupsRow.forEach((row, groupIndex) => {
-									if (groupIndex > 0) {
-										groupString += 'gr_' + (groupIndex + 1) + '.';
-									}
-
-									if (sortKeys.includes('_id.gr_' + (groupIndex + 1))) {
-										sort[groupString + '_id.gr_' + (groupIndex + 1)] = rootOptions.sort['_id.gr_' + (groupIndex + 1)];
-									}
-									else {
-										sort[groupString + '_id.gr_' + (groupIndex + 1)] = 1;
-									}
-								});
-
-								sortKeys.filter(a => !a.startsWith('_id.gr_')).forEach(key => {
-									sort[groupString + key] = rootOptions.sort[key];
-								});
-
-								appendSafeSort(query, sort, selectedFields, customFields);
-							}
-						}
-					}
-
-					if (this.serverConfig['ROOT_URL'] === 'http://localhost:4200') {
-						console.log('_____________ query __________'); console.log(JSON.stringify(query, null, 2));
-					}
-
-						const readPreference = this.serverConfig['ROOT_URL'] !== 'http://localhost:4200' ? 'secondary' : 'primary';
-						let queryResult = {
-							count: 0,
-							results: [],
-							totals: {}
-						};
-						
-						try {
-							queryResult = await executeReportBuilderQuery(modelCollection, query, rootOptions, fieldsTotal, selectedFields, customFields, readPreference);
-						}
-						catch (err) {
-							console.log(err);
-						}
-
-						let tmpRes = [{
-							count: queryResult.count,
-							results: queryResult.results,
-							totals: queryResult.totals
-						}];
-
-					return tmpRes;
-				}
-			},
-			workerTaskWeight: 2
-		}
-	});
-}
-
-function coerceReportBuilderNumeric(value: any): number {
-	if (Array.isArray(value)) {
-		return value.map(v => coerceReportBuilderNumeric(v)).reduce((a, b) => a + b, 0);
-	}
-
-	const num = typeof value === 'number' ? value : (value !== null && value !== undefined ? Number(value) : 0);
-	return isNaN(num) ? 0 : num;
-}
-
-function buildReportBuilderTotalsFieldKeySets(fieldsTotal: any[] = [], selectedFields: any[] = [], customFields: any[] = []) {
-	const numericSelectedFields = selectedFields.filter(field => field?.fieldType === 'Number' || field?.leafValueType === 'Count');
-	const sumKeys = new Set<string>();
-	const avgKeys = new Set<string>();
-
-	fieldsTotal.forEach(totalField => {
-		numericSelectedFields.forEach(selectedField => {
-			const key = `${totalField.id}_${selectedField.id}`;
-			if (!key) {
-				return;
-			}
-
-			if (totalField.type === 'sum') {
-				sumKeys.add(key);
-			}
-			else if (totalField.type === 'avg') {
-				avgKeys.add(key);
-			}
-		});
-
-		customFields.forEach(customField => {
-			const customId = customField?.selFieldId;
-			if (!customId) {
-				return;
-			}
-
-			const key = `${totalField.id}_${customId}`;
-			if (totalField.type === 'sum') {
-				sumKeys.add(key);
-			}
-			else if (totalField.type === 'avg') {
-				avgKeys.add(key);
-			}
-		});
-	});
-
-	return {sumKeys, avgKeys};
-}
-
-function buildReportBuilderTotalsFromSums(fieldsTotal: any[] = [], selectedFields: any[] = [], customFields: any[] = [], sumValues: Record<string, number> = {}, count = 0) {
-	const numericSelectedFields = selectedFields.filter(field => field?.fieldType === 'Number' || field?.leafValueType === 'Count');
-	const totals = {};
-
-	fieldsTotal.forEach(totalField => {
-		numericSelectedFields.forEach(selectedField => {
-			const key = `${totalField.id}_${selectedField.id}`;
-			const sum = coerceReportBuilderNumeric(sumValues[key]);
-
-			if (totalField.type === 'sum') {
-				totals[key] = sum;
-			}
-			else if (totalField.type === 'avg') {
-				totals[key] = count ? round(sum / count) : 0;
-			}
-		});
-
-		customFields.forEach(customField => {
-			const customId = customField?.selFieldId;
-			if (!customId) {
-				return;
-			}
-
-			const key = `${totalField.id}_${customId}`;
-			const sum = coerceReportBuilderNumeric(sumValues[key]);
-
-			if (totalField.type === 'sum') {
-				totals[key] = sum;
-			}
-			else if (totalField.type === 'avg') {
-				totals[key] = count ? round(sum / count) : 0;
-			}
-		});
-	});
-
-	return totals;
-}
-
-function buildReportBuilderNumericSumExpr(fieldKey: string) {
-	const fieldExpr = '$' + fieldKey;
-
-	return {
-		$cond: [
-			{$isArray: fieldExpr},
-			{
-				$reduce: {
-					input: fieldExpr,
-					initialValue: 0,
-					in: {
-						$add: [
-							'$$value',
-							{$convert: {input: '$$this', to: 'double', onError: 0, onNull: 0}}
-						]
-					}
-				}
-			},
-			{$convert: {input: fieldExpr, to: 'double', onError: 0, onNull: 0}}
-		]
-	};
-}
-
-async function executeReportBuilderQuery(modelCollection: any, query: any[], rootOptions: PaginationOptions, fieldsTotal: any[] = [], selectedFields: any[] = [], customFields: any[] = [], readPreference: string = 'primary') {
-	const aggregateOptions = {
-		allowDiskUse: true,
-		readPreference
-	};
-
-	const {sumKeys, avgKeys} = buildReportBuilderTotalsFieldKeySets(fieldsTotal, selectedFields, customFields);
-	const allTotalKeys = new Set<string>([...sumKeys, ...avgKeys]);
-
-	if (rootOptions?.limit && rootOptions.limit > 0) {
-		const resultsFacet: any[] = [];
-		if (rootOptions.skip && rootOptions.skip > 0) {
-			resultsFacet.push({$skip: rootOptions.skip});
-		}
-		resultsFacet.push({$limit: rootOptions.limit});
-
-		const facet: any = {
-			results: resultsFacet,
-			count: [{$count: 'count'}],
-			totals: []
-		};
-
-		if (allTotalKeys.size) {
-			const totalsGroup = {
-				_id: null,
-				__count: {$sum: 1}
-			};
-
-			Array.from(allTotalKeys).forEach(key => {
-				totalsGroup[key] = {$sum: buildReportBuilderNumericSumExpr(key)};
-			});
-
-			facet.totals = [
-				{$group: totalsGroup}
-			];
-		}
-
-		const facetedQuery = query.concat([
-			{$facet: facet}
-		]);
-		const facetedResult = await modelCollection.aggregate(facetedQuery, aggregateOptions, true);
-		const facetDoc = Array.isArray(facetedResult) && facetedResult.length ? facetedResult[0] : {};
-		const count = facetDoc?.count?.[0]?.count || 0;
-		const results = Array.isArray(facetDoc?.results) ? facetDoc.results : [];
-		const totalsDoc = facetDoc?.totals?.[0] || {};
-		const sumValues = {};
-
-		Array.from(allTotalKeys).forEach(key => {
-			sumValues[key] = coerceReportBuilderNumeric(totalsDoc[key]);
-		});
-
-		const totals = buildReportBuilderTotalsFromSums(fieldsTotal, selectedFields, customFields, sumValues, count);
-
-		return {count, results, totals};
-	}
-
-	const fullResult = await modelCollection.aggregate(query, aggregateOptions, true);
-	const rows = Array.isArray(fullResult) ? fullResult : [];
-	const sumValues = {};
-
-	Array.from(allTotalKeys).forEach(key => {
-		sumValues[key] = rows.map(row => coerceReportBuilderNumeric(row ? row[key] : 0)).reduce((a, b) => a + b, 0);
-	});
-
-	let results = rows;
-	if (rootOptions?.skip && rootOptions.skip > 0) {
-		results = results.slice(rootOptions.skip);
-	}
-	if (rootOptions?.limit && rootOptions.limit > 0) {
-		results = results.slice(0, rootOptions.limit);
-	}
-
-	const totals = buildReportBuilderTotalsFromSums(fieldsTotal, selectedFields, customFields, sumValues, rows.length);
-
-	return {
-		count: rows.length,
-		results,
-		totals
-	};
-}
-
-function buildCollectionTree(collectionName: string, lookupNode?: any) {
-	let lookupSchemaData = getReportLookupSchemas(collectionName).sort((a, b) => a.collection_name.localeCompare(b.collection_name));
-	let lookupSchemaTree = lookupSchemaData.find(a => a.is_root === true)?.tree || {};
-
-	let treeItems = buildTree(collectionName, lookupSchemaTree, lookupNode);
-
-	attachLookupChildren(treeItems, lookupSchemaData, lookupSchemaTree);
-
-	return {isLeaf: false, children: treeItems};
-}
-
-function attachLookupChildren(treeItems: any[], lookupSchemaData: any[], lookupSchemaTree: any) {
-	Object.keys(lookupSchemaTree || {}).filter(a => a.endsWith('(Lookup)')).forEach(lookup => {
-		let field = findFieldByPath(treeItems, lookup);
-
-		if (field) {
-			let lookupTree = lookupSchemaData.find(a => a.collection_name === lookupSchemaTree[lookup].lookup_collection);
-
-			if (lookupTree) {
-				let childTree = buildTree(lookupSchemaTree[lookup].lookup_collection, lookupTree.tree, field);
-				attachLookupChildren(childTree, lookupSchemaData, lookupTree.tree);
-				field.children = childTree;
-			}
-		}
-	});
-}
-
-function findFieldByPath(treeItems: any[], lookupPath: string) {
-	let fieldPath = lookupPath.split('.');
-	let field = null;
-
-	fieldPath.forEach(path => {
-		if (!field) {
-			field = treeItems.find(a => a.fieldName === path);
-		}
-		else if (field.children) {
-			field = field.children.find(a => a.fieldName === path);
-		}
-	});
-
-	return field;
-}
-
-function buildJoinLookupNode(collection_root: string, join: ReportBuilderCollectionJoin, alias: string) {
-	return {
-		collection_name: collection_root,
-		columnName: alias,
-		fieldName: alias,
-		fieldType: 'Lookup',
-		fieldTypeName: 'Lookup',
-		distinctFieldValues: [],
-		fieldPath: alias,
-		fieldPathName: alias,
-		path: alias,
-		lookup_collection: join.collection,
-		lookup_local_key: join.local_key,
-		lookup_foreign_key: join.foreign_key,
-		lookup_as: alias,
-		text: alias,
-		value: alias,
-		isLeaf: false,
-		isActive: false,
-		isSelected: false,
-		is_join: false,
-		depth: 0,
-		leafValueType: '',
-		leafFormatType: '',
-		children: []
-	};
-}
-
-function buildJoinAlias(join: ReportBuilderCollectionJoin, joinIndex: number) {
-	if (join.alias && join.alias.trim()) {
-		return join.alias.trim();
-	}
-
-	let joinName = toTitleCase(join.collection.replace(/\_/g, ' ').replace(/-/g, ' '));
-	let joinPath = toTitleCase(join.local_key.replace(/\.\$\./g, ' -> ').replace(/\./g, ' -> ').replace(/\_/g, ' '));
-
-	return `${joinName} (${joinPath || 'Join'}) (Lookup ${joinIndex + 1})`;
-}
-
-function buildArrayAwareNumericFieldExpr(fieldPath: string) {
-	const normalizedFieldPath = (fieldPath || '').replace(/\.\$/g, '');
-	if (!normalizedFieldPath) {
-		return 0;
-	}
-	const fieldExpr = '$' + normalizedFieldPath;
-
-	return {
-		$cond: [
-			{$isArray: fieldExpr},
-			{$sum: {$ifNull: [fieldExpr, []]}},
-			{$ifNull: [fieldExpr, 0]}
-		]
-	};
-}
-
-function buildArrayAwareAverageFieldExpr(fieldPath: string) {
-	const normalizedFieldPath = (fieldPath || '').replace(/\.\$/g, '');
-	if (!normalizedFieldPath) {
-		return 0;
-	}
-	const fieldExpr = '$' + normalizedFieldPath;
-
-	return {
-		$cond: [
-			{$isArray: fieldExpr},
-			{
-				$cond: [
-					{$gt: [{$size: {$ifNull: [fieldExpr, []]}}, 0]},
-					{$avg: {$ifNull: [fieldExpr, []]}},
-					0
-				]
-			},
-			{$ifNull: [fieldExpr, 0]}
-		]
-	};
-}
-
-function appendSafeSort(query: any[], sortSpec: any, selectedFields: any[] = [], customFields: any[] = []) {
-	if (!sortSpec || !Object.keys(sortSpec).length) {
-		return;
-	}
-
-	const safeAddFields = {};
-	const safeSort = {};
-
-	Object.keys(sortSpec).forEach(key => {
-		if (key.startsWith('_id.')) {
-			safeSort[key] = sortSpec[key];
-			return;
-		}
-
-		if (isArrayLikeField(key, selectedFields, customFields)) {
-			const safeKey = 'sort_' + key.replace(/\./g, '_');
-			safeAddFields[safeKey] = {
-				$cond: [
-					{$isArray: '$' + key},
-					{$size: {$ifNull: ['$' + key, []]}},
-					'$' + key
-				]
-			};
-			safeSort[safeKey] = sortSpec[key];
-		}
-		else {
-			safeSort[key] = sortSpec[key];
-		}
-	});
-
-	if (Object.keys(safeAddFields).length) {
-		query.push({$addFields: safeAddFields});
-	}
-
-	if (Object.keys(safeSort).length) {
-		query.push({$sort: safeSort});
-	}
-}
-
-function isArrayLikeField(sortKey: string, selectedFields: any[] = [], customFields: any[] = []) {
-	const field = selectedFields.find(a => a.id === sortKey);
-	const custom = customFields.find(a => a.selFieldId === sortKey);
-
-	const leafValueType = field ? field.leafValueType : (custom ? custom.leafValueType : '');
-
-	return leafValueType !== 'Average' &&
-		leafValueType !== 'Sum' &&
-		leafValueType !== 'Count' &&
-		leafValueType !== 'Minimum' &&
-		leafValueType !== 'Maximum' &&
-		leafValueType !== 'First' &&
-		leafValueType !== 'Last' &&
-		leafValueType !== 'Unique';
-}
-
-function collectLookupAliases(selectedFields: any[] = [], filterArrayFields: any[] = [], groupsRow: any[] = []) {
-	const aliases = new Set<string>();
-
-	const addAlias = (alias: string) => {
-		const normalized = normalizeLookupAlias(alias);
-		if (normalized) {
-			aliases.add(normalized);
-		}
-	};
-
-	(selectedFields || []).forEach(field => {
-		if (field && (field.lookup_collection || (field.fieldPath && field.fieldPath.includes('(Lookup')))) {
-			addAlias(field.lookup_as || extractLookupAlias(field.fieldPath));
-		}
-	});
-
-	(filterArrayFields || []).forEach(field => {
-		if (field && (field.lookup_collection || (field.fieldPath && field.fieldPath.includes('(Lookup')))) {
-			addAlias(field.lookup_as || extractLookupAlias(field.fieldPath));
-		}
-	});
-
-	(groupsRow || []).forEach(group => {
-		if (group?.treeItem && (group.treeItem.lookup_collection || (group.treeItem.fieldPath && group.treeItem.fieldPath.includes('(Lookup')))) {
-			addAlias(group.treeItem.lookup_as || extractLookupAlias(group.treeItem.fieldPath));
-		}
-	});
-
-	return aliases;
-}
-
-function splitFiltersByLookup(filters: any[] = [], lookupAliases: Set<string> = new Set()) {
-	const rootFilters = [];
-	const lookupFilters = [];
-
-	(filters || []).forEach(filter => {
-		const summary = summarizeFilterTargets(filter, lookupAliases);
-
-		if (summary.hasLookup) {
-			// If the filter mixes root + lookup, keep it together in lookupFilters so it stays a single $match/$or
-			lookupFilters.push(filter);
-		}
-		else {
-			rootFilters.push(filter);
-		}
-	});
-
-	return {rootFilters, lookupFilters};
-}
-
-function summarizeFilterTargets(filter: any, lookupAliases: Set<string>) {
-	const result = {hasLookup: false, hasRoot: false};
-
-	if (!filter || typeof filter !== 'object') {
-		return result;
-	}
-
-	Object.keys(filter).forEach(key => {
-		if (key === '$or' || key === '$and') {
-			const branch = filter[key];
-			if (Array.isArray(branch)) {
-				branch.forEach(child => {
-					const childSummary = summarizeFilterTargets(child, lookupAliases);
-					result.hasLookup = result.hasLookup || childSummary.hasLookup;
-					result.hasRoot = result.hasRoot || childSummary.hasRoot;
-				});
-			}
-		}
-		else {
-			const isLookup = isLookupPath(key, lookupAliases);
-			if (isLookup) {
-				result.hasLookup = true;
-			}
-			else {
-				result.hasRoot = true;
-			}
-		}
-	});
-
-	return result;
-}
-
-function isLookupPath(path: string, lookupAliases: Set<string>) {
-	if (!path) {
-		return false;
-	}
-
-	const normalizedPath = path.replace(/\.\$/g, '');
-
-	if (normalizedPath.includes('(Lookup')) {
-		return true;
-	}
-
-	const rootKey = normalizedPath.split('.')[0];
-	return lookupAliases.has(rootKey);
-}
-
-function extractLookupAlias(path: string) {
-	if (!path || !path.includes('(Lookup')) {
-		return '';
-	}
-
-	return path.replace(/\.\$/g, '').split('.')[0];
-}
-
-function normalizeLookupAlias(alias: string) {
-	return (alias || '').replace(/\.\$/g, '').trim();
-}
-
-function collectRootDatePaths(collectionName: string) {
-	const out = new Set<string>();
-	const collection = ResolveIOServer.getMongoManager().collection(collectionName);
-	const schema = collection?.rbSchema || {};
-
-	Object.keys(schema).forEach(path => {
-		if (schema[path]?.rbType === 'Date') {
-			out.add(path.replace(/\.\$/g, ''));
-		}
-	});
-
-	return out;
-}
-
-function coerceDateFilters(filters: any[] = [], datePaths: Set<string>) {
-	const coerceDateValue = (value: any): any => {
-		if (value instanceof Date) {
-			return value;
-		}
-		if (Array.isArray(value)) {
-			return value.map(coerceDateValue);
-		}
-		if (typeof value === 'string' || typeof value === 'number') {
-			const parsed = new Date(value);
-			if (!isNaN(parsed.getTime())) {
-				return parsed;
-			}
-		}
-		return value;
-	};
-
-	const coerceFilterObject = (obj: any): any => {
-		if (!obj || typeof obj !== 'object') {
-			return obj;
-		}
-
-		if (Array.isArray(obj)) {
-			obj.forEach(coerceFilterObject);
-			return obj;
-		}
-
-		if (obj.$or) {
-			obj.$or = obj.$or.map(coerceFilterObject).filter(Boolean);
-			return obj;
-		}
-
-		if (obj.$and) {
-			obj.$and = obj.$and.map(coerceFilterObject).filter(Boolean);
-			return obj;
-		}
-
-		Object.keys(obj).forEach(key => {
-			if (key.startsWith('$')) {
-				return;
-			}
-
-			const normalizedKey = key.replace(/\.\$/g, '');
-			if (!datePaths.has(normalizedKey)) {
-				return;
-			}
-
-			const value = obj[key];
-			if (value && typeof value === 'object' && !Array.isArray(value) && !(value instanceof Date)) {
-				Object.keys(value).forEach(op => {
-					if (op.startsWith('$')) {
-						value[op] = coerceDateValue(value[op]);
-					}
-				});
-			}
-			else {
-				obj[key] = coerceDateValue(value);
-			}
-		});
-
-		return obj;
-	};
-
-	(filters || []).forEach(coerceFilterObject);
-}
-
-// Helpers to support union-based joins (collection_joins without local/foreign key)
-function stripAliasFromPath(path: string, alias: string) {
-	if (!path) {
-		return path;
-	}
-
-	const cleanAlias = alias.replace(/\.\$/g, '');
-	const cleanPath = path.replace(/\.\$/g, '');
-
-	if (cleanPath.startsWith(cleanAlias + '.')) {
-		return cleanPath.substring(cleanAlias.length + 1);
-	}
-
-	return cleanPath;
-}
-
-function buildCollectionPipeline(collectionName: string, alias: string, selectedFields: any[] = [], filters: any[] = [], filterArrays: any[] = [], isRoot = false) {
-	const pipeline: any[] = [];
-	const matchClauses: any[] = [];
-	const matchArrayClauses: any[] = [];
-
-	const targetAlias = isRoot ? '' : alias.replace(/\.\$/g, '');
-
-	const mapFilterForCollection = (filterObj: any, toArray: boolean) => {
-		if (!filterObj || typeof filterObj !== 'object') {
-			return;
-		}
-
-		const mapped = mapFilterPaths(filterObj, targetAlias, isRoot);
-		if (mapped) {
-			(toArray ? matchArrayClauses : matchClauses).push(mapped);
-		}
-	};
-
-	(filters || []).forEach(f => mapFilterForCollection(f, false));
-	(filterArrays || []).forEach(f => mapFilterForCollection(f, true));
-
-	if (matchClauses.length || matchArrayClauses.length) {
-		const match: any = {$and: [...matchClauses, ...matchArrayClauses]};
-		pipeline.push({$match: match});
-
-		if (process.env.NODE_ENV !== 'production') {
-			console.info('RB debug: collection pipeline match', {
-				collection: collectionName,
-				alias: targetAlias || collectionName,
-				matchJson: JSON.stringify(match, null, 2)
-			});
-		}
-	}
-
-	// Projection mapping selected fields for this collection
-	const projection: any = {_id: 1, __rb_collection: targetAlias || collectionName};
-	(selectedFields || [])
-		.filter(f => isFieldForCollection(f, collectionName, targetAlias))
-			.forEach(f => {
-				const mappedPath = stripAliasFromPath(f.fieldPath || '', targetAlias || f.lookup_as || '');
-				if (f.leafValueType === 'Average') {
-					projection[f.id] = buildArrayAwareAverageFieldExpr(mappedPath);
-				}
-				else if (f.leafValueType === 'Sum') {
-					projection[f.id] = buildArrayAwareNumericFieldExpr(mappedPath);
-				}
-			else if (f.leafValueType === 'Count') {
-				projection[f.id] = {$sum: 1};
-			}
-			else if (f.leafValueType === 'Minimum') {
-				projection[f.id] = {$min: '$' + mappedPath};
-			}
-			else if (f.leafValueType === 'Maximum') {
-				projection[f.id] = {$max: '$' + mappedPath};
-			}
-			else {
-				projection[f.id] = '$' + mappedPath;
-			}
-		});
-
-	pipeline.push({$project: projection});
-
-	return pipeline;
-}
-
-function isFieldForCollection(field: any, collectionName: string, alias: string) {
-	if (!field) {
-		return false;
-	}
-
-	// Root collection check
-	if (!alias) {
-		return field.collection_name === collectionName && (!field.lookup_collection || field.lookup_collection === '');
-	}
-
-	// Joined collection check
-	return field.lookup_collection === collectionName || (field.lookup_as && field.lookup_as.replace(/\.\$/g, '') === alias);
-}
-
-function mapFilterPaths(filter: any, alias: string, isRoot: boolean) {
-	if (!filter || typeof filter !== 'object') {
-		return null;
-	}
-
-	if (Array.isArray(filter)) {
-		return filter.map(f => mapFilterPaths(f, alias, isRoot));
-	}
-
-	if (filter.$or) {
-		const mapped = filter.$or.map(f => mapFilterPaths(f, alias, isRoot)).filter(Boolean);
-		return mapped.length ? {$or: mapped} : null;
-	}
-
-	if (filter.$and) {
-		const mapped = filter.$and.map(f => mapFilterPaths(f, alias, isRoot)).filter(Boolean);
-		return mapped.length ? {$and: mapped} : null;
-	}
-
-	const out: any = {};
-	Object.keys(filter).forEach(key => {
-		const cleanKey = key.replace(/\.\$/g, '');
-
-		if (!alias) {
-			// root collection: ignore keys that start with a lookup alias
-			if (cleanKey.includes('(Lookup')) {
-				return;
-			}
-			if (lookupAliasMatches(cleanKey, alias)) {
-				return;
-			}
-			out[cleanKey] = filter[key];
-		}
-		else {
-			if (cleanKey.startsWith(alias + '.')) {
-				out[cleanKey.substring(alias.length + 1)] = filter[key];
-			}
-		}
-	});
-
-	return Object.keys(out).length ? out : null;
-}
-
-function lookupAliasMatches(path: string, alias: string) {
-	if (!path || !alias) {
-		return false;
-	}
-	return path.startsWith(alias + '.') || path === alias;
-}
-
-function buildLayoutSortSpec(sortSpec: any = {}, selectedFields: any[] = []) {
-	const outSort: any = {...sortSpec};
-	const addFields: any = {};
-
-	Object.keys(sortSpec || {}).forEach(key => {
-		if (!key.startsWith('layout_col_')) {
-			return;
-		}
-
-		const normalized = key.replace(/^layout_col_/, '');
-		const parts = normalized.split('_');
-		const idx = parseInt(parts[parts.length - 1], 10);
-
-		if (isNaN(idx)) {
-			return;
-		}
-
-		const layoutFields = (selectedFields || []).filter(f => typeof f?.layoutColumnIndex !== 'undefined' && f.layoutColumnIndex === idx).map(f => f.id).filter(Boolean);
-
-		if (!layoutFields.length) {
-			return;
-		}
-
-		// Build nested $ifNull chain to coalesce across layout column targets
-		let coalesce: any = '';
-		for (let i = layoutFields.length - 1; i >= 0; i--) {
-			const fieldPath = '$' + layoutFields[i];
-			if (i === layoutFields.length - 1) {
-				coalesce = fieldPath;
-			}
-			else {
-				coalesce = {$ifNull: [fieldPath, coalesce]};
-			}
-		}
-
-		const sortKey = 'sort_' + key;
-		addFields[sortKey] = coalesce;
-
-		delete outSort[key];
-		outSort[sortKey] = sortSpec[key];
-	});
-
-	return {sortSpec: outSort, addFields};
-}
-
-function remapFiltersToIds(filters: any[] = [], selectedFields: any[] = []) {
-	const byPath = new Map<string, string>();
-	const layoutMap = new Map<number, string[]>();
-	(selectedFields || []).forEach(f => {
-		if (f?.fieldPath && f?.id) {
-			byPath.set(f.fieldPath.replace(/\.\$/g, ''), f.id);
-		}
-
-		if (typeof f?.layoutColumnIndex !== 'undefined') {
-			const arr = layoutMap.get(f.layoutColumnIndex) || [];
-			arr.push(f.id);
-			layoutMap.set(f.layoutColumnIndex, arr);
-		}
-	});
-
-	const remapObj = (obj: any): any => {
-		if (!obj || typeof obj !== 'object') {
-			return obj;
-		}
-
-		if (Array.isArray(obj)) {
-			return obj.map(remapObj);
-		}
-
-		if (obj.$or) {
-			const mapped = obj.$or.map(remapObj).filter(Boolean);
-			return mapped.length ? {$or: mapped} : null;
-		}
-
-		if (obj.$and) {
-			const mapped = obj.$and.map(remapObj).filter(Boolean);
-			return mapped.length ? {$and: mapped} : null;
-		}
-
-		const out: any = {};
-		Object.keys(obj).forEach(key => {
-			const cleanKey = key.replace(/\.\$/g, '');
-			if (cleanKey.startsWith('layout_col_')) {
-				// map to all field ids in that layout column index
-				const normalized = cleanKey.replace(/^layout_col_/, '');
-				const parts = normalized.split('_');
-				const idx = parseInt(parts[parts.length - 1], 10);
-				const targets = layoutMap.get(idx) || [];
-
-				if (targets.length) {
-					const mappedVal = remapObj(obj[key]);
-					out.$or = targets.map(id => ({[id]: mappedVal}));
-					return;
-				}
-			}
-
-			const mappedKey = byPath.get(cleanKey) || cleanKey;
-			out[mappedKey] = remapObj(obj[key]);
-		});
-
-		return Object.keys(out).length ? out : null;
-	};
-
-	return (filters || []).map(remapObj).filter(Boolean);
-}
-
-function expandLayoutColumnFilters(filters: any[] = [], selectedFields: any[] = []) {
-	const layoutCache: {[key: string]: string[]} = {};
-
-	const resolveLayoutPaths = (layoutKey: string) => {
-		if (layoutCache[layoutKey]) {
-			return layoutCache[layoutKey];
-		}
-
-		let paths: string[] = [];
-		const normalized = (layoutKey || '').replace(/^layout_col_/, '');
-		const parts = normalized.split('_');
-		const idx = parseInt(parts[parts.length - 1], 10);
-
-		if (!isNaN(idx)) {
-			paths = (selectedFields || [])
-				.filter(f => f && (f.layoutColumnIndex === idx || (f.id || '').includes(`f_layout_${idx}_`)))
-				.map(f => f.fieldPath ? f.fieldPath.replace(/\.\$/g, '') : '')
-				.filter(p => !!p);
-		}
-
-		layoutCache[layoutKey] = paths;
-		return paths;
-	};
-
-	const expandFilterObject = (obj: any): any => {
-		if (!obj || typeof obj !== 'object' || Array.isArray(obj)) {
-			return obj;
-		}
-
-		if (obj.$or) {
-			return {$or: obj.$or.map(expandFilterObject)};
-		}
-
-		if (obj.$and) {
-			return {$and: obj.$and.map(expandFilterObject)};
-		}
-
-		let expanded: any = {};
-		let replaced = false;
-
-		Object.keys(obj).forEach(key => {
-			const val = obj[key];
-
-			if (key.startsWith('layout_col_')) {
-				const paths = resolveLayoutPaths(key);
-
-				if (paths.length) {
-					replaced = true;
-					expanded.$or = paths.map(path => ({[path]: val}));
-					// Use console to trace layout filter expansion without requiring a logger on ResolveIOServer
-					console.info('RB layout filter expansion', {layoutKey: key, paths});
-				}
-				else {
-					console.warn('RB layout filter expansion failed', {layoutKey: key, selectedFields});
-				}
-			}
-			else {
-				expanded[key] = val;
-			}
-		});
-
-		return replaced ? expanded : obj;
-	};
-
-	return (filters || []).map(expandFilterObject);
-}
-
-type ReportBuilderAiPayload = {
-	prompt?: string;
-	report_type?: string;
-	report_name?: string;
-	collection_root?: string;
-	collection_joins?: Array<{ collection?: string; alias?: string }>;
-	id_date_field?: string;
-	date_interval?: string;
-	permission_view?: string;
-	allow_mongo_read?: boolean;
-	mongo?: {
-		database?: string;
-		databases?: string[];
-		access?: string;
-		readonly?: boolean;
-	};
-	available_fields?: Array<{
-		field_path?: string;
-		field_path_name?: string;
-		field_type?: string;
-		collection_name?: string;
-	}>;
-	available_collections?: Array<{ collection?: string; name?: string }>;
-	id_client?: string;
-	guardrails?: boolean;
-	config?: {
-		model?: string;
-		temperature?: number;
-		max_tokens?: number;
-		response_format?: string;
-		reasoning_effort?: string;
-		timeout_ms?: number;
-	};
-	field_limit?: number;
-};
-
-type ReportBuilderAiResult = {
-	blocked?: boolean;
-	response?: string;
-	reason?: string;
-	patch?: any;
-	notes?: string;
-	usage?: {
-		input_tokens: number;
-		output_tokens: number;
-		total_tokens: number;
-	};
-	model?: string;
-};
-
-type GuardrailResult = { blocked: boolean; response: string; reason: string };
-type ReportTypeResolution = {
-	reportType: string;
-	inferenceReason: string;
-	inferredDateInterval: string;
-};
-
-async function executeReportBuilderAi(payload: ReportBuilderAiPayload, context: any): Promise<ReportBuilderAiResult> {
-	const input = payload || {};
-	const prompt = normalizeOptionalString(input.prompt);
-	if (!prompt) {
-		throw new Error('Prompt is required.');
-	}
-
-	const isSuperAdmin = await resolveIsSuperAdmin(context?.id_user);
-	const guardrailsEnabled = input.guardrails !== false && !isSuperAdmin;
-	if (guardrailsEnabled) {
-		const guardrail = evaluateReportBuilderGuardrails(prompt);
-		if (guardrail?.blocked) {
-			return guardrail;
-		}
-	}
-
-	const reportTypeResolution = resolveReportTypeForPrompt(input.report_type, prompt);
-	const reportType = reportTypeResolution.reportType;
-	const collectionRoot = normalizeOptionalString(input.collection_root);
-	const collectionJoins = Array.isArray(input.collection_joins) ? input.collection_joins : [];
-	const idDateField = normalizeOptionalString(input.id_date_field);
-	const dateInterval = normalizeDateInterval(input.date_interval) || reportTypeResolution.inferredDateInterval;
-
-	const collections = sanitizeCollections(input.available_collections || []);
-	const fieldLimit = normalizeFieldLimit(input.field_limit);
-	let resolvedFields = sanitizeFields(input.available_fields || []);
-	let usedFallbackFields = false;
-
-	if (!resolvedFields.length && collections.length) {
-		const derivedFields = deriveFieldsFromCollections(collections);
-		resolvedFields = sanitizeFields(derivedFields);
-		usedFallbackFields = resolvedFields.length > 0;
-	}
-
-	const trimmedFields = trimFieldsForPrompt(resolvedFields, fieldLimit, usedFallbackFields);
-	const arraySummary = buildArrayFieldSummary(trimmedFields.fields);
-
-	const systemPrompt = buildReportBuilderSystemPrompt(reportType);
-	let userPrompt = buildReportBuilderUserPrompt({
-		prompt,
-		reportType,
-		reportName: normalizeOptionalString(input.report_name),
-		collectionRoot,
-		collectionJoins,
-		idDateField,
-		dateInterval,
-		collections,
-		fields: trimmedFields.fields,
-		fieldMeta: {
-			truncated: trimmedFields.truncated,
-			total: trimmedFields.total,
-			used: trimmedFields.fields.length
-		},
-		arraySummary
-	});
-
-	const codexModel = resolveReportBuilderCodexModel(input.config);
-	const codexClient = getReportBuilderCodexClient();
-	const runOptions: CodexRunOptions = {
-		timeoutMs: resolveReportBuilderCodexTimeoutMs(input.config),
-		threadOptions: resolveReportBuilderCodexThreadOptions(input.config, codexModel)
-	};
-
-	let responseText = await codexClient.run(buildReportBuilderCodexPrompt(systemPrompt, userPrompt), runOptions);
-	let usage = estimateUsage(
-		[
-			{ role: 'system', content: systemPrompt },
-			{ role: 'user', content: userPrompt }
-		],
-		responseText,
-		codexModel
-	);
-
-	let parsed: any = safeJsonParse(responseText);
-	const allowMongoRead = input.allow_mongo_read === true;
-	if (allowMongoRead && parsed && typeof parsed === 'object' && parsed.mongo_read) {
-		const mongoPayload = resolveMongoReadPayload(parsed.mongo_read, input, collections);
-		if (mongoPayload) {
-			let mongoReadResult: any = null;
-			try {
-				mongoReadResult = await executeAiAssistantMongoRead(mongoPayload, context);
-			}
-			catch (error) {
-				const message = error instanceof Error ? error.message : String(error || 'Mongo read failed.');
-				mongoReadResult = { error: message };
-			}
-			const mongoContext = buildMongoReadContext(mongoPayload, mongoReadResult);
-			userPrompt = buildReportBuilderUserPrompt({
-				prompt,
-				reportType,
-				reportName: normalizeOptionalString(input.report_name),
-				collectionRoot,
-				collectionJoins,
-				idDateField,
-				dateInterval,
-				collections,
-				fields: trimmedFields.fields,
-				fieldMeta: {
-					truncated: trimmedFields.truncated,
-					total: trimmedFields.total,
-					used: trimmedFields.fields.length
-				},
-				arraySummary,
-				mongoReadResult: mongoContext
-			});
-			responseText = await codexClient.run(buildReportBuilderCodexPrompt(systemPrompt, userPrompt), runOptions);
-			const usage2 = estimateUsage(
-				[
-					{ role: 'system', content: systemPrompt },
-					{ role: 'user', content: userPrompt }
-				],
-				responseText,
-				codexModel
-			);
-			usage = {
-				inputTokens: usage.inputTokens + usage2.inputTokens,
-				outputTokens: usage.outputTokens + usage2.outputTokens,
-				totalTokens: usage.totalTokens + usage2.totalTokens
-			};
-			parsed = safeJsonParse(responseText);
-		}
-	}
-
-	if (!parsed || typeof parsed !== 'object') {
-		throw new Error('AI response was not valid JSON.');
-	}
-
-	const sanitizeContext = buildSanitizerContext(collections, resolvedFields);
-	const patch = sanitizeReportBuilderPatch(parsed, sanitizeContext);
-	patch.report_type = reportType;
-	if (reportType === 'Dated' && !patch.date_interval && dateInterval) {
-		patch.date_interval = dateInterval;
-	}
-
-	const summaryNotes = buildPatchNotes(patch, {
-		reportType,
-		truncated: trimmedFields.truncated,
-		totalFields: trimmedFields.total,
-		usedFields: trimmedFields.fields.length,
-		inferenceReason: reportTypeResolution.inferenceReason
-	});
-
-	const idClient = await resolveClientId(input.id_client, context?.id_user);
-	await recordOpenAIUsage({
-		id_client: idClient || '',
-		model: codexModel || 'unknown',
-		input_tokens: usage.inputTokens,
-		output_tokens: usage.outputTokens,
-		total_tokens: usage.totalTokens,
-		category: 'report-builder-ai',
-		id_request: ''
-	});
-
-	return {
-		patch,
-		notes: summaryNotes,
-		usage: {
-			input_tokens: usage.inputTokens,
-			output_tokens: usage.outputTokens,
-			total_tokens: usage.totalTokens
-		},
-		model: codexModel
-	};
-}
-
-function buildReportBuilderSystemPrompt(reportType: string): string {
-	return [
-		'You are a report builder configuration assistant.',
-		'Return ONLY a JSON object (no markdown).',
-		'Schema keys:',
-		'- report_name (string)',
-		'- collection_root (string)',
-		'- collection_joins (array of { collection, alias })',
-		'- layout_columns (array of { header, field_path, collection, mode, text, leaf_value_type, leaf_format_type, show })',
-		'- groups_row (array of field_path strings)',
-		'- filters (array of { field_path, condition, value, high_value, boolean_value, is_rolling, rolling_interval })',
-		'- sort (array of { field_path, order })',
-		'- totals (array of { type, fields })',
-		'- links (array of { field_first, field_second })',
-		'- id_date_field (string)',
-		'- date_interval (Seconds|Minutes|Hours|Daily|Weekly|Monthly|Quarterly|Yearly)',
-		'- notes (string)',
-		'Use only provided collections and field_path values (they reflect the current models/collections).',
-		'Always set collection_root to the best matching collection from available_collections.',
-		'When available_fields spans multiple collections, choose collection_root first and then select fields whose collection_name matches collection_root or a join alias.',
-		'Prefer exact field_path values from available_fields; never invent field paths.',
-		'Translate the request into concrete layout_columns, groups_row, sort, totals, filters, and links whenever possible.',
-		'Every layout column must be complete: include a header plus at least one mapping with a valid field_path (or text mode with non-empty text). Do not return columns without mapped fields.',
-		'Unless the user explicitly asks for a different order, add sort entries for the primary grouping/identifier fields (groups_row or the first key layout_columns) using ascending order so results are alphabetical.',
-		'Always prioritize sort on popular business keys when available: name, company, item (fallback: title, label, customer). Keep ascending unless user asks otherwise.',
-		'If no popular key exists, add stable fallback sort using createdAt/date_created then _id.',
-		'Use filters with explicit boolean logic: $and for required constraints and $or for alternate matches.',
-		'Use custom fields when the request asks for derived metrics (ratios, percentages, margins, computed totals).',
-		'If the request specifies a time grain (daily/weekly/monthly/etc), set date_interval and id_date_field to the best matching date field.',
-		'Treat requests like "over the last X", "by month", "by quarter", and "by <time period>" as Dated report intent.',
-		'If you need sample records to confirm field choices, you may return JSON with {"mongo_read": { "collection": "<collection>", "query": {}, "options": {"limit": 5} }, "notes": "why you need data"} .',
-		'Only request mongo_read when necessary and only use collections from available_collections.',
-		'When mongo_read_result is present in the user context, use it to finalize the patch and do not request another read.',
-		'Use field_type to guide filters/totals (numeric fields for totals, date fields for date_interval, boolean fields for boolean_value).',
-		'If field_summary.truncated is true, only use provided fields and note missing needs in notes.',
-		'If you need joined data, add collection_joins with an alias and use the alias in field_path.',
-		'When fields require related records, use lookup paths and joins rather than guessing flat field names.',
-		'array_summary lists array roots and candidate key_fields for linking arrays.',
-		'If you select fields from multiple array roots, add links that align arrays using shared identifiers (_id or id_<x> style keys).',
-		'Avoid mixing unrelated array roots without links; prefer a single array root or non-array fields to prevent duplicate rows.',
-		'Return a single valid JSON object with double quotes and no trailing commas.',
-		'Omit keys you cannot confidently fill.',
-		'Conditions allowed: eq, ne, lt, lte, gt, gte, bw, nnull, null, regex.',
-		`Report type: ${reportType || 'List'}. Ensure groups_row is set for Group/Dated reports.`,
-		'If unsure, leave a section empty instead of guessing.'
-	].join('\n');
-}
-
-function buildReportBuilderUserPrompt(input: {
-	prompt: string;
-	reportType: string;
-	reportName: string;
-	collectionRoot: string;
-	collectionJoins: Array<{ collection?: string; alias?: string }>;
-	idDateField: string;
-	dateInterval: string;
-	collections: Array<{ collection: string; name: string }>;
-	fields: Array<{ field_path: string; field_path_name: string; field_type: string; collection_name: string }>;
-	fieldMeta?: { truncated: boolean; total: number; used: number };
-	arraySummary?: Array<{ root_path: string; key_fields: string[]; sample_fields: string[] }>;
-	mongoReadResult?: any;
-}): string {
-	const context = {
-		report_type: input.reportType || 'List',
-		current: {
-			report_name: input.reportName || '',
-			collection_root: input.collectionRoot || '',
-			collection_joins: input.collectionJoins || [],
-			id_date_field: input.idDateField || '',
-			date_interval: input.dateInterval || ''
-		},
-		available_collections: input.collections || [],
-		available_fields: input.fields || [],
-		field_summary: input.fieldMeta || undefined,
-		array_summary: input.arraySummary || [],
-		mongo_read_result: input.mongoReadResult || undefined,
-		request: input.prompt
-	};
-	return JSON.stringify(context);
-}
-
-function resolveReportBuilderCodexTimeoutMs(config?: any): number {
-	const serverConfig = ResolveIOServer.getServerConfig() || {};
-	const raw = normalizeOptionalNumber(
-		config?.timeout_ms
-		|| serverConfig['REPORT_BUILDER_CODEX_TIMEOUT_MS']
-		|| process.env.REPORT_BUILDER_CODEX_TIMEOUT_MS
-	);
-	if (raw && raw > 0) {
-		return round(raw);
-	}
-	return DEFAULT_REPORT_BUILDER_CODEX_TIMEOUT_MS;
-}
-
-function resolveReportBuilderCodexModel(config?: any): string {
-	const serverConfig = ResolveIOServer.getServerConfig() || {};
-	const overrideModel = normalizeOptionalString(config?.model);
-	const raw = overrideModel
-		|| normalizeOptionalString(serverConfig['REPORT_BUILDER_CODEX_MODEL'] || process.env.REPORT_BUILDER_CODEX_MODEL)
-		|| normalizeOptionalString(serverConfig['AI_DASHBOARD_CODEX_MODEL'] || process.env.AI_DASHBOARD_CODEX_MODEL)
-		|| normalizeOptionalString(serverConfig['AI_TERMINAL_CODEX_MODEL'] || process.env.AI_TERMINAL_CODEX_MODEL)
-		|| normalizeOptionalString(serverConfig['AI_ASSISTANT_CODEX_MODEL'] || process.env.AI_ASSISTANT_CODEX_MODEL);
-	return raw;
-}
-
-function resolveReportBuilderCodexFallbackModels(model?: string): string[] {
-	const serverConfig = ResolveIOServer.getServerConfig() || {};
-	const primary = normalizeOptionalString(model || resolveReportBuilderCodexModel());
-	const models: string[] = [];
-	const push = (value: any) => {
-		const normalized = normalizeOptionalString(value);
-		if (!normalized || normalized === primary || models.includes(normalized)) {
-			return;
-		}
-		models.push(normalized);
-	};
-	const parseList = (value: any) => normalizeOptionalString(value)
-		.split(',')
-		.map(entry => normalizeOptionalString(entry))
-		.filter(Boolean)
-		.forEach(push);
-
-	parseList(serverConfig['REPORT_BUILDER_CODEX_FALLBACK_MODELS'] || process.env.REPORT_BUILDER_CODEX_FALLBACK_MODELS);
-	push(serverConfig['REPORT_BUILDER_CODEX_FALLBACK_MODEL'] || process.env.REPORT_BUILDER_CODEX_FALLBACK_MODEL);
-	parseList(serverConfig['AI_DASHBOARD_CODEX_FALLBACK_MODELS'] || process.env.AI_DASHBOARD_CODEX_FALLBACK_MODELS);
-	push(serverConfig['AI_DASHBOARD_CODEX_FALLBACK_MODEL'] || process.env.AI_DASHBOARD_CODEX_FALLBACK_MODEL);
-	parseList(serverConfig['AI_TERMINAL_CODEX_FALLBACK_MODELS'] || process.env.AI_TERMINAL_CODEX_FALLBACK_MODELS);
-	push(serverConfig['AI_TERMINAL_CODEX_FALLBACK_MODEL'] || process.env.AI_TERMINAL_CODEX_FALLBACK_MODEL);
-	parseList(serverConfig['AI_ASSISTANT_CODEX_FALLBACK_MODELS'] || process.env.AI_ASSISTANT_CODEX_FALLBACK_MODELS);
-	push(serverConfig['AI_ASSISTANT_CODEX_FALLBACK_MODEL'] || process.env.AI_ASSISTANT_CODEX_FALLBACK_MODEL);
-	return models;
-}
-
-function resolveReportBuilderCodexSettings(): CodexConfig {
-	const serverConfig = ResolveIOServer.getServerConfig() || {};
-	const apiKey = (serverConfig['OPENAI_API_KEY'] || process.env.OPENAI_API_KEY || '').trim();
-	if (!apiKey) {
-		throw new Error('AI API key missing. Add an AI API key to server config.');
-	}
-	const model = resolveReportBuilderCodexModel();
-	const fallbackModels = resolveReportBuilderCodexFallbackModels(model);
-	return {
-		apiKey,
-		baseUrl: (serverConfig['OPENAI_BASE_URL'] || process.env.OPENAI_BASE_URL || '').trim() || undefined,
-		...(model ? { model } : {}),
-		...(fallbackModels.length ? { fallbackModel: fallbackModels[0], fallbackModels } : {}),
-		maxRetries: normalizeOptionalNumber(serverConfig['OPENAI_MAX_RETRIES'] || process.env.OPENAI_MAX_RETRIES),
-		retryDelayMs: normalizeOptionalNumber(serverConfig['OPENAI_RETRY_DELAY_MS'] || process.env.OPENAI_RETRY_DELAY_MS)
-	};
-}
-
-function resolveReportBuilderCodexThreadOptions(config?: any, model?: string): CodexThreadOptions {
-	const serverConfig = ResolveIOServer.getServerConfig() || {};
-	const effort = normalizeReasoningEffort(
-		config?.reasoning_effort
-		|| serverConfig['REPORT_BUILDER_CODEX_REASONING_EFFORT']
-		|| process.env.REPORT_BUILDER_CODEX_REASONING_EFFORT
-	) || 'low';
-	return {
-		...(model ? { model } : {}),
-		sandboxMode: 'read-only',
-		skipGitRepoCheck: true,
-		modelReasoningEffort: effort,
-		networkAccessEnabled: false,
-		webSearchMode: 'disabled',
-		webSearchEnabled: false,
-		approvalPolicy: 'never'
-	};
-}
-
-function getReportBuilderCodexClient(): CodexClient {
-	if (!reportBuilderCodexClient) {
-		reportBuilderCodexClient = new CodexClient(resolveReportBuilderCodexSettings());
-	}
-	return reportBuilderCodexClient;
-}
-
-function buildReportBuilderCodexPrompt(systemPrompt: string, userPrompt: string): string {
-	return `System:\n${systemPrompt}\n\nUser:\n${userPrompt}`.trim();
-}
-
-function resolveReportTypeForPrompt(inputType: string | undefined, prompt: string): ReportTypeResolution {
-	const requestedType = normalizeReportType(inputType);
-	const inferredInterval = inferDateIntervalFromPrompt(prompt);
-	if (!isDatedPrompt(prompt)) {
-		return {
-			reportType: requestedType,
-			inferenceReason: '',
-			inferredDateInterval: inferredInterval
-		};
-	}
-	const reason = requestedType !== 'Dated'
-		? 'Auto-inferred Dated report from time-period language in the request.'
-		: '';
-	return {
-		reportType: 'Dated',
-		inferenceReason: reason,
-		inferredDateInterval: inferredInterval
-	};
-}
-
-function isDatedPrompt(prompt: string): boolean {
-	const text = normalizeOptionalString(prompt).toLowerCase();
-	if (!text) {
-		return false;
-	}
-	const patterns = [
-		/\b(by|per)\s+(day|week|month|quarter|year|hour|minute|second)s?\b/i,
-		/\b(daily|weekly|monthly|quarterly|yearly)\b/i,
-		/\b(last|past|previous|recent)\s+(?:\d+|one|two|three|four|five|six|seven|eight|nine|ten|eleven|twelve)\s+(day|week|month|quarter|year|hour|minute|second)s?\b/i,
-		/\bover\s+the\s+last\s+(?:\d+|one|two|three|four|five|six|seven|eight|nine|ten|eleven|twelve)\s+(day|week|month|quarter|year|hour|minute|second)s?\b/i,
-		/\b(month|quarter|year)\s+over\s+(month|quarter|year)\b/i,
-		/\b(over\s+time|time\s*series|trend(?:ing|s)?)\b/i,
-		/\bby\s+(?:a\s+)?(?:time|date)\s+period\b/i,
-		/\bby\s+period\b/i
-	];
-	return patterns.some(pattern => pattern.test(text));
-}
-
-function inferDateIntervalFromPrompt(prompt: string): string {
-	const text = normalizeOptionalString(prompt).toLowerCase();
-	if (!text) {
-		return '';
-	}
-	const mapping: Array<{ interval: string; pattern: RegExp }> = [
-		{ interval: 'Quarterly', pattern: /\b(quarter|quarters|quarterly|qoq)\b/i },
-		{ interval: 'Monthly', pattern: /\b(month|months|monthly|mom)\b/i },
-		{ interval: 'Weekly', pattern: /\b(week|weeks|weekly|wow)\b/i },
-		{ interval: 'Daily', pattern: /\b(day|days|daily)\b/i },
-		{ interval: 'Yearly', pattern: /\b(year|years|yearly|yoy)\b/i },
-		{ interval: 'Hours', pattern: /\b(hour|hours|hourly)\b/i },
-		{ interval: 'Minutes', pattern: /\b(minute|minutes)\b/i },
-		{ interval: 'Seconds', pattern: /\b(second|seconds)\b/i }
-	];
-	const matched = mapping.find(entry => entry.pattern.test(text));
-	return matched?.interval || '';
-}
-
-function normalizeReportType(value?: string): string {
-	const normalized = normalizeOptionalString(value);
-	if (normalized.toLowerCase() === 'group') {
-		return 'Group';
-	}
-	if (normalized.toLowerCase() === 'dated') {
-		return 'Dated';
-	}
-	return normalized ? toTitleCase(normalized) : 'List';
-}
-
-function normalizeOptionalString(value: any): string {
-	const raw = typeof value === 'string' ? value.trim() : '';
-	return raw || '';
-}
-
-function normalizeOptionalNumber(value: any): number | undefined {
-	const parsed = Number(value);
-	return Number.isFinite(parsed) ? parsed : undefined;
-}
-
-function normalizeReasoningEffort(value: any): CodexThreadOptions['modelReasoningEffort'] | undefined {
-	const normalized = normalizeOptionalString(value).toLowerCase();
-	const allowed = new Set(['minimal', 'low', 'medium', 'high', 'xhigh']);
-	return allowed.has(normalized) ? (normalized as CodexThreadOptions['modelReasoningEffort']) : undefined;
-}
-
-function normalizeFieldLimit(value: any): number {
-	const parsed = Number(value);
-	if (!Number.isFinite(parsed)) {
-		return 600;
-	}
-	return Math.max(50, Math.min(round(parsed), 2000));
-}
-
-function estimateUsage(messages: Array<{ role: string; content: string }>, responseText: string, model?: string) {
-	const inputTokens = countChatTokens(messages, model);
-	const outputTokens = countTokens(responseText || '', model);
-	return {
-		inputTokens,
-		outputTokens,
-		totalTokens: inputTokens + outputTokens
-	};
-}
-
-function sanitizeCollections(raw: Array<{ collection?: string; name?: string }>): Array<{ collection: string; name: string }> {
-	const out: Array<{ collection: string; name: string }> = [];
-	const seen = new Set<string>();
-	(raw || []).forEach(entry => {
-		const collection = normalizeOptionalString(entry?.collection);
-		if (!collection) {
-			return;
-		}
-		const key = collection.toLowerCase();
-		if (seen.has(key)) {
-			return;
-		}
-		seen.add(key);
-		out.push({
-			collection,
-			name: normalizeOptionalString(entry?.name) || toTitleCase(collection.replace(/[-_]/g, ' '))
-		});
-	});
-	return out;
-}
-
-function sanitizeFields(raw: Array<any>): Array<{ field_path: string; field_path_name: string; field_type: string; collection_name: string }> {
-	const out: Array<{ field_path: string; field_path_name: string; field_type: string; collection_name: string }> = [];
-	const seen = new Set<string>();
-	(raw || []).forEach(entry => {
-		const fieldPath = normalizeOptionalString(entry?.field_path || entry?.fieldPath);
-		if (!fieldPath) {
-			return;
-		}
-		const key = fieldPath.toLowerCase();
-		if (seen.has(key)) {
-			return;
-		}
-		seen.add(key);
-		out.push({
-			field_path: fieldPath,
-			field_path_name: normalizeOptionalString(entry?.field_path_name || entry?.fieldPathName || entry?.field_name) || fieldPath,
-			field_type: normalizeOptionalString(entry?.field_type || entry?.fieldType || entry?.field_type_name || entry?.fieldTypeName) || 'String',
-			collection_name: normalizeOptionalString(entry?.collection_name || entry?.collectionName || entry?.collection) || ''
-		});
-	});
-	return out;
-}
-
-function resolveCollectionNameFromList(value: any, collections: Array<{ collection: string; name: string }>): string {
-	const key = normalizeKey(value);
-	if (!key) {
-		return '';
-	}
-	for (const col of collections || []) {
-		if (normalizeKey(col.collection) === key || normalizeKey(col.name) === key) {
-			return col.collection;
-		}
-	}
-	return '';
-}
-
-function resolveMongoReadPayload(raw: any, input: ReportBuilderAiPayload, collections: Array<{ collection: string; name: string }>): AiAssistantMongoReadInput | null {
-	if (!raw || typeof raw !== 'object') {
-		return null;
-	}
-	const collection = resolveCollectionNameFromList(raw.collection || raw.collection_name || raw.collectionName, collections);
-	if (!collection) {
-		return null;
-	}
-	const query = raw.query && typeof raw.query === 'object' && !Array.isArray(raw.query) ? raw.query : {};
-	const optionsRaw = raw.options && typeof raw.options === 'object' ? raw.options : {};
-	const limitRaw = normalizeOptionalNumber(optionsRaw.limit);
-	const skipRaw = normalizeOptionalNumber(optionsRaw.skip);
-	const permissionView = normalizeOptionalString((input as any).permission_view || (input as any).permissionView) || '/report-builder';
-	const request: AiAssistantMongoReadInput = {
-		collection,
-		database: normalizeOptionalString(raw.database) || undefined,
-		query,
-		options: {
-			projection: optionsRaw.projection && typeof optionsRaw.projection === 'object' ? optionsRaw.projection : undefined,
-			sort: optionsRaw.sort && typeof optionsRaw.sort === 'object' ? optionsRaw.sort : undefined,
-			limit: limitRaw ? Math.min(Math.max(round(limitRaw), 1), 10) : 5,
-			skip: skipRaw ? Math.max(round(skipRaw), 0) : undefined,
-			includeTotal: optionsRaw.includeTotal === true
-		},
-		permissionView: permissionView || undefined,
-		id_client: normalizeOptionalString(input.id_client) || undefined,
-		mongo: input.mongo
-	};
-	return request;
-}
-
-function buildMongoReadContext(request: AiAssistantMongoReadInput, response: any) {
-	const documents = Array.isArray(response?.documents) ? response.documents : [];
-	const total = typeof response?.total === 'number' ? response.total : null;
-	const sample = summarizeMongoDocuments(documents);
-	return {
-		request: {
-			collection: request.collection,
-			query: request.query || {},
-			options: request.options || {}
-		},
-		result: {
-			total,
-			sample,
-			fields: extractMongoSampleFields(sample)
-		}
-	};
-}
-
-function summarizeMongoDocuments(documents: any[]) {
-	const maxDocs = 5;
-	return (documents || []).slice(0, maxDocs).map(doc => pruneMongoValue(doc, 0));
-}
-
-function pruneMongoValue(value: any, depth: number): any {
-	const maxDepth = 3;
-	const maxKeys = 30;
-	const maxArray = 8;
-	const maxString = 200;
-
-	if (depth >= maxDepth) {
-		return '[Truncated]';
-	}
-	if (Array.isArray(value)) {
-		return value.slice(0, maxArray).map(item => pruneMongoValue(item, depth + 1));
-	}
-	if (value && typeof value === 'object') {
-		const keys = Object.keys(value);
-		const trimmedKeys = keys.slice(0, maxKeys);
-		const result: any = {};
-		trimmedKeys.forEach(key => {
-			result[key] = pruneMongoValue(value[key], depth + 1);
-		});
-		if (keys.length > trimmedKeys.length) {
-			result.__truncated__ = true;
-		}
-		return result;
-	}
-	if (typeof value === 'string' && value.length > maxString) {
-		return value.slice(0, maxString) + '...';
-	}
-	return value;
-}
-
-function extractMongoSampleFields(samples: any[]): string[] {
-	const fields = new Set<string>();
-	(samples || []).forEach(sample => {
-		if (!sample || typeof sample !== 'object') {
-			return;
-		}
-		Object.keys(sample).forEach(key => fields.add(key));
-	});
-	return Array.from(fields);
-}
-
-function collectTreeLeaves(items: any[], res: any[]) {
-	(items || []).forEach(item => {
-		if (item?.isLeaf) {
-			res.push(item);
-			return;
-		}
-		if (item?.children?.length) {
-			collectTreeLeaves(item.children, res);
-		}
-	});
-}
-
-function deriveFieldsFromCollections(collections: Array<{ collection: string; name: string }>) {
-	const fields: Array<{ field_path: string; field_path_name: string; field_type: string; collection_name: string }> = [];
-	const seen = new Set<string>();
-
-	(collections || []).forEach(col => {
-		const collectionName = normalizeOptionalString(col?.collection);
-		if (!collectionName) {
-			return;
-		}
-
-		let tree: any;
-		try {
-			tree = buildCollectionTree(collectionName);
-		}
-		catch (error) {
-			const message = error instanceof Error ? error.message : String(error || 'Unknown error');
-			console.warn('RB AI field derivation failed', {collection: collectionName, error: message});
-			return;
-		}
-
-		const leaves: any[] = [];
-		collectTreeLeaves(tree?.children || [], leaves);
-
-		leaves.forEach(leaf => {
-			const fieldPath = normalizeOptionalString(leaf?.fieldPath);
-			if (!fieldPath) {
-				return;
-			}
-			const key = fieldPath.toLowerCase();
-			if (seen.has(key)) {
-				return;
-			}
-			seen.add(key);
-			fields.push({
-				field_path: fieldPath,
-				field_path_name: normalizeOptionalString(leaf?.fieldPathName) || fieldPath,
-				field_type: normalizeOptionalString(leaf?.fieldType) || 'String',
-				collection_name: normalizeOptionalString(leaf?.collection_name || leaf?.collection) || collectionName
-			});
-		});
-	});
-
-	return fields;
-}
-
-function trimFieldsForPrompt(
-	fields: Array<{ field_path: string; field_path_name: string; field_type: string; collection_name: string }>,
-	limit: number,
-	balanceByCollection = false
-) {
-	if (!fields || !fields.length) {
-		return { fields: [], truncated: false, total: 0 };
-	}
-	if (fields.length <= limit) {
-		return { fields, truncated: false, total: fields.length };
-	}
-
-	if (balanceByCollection) {
-		const buckets = new Map<string, Array<{ field_path: string; field_path_name: string; field_type: string; collection_name: string }>>();
-		const order: string[] = [];
-
-		fields.forEach(field => {
-			const key = normalizeOptionalString(field?.collection_name) || 'unknown';
-			if (!buckets.has(key)) {
-				buckets.set(key, []);
-				order.push(key);
-			}
-			buckets.get(key)?.push(field);
-		});
-
-		if (buckets.size > 1) {
-			const trackers = order.map(key => ({
-				key,
-				list: buckets.get(key) || [],
-				index: 0
-			}));
-			const trimmed: Array<{ field_path: string; field_path_name: string; field_type: string; collection_name: string }> = [];
-			let added = true;
-
-			while (trimmed.length < limit && added) {
-				added = false;
-				for (const tracker of trackers) {
-					if (trimmed.length >= limit) {
-						break;
-					}
-					if (tracker.index < tracker.list.length) {
-						trimmed.push(tracker.list[tracker.index]);
-						tracker.index += 1;
-						added = true;
-					}
-				}
-			}
-
-			return { fields: trimmed, truncated: true, total: fields.length };
-		}
-	}
-
-	const trimmed = fields.slice(0, limit);
-	return { fields: trimmed, truncated: true, total: fields.length };
-}
-
-function buildArrayFieldSummary(
-	fields: Array<{ field_path: string; field_path_name: string; field_type: string; collection_name: string }>
-): Array<{ root_path: string; key_fields: string[]; sample_fields: string[] }> {
-	const roots = new Map<string, { root_path: string; key_fields: string[]; sample_fields: string[] }>();
-	(fields || []).forEach(field => {
-		const fieldPath = normalizeOptionalString(field?.field_path);
-		if (!fieldPath || !fieldPath.includes('.$')) {
-			return;
-		}
-		const root = resolveArrayRoot(fieldPath);
-		if (!root) {
-			return;
-		}
-		let entry = roots.get(root);
-		if (!entry) {
-			entry = { root_path: root, key_fields: [], sample_fields: [] };
-			roots.set(root, entry);
-		}
-		if (!entry.sample_fields.includes(fieldPath) && entry.sample_fields.length < 8) {
-			entry.sample_fields.push(fieldPath);
-		}
-		if (isLinkCandidateFieldPath(fieldPath) && !entry.key_fields.includes(fieldPath) && entry.key_fields.length < 8) {
-			entry.key_fields.push(fieldPath);
-		}
-	});
-	return Array.from(roots.values());
-}
-
-function buildSanitizerContext(
-	collections: Array<{ collection: string; name: string }>,
-	fields: Array<{ field_path: string; field_path_name: string; field_type: string; collection_name: string }>
-) {
-	const collectionIndex = new Map<string, { collection: string; name: string }>();
-	const fieldIndex = new Map<string, { field_path: string; field_path_name: string; field_type: string; collection_name: string }>();
-	const fieldNameIndex = new Map<string, string>();
-
-	collections.forEach(col => {
-		const key = normalizeKey(col.collection);
-		if (key) {
-			collectionIndex.set(key, col);
-		}
-		const nameKey = normalizeKey(col.name);
-		if (nameKey) {
-			collectionIndex.set(nameKey, col);
-		}
-	});
-
-	fields.forEach(field => {
-		const pathKey = normalizePathKey(field.field_path);
-		if (pathKey) {
-			fieldIndex.set(pathKey, field);
-		}
-		const nameKey = normalizeKey(field.field_path_name);
-		if (nameKey && !fieldNameIndex.has(nameKey)) {
-			fieldNameIndex.set(nameKey, field.field_path);
-		}
-	});
-
-	return { collectionIndex, fieldIndex, fieldNameIndex };
-}
-
-function sanitizeReportBuilderPatch(raw: any, ctx: ReturnType<typeof buildSanitizerContext>) {
-	const patch: any = {};
-	if (!raw || typeof raw !== 'object') {
-		return patch;
-	}
-
-	const reportName = normalizeOptionalString(raw.report_name || raw.reportName || raw.title);
-	if (reportName) {
-		patch.report_name = reportName.slice(0, 120);
-	}
-
-	const collectionRoot = resolveCollectionName(raw.collection_root || raw.collectionRoot, ctx);
-	if (collectionRoot) {
-		patch.collection_root = collectionRoot;
-	}
-
-	const joinsRaw = Array.isArray(raw.collection_joins || raw.joins) ? (raw.collection_joins || raw.joins) : [];
-	const joins: Array<{ collection: string; alias?: string }> = [];
-	joinsRaw.forEach((join: any) => {
-		const collection = resolveCollectionName(join?.collection || join?.name, ctx);
-		if (!collection) {
-			return;
-		}
-		const alias = sanitizeAlias(join?.alias);
-		joins.push({ collection, ...(alias ? { alias } : {}) });
-	});
-	if (joins.length) {
-		patch.collection_joins = joins;
-	}
-
-	const layoutColumnsRaw = Array.isArray(raw.layout_columns || raw.columns || raw.layout) ? (raw.layout_columns || raw.columns || raw.layout) : [];
-	const layoutColumns: any[] = [];
-	layoutColumnsRaw.forEach((col: any) => {
-		if (!col || typeof col !== 'object') {
-			return;
-		}
-		let header = normalizeOptionalString(col.header || col.title || col.name);
-		let fieldPath = resolveFieldPath(col.field_path || col.fieldPath || col.field || col.field_name || col.fieldName || col.path, ctx);
-		if (!fieldPath && header) {
-			fieldPath = resolveFieldPath(header, ctx);
-		}
-		const mappingsRaw = Array.isArray(col.mappings) ? col.mappings : [];
-		const mappings: any[] = [];
-		mappingsRaw.forEach((map: any) => {
-			const mappedField = resolveFieldPath(map?.field_path || map?.fieldPath || map?.field || map?.field_name || map?.fieldName || map?.path || map?.name, ctx);
-			const mode = normalizeLayoutMode(map?.mode);
-			const text = normalizeOptionalString(map?.text);
-			const collection = resolveCollectionName(map?.collection, ctx);
-			if (mode === 'text') {
-				if (text) {
-					mappings.push({
-						mode,
-						text,
-						collection
-					});
-				}
-			}
-			else if (mappedField) {
-				mappings.push({
-					mode,
-					field_path: mappedField,
-					collection,
-					leaf_value_type: normalizeOptionalString(map?.leaf_value_type || map?.leafValueType),
-					leaf_format_type: normalizeOptionalString(map?.leaf_format_type || map?.leafFormatType),
-					show: typeof map?.show === 'boolean' ? map.show : undefined
-				});
-			}
-		});
-
-		if (!mappings.length) {
-			if (fieldPath) {
-				mappings.push({ field_path: fieldPath, mode: normalizeLayoutMode(col.mode) });
-			}
-			else {
-				const text = normalizeOptionalString(col.text);
-				const mode = normalizeLayoutMode(col.mode);
-				if ((mode === 'text' || text) && text) {
-					mappings.push({
-						mode: 'text',
-						text,
-						collection: resolveCollectionName(col.collection, ctx)
-					});
-				}
-			}
-		}
-
-		if (!fieldPath) {
-			const firstMapped = mappings.find(mapping => !!mapping?.field_path);
-			if (firstMapped?.field_path) {
-				fieldPath = firstMapped.field_path;
-			}
-		}
-
-		if (!header && fieldPath) {
-			const meta = ctx.fieldIndex.get(normalizePathKey(fieldPath));
-			header = normalizeOptionalString(meta?.field_path_name);
-		}
-
-		if (!mappings.length) {
-			return;
-		}
-
-		layoutColumns.push({
-			header: header || '',
-			field_path: fieldPath || '',
-			collection: resolveCollectionName(col.collection, ctx),
-			mode: normalizeLayoutMode(col.mode),
-			text: normalizeOptionalString(col.text),
-			mappings
-		});
-	});
-
-	if (!layoutColumns.length && Array.isArray(raw.selected_fields)) {
-		(raw.selected_fields || []).forEach((field: any) => {
-			const fieldPath = resolveFieldPath(field, ctx);
-			if (!fieldPath) {
-				return;
-			}
-			layoutColumns.push({
-				header: '',
-				field_path: fieldPath,
-				mappings: [{ field_path: fieldPath }]
-			});
-		});
-	}
-
-	if (layoutColumns.length) {
-		patch.layout_columns = layoutColumns;
-	}
-
-	const groupsRowRaw = Array.isArray(raw.groups_row) ? raw.groups_row : [];
-	const groupsRow = groupsRowRaw.map((entry: any) => resolveFieldPath(entry, ctx)).filter(Boolean);
-	if (groupsRow.length) {
-		patch.groups_row = groupsRow;
-	}
-
-	const filtersRaw = Array.isArray(raw.filters) ? raw.filters : [];
-	const filters: any[] = [];
-	filtersRaw.forEach((filter: any) => {
-		const fieldPath = resolveFieldPath(filter?.field_path || filter?.fieldPath, ctx);
-		if (!fieldPath) {
-			return;
-		}
-		const fieldMeta = ctx.fieldIndex.get(normalizePathKey(fieldPath));
-		const condition = normalizeFilterCondition(filter?.condition);
-		if (!condition) {
-			return;
-		}
-		const value = normalizeFilterValue(filter?.value, fieldMeta?.field_type);
-		const highValue = normalizeFilterValue(filter?.high_value, fieldMeta?.field_type);
-		const booleanValue = normalizeBooleanValue(filter?.boolean_value);
-		filters.push({
-			field_path: fieldPath,
-			condition,
-			value,
-			high_value: highValue,
-			boolean_value: booleanValue,
-			is_rolling: typeof filter?.is_rolling === 'boolean' ? filter.is_rolling : undefined,
-			rolling_interval: normalizeOptionalString(filter?.rolling_interval)
-		});
-	});
-	if (filters.length) {
-		patch.filters = filters;
-	}
-
-	const sortRaw = Array.isArray(raw.sort) ? raw.sort : [];
-	const sort: any[] = [];
-	sortRaw.forEach((entry: any) => {
-		const fieldPath = resolveFieldPath(entry?.field_path || entry?.fieldPath, ctx);
-		if (!fieldPath) {
-			return;
-		}
-		sort.push({
-			field_path: fieldPath,
-			order: normalizeSortOrder(entry?.order)
-		});
-	});
-	if (sort.length) {
-		patch.sort = sort;
-	}
-	else {
-		const defaultSortFields = buildDefaultSortFields(groupsRow, layoutColumns);
-		if (defaultSortFields.length) {
-			patch.sort = defaultSortFields.map(field_path => ({ field_path, order: 'asc' }));
-		}
-	}
-
-	const totalsRaw = Array.isArray(raw.totals) ? raw.totals : [];
-	const totals: any[] = [];
-	totalsRaw.forEach((total: any) => {
-		const type = normalizeTotalType(total?.type);
-		const fields = Array.isArray(total?.fields) ? total.fields : [];
-		const mappedFields = fields.map((field: any) => resolveFieldPath(field, ctx)).filter(Boolean);
-		if (!type || !mappedFields.length) {
-			return;
-		}
-		totals.push({ type, fields: mappedFields });
-	});
-	if (totals.length) {
-		patch.totals = totals;
-	}
-
-	const linksRaw = Array.isArray(raw.links) ? raw.links : [];
-	const links: any[] = [];
-	linksRaw.forEach((link: any) => {
-		const first = resolveFieldPath(link?.field_first || link?.fieldFirst, ctx);
-		const second = resolveFieldPath(link?.field_second || link?.fieldSecond, ctx);
-		if (!first || !second) {
-			return;
-		}
-		links.push({ field_first: first, field_second: second });
-	});
-	if (links.length) {
-		patch.links = links;
-	}
-
-	const dateField = resolveFieldPath(raw.id_date_field || raw.date_field || raw.dateField, ctx);
-	if (dateField) {
-		patch.id_date_field = dateField;
-	}
-
-	const dateInterval = normalizeDateInterval(raw.date_interval || raw.dateInterval);
-	if (dateInterval) {
-		patch.date_interval = dateInterval;
-	}
-
-	const notes = normalizeOptionalString(raw.notes || raw.summary || raw.message);
-	if (notes) {
-		patch.notes = notes.slice(0, 400);
-	}
-
-	return patch;
-}
-
-function buildDefaultSortFields(groupsRow: string[], layoutColumns: any[]): string[] {
-	const fields: string[] = [];
-	const addField = (fieldPath?: string) => {
-		const normalized = normalizeOptionalString(fieldPath);
-		if (normalized && !fields.includes(normalized)) {
-			fields.push(normalized);
-		}
-	};
-
-	(groupsRow || []).forEach(addField);
-	if (fields.length) {
-		return fields;
-	}
-
-	(layoutColumns || []).forEach((col: any) => {
-		if (!col || typeof col !== 'object') {
-			return;
-		}
-		let fieldPath = '';
-		const mappings = Array.isArray(col.mappings) ? col.mappings : [];
-		for (const mapping of mappings) {
-			if (mapping?.field_path) {
-				fieldPath = mapping.field_path;
-				break;
-			}
-		}
-		if (!fieldPath && col.field_path) {
-			fieldPath = col.field_path;
-		}
-		addField(fieldPath);
-	});
-
-	return fields;
-}
-
-function buildPatchNotes(
-	patch: any,
-	meta: { reportType: string; truncated: boolean; totalFields: number; usedFields: number; inferenceReason?: string }
-) {
-	const columns = Array.isArray(patch?.layout_columns) ? patch.layout_columns.length : 0;
-	const groups = Array.isArray(patch?.groups_row) ? patch.groups_row.length : 0;
-	const filters = Array.isArray(patch?.filters) ? patch.filters.length : 0;
-	const joins = Array.isArray(patch?.collection_joins) ? patch.collection_joins.length : 0;
-	const parts = [
-		`AI suggested ${columns} column${columns === 1 ? '' : 's'}`,
-		groups ? `${groups} group${groups === 1 ? '' : 's'}` : '',
-		filters ? `${filters} filter${filters === 1 ? '' : 's'}` : '',
-		joins ? `${joins} join${joins === 1 ? '' : 's'}` : ''
-	].filter(Boolean);
-	let note = parts.length ? parts.join(', ') + '.' : 'AI suggestions ready.';
-	if (patch?.notes) {
-		note += ` ${patch.notes}`;
-	}
-	if (meta.inferenceReason) {
-		note += ` ${meta.inferenceReason}`;
-	}
-	if (meta.truncated) {
-		note += ` Field list trimmed to ${meta.usedFields} of ${meta.totalFields} available fields.`;
-	}
-	return note;
-}
-
-function normalizeLayoutMode(value: any): 'variable' | 'text' {
-	const normalized = normalizeOptionalString(value).toLowerCase();
-	return normalized === 'text' ? 'text' : 'variable';
-}
-
-function normalizeFilterCondition(value: any): string {
-	const allowed = new Set(['eq', 'ne', 'lt', 'lte', 'gt', 'gte', 'bw', 'nnull', 'null', 'regex']);
-	const normalized = normalizeOptionalString(value).toLowerCase();
-	return allowed.has(normalized) ? normalized : '';
-}
-
-function normalizeSortOrder(value: any): string {
-	const normalized = normalizeOptionalString(value).toLowerCase();
-	return normalized === 'dsc' || normalized === 'desc' ? 'dsc' : 'asc';
-}
-
-function normalizeTotalType(value: any): string {
-	const normalized = normalizeOptionalString(value).toLowerCase();
-	if (normalized === 'avg' || normalized === 'sum') {
-		return normalized;
-	}
-	return '';
-}
-
-function normalizeDateInterval(value: any): string {
-	const normalized = normalizeOptionalString(value);
-	if (!normalized) {
-		return '';
-	}
-	const map: Record<string, string> = {
-		seconds: 'Seconds',
-		minutes: 'Minutes',
-		hours: 'Hours',
-		daily: 'Daily',
-		weekly: 'Weekly',
-		monthly: 'Monthly',
-		quarterly: 'Quarterly',
-		yearly: 'Yearly'
-	};
-	const key = normalized.toLowerCase();
-	return map[key] || '';
-}
-
-function normalizeFilterValue(value: any, fieldType?: string): any {
-	if (fieldType === 'Number') {
-		const num = Number(value);
-		return Number.isFinite(num) ? num : value;
-	}
-	if (fieldType === 'Boolean') {
-		if (value === true || value === false) {
-			return value;
-		}
-		if (typeof value === 'string') {
-			return value.toLowerCase() === 'true';
-		}
-		return value;
-	}
-	if (fieldType === 'Date') {
-		if (value instanceof Date) {
-			return value;
-		}
-		if (typeof value === 'string') {
-			const parsed = new Date(value);
-			return isNaN(parsed.getTime()) ? value : parsed.toISOString();
-		}
-	}
-	return value;
-}
-
-function normalizeBooleanValue(value: any): boolean | undefined {
-	if (value === true || value === false) {
-		return value;
-	}
-	if (typeof value === 'string') {
-		if (value.toLowerCase() === 'true') {
-			return true;
-		}
-		if (value.toLowerCase() === 'false') {
-			return false;
-		}
-	}
-	return undefined;
-}
-
-function resolveCollectionName(value: any, ctx: ReturnType<typeof buildSanitizerContext>): string {
-	const key = normalizeKey(value);
-	if (!key) {
-		return '';
-	}
-	const found = ctx.collectionIndex.get(key);
-	return found ? found.collection : '';
-}
-
-function resolveFieldPath(value: any, ctx: ReturnType<typeof buildSanitizerContext>): string {
-	const pathKey = normalizePathKey(value);
-	if (pathKey && ctx.fieldIndex.has(pathKey)) {
-		return ctx.fieldIndex.get(pathKey)?.field_path || '';
-	}
-	const nameKey = normalizeKey(value);
-	if (nameKey && ctx.fieldNameIndex.has(nameKey)) {
-		return ctx.fieldNameIndex.get(nameKey) || '';
-	}
-	return '';
-}
-
-function sanitizeAlias(value: any): string {
-	const alias = normalizeOptionalString(value);
-	if (!alias) {
-		return '';
-	}
-	return alias.replace(/[^\w\- ]/g, '').trim().slice(0, 40);
-}
-
-function normalizeKey(value: any): string {
-	return normalizeOptionalString(value).toLowerCase().replace(/[^a-z0-9]+/g, '');
-}
-
-function normalizePathKey(value: any): string {
-	return normalizeOptionalString(value).toLowerCase();
-}
-
-function resolveArrayRoot(path: string): string {
-	const raw = normalizeOptionalString(path);
-	if (!raw) {
-		return '';
-	}
-	const idx = raw.indexOf('.$');
-	if (idx === -1) {
-		return '';
-	}
-	return raw.slice(0, idx);
-}
-
-function isLinkCandidateFieldPath(path: string): boolean {
-	const normalized = normalizeOptionalString(path).toLowerCase();
-	if (!normalized) {
-		return false;
-	}
-	const last = (normalized.split('.').pop() || '').replace(/\$/g, '');
-	if (!last) {
-		return false;
-	}
-	if (last === 'id' || last === '_id') {
-		return true;
-	}
-	if (last.endsWith('_id') || last.endsWith('_uuid') || last.endsWith('_guid')) {
-		return true;
-	}
-	if (last.startsWith('id_')) {
-		return true;
-	}
-	return false;
-}
-
-function safeJsonParse(value: string): any {
-	if (!value) {
-		return null;
-	}
-	try {
-		return JSON.parse(value);
-	}
-	catch {
-		const match = value.match(/\{[\s\S]*\}/);
-		if (!match) {
-			return null;
-		}
-		try {
-			return JSON.parse(match[0]);
-		}
-		catch {
-			return null;
-		}
-	}
-}
-
-function evaluateReportBuilderGuardrails(message: string): GuardrailResult | null {
-	const normalized = String(message || '').toLowerCase();
-	const patterns: Array<{ pattern: RegExp; reason: string }> = [
-		{ pattern: /\b(source\s*code|full\s*code|entire\s*code|repo\s*dump|repository|git\s*clone)\b/i, reason: 'Code access is restricted.' },
-		{ pattern: /\b(credentials?|passwords?|secrets?|tokens?)\b/i, reason: 'Credentials and secrets are restricted.' },
-		{ pattern: /\b(delete|drop|truncate)\s+(database|db|schema|table)\b/i, reason: 'Database operations are restricted.' },
-		{ pattern: /\b(shell|terminal|ssh|sudo|rm\s+-rf|chmod|chown)\b/i, reason: 'Server operations are restricted.' },
-		{ pattern: /\b(exploit|bypass|malware|phishing|ransomware|ddos|sql\s*injection)\b/i, reason: 'Security abuse is restricted.' },
-		{ pattern: /\b(credit\s*card|social\s*security|ssn|bank\s*account)\b/i, reason: 'Sensitive personal data is restricted.' }
-	];
-	for (const entry of patterns) {
-		if (entry.pattern.test(normalized)) {
-			return {
-				blocked: true,
-				reason: entry.reason,
-				response: 'I can’t help with that request because it could access restricted systems or data. Please describe the report you need (fields, filters, timeframe) and I can configure it safely.'
-			};
-		}
-	}
-	return null;
-}
-
-async function resolveIsSuperAdmin(id_user?: string): Promise<boolean> {
-	if (!id_user) {
-		return false;
-	}
-	try {
-		const user = await Users.findById(id_user);
-		return !!user?.roles?.super_admin;
-	}
-	catch {
-		return false;
-	}
-}
-
-async function resolveClientId(idClientInput?: string, idUser?: string): Promise<string> {
-	const normalized = normalizeOptionalString(idClientInput);
-	if (normalized) {
-		return normalized;
-	}
-	if (!idUser) {
-		return '';
-	}
-	try {
-		const user = await Users.findById(idUser);
-		const fromOther = normalizeOptionalString(user?.other?.id_client || user?.other?.idClient);
-		return fromOther;
-	}
-	catch {
-		return '';
-	}
-}