manifest 5.33.20 → 5.34.0

package/README.md

@@ -97,6 +97,7 @@ Works with 300+ models across these providers:
 | [Z.ai (Zhipu)](https://z.ai/)                                                  | `glm-5`, `glm-4.7`, `glm-4.5` + 5 more                               |
 | [OpenRouter](https://openrouter.ai/)                                           | 300+ models from all providers                                       |
 | [Ollama](https://ollama.com/)                                                  | Run any model locally (Llama, Gemma, Mistral, ...)                   |
+| Custom providers                                                               | Any provider with an OpenAI-compatible API endpoint                  |
 
 ## Contributing
 

package/dist/backend/analytics/services/messages-query.service.js

@@ -22,6 +22,7 @@ const query_helpers_1 = require("./query-helpers");
 const tenant_cache_service_1 = require("../../common/services/tenant-cache.service");
 const sql_dialect_1 = require("../../common/utils/sql-dialect");
 const provider_inference_1 = require("../../common/utils/provider-inference");
+const ttl_cache_1 = require("../../common/utils/ttl-cache");
 const MODELS_CACHE_TTL_MS = 60_000;
 const COUNT_CACHE_TTL_MS = 30_000;
 const MAX_CACHE_ENTRIES = 5_000;
@@ -30,8 +31,14 @@ let MessagesQueryService = class MessagesQueryService {
     dataSource;
     tenantCache;
     dialect;
-    modelsCache = new Map();
-    countCache = new Map();
+    modelsCache = new ttl_cache_1.TtlCache({
+        maxSize: MAX_CACHE_ENTRIES,
+        ttlMs: MODELS_CACHE_TTL_MS,
+    });
+    countCache = new ttl_cache_1.TtlCache({
+        maxSize: MAX_CACHE_ENTRIES,
+        ttlMs: COUNT_CACHE_TTL_MS,
+    });
     constructor(turnRepo, dataSource, tenantCache) {
         this.turnRepo = turnRepo;
         this.dataSource = dataSource;
@@ -104,7 +111,7 @@ let MessagesQueryService = class MessagesQueryService {
             }
         }
         const cachedCount = params.cursor ? this.countCache.get(countCacheKey) : undefined;
-        const countHit = cachedCount && cachedCount.expiresAt > Date.now();
+        const countHit = cachedCount !== undefined;
         const [countResult, rows, allModels] = await Promise.all([
             countHit ? null : countQb.getRawOne(),
             dataQb
@@ -116,11 +123,11 @@ let MessagesQueryService = class MessagesQueryService {
         ]);
         let totalCount;
         if (countHit) {
-            totalCount = cachedCount.count;
+            totalCount = cachedCount;
         }
         else {
             totalCount = Number(countResult?.total ?? 0);
-            this.setCountCache(countCacheKey, totalCount);
+            this.countCache.set(countCacheKey, totalCount);
         }
         const hasMore = rows.length > params.limit;
         const items = rows.slice(0, params.limit);
@@ -149,11 +156,8 @@ let MessagesQueryService = class MessagesQueryService {
     async getDistinctModels(userId, range, tenantId, agentName) {
         const cacheKey = `${userId}:${agentName ?? ''}:${range ?? 'all'}`;
         const cached = this.modelsCache.get(cacheKey);
-        if (cached && cached.expiresAt > Date.now()) {
-            return cached.models;
-        }
         if (cached)
-            this.modelsCache.delete(cacheKey);
+            return cached;
         const cutoff = range ? (0, sql_dialect_1.computeCutoff)((0, range_util_1.rangeToInterval)(range)) : undefined;
         const modelsQb = this.turnRepo
             .createQueryBuilder('at')
@@ -166,12 +170,7 @@ let MessagesQueryService = class MessagesQueryService {
         (0, query_helpers_1.addTenantFilter)(modelsQb, userId, agentName, tenantId);
         const modelsResult = await modelsQb.orderBy('at.model', 'ASC').getRawMany();
         const models = modelsResult.map((r) => String(r['model']));
-        if (this.modelsCache.size >= MAX_CACHE_ENTRIES && !this.modelsCache.has(cacheKey)) {
-            const firstKey = this.modelsCache.keys().next().value;
-            if (firstKey !== undefined)
-                this.modelsCache.delete(firstKey);
-        }
-        this.modelsCache.set(cacheKey, { models, expiresAt: Date.now() + MODELS_CACHE_TTL_MS });
+        this.modelsCache.set(cacheKey, models);
         return models;
     }
     buildCountCacheKey(params) {
@@ -185,14 +184,6 @@ let MessagesQueryService = class MessagesQueryService {
             params.cost_max ?? '',
         ].join(':');
     }
-    setCountCache(key, count) {
-        if (this.countCache.size >= MAX_CACHE_ENTRIES && !this.countCache.has(key)) {
-            const firstKey = this.countCache.keys().next().value;
-            if (firstKey !== undefined)
-                this.countCache.delete(firstKey);
-        }
-        this.countCache.set(key, { count, expiresAt: Date.now() + COUNT_CACHE_TTL_MS });
-    }
 };
 exports.MessagesQueryService = MessagesQueryService;
 exports.MessagesQueryService = MessagesQueryService = __decorate([

package/dist/backend/common/utils/ttl-cache.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TtlCache = void 0;
+class TtlCache {
+    store = new Map();
+    maxSize;
+    ttlMs;
+    constructor(options) {
+        this.maxSize = options.maxSize;
+        this.ttlMs = options.ttlMs;
+    }
+    get(key) {
+        const entry = this.store.get(key);
+        if (!entry)
+            return undefined;
+        if (entry.expiresAt <= Date.now()) {
+            this.store.delete(key);
+            return undefined;
+        }
+        return entry.value;
+    }
+    set(key, value) {
+        if (this.store.size >= this.maxSize && !this.store.has(key)) {
+            const firstKey = this.store.keys().next().value;
+            if (firstKey !== undefined)
+                this.store.delete(firstKey);
+        }
+        this.store.set(key, { value, expiresAt: Date.now() + this.ttlMs });
+    }
+    delete(key) {
+        return this.store.delete(key);
+    }
+    has(key) {
+        const entry = this.store.get(key);
+        if (!entry)
+            return false;
+        if (entry.expiresAt <= Date.now()) {
+            this.store.delete(key);
+            return false;
+        }
+        return true;
+    }
+    clear() {
+        this.store.clear();
+    }
+    get size() {
+        return this.store.size;
+    }
+    evictExpired() {
+        const now = Date.now();
+        for (const [key, entry] of this.store) {
+            if (entry.expiresAt <= now) {
+                this.store.delete(key);
+            }
+        }
+    }
+}
+exports.TtlCache = TtlCache;
+//# sourceMappingURL=ttl-cache.js.map

package/dist/backend/main.js

@@ -102,8 +102,8 @@ async function bootstrap() {
         });
     }
     else {
-        const rateLimit = require('express-rate-limit');
-        const loginLimiter = rateLimit.default({
+        const { default: rateLimit } = await Promise.resolve().then(() => __importStar(require('express-rate-limit')));
+        const loginLimiter = rateLimit({
             windowMs: 15 * 60 * 1000,
             max: 20,
             standardHeaders: true,
@@ -111,7 +111,7 @@ async function bootstrap() {
             message: { error: 'Too many login attempts. Try again later.' },
         });
         expressApp.use('/api/auth/sign-in', loginLimiter);
-        const { toNodeHandler } = require('better-auth/node');
+        const { toNodeHandler } = await Promise.resolve().then(() => __importStar(require('better-auth/node')));
         expressApp.all('/api/auth/*splat', toNodeHandler(auth_instance_1.auth));
     }
     expressApp.use(express.json({ limit: '1mb' }));

package/dist/backend/model-discovery/provider-model-fetcher.service.js

@@ -17,57 +17,47 @@ const DEFAULT_CONTEXT_WINDOW = 128000;
 const ANTHROPIC_DEFAULT_CONTEXT = 200000;
 const GEMINI_DEFAULT_CONTEXT = 1000000;
 const MINIMAX_SUBSCRIPTION_MODELS_URL = 'https://api.minimax.io/anthropic/v1/models?limit=100';
-function parseOpenAI(body, provider) {
-    const data = body?.data;
-    if (!Array.isArray(data))
-        return [];
-    return data
-        .filter((m) => {
-        const entry = m;
-        return typeof entry.id === 'string' && entry.id.length > 0;
-    })
-        .map((m) => {
-        const entry = m;
-        return {
-            id: entry.id,
-            displayName: entry.id,
-            provider,
-            contextWindow: DEFAULT_CONTEXT_WINDOW,
-            inputPricePerToken: null,
-            outputPricePerToken: null,
-            capabilityReasoning: false,
-            capabilityCode: false,
-            qualityScore: 3,
-        };
-    });
+function createModelParser(config) {
+    return (body, provider) => {
+        const arr = body?.[config.arrayKey];
+        if (!Array.isArray(arr))
+            return [];
+        return arr
+            .filter((m) => config.filter(m))
+            .map((m) => {
+            const entry = m;
+            const id = config.getId(entry);
+            const ctxVal = config.contextWindow ?? DEFAULT_CONTEXT_WINDOW;
+            return {
+                id,
+                displayName: config.getDisplayName(entry, id),
+                provider,
+                contextWindow: typeof ctxVal === 'function' ? ctxVal(entry) : ctxVal,
+                inputPricePerToken: config.inputPricePerToken ?? null,
+                outputPricePerToken: config.outputPricePerToken ?? null,
+                capabilityReasoning: false,
+                capabilityCode: config.capabilityCode ?? false,
+                qualityScore: config.qualityScore ?? 3,
+            };
+        });
+    };
 }
+const parseOpenAI = createModelParser({
+    arrayKey: 'data',
+    filter: (entry) => typeof entry.id === 'string' && entry.id.length > 0,
+    getId: (entry) => entry.id,
+    getDisplayName: (_entry, id) => id,
+});
 function bearerHeaders(key) {
     return { Authorization: `Bearer ${key}` };
 }
-function parseAnthropic(body, provider) {
-    const data = body?.data;
-    if (!Array.isArray(data))
-        return [];
-    return data
-        .filter((m) => {
-        const entry = m;
-        return typeof entry.id === 'string' && entry.type === 'model';
-    })
-        .map((m) => {
-        const entry = m;
-        return {
-            id: entry.id,
-            displayName: entry.display_name || entry.id,
-            provider,
-            contextWindow: ANTHROPIC_DEFAULT_CONTEXT,
-            inputPricePerToken: null,
-            outputPricePerToken: null,
-            capabilityReasoning: false,
-            capabilityCode: false,
-            qualityScore: 3,
-        };
-    });
-}
+const parseAnthropic = createModelParser({
+    arrayKey: 'data',
+    filter: (entry) => typeof entry.id === 'string' && entry.type === 'model',
+    getId: (entry) => entry.id,
+    getDisplayName: (entry, id) => entry.display_name || id,
+    contextWindow: ANTHROPIC_DEFAULT_CONTEXT,
+});
 function parseGemini(body, provider) {
     const models = body?.models;
     if (!Array.isArray(models))
@@ -128,76 +118,33 @@ function parseOpenRouter(body, provider) {
         };
     });
 }
-function parseOllama(body, provider) {
-    const models = body?.models;
-    if (!Array.isArray(models))
-        return [];
-    return models
-        .filter((m) => typeof m.name === 'string')
-        .map((m) => {
-        const entry = m;
-        const id = entry.name.replace(/:latest$/, '');
-        return {
-            id,
-            displayName: id,
-            provider,
-            contextWindow: DEFAULT_CONTEXT_WINDOW,
-            inputPricePerToken: 0,
-            outputPricePerToken: 0,
-            capabilityReasoning: false,
-            capabilityCode: false,
-            qualityScore: 2,
-        };
-    });
-}
-function parseOpenaiSubscription(body, provider) {
-    const data = body?.models;
-    if (!Array.isArray(data))
-        return [];
-    return data
-        .filter((m) => {
-        const entry = m;
-        return typeof entry.slug === 'string' && entry.visibility === 'list';
-    })
-        .map((m) => {
-        const entry = m;
-        return {
-            id: entry.slug,
-            displayName: entry.display_name || entry.slug,
-            provider,
-            contextWindow: entry.context_window ?? 200000,
-            inputPricePerToken: 0,
-            outputPricePerToken: 0,
-            capabilityReasoning: false,
-            capabilityCode: true,
-            qualityScore: 3,
-        };
-    });
-}
-function parseCopilot(body, provider) {
-    const data = body?.data;
-    if (!Array.isArray(data))
-        return [];
-    return data
-        .filter((m) => {
-        const entry = m;
-        return typeof entry.id === 'string' && entry.id.length > 0;
-    })
-        .map((m) => {
-        const entry = m;
-        return {
-            id: `copilot/${entry.id}`,
-            displayName: entry.id,
-            provider,
-            contextWindow: DEFAULT_CONTEXT_WINDOW,
-            inputPricePerToken: 0,
-            outputPricePerToken: 0,
-            capabilityReasoning: false,
-            capabilityCode: false,
-            qualityScore: 3,
-        };
-    });
-}
+const parseOllama = createModelParser({
+    arrayKey: 'models',
+    filter: (entry) => typeof entry.name === 'string',
+    getId: (entry) => entry.name.replace(/:latest$/, ''),
+    getDisplayName: (_entry, id) => id,
+    inputPricePerToken: 0,
+    outputPricePerToken: 0,
+    qualityScore: 2,
+});
+const parseOpenaiSubscription = createModelParser({
+    arrayKey: 'models',
+    filter: (entry) => typeof entry.slug === 'string' && entry.visibility === 'list',
+    getId: (entry) => entry.slug,
+    getDisplayName: (entry, id) => entry.display_name || id,
+    contextWindow: (entry) => entry.context_window ?? 200000,
+    inputPricePerToken: 0,
+    outputPricePerToken: 0,
+    capabilityCode: true,
+});
+const parseCopilot = createModelParser({
+    arrayKey: 'data',
+    filter: (entry) => typeof entry.id === 'string' && entry.id.length > 0,
+    getId: (entry) => `copilot/${entry.id}`,
+    getDisplayName: (entry) => entry.id,
+    inputPricePerToken: 0,
+    outputPricePerToken: 0,
+});
 exports.PROVIDER_CONFIGS = {
     openai: {
         endpoint: 'https://api.openai.com/v1/models',

package/dist/backend/notifications/notifications.module.js

@@ -13,6 +13,7 @@ const notification_rules_service_1 = require("./services/notification-rules.serv
 const notification_cron_service_1 = require("./services/notification-cron.service");
 const notification_email_service_1 = require("./services/notification-email.service");
 const email_provider_config_service_1 = require("./services/email-provider-config.service");
+const notification_log_service_1 = require("./services/notification-log.service");
 const limit_check_service_1 = require("./services/limit-check.service");
 let NotificationsModule = class NotificationsModule {
 };
@@ -25,6 +26,7 @@ exports.NotificationsModule = NotificationsModule = __decorate([
             notification_cron_service_1.NotificationCronService,
             notification_email_service_1.NotificationEmailService,
             email_provider_config_service_1.EmailProviderConfigService,
+            notification_log_service_1.NotificationLogService,
             limit_check_service_1.LimitCheckService,
         ],
         exports: [limit_check_service_1.LimitCheckService],

package/dist/backend/notifications/services/limit-check.service.js

@@ -12,38 +12,33 @@ var LimitCheckService_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LimitCheckService = void 0;
 const common_1 = require("@nestjs/common");
-const typeorm_1 = require("typeorm");
-const uuid_1 = require("uuid");
 const notification_rules_service_1 = require("./notification-rules.service");
 const notification_email_service_1 = require("./notification-email.service");
 const email_provider_config_service_1 = require("./email-provider-config.service");
+const notification_log_service_1 = require("./notification-log.service");
 const ingest_event_bus_service_1 = require("../../common/services/ingest-event-bus.service");
 const manifest_runtime_service_1 = require("../../common/services/manifest-runtime.service");
 const period_util_1 = require("../../common/utils/period.util");
-const sql_dialect_1 = require("../../common/utils/sql-dialect");
-const local_mode_constants_1 = require("../../common/constants/local-mode.constants");
 const CACHE_TTL_MS = 60_000;
 const MAX_CACHE_SIZE = 10_000;
 let LimitCheckService = LimitCheckService_1 = class LimitCheckService {
-    ds;
     rulesService;
     emailService;
     emailProviderConfig;
     ingestBus;
     runtime;
+    notificationLog;
     logger = new common_1.Logger(LimitCheckService_1.name);
-    dialect;
     rulesCache = new Map();
     consumptionCache = new Map();
     ingestSub;
-    constructor(ds, rulesService, emailService, emailProviderConfig, ingestBus, runtime) {
-        this.ds = ds;
+    constructor(rulesService, emailService, emailProviderConfig, ingestBus, runtime, notificationLog) {
         this.rulesService = rulesService;
         this.emailService = emailService;
         this.emailProviderConfig = emailProviderConfig;
         this.ingestBus = ingestBus;
         this.runtime = runtime;
-        this.dialect = (0, sql_dialect_1.detectDialect)(ds.options.type);
+        this.notificationLog = notificationLog;
     }
     onModuleInit() {
         this.ingestSub = this.ingestBus.all().subscribe(() => {
@@ -53,9 +48,6 @@ let LimitCheckService = LimitCheckService_1 = class LimitCheckService {
     onModuleDestroy() {
         this.ingestSub?.unsubscribe();
     }
-    sql(query) {
-        return (0, sql_dialect_1.portableSql)(query, this.dialect);
-    }
     async checkLimits(tenantId, agentName) {
         const rules = await this.getCachedRules(tenantId, agentName);
         if (rules.length === 0)
@@ -88,12 +80,11 @@ let LimitCheckService = LimitCheckService_1 = class LimitCheckService {
         }
     }
     async notifyLimitExceeded(rule, actual, periodStart, periodEnd) {
-        const alreadySent = await this.ds.query(this.sql(`SELECT 1 FROM notification_logs WHERE rule_id = $1 AND period_start = $2`), [rule.id, periodStart]);
-        if (alreadySent.length > 0)
+        if (await this.notificationLog.hasAlreadySent(rule.id, periodStart))
             return;
-        const now = new Date().toISOString().replace('T', ' ').replace('Z', '').slice(0, 19);
+        const now = (0, notification_log_service_1.formatNotificationTimestamp)();
         const providerConfig = await this.emailProviderConfig.getFullConfig(rule.user_id);
-        const email = await this.resolveUserEmail(rule.user_id, providerConfig);
+        const email = await this.notificationLog.resolveUserEmail(rule.user_id, providerConfig?.notificationEmail);
         let emailSent = false;
         if (email) {
             emailSent = await this.emailService.sendThresholdAlert(email, {
@@ -109,34 +100,17 @@ let LimitCheckService = LimitCheckService_1 = class LimitCheckService {
             }, providerConfig ?? undefined);
         }
         if (emailSent || !email) {
-            await this.ds.query(this.sql(`INSERT INTO notification_logs
-           (id, rule_id, period_start, period_end, actual_value, threshold_value, metric_type, agent_name, sent_at)
-           VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)`), [
-                (0, uuid_1.v4)(),
-                rule.id,
+            await this.notificationLog.insertLog({
+                ruleId: rule.id,
                 periodStart,
                 periodEnd,
-                actual,
-                rule.threshold,
-                rule.metric_type,
-                rule.agent_name,
-                now,
-            ]);
-        }
-    }
-    async resolveUserEmail(userId, fullConfig) {
-        if (fullConfig?.notificationEmail)
-            return fullConfig.notificationEmail;
-        if (this.runtime.isLocalMode()) {
-            const configEmail = (0, local_mode_constants_1.readLocalNotificationEmail)();
-            if (configEmail)
-                return configEmail;
+                actualValue: actual,
+                thresholdValue: rule.threshold,
+                metricType: rule.metric_type,
+                agentName: rule.agent_name,
+                sentAt: now,
+            });
         }
-        const rows = await this.ds.query(this.sql(`SELECT email FROM "user" WHERE id = $1`), [userId]);
-        const email = rows[0]?.email ?? null;
-        if (email === local_mode_constants_1.LOCAL_EMAIL)
-            return null;
-        return email;
     }
     async getCachedRules(tenantId, agentName) {
         const key = `${tenantId}:${agentName}`;
@@ -179,11 +153,11 @@ let LimitCheckService = LimitCheckService_1 = class LimitCheckService {
 exports.LimitCheckService = LimitCheckService;
 exports.LimitCheckService = LimitCheckService = LimitCheckService_1 = __decorate([
     (0, common_1.Injectable)(),
-    __metadata("design:paramtypes", [typeorm_1.DataSource,
-        notification_rules_service_1.NotificationRulesService,
+    __metadata("design:paramtypes", [notification_rules_service_1.NotificationRulesService,
         notification_email_service_1.NotificationEmailService,
         email_provider_config_service_1.EmailProviderConfigService,
         ingest_event_bus_service_1.IngestEventBusService,
-        manifest_runtime_service_1.ManifestRuntimeService])
+        manifest_runtime_service_1.ManifestRuntimeService,
+        notification_log_service_1.NotificationLogService])
 ], LimitCheckService);
 //# sourceMappingURL=limit-check.service.js.map

package/dist/backend/notifications/services/notification-cron.service.js

@@ -13,30 +13,25 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.NotificationCronService = void 0;
 const common_1 = require("@nestjs/common");
 const schedule_1 = require("@nestjs/schedule");
-const typeorm_1 = require("typeorm");
-const uuid_1 = require("uuid");
 const notification_rules_service_1 = require("./notification-rules.service");
 const notification_email_service_1 = require("./notification-email.service");
 const email_provider_config_service_1 = require("./email-provider-config.service");
+const notification_log_service_1 = require("./notification-log.service");
 const manifest_runtime_service_1 = require("../../common/services/manifest-runtime.service");
-const sql_dialect_1 = require("../../common/utils/sql-dialect");
 const period_util_1 = require("../../common/utils/period.util");
-const local_mode_constants_1 = require("../../common/constants/local-mode.constants");
 let NotificationCronService = NotificationCronService_1 = class NotificationCronService {
-    ds;
     rulesService;
     emailService;
     emailProviderConfigService;
     runtime;
+    notificationLog;
     logger = new common_1.Logger(NotificationCronService_1.name);
-    dialect;
-    constructor(ds, rulesService, emailService, emailProviderConfigService, runtime) {
-        this.ds = ds;
+    constructor(rulesService, emailService, emailProviderConfigService, runtime, notificationLog) {
         this.rulesService = rulesService;
         this.emailService = emailService;
         this.emailProviderConfigService = emailProviderConfigService;
         this.runtime = runtime;
-        this.dialect = (0, sql_dialect_1.detectDialect)(ds.options.type);
+        this.notificationLog = notificationLog;
     }
     async onModuleInit() {
         try {
@@ -49,9 +44,6 @@ let NotificationCronService = NotificationCronService_1 = class NotificationCron
             this.logger.error(`Startup catch-up failed: ${err}`);
         }
     }
-    sql(query) {
-        return (0, sql_dialect_1.portableSql)(query, this.dialect);
-    }
     async checkThresholds(userId) {
         const rules = userId
             ? await this.rulesService.getActiveRulesForUser(userId)
@@ -103,16 +95,15 @@ let NotificationCronService = NotificationCronService_1 = class NotificationCron
     }
     async evaluateRule(rule, actual) {
         const { periodStart, periodEnd } = (0, period_util_1.computePeriodBoundaries)(rule.period);
-        const alreadySent = await this.ds.query(this.sql(`SELECT 1 FROM notification_logs WHERE rule_id = $1 AND period_start = $2`), [rule.id, periodStart]);
-        if (alreadySent.length > 0)
+        if (await this.notificationLog.hasAlreadySent(rule.id, periodStart))
             return false;
         if (actual < rule.threshold)
             return false;
-        const now = new Date().toISOString().replace('T', ' ').replace('Z', '').slice(0, 19);
-        const email = await this.resolveUserEmail(rule.user_id);
+        const now = (0, notification_log_service_1.formatNotificationTimestamp)();
+        const fullConfig = await this.emailProviderConfigService.getFullConfig(rule.user_id);
+        const email = await this.notificationLog.resolveUserEmail(rule.user_id, fullConfig?.notificationEmail);
         let emailSent = false;
         if (email) {
-            const providerConfig = await this.emailProviderConfigService.getFullConfig(rule.user_id);
             emailSent = await this.emailService.sendThresholdAlert(email, {
                 agentName: rule.agent_name,
                 metricType: rule.metric_type,
@@ -122,46 +113,28 @@ let NotificationCronService = NotificationCronService_1 = class NotificationCron
                 timestamp: now,
                 agentUrl: `${this.runtime.getAuthBaseUrl()}/agents/${encodeURIComponent(rule.agent_name)}`,
                 alertType: 'soft',
-            }, providerConfig ?? undefined);
+            }, fullConfig ?? undefined);
         }
         else {
             this.logger.warn(`No email found for user ${rule.user_id}, skipping alert for rule ${rule.id}`);
         }
         if (emailSent || !email) {
-            await this.ds.query(this.sql(`INSERT INTO notification_logs
-           (id, rule_id, period_start, period_end, actual_value, threshold_value, metric_type, agent_name, sent_at)
-           VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)`), [
-                (0, uuid_1.v4)(),
-                rule.id,
+            await this.notificationLog.insertLog({
+                ruleId: rule.id,
                 periodStart,
                 periodEnd,
-                actual,
-                rule.threshold,
-                rule.metric_type,
-                rule.agent_name,
-                now,
-            ]);
+                actualValue: actual,
+                thresholdValue: rule.threshold,
+                metricType: rule.metric_type,
+                agentName: rule.agent_name,
+                sentAt: now,
+            });
         }
         else {
             this.logger.warn(`Failed to send alert for rule ${rule.id}, will retry next cron run`);
         }
         return emailSent || !email;
     }
-    async resolveUserEmail(userId) {
-        const fullConfig = await this.emailProviderConfigService.getFullConfig(userId);
-        if (fullConfig?.notificationEmail)
-            return fullConfig.notificationEmail;
-        if (this.runtime.isLocalMode()) {
-            const configEmail = (0, local_mode_constants_1.readLocalNotificationEmail)();
-            if (configEmail)
-                return configEmail;
-        }
-        const rows = await this.ds.query(this.sql(`SELECT email FROM "user" WHERE id = $1`), [userId]);
-        const email = rows[0]?.email ?? null;
-        if (email === local_mode_constants_1.LOCAL_EMAIL)
-            return null;
-        return email;
-    }
 };
 exports.NotificationCronService = NotificationCronService;
 __decorate([
@@ -172,10 +145,10 @@ __decorate([
 ], NotificationCronService.prototype, "checkThresholds", null);
 exports.NotificationCronService = NotificationCronService = NotificationCronService_1 = __decorate([
     (0, common_1.Injectable)(),
-    __metadata("design:paramtypes", [typeorm_1.DataSource,
-        notification_rules_service_1.NotificationRulesService,
+    __metadata("design:paramtypes", [notification_rules_service_1.NotificationRulesService,
         notification_email_service_1.NotificationEmailService,
         email_provider_config_service_1.EmailProviderConfigService,
-        manifest_runtime_service_1.ManifestRuntimeService])
+        manifest_runtime_service_1.ManifestRuntimeService,
+        notification_log_service_1.NotificationLogService])
 ], NotificationCronService);
 //# sourceMappingURL=notification-cron.service.js.map