@resolveio/server-lib 20.14.6 → 20.14.8

package/methods/cron-jobs.js

@@ -84,12 +84,15 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.loadCronJobMethods = loadCronJobMethods;
+var axios_1 = require("axios");
 var Excel = require("exceljs");
 var moment = require("moment-timezone");
 var simpl_schema_1 = require("simpl-schema");
 var cron_job_collection_1 = require("../collections/cron-job.collection");
 var file_collection_1 = require("../collections/file.collection");
+var openai_usage_ledger_collection_1 = require("../collections/openai-usage-ledger.collection");
 var report_builder_report_collection_1 = require("../collections/report-builder-report.collection");
+var resolveio_server_app_1 = require("../resolveio-server-app");
 var common_1 = require("../util/common");
 function getFilterTargets(fieldPath, report) {
     if (!fieldPath) {
@@ -789,6 +792,103 @@ function applyClientGroupSortToData(results, report, sorts) {
     };
     sortGroupLevel(results, 0);
 }
+var OPENAI_USAGE_BILLING_ENDPOINT = 'https://backend.resolveio.com/api/openai-usage/report';
+var OPENAI_USAGE_DEFAULT_LOOKBACK_DAYS = 30;
+var OPENAI_USAGE_DEFAULT_BATCH_SIZE = 500;
+var OPENAI_USAGE_DEFAULT_OVERLAP_MINUTES = 10;
+var toNumberSetting = function (value, fallback, allowZero) {
+    if (allowZero === void 0) { allowZero = false; }
+    var parsed = Number(value);
+    if (!Number.isFinite(parsed)) {
+        return fallback;
+    }
+    if (allowZero && parsed === 0) {
+        return 0;
+    }
+    return parsed > 0 ? Math.floor(parsed) : fallback;
+};
+var normalizeString = function (value) {
+    if (typeof value !== 'string') {
+        return '';
+    }
+    return value.trim();
+};
+var normalizeIdentifier = function (value) {
+    if (value === undefined || value === null) {
+        return '';
+    }
+    return String(value).trim();
+};
+var normalizeDate = function (value) {
+    if (!value) {
+        return null;
+    }
+    var date = value instanceof Date ? value : new Date(value);
+    if (Number.isNaN(date.getTime())) {
+        return null;
+    }
+    return date;
+};
+var resolveOpenAIUsageSyncConfig = function () {
+    var _a, _b;
+    var config = ((_a = resolveio_server_app_1.ResolveIOServer.getServerConfig) === null || _a === void 0 ? void 0 : _a.call(resolveio_server_app_1.ResolveIOServer)) || {};
+    var endpoint = normalizeString(config['OPENAI_USAGE_BILLING_URL']
+        || config['OPENAI_USAGE_REPORT_URL']
+        || process.env.OPENAI_USAGE_BILLING_URL
+        || process.env.OPENAI_USAGE_REPORT_URL) || OPENAI_USAGE_BILLING_ENDPOINT;
+    var apiKey = normalizeString(config['OPENAI_USAGE_INGEST_KEY']
+        || config['OPENAI_USAGE_API_KEY']
+        || process.env.OPENAI_USAGE_INGEST_KEY
+        || process.env.OPENAI_USAGE_API_KEY
+        || process.env.OPENAI_USAGE_REPORT_KEY);
+    var batchSize = toNumberSetting(config['OPENAI_USAGE_SYNC_BATCH_SIZE'] || process.env.OPENAI_USAGE_SYNC_BATCH_SIZE, OPENAI_USAGE_DEFAULT_BATCH_SIZE);
+    var lookbackDays = toNumberSetting(config['OPENAI_USAGE_SYNC_LOOKBACK_DAYS'] || process.env.OPENAI_USAGE_SYNC_LOOKBACK_DAYS, OPENAI_USAGE_DEFAULT_LOOKBACK_DAYS);
+    var overlapMinutes = toNumberSetting(config['OPENAI_USAGE_SYNC_OVERLAP_MINUTES'] || process.env.OPENAI_USAGE_SYNC_OVERLAP_MINUTES, OPENAI_USAGE_DEFAULT_OVERLAP_MINUTES, true);
+    var enabledRaw = (_b = config['OPENAI_USAGE_SYNC_ENABLED']) !== null && _b !== void 0 ? _b : process.env.OPENAI_USAGE_SYNC_ENABLED;
+    var enabled = typeof enabledRaw === 'string'
+        ? enabledRaw.trim().toLowerCase() !== 'false' && enabledRaw.trim() !== '0'
+        : enabledRaw !== false;
+    return { config: config, endpoint: endpoint, apiKey: apiKey, batchSize: batchSize, lookbackDays: lookbackDays, overlapMinutes: overlapMinutes, enabled: enabled };
+};
+var buildOpenAIUsageQuery = function (cursorAt, cursorId) {
+    var base = {
+        billable: { $ne: false }
+    };
+    if (!cursorId) {
+        base.timestamp = { $gte: cursorAt };
+        return base;
+    }
+    base.$or = [
+        { timestamp: { $gt: cursorAt } },
+        { timestamp: cursorAt, _id: { $gt: cursorId } }
+    ];
+    return base;
+};
+var normalizeUsagePayloadEntry = function (entry) {
+    if (!entry) {
+        return null;
+    }
+    var timestamp = normalizeDate(entry.timestamp);
+    var idClient = normalizeIdentifier(entry.id_client);
+    if (!timestamp || !idClient) {
+        return null;
+    }
+    var id = normalizeIdentifier(entry._id) || normalizeIdentifier(entry.id) || '';
+    return {
+        _id: id || undefined,
+        id_client: idClient,
+        timestamp: timestamp,
+        model: normalizeString(entry.model) || 'unknown',
+        input_tokens: Number(entry.input_tokens || 0),
+        output_tokens: Number(entry.output_tokens || 0),
+        total_tokens: Number(entry.total_tokens || 0),
+        cost_estimate: Number(entry.cost_estimate || 0),
+        billable: entry.billable !== false,
+        category: normalizeString(entry.category),
+        id_request: normalizeIdentifier(entry.id_request),
+        id_conversation: normalizeIdentifier(entry.id_conversation)
+    };
+};
 function loadCronJobMethods(methodManager) {
     methodManager.methods({
         cronEmailMergedDocsCleanUp: {
@@ -836,6 +936,111 @@ function loadCronJobMethods(methodManager) {
                 });
             }
         },
+        cronOpenAIUsageBillingSync: {
+            function: function () {
+                return __awaiter(this, void 0, void 0, function () {
+                    var _a, config, endpoint, apiKey, batchSize, lookbackDays, overlapMinutes, enabled, rootUrl, jobDoc, runData, lastSyncedAt, lastSyncedId, lookbackMs, cursorAt, cursorId, totalSent, cursorMoved, source, i, query, entries, payloadEntries, lastEntry;
+                    var _b;
+                    return __generator(this, function (_c) {
+                        switch (_c.label) {
+                            case 0:
+                                _a = resolveOpenAIUsageSyncConfig(), config = _a.config, endpoint = _a.endpoint, apiKey = _a.apiKey, batchSize = _a.batchSize, lookbackDays = _a.lookbackDays, overlapMinutes = _a.overlapMinutes, enabled = _a.enabled;
+                                if (!enabled) {
+                                    return [2 /*return*/, true];
+                                }
+                                rootUrl = normalizeString(config['ROOT_URL']);
+                                if (rootUrl === 'https://resolveio.com' || rootUrl === 'http://localhost:4200') {
+                                    return [2 /*return*/, true];
+                                }
+                                if (!endpoint || !apiKey) {
+                                    console.warn('[OpenAI Usage Sync] Missing endpoint or API key.');
+                                    return [2 /*return*/, false];
+                                }
+                                return [4 /*yield*/, cron_job_collection_1.CronJobs.findOne({ name: 'OpenAI Usage Billing Sync' })];
+                            case 1:
+                                jobDoc = _c.sent();
+                                runData = jobDoc === null || jobDoc === void 0 ? void 0 : jobDoc.method_run_data;
+                                lastSyncedAt = normalizeDate(runData === null || runData === void 0 ? void 0 : runData.last_synced_at);
+                                lastSyncedId = normalizeString(runData === null || runData === void 0 ? void 0 : runData.last_synced_id);
+                                lookbackMs = lookbackDays * 24 * 60 * 60 * 1000;
+                                cursorAt = lastSyncedAt || new Date(Date.now() - lookbackMs);
+                                if (lastSyncedAt && overlapMinutes > 0) {
+                                    cursorAt = new Date(cursorAt.getTime() - overlapMinutes * 60 * 1000);
+                                }
+                                cursorId = lastSyncedId;
+                                totalSent = 0;
+                                cursorMoved = false;
+                                source = {
+                                    clientSlug: (_b = resolveio_server_app_1.ResolveIOServer.getClientName) === null || _b === void 0 ? void 0 : _b.call(resolveio_server_app_1.ResolveIOServer),
+                                    clientName: normalizeString(config['CLIENT_NAME']),
+                                    rootUrl: rootUrl,
+                                    reportedAt: new Date(),
+                                    appVersion: process.env.APP_VERSION
+                                };
+                                i = 0;
+                                _c.label = 2;
+                            case 2:
+                                if (!(i < 1000)) return [3 /*break*/, 7];
+                                query = buildOpenAIUsageQuery(cursorAt, cursorId);
+                                return [4 /*yield*/, openai_usage_ledger_collection_1.OpenAIUsageLedger.find(query, {
+                                        sort: { timestamp: 1, _id: 1 },
+                                        limit: batchSize
+                                    })];
+                            case 3:
+                                entries = _c.sent();
+                                if (!entries.length) {
+                                    return [3 /*break*/, 7];
+                                }
+                                payloadEntries = entries
+                                    .map(function (entry) { return normalizeUsagePayloadEntry(entry); })
+                                    .filter(Boolean);
+                                if (!payloadEntries.length) return [3 /*break*/, 5];
+                                return [4 /*yield*/, axios_1.default.post(endpoint, { entries: payloadEntries, source: source }, {
+                                        headers: {
+                                            'Content-Type': 'application/json',
+                                            'X-ResolveIO-OpenAI-Usage-Key': apiKey,
+                                            'X-OpenAI-Usage-Key': apiKey,
+                                            'X-API-Key': apiKey
+                                        },
+                                        timeout: 20000
+                                    })];
+                            case 4:
+                                _c.sent();
+                                totalSent += payloadEntries.length;
+                                _c.label = 5;
+                            case 5:
+                                lastEntry = entries[entries.length - 1];
+                                if (lastEntry) {
+                                    cursorAt = normalizeDate(lastEntry.timestamp) || cursorAt;
+                                    cursorId = normalizeString(lastEntry._id) || cursorId;
+                                    cursorMoved = true;
+                                }
+                                if (entries.length < batchSize) {
+                                    return [3 /*break*/, 7];
+                                }
+                                _c.label = 6;
+                            case 6:
+                                i++;
+                                return [3 /*break*/, 2];
+                            case 7:
+                                if (!cursorMoved) return [3 /*break*/, 9];
+                                return [4 /*yield*/, cron_job_collection_1.CronJobs.updateOne({ name: 'OpenAI Usage Billing Sync' }, {
+                                        $set: {
+                                            'method_run_data.last_synced_at': cursorAt,
+                                            'method_run_data.last_synced_id': cursorId,
+                                            'method_run_data.last_sent_at': new Date(),
+                                            'method_run_data.last_sent_count': totalSent
+                                        }
+                                    })];
+                            case 8:
+                                _c.sent();
+                                _c.label = 9;
+                            case 9: return [2 /*return*/, true];
+                        }
+                    });
+                });
+            }
+        },
         reportbuilderCronJob: {
             check: new simpl_schema_1.default({
                 data: {