manifest 5.24.0 → 5.24.1

package/dist/backend/common/utils/sql-dialect.js

@@ -18,13 +18,12 @@ function timestampType() {
     return process.env['MANIFEST_MODE'] === 'local' ? 'datetime' : 'timestamp';
 }
 function timestampDefault() {
-    return process.env['MANIFEST_MODE'] === 'local'
-        ? () => 'CURRENT_TIMESTAMP'
-        : () => 'NOW()';
+    return process.env['MANIFEST_MODE'] === 'local' ? () => 'CURRENT_TIMESTAMP' : () => 'NOW()';
 }
 function computeCutoff(interval) {
     const ms = intervalToMs(interval);
-    return new Date(Date.now() - ms).toISOString();
+    const cutoff = new Date(Date.now() - ms);
+    return formatLocalIso(cutoff);
 }
 function intervalToMs(interval) {
     const match = interval.match(/^(\d+)\s+(hour|hours|day|days)$/);
@@ -37,12 +36,13 @@ function intervalToMs(interval) {
     return unit.startsWith('hour') ? n * 3600_000 : n * 86400_000;
 }
 function sqlNow() {
-    return new Date().toISOString();
+    return formatLocalIso(new Date());
 }
 function sqlHourBucket(col, dialect) {
-    return dialect === 'sqlite'
-        ? `strftime('%Y-%m-%dT%H:00:00', ${col})`
-        : `to_char(date_trunc('hour', ${col}), 'YYYY-MM-DD"T"HH24:MI:SS')`;
+    if (dialect === 'sqlite') {
+        return `strftime('%Y-%m-%dT%H:00:00', ${col})`;
+    }
+    return `to_char(date_trunc('hour', ${col}), 'YYYY-MM-DD"T"HH24:MI:SS')`;
 }
 function sqlDateBucket(col, dialect) {
     return dialect === 'sqlite'
@@ -61,8 +61,11 @@ function portableSql(sql, dialect) {
     return sql.replace(/\$\d+/g, '?');
 }
 function sqlCastInterval(paramName, dialect) {
-    return dialect === 'sqlite'
-        ? `:${paramName}`
-        : `CAST(:${paramName} AS interval)`;
+    return dialect === 'sqlite' ? `:${paramName}` : `CAST(:${paramName} AS interval)`;
+}
+function formatLocalIso(d) {
+    const pad = (n) => String(n).padStart(2, '0');
+    return (`${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}` +
+        `T${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`);
 }
 //# sourceMappingURL=sql-dialect.js.map

package/dist/backend/notifications/emails/threshold-alert.js

@@ -17,9 +17,10 @@ function formatTimestamp(raw) {
     return `${monthName} ${dayNum}, ${timePart}`;
 }
 function formatValue(value, metric) {
+    const num = Number(value);
     if (metric === 'cost')
-        return `$${value.toFixed(4)}`;
-    return value.toLocaleString();
+        return `$${num.toLocaleString(undefined, { minimumFractionDigits: 2, maximumFractionDigits: 2 })}`;
+    return num.toLocaleString(undefined, { maximumFractionDigits: 0 });
 }
 function ThresholdAlertEmail(props) {
     const { agentName, metricType, threshold, actualValue, period, timestamp, agentUrl, logoUrl = 'https://app.manifest.build/manifest-logo.png', alertType = 'hard', periodResetDate, } = props;

package/dist/backend/routing/proxy/google-adapter.js

@@ -4,6 +4,47 @@ exports.toGoogleRequest = toGoogleRequest;
 exports.fromGoogleResponse = fromGoogleResponse;
 exports.transformGoogleStreamChunk = transformGoogleStreamChunk;
 const crypto_1 = require("crypto");
+const UNSUPPORTED_SCHEMA_FIELDS = new Set([
+    'patternProperties',
+    'additionalProperties',
+    '$schema',
+    '$id',
+    '$ref',
+    '$defs',
+    'definitions',
+    'allOf',
+    'anyOf',
+    'oneOf',
+    'not',
+    'if',
+    'then',
+    'else',
+    'dependentSchemas',
+    'dependentRequired',
+    'unevaluatedProperties',
+    'unevaluatedItems',
+    'contentMediaType',
+    'contentEncoding',
+    'examples',
+    'default',
+    'const',
+    'title',
+]);
+function sanitizeSchema(schema, isPropertiesMap = false) {
+    if (schema === null || schema === undefined || typeof schema !== 'object') {
+        return schema;
+    }
+    if (Array.isArray(schema)) {
+        return schema.map((item) => sanitizeSchema(item));
+    }
+    const result = {};
+    for (const [key, value] of Object.entries(schema)) {
+        if (!isPropertiesMap && UNSUPPORTED_SCHEMA_FIELDS.has(key))
+            continue;
+        result[key] = sanitizeSchema(value, key === 'properties');
+    }
+    return result;
+}
 function mapRole(role) {
     if (role === 'assistant')
         return 'model';
@@ -64,7 +105,7 @@ function convertTools(tools) {
         return {
             name: fn.name,
             description: fn.description,
-            parameters: fn.parameters,
+            parameters: fn.parameters ? sanitizeSchema(fn.parameters) : undefined,
         };
     })
         .filter(Boolean);

package/dist/backend/routing/proxy/proxy.service.js

@@ -173,11 +173,11 @@ let ProxyService = ProxyService_1 = class ProxyService {
         if (!exceeded)
             return;
         const fmt = exceeded.metricType === 'cost'
-            ? `$${exceeded.actual.toFixed(2)}`
-            : exceeded.actual.toLocaleString();
+            ? `$${Number(exceeded.actual).toLocaleString(undefined, { minimumFractionDigits: 2, maximumFractionDigits: 2 })}`
+            : Number(exceeded.actual).toLocaleString(undefined, { maximumFractionDigits: 0 });
         const threshFmt = exceeded.metricType === 'cost'
-            ? `$${exceeded.threshold.toFixed(2)}`
-            : exceeded.threshold.toLocaleString();
+            ? `$${Number(exceeded.threshold).toLocaleString(undefined, { minimumFractionDigits: 2, maximumFractionDigits: 2 })}`
+            : Number(exceeded.threshold).toLocaleString(undefined, { maximumFractionDigits: 0 });
         throw new common_1.HttpException({
             error: {
                 message: `Limit exceeded: ${exceeded.metricType} usage (${fmt}) exceeds ${threshFmt} per ${exceeded.period}`,
@@ -192,16 +192,15 @@ let ProxyService = ProxyService_1 = class ProxyService {
             .slice(-SCORING_RECENT_MESSAGES);
     }
     detectHeartbeat(scoringMessages) {
-        return scoringMessages.some((m) => {
-            if (m.role !== 'user')
-                return false;
-            if (typeof m.content === 'string')
-                return m.content.includes('HEARTBEAT_OK');
-            if (Array.isArray(m.content)) {
-                return m.content.some((p) => p.type === 'text' && typeof p.text === 'string' && p.text.includes('HEARTBEAT_OK'));
-            }
+        const lastUser = [...scoringMessages].reverse().find((m) => m.role === 'user');
+        if (!lastUser)
             return false;
-        });
+        if (typeof lastUser.content === 'string')
+            return lastUser.content.includes('HEARTBEAT_OK');
+        if (Array.isArray(lastUser.content)) {
+            return lastUser.content.some((p) => p.type === 'text' && typeof p.text === 'string' && p.text.includes('HEARTBEAT_OK'));
+        }
+        return false;
     }
     async forwardToProvider(provider, apiKey, model, body, stream, sessionKey, signal, authType) {
         const extraHeaders = {};

package/dist/backend/routing/resolve.controller.js

@@ -21,6 +21,7 @@ const otlp_auth_guard_1 = require("../otlp/guards/otlp-auth.guard");
 const resolve_service_1 = require("./resolve.service");
 const routing_service_1 = require("./routing.service");
 const resolve_request_dto_1 = require("./dto/resolve-request.dto");
+const product_telemetry_1 = require("../common/utils/product-telemetry");
 class SubscriptionProviderItem {
     provider;
 }
@@ -55,8 +56,13 @@ let ResolveController = class ResolveController {
         const { agentId, userId } = req.ingestionContext;
         let registered = 0;
         for (const item of body.providers) {
-            await this.routingService.upsertProvider(agentId, userId, item.provider, undefined, 'subscription');
-            registered++;
+            const { isNew } = await this.routingService.registerSubscriptionProvider(agentId, userId, item.provider);
+            if (isNew) {
+                (0, product_telemetry_1.trackCloudEvent)('routing_provider_connected', userId, {
+                    provider: `${item.provider} (Subscription)`,
+                });
+                registered++;
+            }
         }
         return { registered };
     }

package/dist/backend/routing/routing.controller.js

@@ -62,8 +62,9 @@ let RoutingController = class RoutingController {
         }
         const { provider: result, isNew } = await this.routingService.upsertProvider(agent.id, user.id, body.provider, body.apiKey, body.authType);
         if (isNew) {
+            const providerLabel = body.authType === 'subscription' ? `${body.provider} (Subscription)` : body.provider;
             (0, product_telemetry_1.trackCloudEvent)('routing_provider_connected', user.id, {
-                provider: body.provider,
+                provider: providerLabel,
             });
         }
         return {

package/dist/backend/routing/routing.service.js

@@ -90,6 +90,29 @@ let RoutingService = RoutingService_1 = class RoutingService {
         this.routingCache.invalidateAgent(agentId);
         return { provider: record, isNew: true };
     }
+    async registerSubscriptionProvider(agentId, userId, provider) {
+        const existing = await this.providerRepo.findOne({
+            where: { agent_id: agentId, provider, auth_type: 'subscription' },
+        });
+        if (existing)
+            return { isNew: false };
+        const record = Object.assign(new user_provider_entity_1.UserProvider(), {
+            id: (0, crypto_1.randomUUID)(),
+            user_id: userId,
+            agent_id: agentId,
+            provider,
+            auth_type: 'subscription',
+            api_key_encrypted: null,
+            key_prefix: null,
+            is_active: true,
+            connected_at: new Date().toISOString(),
+            updated_at: new Date().toISOString(),
+        });
+        await this.providerRepo.insert(record);
+        await this.autoAssign.recalculate(agentId);
+        this.routingCache.invalidateAgent(agentId);
+        return { isNew: true };
+    }
     async removeProvider(agentId, provider, authType) {
         const where = { agent_id: agentId, provider };
         if (authType)