waypoi 0.0.0

package/tests/modelRef.test.ts

@@ -0,0 +1,23 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { parseModelRef } from "../cli/modelRef.ts";
+
+test("parseModelRef parses provider/model format", () => {
+  const parsed = parseModelRef("pcai/gpt-4o");
+  assert.equal(parsed.providerId, "pcai");
+  assert.equal(parsed.modelId, "gpt-4o");
+  assert.equal(parsed.canonical, "pcai/gpt-4o");
+});
+
+test("parseModelRef leaves model-only refs unchanged", () => {
+  const parsed = parseModelRef("gpt-4o");
+  assert.equal(parsed.providerId, undefined);
+  assert.equal(parsed.modelId, "gpt-4o");
+  assert.equal(parsed.canonical, undefined);
+});
+
+test("parseModelRef treats malformed refs as model-only", () => {
+  const parsed = parseModelRef("pcai/");
+  assert.equal(parsed.providerId, undefined);
+  assert.equal(parsed.modelId, "pcai/");
+});

package/tests/modelsRoutes.test.ts

@@ -0,0 +1,154 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import path from "path";
+import { promises as fs } from "fs";
+import Fastify from "fastify";
+import { registerModelsRoutes } from "../src/routes/models";
+import type { StoragePaths } from "../src/storage/files";
+
+function makePaths(baseDir: string): StoragePaths {
+  return {
+    baseDir,
+    configPath: path.join(baseDir, "config.yaml"),
+    healthPath: path.join(baseDir, "health.json"),
+    providerHealthPath: path.join(baseDir, "providers_health.json"),
+    requestLogPath: path.join(baseDir, "request_logs.jsonl"),
+    providersPath: path.join(baseDir, "providers.json"),
+    poolsPath: path.join(baseDir, "pools.json"),
+    poolStatePath: path.join(baseDir, "pool_state.json"),
+  };
+}
+
+async function makeWorkspaceTempDir(prefix: string): Promise<string> {
+  const base = path.join(process.cwd(), "tmp");
+  await fs.mkdir(base, { recursive: true });
+  return fs.mkdtemp(path.join(base, prefix));
+}
+
+async function writeProvidersFixture(paths: StoragePaths): Promise<void> {
+  const providers = {
+    version: 3,
+    updatedAt: new Date().toISOString(),
+    providers: [
+      {
+        id: "prov-a",
+        name: "Provider A",
+        protocol: "openai",
+        baseUrl: "http://example-a.test",
+        enabled: true,
+        supportsRouting: true,
+        importedAt: new Date().toISOString(),
+        models: [
+          {
+            providerModelId: "prov-a/model-up",
+            providerId: "prov-a",
+            modelId: "model-up",
+            upstreamModel: "model-up",
+            enabled: true,
+            free: false,
+            modalities: ["text"],
+            endpointType: "llm",
+            capabilities: { input: ["text"], output: ["text"] },
+            aliases: [],
+          },
+          {
+            providerModelId: "prov-a/model-down",
+            providerId: "prov-a",
+            modelId: "model-down",
+            upstreamModel: "model-down",
+            enabled: true,
+            free: false,
+            modalities: ["text"],
+            endpointType: "llm",
+            capabilities: { input: ["text"], output: ["text"] },
+            aliases: [],
+          },
+          {
+            providerModelId: "prov-a/model-unknown",
+            providerId: "prov-a",
+            modelId: "model-unknown",
+            upstreamModel: "model-unknown",
+            enabled: true,
+            free: false,
+            modalities: ["text"],
+            endpointType: "llm",
+            capabilities: { input: ["text"], output: ["text"] },
+            aliases: [],
+          },
+        ],
+      },
+    ],
+  };
+
+  await fs.writeFile(paths.providersPath, JSON.stringify(providers, null, 2), "utf8");
+}
+
+async function writeProviderHealthFixture(paths: StoragePaths): Promise<void> {
+  const health = {
+    models: {
+      "prov-a/model-up": {
+        status: "up",
+        consecutiveFailures: 0,
+        lastCheckedAt: "2026-03-06T12:00:00.000Z",
+        latencyMsEwma: 123.4,
+      },
+      "prov-a/model-down": {
+        status: "down",
+        consecutiveFailures: 4,
+        lastCheckedAt: "2026-03-06T12:01:00.000Z",
+        lastError: "status 503",
+      },
+    },
+  };
+  await fs.writeFile(paths.providerHealthPath, JSON.stringify(health, null, 2), "utf8");
+}
+
+test("/v1/models includes additive waypoi_health metadata", async () => {
+  const baseDir = await makeWorkspaceTempDir("waypoi-models-test-");
+  const paths = makePaths(baseDir);
+  await writeProvidersFixture(paths);
+  await writeProviderHealthFixture(paths);
+
+  const app = Fastify();
+  await registerModelsRoutes(app, paths);
+
+  const res = await app.inject({ method: "GET", url: "/v1/models" });
+  assert.equal(res.statusCode, 200);
+  const json = res.json() as {
+    data: Array<{ id: string; waypoi_health?: { status: "up" | "down" | "unknown"; consecutiveFailures?: number } }>;
+  };
+
+  const up = json.data.find((entry) => entry.id === "prov-a/model-up");
+  const down = json.data.find((entry) => entry.id === "prov-a/model-down");
+  const unknown = json.data.find((entry) => entry.id === "prov-a/model-unknown");
+  assert.ok(up);
+  assert.ok(down);
+  assert.ok(unknown);
+  assert.equal(up.waypoi_health?.status, "up");
+  assert.equal(down.waypoi_health?.status, "down");
+  assert.equal(down.waypoi_health?.consecutiveFailures, 4);
+  assert.equal(unknown.waypoi_health?.status, "unknown");
+
+  await app.close();
+});
+
+test("/v1/models?available_only=true excludes down but keeps up and unknown", async () => {
+  const baseDir = await makeWorkspaceTempDir("waypoi-models-test-");
+  const paths = makePaths(baseDir);
+  await writeProvidersFixture(paths);
+  await writeProviderHealthFixture(paths);
+
+  const app = Fastify();
+  await registerModelsRoutes(app, paths);
+
+  const res = await app.inject({ method: "GET", url: "/v1/models?available_only=true" });
+  assert.equal(res.statusCode, 200);
+  const json = res.json() as { data: Array<{ id: string }> };
+  const ids = json.data.map((entry) => entry.id);
+
+  assert.ok(ids.includes("prov-a/model-up"));
+  assert.ok(ids.includes("prov-a/model-unknown"));
+  assert.ok(!ids.includes("prov-a/model-down"));
+
+  await app.close();
+});

package/tests/sessionMediaCache.test.ts

@@ -0,0 +1,167 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import path from 'path'
+import { promises as fs } from 'fs'
+import {
+  createSession,
+  addMessage,
+  deleteSession,
+  getSession,
+  resolveSessionsDir,
+} from '../src/storage/sessionRepository'
+import {
+  getCacheStats,
+  getMediaPath,
+  getMediaRefCount,
+  storeMedia,
+} from '../src/storage/imageCache'
+import type { StoragePaths } from '../src/storage/files'
+
+function makePaths(baseDir: string): StoragePaths {
+  return {
+    baseDir,
+    configPath: path.join(baseDir, 'config.yaml'),
+    healthPath: path.join(baseDir, 'health.json'),
+    providerHealthPath: path.join(baseDir, 'providers_health.json'),
+    requestLogPath: path.join(baseDir, 'request_logs.jsonl'),
+    providersPath: path.join(baseDir, 'providers.json'),
+    poolsPath: path.join(baseDir, 'pools.json'),
+    poolStatePath: path.join(baseDir, 'pool_state.json'),
+  }
+}
+
+async function makeWorkspaceTempDir(prefix: string): Promise<string> {
+  const base = path.join(process.cwd(), 'tmp')
+  await fs.mkdir(base, { recursive: true })
+  return fs.mkdtemp(path.join(base, prefix))
+}
+
+const DATA_URL_A = 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO5P6n4AAAAASUVORK5CYII='
+const DATA_URL_B = 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAQAAABLbSncAAAADElEQVR42mP8z/CfAQADgwGfWQ36KQAAAABJRU5ErkJggg=='
+
+function toHashFromAdminUrl(url: string): string {
+  const match = url.match(/^\/admin\/media\/([a-f0-9]{16})$/)
+  if (!match) {
+    throw new Error(`Expected /admin/media/<hash> url, got ${url}`)
+  }
+  return match[1]
+}
+
+test('session message persistence normalizes image refs to local cache urls', async () => {
+  const baseDir = await makeWorkspaceTempDir('waypoi-session-media-')
+  const paths = makePaths(baseDir)
+
+  const session = await createSession(paths, { name: 'Media Session' })
+  await addMessage(paths, session.id, {
+    role: 'user',
+    content: [
+      { type: 'text', text: 'hello' },
+      { type: 'image_url', image_url: { url: DATA_URL_A } },
+    ],
+    images: [DATA_URL_A],
+  })
+
+  const loaded = await getSession(paths, session.id)
+  assert.ok(loaded)
+  assert.equal(loaded?.storageVersion, 2)
+  const msg = loaded?.messages[0]
+  assert.ok(msg)
+  assert.ok(Array.isArray(msg?.images))
+  const imageRef = msg?.images?.[0] ?? ''
+  assert.match(imageRef, /^\/admin\/media\/[a-f0-9]{16}$/)
+
+  const contentImage = Array.isArray(msg?.content)
+    ? msg?.content.find((part) => part.type === 'image_url')
+    : null
+  assert.ok(contentImage && contentImage.type === 'image_url')
+  assert.match(contentImage.image_url.url, /^\/admin\/media\/[a-f0-9]{16}$/)
+
+  const hash = toHashFromAdminUrl(contentImage.image_url.url)
+  const mediaPath = await getMediaPath(paths, hash)
+  assert.ok(mediaPath)
+  const refCount = await getMediaRefCount(paths, hash)
+  assert.equal(refCount, 1)
+})
+
+test('loading legacy inline-image session lazily migrates to local refs and bumps storageVersion', async () => {
+  const baseDir = await makeWorkspaceTempDir('waypoi-session-media-')
+  const paths = makePaths(baseDir)
+
+  const sessionId = 'legacy-session'
+  const sessionsDir = resolveSessionsDir(paths)
+  await fs.mkdir(sessionsDir, { recursive: true })
+  const filePath = path.join(sessionsDir, `${sessionId}.json`)
+  const now = new Date().toISOString()
+  await fs.writeFile(
+    filePath,
+    JSON.stringify(
+      {
+        id: sessionId,
+        name: 'Legacy',
+        storageVersion: 1,
+        messages: [
+          {
+            id: 'm1',
+            role: 'assistant',
+            content: [{ type: 'image_url', image_url: { url: DATA_URL_B } }],
+            images: [DATA_URL_B],
+            createdAt: now,
+          },
+        ],
+        createdAt: now,
+        updatedAt: now,
+      },
+      null,
+      2
+    ),
+    'utf8'
+  )
+
+  const loaded = await getSession(paths, sessionId)
+  assert.ok(loaded)
+  assert.equal(loaded?.storageVersion, 2)
+
+  const migratedImage = Array.isArray(loaded?.messages[0]?.content)
+    ? loaded?.messages[0]?.content.find((part) => part.type === 'image_url')
+    : null
+  assert.ok(migratedImage && migratedImage.type === 'image_url')
+  assert.match(migratedImage.image_url.url, /^\/admin\/media\/[a-f0-9]{16}$/)
+
+  const reReadRaw = JSON.parse(await fs.readFile(filePath, 'utf8')) as { storageVersion: number }
+  assert.equal(reReadRaw.storageVersion, 2)
+})
+
+test('eviction preserves referenced media and reports blocked evictions when only referenced remain', async () => {
+  const baseDir = await makeWorkspaceTempDir('waypoi-session-media-')
+  const paths = makePaths(baseDir)
+
+  const session = await createSession(paths, { name: 'Ref Test' })
+  await addMessage(paths, session.id, {
+    role: 'user',
+    content: [{ type: 'image_url', image_url: { url: DATA_URL_A } }],
+    images: [DATA_URL_A],
+  })
+  await addMessage(paths, session.id, {
+    role: 'assistant',
+    content: [{ type: 'image_url', image_url: { url: DATA_URL_B } }],
+    images: [DATA_URL_B],
+  })
+
+  const before = await getCacheStats(paths)
+  assert.equal(before.referencedCount, 2)
+
+  // Force cache pressure with tiny limit; unreferenced candidate gets evicted first,
+  // then eviction is blocked when only referenced entries remain.
+  await storeMedia(paths, Buffer.from('unreferenced-bytes', 'utf8'), {
+    maxSizeBytes: 1,
+    mimeType: 'image/png',
+  })
+
+  const after = await getCacheStats(paths)
+  assert.equal(after.referencedCount, 2)
+  assert.ok(after.evictionBlockedCount >= 1)
+
+  await deleteSession(paths, session.id)
+  const finalStats = await getCacheStats(paths)
+  assert.equal(finalStats.referencedCount, 0)
+})

package/tests/statsRoutes.test.ts

@@ -0,0 +1,323 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import path from 'path'
+import { promises as fs } from 'fs'
+import Fastify from 'fastify'
+import { registerStatsRoutes } from '../src/routes/stats'
+import { appendStats } from '../src/storage/statsRepository'
+import type { RequestStats } from '../src/types'
+import type { StoragePaths } from '../src/storage/files'
+
+function makePaths(baseDir: string): StoragePaths {
+  return {
+    baseDir,
+    configPath: path.join(baseDir, 'config.yaml'),
+    healthPath: path.join(baseDir, 'health.json'),
+    providerHealthPath: path.join(baseDir, 'providers_health.json'),
+    requestLogPath: path.join(baseDir, 'request_logs.jsonl'),
+    providersPath: path.join(baseDir, 'providers.json'),
+    poolsPath: path.join(baseDir, 'pools.json'),
+    poolStatePath: path.join(baseDir, 'pool_state.json'),
+  }
+}
+
+async function makeWorkspaceTempDir(prefix: string): Promise<string> {
+  const base = path.join(process.cwd(), 'tmp')
+  await fs.mkdir(base, { recursive: true })
+  return fs.mkdtemp(path.join(base, prefix))
+}
+
+function buildStat(overrides: Partial<RequestStats>): RequestStats {
+  return {
+    requestId: overrides.requestId ?? `req-${Math.random().toString(36).slice(2)}`,
+    timestamp: overrides.timestamp ?? new Date(),
+    route: overrides.route ?? '/v1/chat/completions',
+    method: overrides.method ?? 'POST',
+    publicModel: overrides.publicModel ?? 'gpt-4o-mini',
+    endpointId: overrides.endpointId ?? 'ep-default',
+    endpointName: overrides.endpointName ?? 'default',
+    upstreamModel: overrides.upstreamModel ?? 'upstream',
+    requestBytes: overrides.requestBytes ?? 128,
+    responseBytes: overrides.responseBytes ?? 512,
+    latencyMs: overrides.latencyMs ?? 150,
+    statusCode: overrides.statusCode ?? 200,
+    errorType: overrides.errorType,
+    totalTokens: overrides.totalTokens ?? 100,
+    promptTokens: overrides.promptTokens === undefined ? 50 : overrides.promptTokens,
+    completionTokens: overrides.completionTokens === undefined ? 50 : overrides.completionTokens,
+  }
+}
+
+test('stats routes honor exact 1h window across aggregate/latency/tokens', async () => {
+  const baseDir = await makeWorkspaceTempDir('waypoi-stats-test-')
+  const paths = makePaths(baseDir)
+  const app = Fastify()
+  await registerStatsRoutes(app, paths)
+
+  const now = Date.now()
+  await appendStats(
+    paths,
+    buildStat({ requestId: 'old', timestamp: new Date(now - 2 * 60 * 60 * 1000), endpointId: 'ep-1', totalTokens: 40 })
+  )
+  await appendStats(
+    paths,
+    buildStat({ requestId: 'recent', timestamp: new Date(now - 10 * 60 * 1000), endpointId: 'ep-1', totalTokens: 80 })
+  )
+
+  const statsRes = await app.inject({ method: 'GET', url: '/admin/stats?window=1h' })
+  assert.equal(statsRes.statusCode, 200)
+  const statsJson = statsRes.json() as {
+    window: string
+    timeZone: string
+    total: number
+    byEndpoint: Record<string, { count: number; errors: number }>
+  }
+  assert.equal(statsJson.window, '1h')
+  assert.equal(statsJson.timeZone, 'UTC')
+  assert.equal(statsJson.total, 1)
+
+  const latencyRes = await app.inject({ method: 'GET', url: '/admin/stats/latency?window=1h' })
+  assert.equal(latencyRes.statusCode, 200)
+  const latencyJson = latencyRes.json() as { window: string; timeZone: string; count: number }
+  assert.equal(latencyJson.window, '1h')
+  assert.equal(latencyJson.timeZone, 'UTC')
+  assert.equal(latencyJson.count, 1)
+
+  const tokenRes = await app.inject({ method: 'GET', url: '/admin/stats/tokens?window=1h' })
+  assert.equal(tokenRes.statusCode, 200)
+  const tokenJson = tokenRes.json() as {
+    window: string
+    totalRequests: number
+    bucketGranularity: string
+    totalInputTokens: number
+    totalOutputTokens: number
+    splitUnknownCount: number
+    splitUnknownRate: number
+  }
+  assert.equal(tokenJson.window, '1h')
+  assert.equal(tokenJson.totalRequests, 1)
+  assert.equal(tokenJson.bucketGranularity, 'hour')
+  assert.equal(tokenJson.totalInputTokens, 50)
+  assert.equal(tokenJson.totalOutputTokens, 50)
+  assert.equal(tokenJson.splitUnknownCount, 0)
+  assert.equal(tokenJson.splitUnknownRate, 0)
+
+  await app.close()
+})
+
+test('stats and latency endpoints honor requested timezone with UTC fallback', async () => {
+  const baseDir = await makeWorkspaceTempDir('waypoi-stats-test-')
+  const paths = makePaths(baseDir)
+  const app = Fastify()
+  await registerStatsRoutes(app, paths)
+
+  await appendStats(paths, buildStat({ requestId: 'tz-meta', timestamp: new Date(), totalTokens: 10 }))
+
+  const localStatsRes = await app.inject({ method: 'GET', url: '/admin/stats?window=1h&timeZone=America/Chicago' })
+  assert.equal(localStatsRes.statusCode, 200)
+  const localStats = localStatsRes.json() as { timeZone: string }
+  assert.equal(localStats.timeZone, 'America/Chicago')
+
+  const invalidStatsRes = await app.inject({ method: 'GET', url: '/admin/stats?window=1h&timeZone=Not/A_Zone' })
+  assert.equal(invalidStatsRes.statusCode, 200)
+  const invalidStats = invalidStatsRes.json() as { timeZone: string }
+  assert.equal(invalidStats.timeZone, 'UTC')
+
+  const localLatencyRes = await app.inject({ method: 'GET', url: '/admin/stats/latency?window=1h&timeZone=America/Chicago' })
+  assert.equal(localLatencyRes.statusCode, 200)
+  const localLatency = localLatencyRes.json() as { timeZone: string }
+  assert.equal(localLatency.timeZone, 'America/Chicago')
+
+  const invalidLatencyRes = await app.inject({ method: 'GET', url: '/admin/stats/latency?window=1h&timeZone=Not/A_Zone' })
+  assert.equal(invalidLatencyRes.statusCode, 200)
+  const invalidLatency = invalidLatencyRes.json() as { timeZone: string }
+  assert.equal(invalidLatency.timeZone, 'UTC')
+
+  await app.close()
+})
+
+test('latency route returns normalized empty payload shape', async () => {
+  const baseDir = await makeWorkspaceTempDir('waypoi-stats-test-')
+  const paths = makePaths(baseDir)
+  const app = Fastify()
+  await registerStatsRoutes(app, paths)
+
+  const res = await app.inject({ method: 'GET', url: '/admin/stats/latency?window=1h' })
+  assert.equal(res.statusCode, 200)
+
+  const json = res.json() as {
+    count: number
+    min: number | null
+    max: number | null
+    avg: number | null
+    p50: number | null
+    p95: number | null
+    p99: number | null
+    histogram: Record<string, number>
+  }
+
+  assert.equal(json.count, 0)
+  assert.equal(json.min, null)
+  assert.equal(json.max, null)
+  assert.equal(json.avg, null)
+  assert.equal(json.p50, null)
+  assert.equal(json.p95, null)
+  assert.equal(json.p99, null)
+  assert.deepEqual(json.histogram, {})
+
+  await app.close()
+})
+
+test('token usage exposes hourly vs daily bucket granularity', async () => {
+  const baseDir = await makeWorkspaceTempDir('waypoi-stats-test-')
+  const paths = makePaths(baseDir)
+  const app = Fastify()
+  await registerStatsRoutes(app, paths)
+
+  const now = Date.now()
+  await appendStats(paths, buildStat({ requestId: 'h1', timestamp: new Date(now - 90 * 60 * 1000), totalTokens: 25 }))
+  await appendStats(paths, buildStat({ requestId: 'h2', timestamp: new Date(now - 5 * 60 * 1000), totalTokens: 50 }))
+
+  const hourly = await app.inject({ method: 'GET', url: '/admin/stats/tokens?window=24h' })
+  assert.equal(hourly.statusCode, 200)
+  const hourlyJson = hourly.json() as {
+    bucketGranularity: string
+    byDay: Array<{ date: string; inputTokens: number; outputTokens: number; splitUnknown: number }>
+  }
+  assert.equal(hourlyJson.bucketGranularity, 'hour')
+  assert.ok(hourlyJson.byDay.every((row) => row.date.includes('T')))
+  assert.ok(hourlyJson.byDay.every((row) => typeof row.inputTokens === 'number'))
+  assert.ok(hourlyJson.byDay.every((row) => typeof row.outputTokens === 'number'))
+  assert.ok(hourlyJson.byDay.every((row) => typeof row.splitUnknown === 'number'))
+
+  const daily = await app.inject({ method: 'GET', url: '/admin/stats/tokens?window=7d' })
+  assert.equal(daily.statusCode, 200)
+  const dailyJson = daily.json() as {
+    bucketGranularity: string
+    byDay: Array<{ date: string; inputTokens: number; outputTokens: number; splitUnknown: number }>
+  }
+  assert.equal(dailyJson.bucketGranularity, 'day')
+  assert.ok(dailyJson.byDay.every((row) => !row.date.includes('T')))
+  assert.ok(dailyJson.byDay.every((row) => typeof row.inputTokens === 'number'))
+  assert.ok(dailyJson.byDay.every((row) => typeof row.outputTokens === 'number'))
+  assert.ok(dailyJson.byDay.every((row) => typeof row.splitUnknown === 'number'))
+
+  await app.close()
+})
+
+test('token usage marks unknown split when only total tokens are present', async () => {
+  const baseDir = await makeWorkspaceTempDir('waypoi-stats-test-')
+  const paths = makePaths(baseDir)
+  const app = Fastify()
+  await registerStatsRoutes(app, paths)
+
+  await appendStats(
+    paths,
+    buildStat({
+      requestId: 'split-unknown',
+      timestamp: new Date(),
+      totalTokens: 42,
+      promptTokens: null,
+      completionTokens: null,
+    })
+  )
+
+  const res = await app.inject({ method: 'GET', url: '/admin/stats/tokens?window=1h' })
+  assert.equal(res.statusCode, 200)
+  const json = res.json() as {
+    totalTokens: number
+    totalRequests: number
+    totalInputTokens: number
+    totalOutputTokens: number
+    splitUnknownCount: number
+    splitUnknownRate: number
+    byDay: Array<{ tokens: number; inputTokens: number; outputTokens: number; splitUnknown: number }>
+  }
+
+  assert.equal(json.totalTokens, 42)
+  assert.equal(json.totalRequests, 1)
+  assert.equal(json.totalInputTokens, 0)
+  assert.equal(json.totalOutputTokens, 0)
+  assert.equal(json.splitUnknownCount, 1)
+  assert.equal(json.splitUnknownRate, 1)
+  assert.equal(json.byDay.length, 1)
+  assert.equal(json.byDay[0].tokens, 42)
+  assert.equal(json.byDay[0].inputTokens, 0)
+  assert.equal(json.byDay[0].outputTokens, 0)
+  assert.equal(json.byDay[0].splitUnknown, 1)
+
+  await app.close()
+})
+
+test('token usage buckets follow requested timezone instead of UTC', async () => {
+  const baseDir = await makeWorkspaceTempDir('waypoi-stats-test-')
+  const paths = makePaths(baseDir)
+  const app = Fastify()
+  await registerStatsRoutes(app, paths)
+
+  await appendStats(
+    paths,
+    buildStat({
+      requestId: 'tz-shift',
+      timestamp: new Date('2026-01-01T01:30:00.000Z'),
+      totalTokens: 42,
+    })
+  )
+
+  const utcRes = await app.inject({ method: 'GET', url: '/admin/stats/tokens?window=365d&timeZone=UTC' })
+  assert.equal(utcRes.statusCode, 200)
+  const utcJson = utcRes.json() as {
+    bucketTimeZone: string
+    byDay: Array<{ date: string }>
+  }
+  assert.equal(utcJson.bucketTimeZone, 'UTC')
+
+  const localRes = await app.inject({
+    method: 'GET',
+    url: '/admin/stats/tokens?window=365d&timeZone=America/Chicago',
+  })
+  assert.equal(localRes.statusCode, 200)
+  const localJson = localRes.json() as {
+    bucketTimeZone: string
+    byDay: Array<{ date: string }>
+  }
+  assert.equal(localJson.bucketTimeZone, 'America/Chicago')
+  assert.notEqual(localJson.byDay[0]?.date, utcJson.byDay[0]?.date)
+
+  await app.close()
+})
+
+test('stats aggregate keeps byEndpoint error counts', async () => {
+  const baseDir = await makeWorkspaceTempDir('waypoi-stats-test-')
+  const paths = makePaths(baseDir)
+  const app = Fastify()
+  await registerStatsRoutes(app, paths)
+
+  const now = Date.now()
+  await appendStats(
+    paths,
+    buildStat({ requestId: 'ok', timestamp: new Date(now - 2 * 60 * 1000), endpointId: 'ep-chat', statusCode: 200, totalTokens: 90 })
+  )
+  await appendStats(
+    paths,
+    buildStat({
+      requestId: 'err',
+      timestamp: new Date(now - 1 * 60 * 1000),
+      endpointId: 'ep-chat',
+      statusCode: 500,
+      errorType: 'upstream_error',
+      totalTokens: 30,
+    })
+  )
+
+  const res = await app.inject({ method: 'GET', url: '/admin/stats?window=1h' })
+  assert.equal(res.statusCode, 200)
+  const json = res.json() as {
+    byEndpoint: Record<string, { count: number; errors: number }>
+  }
+
+  assert.equal(json.byEndpoint['ep-chat'].count, 2)
+  assert.equal(json.byEndpoint['ep-chat'].errors, 1)
+
+  await app.close()
+})

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "CommonJS",
+    "moduleResolution": "Node",
+    "outDir": "dist",
+    "rootDir": ".",
+    "strict": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "skipLibCheck": true
+  },
+  "include": ["src", "cli", "scripts"],
+  "exclude": ["node_modules", "dist", "archive"]
+}