ldrouter 1.19.0 → 1.19.1

package/CHANGELOG.md

@@ -4,6 +4,14 @@ All notable changes to this project are documented here. The format follows
 [Keep a Changelog](https://keepachangelog.com/) and the project adheres to
 [Semantic Versioning](https://semver.org/).
 
+## [1.19.1] - 2026-10-12
+
+### Fixed
+
+- **Streamed requests to OpenAI-compatible providers logged `Tokens 0`.** Such providers omit `usage` from a streamed answer unless the caller opts in with `stream_options.include_usage`, and the gateway dropped that field when converting the client body to the canonical request — so the upstream was never asked and every streamed request to those providers persisted 0 tokens. Upstream resale platforms read that as a zero-usage request and flag the key (`zero_usage_rewritten`). The gateway now always sends `stream_options: { include_usage: true }` on streamed OpenAI-compatible upstream calls, so request logs, statistics and the dashboard carry real token counts. Anthropic-compatible providers are unaffected: `/v1/messages` reports usage unconditionally. Non-streaming calls already carried usage in the response body.
+
+- **Statistics failed with `Statistics ranges overlapping compacted history must include complete UTC days.`** A day was treated as compacted history as soon as it had a row in `daily_model_stats` — but that aggregate is written for every logged request, so every day with traffic has one. Any range that clipped such a day was refused with 400, and because the preset windows started at "now minus N days" they always clipped their own first day: the Statistics page showed only "Failed to load statistics" for Today, 7 days and 30 days alike once a day's raw detail had been pruned by retention or left behind by a compact restore. A day is now served from its aggregate only when its raw detail is genuinely gone (it holds fewer raw rows than it logged), and the preset windows are aligned to UTC day boundaries so the day they start on is whole rather than clipped.
+
 ## [1.19.0] - 2026-10-12
 
 ### Added

package/dist/server/protocols/canonical.js

@@ -78,6 +78,7 @@ export function openAIToCanonical(req) {
         maxOutputTokens: req.max_tokens,
         stop: Array.isArray(req.stop) ? req.stop : req.stop ? [req.stop] : undefined,
         stream: Boolean(req.stream),
+        streamIncludeUsage: Boolean(req.stream_options?.include_usage),
         responseFormat,
         reasoning: req.reasoning_effort ? { effort: req.reasoning_effort } : undefined,
     };
@@ -88,6 +89,11 @@ export function canonicalToOpenAIRequest(req, targetModel) {
         stream: req.stream,
         messages: [],
     };
+    // OpenAI-compatible upstreams omit `usage` from a streamed answer unless the
+    // request opts in. Without this the gateway persisted 0 tokens for every
+    // streamed request to such a provider (live: "Tokens 0" on the Requests page).
+    if (req.stream)
+        out.stream_options = { include_usage: true };
     if (req.system)
         out.messages.push({ role: 'system', content: req.system });
     for (const m of req.messages) {

package/dist/server/routes/admin/stats.js

@@ -4,19 +4,29 @@ import { getDb, schema } from '../../db/index.js';
 import { requireAdminAuth } from '../../auth/middleware.js';
 import { GatewayError } from '../../errors.js';
 import { toSummary, loadSummaryMaps } from './requests.js';
+/**
+ * Midnight UTC, `offsetDays` from the day containing `now`.
+ *
+ * Preset windows are day-aligned on purpose. A rolling window always clips its first day, and a
+ * clipped day whose raw rows were pruned cannot be reconstructed from the day-granular aggregate —
+ * so a compacted install answered 400 for every preset the UI can send. Aligning the window makes
+ * the first day whole and leaves only today partial, which is never served from an aggregate.
+ */
+function utcDayStart(now, offsetDays) {
+    return new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate() + offsetDays));
+}
 const PRESETS = {
     today: () => {
         const now = new Date();
-        const from = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate()));
-        return { from, to: now, bucket: 'hour' };
+        return { from: utcDayStart(now, 0), to: now, bucket: 'hour' };
     },
     '7d': () => {
         const now = new Date();
-        return { from: new Date(now.getTime() - 7 * 24 * 3600 * 1000), to: now, bucket: 'day' };
+        return { from: utcDayStart(now, -6), to: now, bucket: 'day' };
     },
     '30d': () => {
         const now = new Date();
-        return { from: new Date(now.getTime() - 30 * 24 * 3600 * 1000), to: now, bucket: 'day' };
+        return { from: utcDayStart(now, -29), to: now, bucket: 'day' };
     },
 };
 /**
@@ -50,10 +60,43 @@ function cacheHitRateFor(db, conds) {
 function rangeFromQuery(q) {
     if (q.preset && PRESETS[q.preset])
         return PRESETS[q.preset]();
-    const from = q.from ? new Date(q.from) : new Date(Date.now() - 7 * 24 * 3600 * 1000);
-    const to = q.to ? new Date(q.to) : new Date();
+    const now = new Date();
+    const from = q.from ? new Date(q.from) : utcDayStart(now, -6);
+    const to = q.to ? new Date(q.to) : now;
     return { from, to, bucket: q.bucket === 'hour' ? 'hour' : 'day' };
 }
+/**
+ * UTC days whose raw request detail is gone and that therefore must be answered from the
+ * day-granular aggregate.
+ *
+ * Having a `daily_model_stats` row proves nothing: the aggregate is written for EVERY logged
+ * request, so every day with traffic has one, and treating that as "compacted" made every
+ * rolling preset (whose window always clips its first day) answer 400. Only the raw log
+ * separates the states, and only a day holding FEWER raw rows than it logged needs its
+ * aggregate — which is exactly what retention (cutoff mid-day) and a compact export/restore
+ * leave behind.
+ *
+ * Counted over whole UTC days, never the requested window: a clipped first day still has all
+ * of its raw rows, and comparing a window-scoped count against a whole-day aggregate would
+ * report every such day as pruned. `created_at` is indexed, so this is one grouped range scan.
+ */
+function aggregateRequiredDays(db, aggregateRows) {
+    const loggedByDay = new Map();
+    for (const r of aggregateRows)
+        loggedByDay.set(r.day, (loggedByDay.get(r.day) ?? 0) + r.requests);
+    if (loggedByDay.size === 0)
+        return [];
+    // ISO-8601 UTC dates sort lexicographically, so min/max bound the whole-day scan.
+    const days = [...loggedByDay.keys()].sort();
+    const rawCounts = db
+        .select({ day: sql `substr(created_at,1,10)`, c: sql `COUNT(*)` })
+        .from(schema.requests)
+        .where(and(gte(schema.requests.createdAt, `${days[0]}T00:00:00.000Z`), lte(schema.requests.createdAt, `${days[days.length - 1]}T23:59:59.999Z`)))
+        .groupBy(sql `substr(created_at,1,10)`)
+        .all();
+    const rawByDay = new Map(rawCounts.map((r) => [r.day, Number(r.c)]));
+    return [...loggedByDay].filter(([day, logged]) => (rawByDay.get(day) ?? 0) < logged).map(([day]) => day);
+}
 export async function registerStatsRoutes(app) {
     app.addHook('preHandler', requireAdminAuth);
     app.get('/api/admin/stats', async (req) => {
@@ -65,9 +108,12 @@ export async function registerStatsRoutes(app) {
         const conds = [gte(schema.requests.createdAt, fromIso), lte(schema.requests.createdAt, toIso)];
         const utcToday = new Date().toISOString().slice(0, 10);
         const aggregateRows = db.select().from(schema.dailyModelStats).where(and(gte(schema.dailyModelStats.day, fromIso.slice(0, 10)), lte(schema.dailyModelStats.day, toIso.slice(0, 10)))).all();
-        const overlappingAggregateDays = [...new Set(aggregateRows.map((r) => r.day))].filter((day) => day < utcToday && `${day}T00:00:00.000Z` <= toIso && `${day}T23:59:59.999Z` >= fromIso);
-        const aggregateDays = overlappingAggregateDays.filter((day) => `${day}T00:00:00.000Z` >= fromIso && `${day}T23:59:59.999Z` <= toIso);
-        if (aggregateDays.length !== overlappingAggregateDays.length) {
+        // Only days whose raw detail is actually gone are answered from the day-granular aggregate.
+        // A day that still has its raw rows is served from raw, exactly like a fresh install.
+        const aggregateDays = aggregateRequiredDays(db, aggregateRows)
+            .filter((day) => day < utcToday && `${day}T00:00:00.000Z` <= toIso && `${day}T23:59:59.999Z` >= fromIso);
+        const clippedDays = aggregateDays.filter((day) => `${day}T00:00:00.000Z` < fromIso || `${day}T23:59:59.999Z` > toIso);
+        if (clippedDays.length > 0) {
             throw new GatewayError('invalid_request_error', 'Statistics ranges overlapping compacted history must include complete UTC days.', { status: 400 });
         }
         const percentilesAvailable = aggregateDays.length === 0;
@@ -306,7 +352,8 @@ export async function registerStatsRoutes(app) {
 function buildSummary(db, fromIso, toIso) {
     // For previous period, use the same aggregate/raw partition as the primary range.
     const days = db.select().from(schema.dailyModelStats).where(and(gte(schema.dailyModelStats.day, fromIso.slice(0, 10)), lte(schema.dailyModelStats.day, toIso.slice(0, 10)))).all();
-    const daySet = [...new Set(days.map((x) => x.day))].filter((day) => day < new Date().toISOString().slice(0, 10) && `${day}T00:00:00.000Z` >= fromIso && `${day}T23:59:59.999Z` <= toIso);
+    // Same rule as the primary range: a day only needs its aggregate when its raw detail is gone.
+    const daySet = aggregateRequiredDays(db, days).filter((day) => day < new Date().toISOString().slice(0, 10) && `${day}T00:00:00.000Z` >= fromIso && `${day}T23:59:59.999Z` <= toIso);
     const aggregates = days.filter((x) => daySet.includes(x.day));
     const rawOnly = daySet.length ? and(gte(schema.requests.createdAt, fromIso), lte(schema.requests.createdAt, toIso), sql `substr(created_at,1,10) NOT IN (${sql.join(daySet.map((day) => sql `${day}`), sql `, `)})`) : and(gte(schema.requests.createdAt, fromIso), lte(schema.requests.createdAt, toIso));
     const agg = aggregates.reduce((a, x) => ({ total: a.total + x.requests, success: a.success + x.successfulRequests, failed: a.failed + x.failedRequests, input: a.input + x.inputTokens, output: a.output + x.outputTokens, cacheRead: a.cacheRead + x.cacheReadTokens, cacheWrite: a.cacheWrite + x.cacheWriteTokens, reasoning: a.reasoning + x.reasoningTokens, gateway: a.gateway + x.gatewayCacheHits, fallback: a.fallback + x.fallbackRequests, latency: a.latency + x.latencySuccessSumMs, latencyCount: a.latencyCount + x.latencySuccessCount, ttft: a.ttft + x.ttftSumMs, ttftCount: a.ttftCount + x.ttftCount }), { total: 0, success: 0, failed: 0, input: 0, output: 0, cacheRead: 0, cacheWrite: 0, reasoning: 0, gateway: 0, fallback: 0, latency: 0, latencyCount: 0, ttft: 0, ttftCount: 0 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ldrouter",
-  "version": "1.19.0",
+  "version": "1.19.1",
   "description": "LateDev Router — lightweight self-hosted LLM gateway with admin UI",
   "type": "module",
   "license": "MIT",