@resolveio/server-lib 20.14.1 → 20.14.3

package/methods/report-builder.js

@@ -90,11 +90,14 @@ var user_collection_1 = require("../collections/user.collection");
 var openai_usage_ledger_manager_1 = require("../managers/openai-usage-ledger.manager");
 var pagination_model_1 = require("../models/pagination.model");
 var resolveio_server_app_1 = require("../resolveio-server-app");
-var openai_client_1 = require("../services/openai-client");
+var codex_client_1 = require("../services/codex-client");
 var common_1 = require("../util/common");
 var report_builder_unwinds_1 = require("../util/report-builder-unwinds");
 var schema_report_builder_1 = require("../util/schema-report-builder");
 var tokenizer_1 = require("../util/tokenizer");
+var DEFAULT_REPORT_BUILDER_CODEX_MODEL = 'gpt-5.2-codex';
+var DEFAULT_REPORT_BUILDER_CODEX_TIMEOUT_MS = 60000;
+var reportBuilderCodexClient = null;
 function loadReportBuilderMethods(methodManager) {
     methodManager.methods({
         reportBuilderAiSuggest: {
@@ -1660,10 +1663,9 @@ function expandLayoutColumnFilters(filters, selectedFields) {
 }
 function executeReportBuilderAi(payload, context) {
     return __awaiter(this, void 0, void 0, function () {
-        var input, prompt, isSuperAdmin, guardrailsEnabled, guardrail, reportType, collectionRoot, collectionJoins, collections, resolvedFields, fieldLimit, trimmedFields, systemPrompt, userPrompt, openaiSettings, client, responseFormat, response, usage, parsed, sanitizeContext, patch, summaryNotes, idClient;
-        var _a;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
+        var input, prompt, isSuperAdmin, guardrailsEnabled, guardrail, reportType, collectionRoot, collectionJoins, collections, resolvedFields, fieldLimit, trimmedFields, arraySummary, systemPrompt, userPrompt, codexModel, codexClient, codexPrompt, runOptions, responseText, usage, parsed, sanitizeContext, patch, summaryNotes, idClient;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
                 case 0:
                     input = payload || {};
                     prompt = normalizeOptionalString(input.prompt);
@@ -1672,7 +1674,7 @@ function executeReportBuilderAi(payload, context) {
                     }
                     return [4 /*yield*/, resolveIsSuperAdmin(context === null || context === void 0 ? void 0 : context.id_user)];
                 case 1:
-                    isSuperAdmin = _b.sent();
+                    isSuperAdmin = _a.sent();
                     guardrailsEnabled = input.guardrails !== false && !isSuperAdmin;
                     if (guardrailsEnabled) {
                         guardrail = evaluateReportBuilderGuardrails(prompt);
@@ -1687,6 +1689,7 @@ function executeReportBuilderAi(payload, context) {
                     resolvedFields = sanitizeFields(input.available_fields || []);
                     fieldLimit = normalizeFieldLimit(input.field_limit);
                     trimmedFields = trimFieldsForPrompt(resolvedFields, fieldLimit);
+                    arraySummary = buildArrayFieldSummary(trimmedFields.fields);
                     systemPrompt = buildReportBuilderSystemPrompt(reportType);
                     userPrompt = buildReportBuilderUserPrompt({
                         prompt: prompt,
@@ -1697,22 +1700,29 @@ function executeReportBuilderAi(payload, context) {
                         idDateField: normalizeOptionalString(input.id_date_field),
                         dateInterval: normalizeOptionalString(input.date_interval),
                         collections: collections,
-                        fields: trimmedFields.fields
+                        fields: trimmedFields.fields,
+                        fieldMeta: {
+                            truncated: trimmedFields.truncated,
+                            total: trimmedFields.total,
+                            used: trimmedFields.fields.length
+                        },
+                        arraySummary: arraySummary
                     });
-                    openaiSettings = resolveReportBuilderOpenAISettings(input.config);
-                    client = new openai_client_1.OpenAIClient(openaiSettings);
-                    responseFormat = normalizeOpenAIResponseFormat((_a = input.config) === null || _a === void 0 ? void 0 : _a.response_format) || 'json';
-                    return [4 /*yield*/, client.chat([
-                            { role: 'system', content: systemPrompt },
-                            { role: 'user', content: userPrompt }
-                        ], { timeoutMs: 60000, responseFormat: responseFormat })];
+                    codexModel = resolveReportBuilderCodexModel(input.config);
+                    codexClient = getReportBuilderCodexClient();
+                    codexPrompt = buildReportBuilderCodexPrompt(systemPrompt, userPrompt);
+                    runOptions = {
+                        timeoutMs: resolveReportBuilderCodexTimeoutMs(input.config),
+                        threadOptions: resolveReportBuilderCodexThreadOptions(input.config, codexModel)
+                    };
+                    return [4 /*yield*/, codexClient.run(codexPrompt, runOptions)];
                 case 2:
-                    response = _b.sent();
-                    usage = response.usage || estimateUsage([
+                    responseText = _a.sent();
+                    usage = estimateUsage([
                         { role: 'system', content: systemPrompt },
                         { role: 'user', content: userPrompt }
-                    ], response.content, response.model || openaiSettings.model);
-                    parsed = safeJsonParse(response.content);
+                    ], responseText, codexModel);
+                    parsed = safeJsonParse(responseText);
                     if (!parsed || typeof parsed !== 'object') {
                         throw new Error('AI response was not valid JSON.');
                     }
@@ -1726,20 +1736,20 @@ function executeReportBuilderAi(payload, context) {
                     });
                     return [4 /*yield*/, resolveClientId(input.id_client, context === null || context === void 0 ? void 0 : context.id_user)];
                 case 3:
-                    idClient = _b.sent();
+                    idClient = _a.sent();
                     if (!idClient) return [3 /*break*/, 5];
                     return [4 /*yield*/, (0, openai_usage_ledger_manager_1.recordOpenAIUsage)({
                             id_client: idClient,
-                            model: response.model || openaiSettings.model || 'unknown',
+                            model: codexModel || 'unknown',
                             input_tokens: usage.inputTokens,
                             output_tokens: usage.outputTokens,
                             total_tokens: usage.totalTokens,
                             category: 'report-builder-ai',
-                            id_request: response.requestId || ''
+                            id_request: ''
                         })];
                 case 4:
-                    _b.sent();
-                    _b.label = 5;
+                    _a.sent();
+                    _a.label = 5;
                 case 5: return [2 /*return*/, {
                         patch: patch,
                         notes: summaryNotes,
@@ -1748,7 +1758,7 @@ function executeReportBuilderAi(payload, context) {
                             output_tokens: usage.outputTokens,
                             total_tokens: usage.totalTokens
                         },
-                        model: response.model || openaiSettings.model
+                        model: codexModel
                     }];
             }
         });
@@ -1771,7 +1781,17 @@ function buildReportBuilderSystemPrompt(reportType) {
         '- id_date_field (string)',
         '- date_interval (Seconds|Minutes|Hours|Daily|Weekly|Monthly|Quarterly|Yearly)',
         '- notes (string)',
-        'Use only provided collections and field_path values.',
+        '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.',
+        'Prefer exact field_path values from available_fields; never invent field paths.',
+        '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.',
+        'array_summary lists array roots and candidate key_fields for linking arrays.',
+        'If you select fields from multiple array roots, add links that align the arrays using key_fields.',
+        '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: ".concat(reportType || 'List', ". Ensure groups_row is set for Group/Dated reports."),
         'If unsure, leave a section empty instead of guessing.'
@@ -1789,32 +1809,62 @@ function buildReportBuilderUserPrompt(input) {
         },
         available_collections: input.collections || [],
         available_fields: input.fields || [],
+        field_summary: input.fieldMeta || undefined,
+        array_summary: input.arraySummary || [],
         request: input.prompt
     };
     return JSON.stringify(context);
 }
-function resolveReportBuilderOpenAISettings(config) {
-    var _a;
+function resolveReportBuilderCodexTimeoutMs(config) {
+    var serverConfig = resolveio_server_app_1.ResolveIOServer.getServerConfig() || {};
+    var raw = normalizeOptionalNumber((config === null || config === void 0 ? void 0 : config.timeout_ms)
+        || serverConfig['REPORT_BUILDER_CODEX_TIMEOUT_MS']
+        || process.env.REPORT_BUILDER_CODEX_TIMEOUT_MS);
+    if (raw && raw > 0) {
+        return (0, common_1.round)(raw);
+    }
+    return DEFAULT_REPORT_BUILDER_CODEX_TIMEOUT_MS;
+}
+function resolveReportBuilderCodexModel(config) {
+    var serverConfig = resolveio_server_app_1.ResolveIOServer.getServerConfig() || {};
+    var overrideModel = normalizeOptionalString(config === null || config === void 0 ? void 0 : config.model);
+    var 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 || DEFAULT_REPORT_BUILDER_CODEX_MODEL;
+}
+function resolveReportBuilderCodexSettings() {
     var serverConfig = resolveio_server_app_1.ResolveIOServer.getServerConfig() || {};
     var apiKey = (serverConfig['OPENAI_API_KEY'] || process.env.OPENAI_API_KEY || '').trim();
     if (!apiKey) {
         throw new Error('OpenAI API key missing. Add OPENAI_API_KEY to server config.');
     }
-    var overrideModel = normalizeOptionalString(config === null || config === void 0 ? void 0 : config.model);
-    var model = overrideModel
-        || normalizeOptionalString(serverConfig['REPORT_BUILDER_OPENAI_MODEL'] || process.env.REPORT_BUILDER_OPENAI_MODEL)
-        || normalizeOptionalString(serverConfig['OPENAI_MODEL'] || process.env.OPENAI_MODEL)
-        || 'gpt-5.1';
     return {
         apiKey: apiKey,
         baseUrl: (serverConfig['OPENAI_BASE_URL'] || process.env.OPENAI_BASE_URL || '').trim() || undefined,
-        model: model,
-        temperature: (_a = normalizeOptionalNumber(config === null || config === void 0 ? void 0 : config.temperature)) !== null && _a !== void 0 ? _a : 0.2,
-        maxTokens: normalizeOptionalNumber(config === null || config === void 0 ? void 0 : config.max_tokens),
+        model: resolveReportBuilderCodexModel(),
         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, model) {
+    var serverConfig = resolveio_server_app_1.ResolveIOServer.getServerConfig() || {};
+    var effort = normalizeReasoningEffort((config === null || config === void 0 ? void 0 : config.reasoning_effort)
+        || serverConfig['REPORT_BUILDER_CODEX_REASONING_EFFORT']
+        || process.env.REPORT_BUILDER_CODEX_REASONING_EFFORT) || 'low';
+    return __assign(__assign({}, (model ? { model: model } : {})), { sandboxMode: 'read-only', skipGitRepoCheck: true, modelReasoningEffort: effort, networkAccessEnabled: false, webSearchMode: 'disabled', webSearchEnabled: false, approvalPolicy: 'never' });
+}
+function getReportBuilderCodexClient() {
+    if (!reportBuilderCodexClient) {
+        reportBuilderCodexClient = new codex_client_1.CodexClient(resolveReportBuilderCodexSettings());
+    }
+    return reportBuilderCodexClient;
+}
+function buildReportBuilderCodexPrompt(systemPrompt, userPrompt) {
+    return "System:\n".concat(systemPrompt, "\n\nUser:\n").concat(userPrompt).trim();
+}
 function normalizeReportType(value) {
     var normalized = normalizeOptionalString(value);
     if (normalized.toLowerCase() === 'group') {
@@ -1833,28 +1883,10 @@ function normalizeOptionalNumber(value) {
     var parsed = Number(value);
     return Number.isFinite(parsed) ? parsed : undefined;
 }
-function normalizeOpenAIResponseFormat(value) {
-    if (!value) {
-        return undefined;
-    }
-    if (typeof value === 'string') {
-        var normalized = value.trim().toLowerCase();
-        if (!normalized) {
-            return undefined;
-        }
-        if (normalized === 'text' || normalized === 'json' || normalized === 'json_object') {
-            return normalized;
-        }
-        return { type: normalized };
-    }
-    if (typeof value === 'object') {
-        var typeValue = normalizeOptionalString(value.type);
-        if (!typeValue) {
-            return undefined;
-        }
-        return __assign(__assign({}, value), { type: typeValue });
-    }
-    return undefined;
+function normalizeReasoningEffort(value) {
+    var normalized = normalizeOptionalString(value).toLowerCase();
+    var allowed = new Set(['minimal', 'low', 'medium', 'high', 'xhigh']);
+    return allowed.has(normalized) ? normalized : undefined;
 }
 function normalizeFieldLimit(value) {
     var parsed = Number(value);
@@ -1924,6 +1956,31 @@ function trimFieldsForPrompt(fields, limit) {
     var trimmed = fields.slice(0, limit);
     return { fields: trimmed, truncated: true, total: fields.length };
 }
+function buildArrayFieldSummary(fields) {
+    var roots = new Map();
+    (fields || []).forEach(function (field) {
+        var fieldPath = normalizeOptionalString(field === null || field === void 0 ? void 0 : field.field_path);
+        if (!fieldPath || !fieldPath.includes('.$')) {
+            return;
+        }
+        var root = resolveArrayRoot(fieldPath);
+        if (!root) {
+            return;
+        }
+        var 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, fields) {
     var collectionIndex = new Map();
     var fieldIndex = new Map();
@@ -2259,6 +2316,37 @@ function normalizeKey(value) {
 function normalizePathKey(value) {
     return normalizeOptionalString(value).toLowerCase();
 }
+function resolveArrayRoot(path) {
+    var raw = normalizeOptionalString(path);
+    if (!raw) {
+        return '';
+    }
+    var idx = raw.indexOf('.$');
+    if (idx === -1) {
+        return '';
+    }
+    return raw.slice(0, idx);
+}
+function isLinkCandidateFieldPath(path) {
+    var normalized = normalizeOptionalString(path).toLowerCase();
+    if (!normalized) {
+        return false;
+    }
+    var 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) {
     if (!value) {
         return null;