@opengeni/db 0.28.9 → 0.36.0

package/src/insights.ts

@@ -19,10 +19,15 @@ export type ModelCallFactAggregateRow = {
   inputTokens: number;
   outputTokens: number;
   cachedTokens: number;
+  cacheInputTokens: number;
   cacheWriteTokens: number;
   reasoningTokens: number;
   totalTokens: number;
+  tokenKnownCalls: number;
+  cacheKnownCalls: number;
   pricedCostMicros: number;
+  estimatedProviderCostMicros: number;
+  estimatedProviderCostKnownCalls: number;
 };
 
 export type InsightsDayBucket = {
@@ -52,15 +57,21 @@ export type RootSessionDriverRow = {
   rootSessionId: string;
   title: string | null;
   pricedCostMicros: number;
-  inputTokens: number;
+  estimatedProviderCostMicros: number;
+  estimatedProviderCostKnownCalls: number;
+  totalTokens: number;
   cachedTokens: number;
+  cacheInputTokens: number;
 };
 
 export type ScheduleFactAggregate = {
   scheduledTaskId: string;
   pricedCostMicros: number;
-  inputTokens: number;
+  estimatedProviderCostMicros: number;
+  estimatedProviderCostKnownCalls: number;
+  totalTokens: number;
   cachedTokens: number;
+  cacheInputTokens: number;
   calls: number;
   /** Prefer credits whenever any credits-path call exists in the window. */
   billingPath: string;
@@ -88,10 +99,36 @@ export type FloorSessionRow = {
   createdAt: Date;
 };
 
+export type RecentModelCallRow = {
+  id: string;
+  occurredAt: Date;
+  recordedAt: Date;
+  sessionId: string;
+  sessionTitle: string | null;
+  turnId: string;
+  provider: string;
+  providerApi: string;
+  model: string;
+  billingPath: string;
+  inputTokens: number | null;
+  outputTokens: number | null;
+  cachedTokens: number | null;
+  cacheWriteTokens: number | null;
+  reasoningTokens: number | null;
+  totalTokens: number | null;
+  pricedCostMicros: number;
+  estimatedProviderCostMicros: number | null;
+  pricingSource: string | null;
+};
+
 function dayKeyUtc(value: Date): string {
   return value.toISOString().slice(0, 10);
 }
 
+function hourKeyUtc(value: Date): string {
+  return `${value.toISOString().slice(0, 13)}:00`;
+}
+
 export async function sumUsageQuantityInRange(
   db: Database,
   input: {
@@ -120,7 +157,7 @@ export async function sumUsageQuantityInRange(
   });
 }
 
-export async function sumUsageQuantityByDay(
+async function sumUsageQuantityByBucket(
   db: Database,
   input: {
     workspaceId: string;
@@ -128,12 +165,21 @@ export async function sumUsageQuantityByDay(
     since: Date;
     until: Date;
   },
+  granularity: "day" | "hour",
 ): Promise<Map<string, number>> {
   const context = await rlsContextForWorkspace(db, input.workspaceId);
   return await withRlsContext(db, context, async (scopedDb) => {
+    const bucket =
+      granularity === "hour"
+        ? sql<string>`to_char(date_trunc('hour', ${schema.usageEvents.occurredAt} at time zone 'UTC'), 'YYYY-MM-DD"T"HH24:00')`
+        : sql<string>`to_char(date_trunc('day', ${schema.usageEvents.occurredAt} at time zone 'UTC'), 'YYYY-MM-DD')`;
+    const bucketGroup =
+      granularity === "hour"
+        ? sql`date_trunc('hour', ${schema.usageEvents.occurredAt} at time zone 'UTC')`
+        : sql`date_trunc('day', ${schema.usageEvents.occurredAt} at time zone 'UTC')`;
     const rows = await scopedDb
       .select({
-        day: sql<string>`to_char(date_trunc('day', ${schema.usageEvents.occurredAt} at time zone 'UTC'), 'YYYY-MM-DD')`,
+        bucket,
         total: sql<number>`coalesce(sum(${schema.usageEvents.quantity}), 0)`,
       })
       .from(schema.usageEvents)
@@ -145,11 +191,35 @@ export async function sumUsageQuantityByDay(
           lt(schema.usageEvents.occurredAt, input.until),
         ),
       )
-      .groupBy(sql`date_trunc('day', ${schema.usageEvents.occurredAt} at time zone 'UTC')`);
-    return new Map(rows.map((row) => [row.day, Number(row.total)]));
+      .groupBy(bucketGroup);
+    return new Map(rows.map((row) => [row.bucket, Number(row.total)]));
   });
 }
 
+export async function sumUsageQuantityByDay(
+  db: Database,
+  input: {
+    workspaceId: string;
+    eventType: string;
+    since: Date;
+    until: Date;
+  },
+): Promise<Map<string, number>> {
+  return await sumUsageQuantityByBucket(db, input, "day");
+}
+
+export async function sumUsageQuantityByHour(
+  db: Database,
+  input: {
+    workspaceId: string;
+    eventType: string;
+    since: Date;
+    until: Date;
+  },
+): Promise<Map<string, number>> {
+  return await sumUsageQuantityByBucket(db, input, "hour");
+}
+
 export async function aggregateModelCallFacts(
   db: Database,
   input: {
@@ -178,10 +248,15 @@ export async function aggregateModelCallFacts(
         inputTokens: sql<number>`coalesce(sum(${schema.modelCallFacts.inputTokens}), 0)`,
         outputTokens: sql<number>`coalesce(sum(${schema.modelCallFacts.outputTokens}), 0)`,
         cachedTokens: sql<number>`coalesce(sum(${schema.modelCallFacts.cachedTokens}), 0)`,
+        cacheInputTokens: sql<number>`coalesce(sum(${schema.modelCallFacts.inputTokens}) filter (where ${schema.modelCallFacts.cachedTokens} is not null and ${schema.modelCallFacts.inputTokens} is not null), 0)`,
         cacheWriteTokens: sql<number>`coalesce(sum(${schema.modelCallFacts.cacheWriteTokens}), 0)`,
         reasoningTokens: sql<number>`coalesce(sum(${schema.modelCallFacts.reasoningTokens}), 0)`,
         totalTokens: sql<number>`coalesce(sum(${schema.modelCallFacts.totalTokens}), 0)`,
-        pricedCostMicros: sql<number>`coalesce(sum(${schema.modelCallFacts.pricedCostMicros}), 0)`,
+        tokenKnownCalls: sql<number>`count(${schema.modelCallFacts.totalTokens})::int`,
+        cacheKnownCalls: sql<number>`count(*) filter (where ${schema.modelCallFacts.cachedTokens} is not null and ${schema.modelCallFacts.inputTokens} is not null)::int`,
+        pricedCostMicros: sql<number>`coalesce(sum(${schema.modelCallFacts.pricedCostMicros}) filter (where ${schema.modelCallFacts.billingPath} = 'opengeni_credits'), 0)`,
+        estimatedProviderCostMicros: sql<number>`coalesce(sum(${schema.modelCallFacts.estimatedProviderCostMicros}), 0)`,
+        estimatedProviderCostKnownCalls: sql<number>`count(${schema.modelCallFacts.estimatedProviderCostMicros})::int`,
       })
       .from(schema.modelCallFacts)
       .where(and(...clauses))
@@ -198,15 +273,36 @@ export async function aggregateModelCallFacts(
       inputTokens: Number(row.inputTokens),
       outputTokens: Number(row.outputTokens),
       cachedTokens: Number(row.cachedTokens),
+      cacheInputTokens: Number(row.cacheInputTokens),
       cacheWriteTokens: Number(row.cacheWriteTokens),
       reasoningTokens: Number(row.reasoningTokens),
       totalTokens: Number(row.totalTokens),
+      tokenKnownCalls: Number(row.tokenKnownCalls),
+      cacheKnownCalls: Number(row.cacheKnownCalls),
       pricedCostMicros: Number(row.pricedCostMicros),
+      estimatedProviderCostMicros: Number(row.estimatedProviderCostMicros),
+      estimatedProviderCostKnownCalls: Number(row.estimatedProviderCostKnownCalls),
     }));
   });
 }
 
-export async function aggregateModelCallFactsByDay(
+type ModelCallFactSeriesAggregate = {
+  costMicros: number;
+  estimatedProviderCostMicros: number;
+  estimatedProviderCostKnownCalls: number;
+  inputTokens: number;
+  outputTokens: number;
+  cachedTokens: number;
+  cacheInputTokens: number;
+  cacheWriteTokens: number;
+  reasoningTokens: number;
+  totalTokens: number;
+  tokenKnownCalls: number;
+  cacheKnownCalls: number;
+  calls: number;
+};
+
+async function aggregateModelCallFactsByBucket(
   db: Database,
   input: {
     workspaceId: string;
@@ -215,9 +311,8 @@ export async function aggregateModelCallFactsByDay(
     provider?: string | null;
     model?: string | null;
   },
-): Promise<
-  Map<string, { costMicros: number; inputTokens: number; cachedTokens: number; calls: number }>
-> {
+  granularity: "day" | "hour",
+): Promise<Map<string, ModelCallFactSeriesAggregate>> {
   const context = await rlsContextForWorkspace(db, input.workspaceId);
   return await withRlsContext(db, context, async (scopedDb) => {
     const clauses = [
@@ -227,24 +322,50 @@ export async function aggregateModelCallFactsByDay(
       ...(input.provider ? [eq(schema.modelCallFacts.provider, input.provider)] : []),
       ...(input.model ? [eq(schema.modelCallFacts.model, input.model)] : []),
     ];
+    const bucket =
+      granularity === "hour"
+        ? sql<string>`to_char(date_trunc('hour', ${schema.modelCallFacts.occurredAt} at time zone 'UTC'), 'YYYY-MM-DD"T"HH24:00')`
+        : sql<string>`to_char(date_trunc('day', ${schema.modelCallFacts.occurredAt} at time zone 'UTC'), 'YYYY-MM-DD')`;
+    const bucketGroup =
+      granularity === "hour"
+        ? sql`date_trunc('hour', ${schema.modelCallFacts.occurredAt} at time zone 'UTC')`
+        : sql`date_trunc('day', ${schema.modelCallFacts.occurredAt} at time zone 'UTC')`;
     const rows = await scopedDb
       .select({
-        day: sql<string>`to_char(date_trunc('day', ${schema.modelCallFacts.occurredAt} at time zone 'UTC'), 'YYYY-MM-DD')`,
-        costMicros: sql<number>`coalesce(sum(${schema.modelCallFacts.pricedCostMicros}), 0)`,
+        bucket,
+        costMicros: sql<number>`coalesce(sum(${schema.modelCallFacts.pricedCostMicros}) filter (where ${schema.modelCallFacts.billingPath} = 'opengeni_credits'), 0)`,
+        estimatedProviderCostMicros: sql<number>`coalesce(sum(${schema.modelCallFacts.estimatedProviderCostMicros}), 0)`,
+        estimatedProviderCostKnownCalls: sql<number>`count(${schema.modelCallFacts.estimatedProviderCostMicros})::int`,
         inputTokens: sql<number>`coalesce(sum(${schema.modelCallFacts.inputTokens}), 0)`,
+        outputTokens: sql<number>`coalesce(sum(${schema.modelCallFacts.outputTokens}), 0)`,
         cachedTokens: sql<number>`coalesce(sum(${schema.modelCallFacts.cachedTokens}), 0)`,
+        cacheInputTokens: sql<number>`coalesce(sum(${schema.modelCallFacts.inputTokens}) filter (where ${schema.modelCallFacts.cachedTokens} is not null and ${schema.modelCallFacts.inputTokens} is not null), 0)`,
+        cacheWriteTokens: sql<number>`coalesce(sum(${schema.modelCallFacts.cacheWriteTokens}), 0)`,
+        reasoningTokens: sql<number>`coalesce(sum(${schema.modelCallFacts.reasoningTokens}), 0)`,
+        totalTokens: sql<number>`coalesce(sum(${schema.modelCallFacts.totalTokens}), 0)`,
+        tokenKnownCalls: sql<number>`count(${schema.modelCallFacts.totalTokens})::int`,
+        cacheKnownCalls: sql<number>`count(*) filter (where ${schema.modelCallFacts.cachedTokens} is not null and ${schema.modelCallFacts.inputTokens} is not null)::int`,
         calls: sql<number>`count(*)::int`,
       })
       .from(schema.modelCallFacts)
       .where(and(...clauses))
-      .groupBy(sql`date_trunc('day', ${schema.modelCallFacts.occurredAt} at time zone 'UTC')`);
+      .groupBy(bucketGroup);
     return new Map(
       rows.map((row) => [
-        row.day,
+        row.bucket,
         {
           costMicros: Number(row.costMicros),
+          estimatedProviderCostMicros: Number(row.estimatedProviderCostMicros),
+          estimatedProviderCostKnownCalls: Number(row.estimatedProviderCostKnownCalls),
           inputTokens: Number(row.inputTokens),
+          outputTokens: Number(row.outputTokens),
           cachedTokens: Number(row.cachedTokens),
+          cacheInputTokens: Number(row.cacheInputTokens),
+          cacheWriteTokens: Number(row.cacheWriteTokens),
+          reasoningTokens: Number(row.reasoningTokens),
+          totalTokens: Number(row.totalTokens),
+          tokenKnownCalls: Number(row.tokenKnownCalls),
+          cacheKnownCalls: Number(row.cacheKnownCalls),
           calls: Number(row.calls),
         },
       ]),
@@ -252,6 +373,32 @@ export async function aggregateModelCallFactsByDay(
   });
 }
 
+export async function aggregateModelCallFactsByDay(
+  db: Database,
+  input: {
+    workspaceId: string;
+    since: Date;
+    until: Date;
+    provider?: string | null;
+    model?: string | null;
+  },
+): Promise<Map<string, ModelCallFactSeriesAggregate>> {
+  return await aggregateModelCallFactsByBucket(db, input, "day");
+}
+
+export async function aggregateModelCallFactsByHour(
+  db: Database,
+  input: {
+    workspaceId: string;
+    since: Date;
+    until: Date;
+    provider?: string | null;
+    model?: string | null;
+  },
+): Promise<Map<string, ModelCallFactSeriesAggregate>> {
+  return await aggregateModelCallFactsByBucket(db, input, "hour");
+}
+
 export async function aggregateWarmSecondsByGroup(
   db: Database,
   input: InsightsTimeWindow & { workspaceId: string; limit?: number },
@@ -378,9 +525,12 @@ export async function aggregateRootSessionDrivers(
       .select({
         rootSessionId: childSessions.rootSessionId,
         title: rootSessions.title,
-        pricedCostMicros: sql<number>`coalesce(sum(${schema.modelCallFacts.pricedCostMicros}), 0)`,
-        inputTokens: sql<number>`coalesce(sum(${schema.modelCallFacts.inputTokens}), 0)`,
+        pricedCostMicros: sql<number>`coalesce(sum(${schema.modelCallFacts.pricedCostMicros}) filter (where ${schema.modelCallFacts.billingPath} = 'opengeni_credits'), 0)`,
+        estimatedProviderCostMicros: sql<number>`coalesce(sum(${schema.modelCallFacts.estimatedProviderCostMicros}), 0)`,
+        estimatedProviderCostKnownCalls: sql<number>`count(${schema.modelCallFacts.estimatedProviderCostMicros})::int`,
+        totalTokens: sql<number>`coalesce(sum(${schema.modelCallFacts.totalTokens}), 0)`,
         cachedTokens: sql<number>`coalesce(sum(${schema.modelCallFacts.cachedTokens}), 0)`,
+        cacheInputTokens: sql<number>`coalesce(sum(${schema.modelCallFacts.inputTokens}) filter (where ${schema.modelCallFacts.cachedTokens} is not null and ${schema.modelCallFacts.inputTokens} is not null), 0)`,
       })
       .from(schema.modelCallFacts)
       .innerJoin(
@@ -399,14 +549,17 @@ export async function aggregateRootSessionDrivers(
       )
       .where(and(...clauses))
       .groupBy(childSessions.rootSessionId, rootSessions.title)
-      .orderBy(sql`coalesce(sum(${schema.modelCallFacts.pricedCostMicros}), 0) desc`);
+      .orderBy(sql`coalesce(sum(${schema.modelCallFacts.totalTokens}), 0) desc`);
     const rows = input.rootSessionIds ? await query : await query.limit(input.limit ?? 8);
     return rows.map((row) => ({
       rootSessionId: row.rootSessionId,
       title: row.title,
       pricedCostMicros: Number(row.pricedCostMicros),
-      inputTokens: Number(row.inputTokens),
+      estimatedProviderCostMicros: Number(row.estimatedProviderCostMicros),
+      estimatedProviderCostKnownCalls: Number(row.estimatedProviderCostKnownCalls),
+      totalTokens: Number(row.totalTokens),
       cachedTokens: Number(row.cachedTokens),
+      cacheInputTokens: Number(row.cacheInputTokens),
     }));
   });
 }
@@ -436,6 +589,62 @@ export async function listModelCallFacets(
   });
 }
 
+export async function listRecentModelCalls(
+  db: Database,
+  input: InsightsTimeWindow & {
+    workspaceId: string;
+    provider?: string | null;
+    model?: string | null;
+    limit?: number;
+  },
+): Promise<RecentModelCallRow[]> {
+  const context = await rlsContextForWorkspace(db, input.workspaceId);
+  const factSessions = alias(schema.sessions, "insight_recent_fact_sessions");
+  return await withRlsContext(db, context, async (scopedDb) => {
+    const clauses = [
+      eq(schema.modelCallFacts.workspaceId, input.workspaceId),
+      gte(schema.modelCallFacts.occurredAt, input.since),
+      lt(schema.modelCallFacts.occurredAt, input.until),
+      ...(input.provider ? [eq(schema.modelCallFacts.provider, input.provider)] : []),
+      ...(input.model ? [eq(schema.modelCallFacts.model, input.model)] : []),
+    ];
+    const rows = await scopedDb
+      .select({
+        id: schema.modelCallFacts.id,
+        occurredAt: schema.modelCallFacts.occurredAt,
+        recordedAt: schema.modelCallFacts.recordedAt,
+        sessionId: schema.modelCallFacts.sessionId,
+        sessionTitle: factSessions.title,
+        turnId: schema.modelCallFacts.turnId,
+        provider: schema.modelCallFacts.provider,
+        providerApi: schema.modelCallFacts.providerApi,
+        model: schema.modelCallFacts.model,
+        billingPath: schema.modelCallFacts.billingPath,
+        inputTokens: schema.modelCallFacts.inputTokens,
+        outputTokens: schema.modelCallFacts.outputTokens,
+        cachedTokens: schema.modelCallFacts.cachedTokens,
+        cacheWriteTokens: schema.modelCallFacts.cacheWriteTokens,
+        reasoningTokens: schema.modelCallFacts.reasoningTokens,
+        totalTokens: schema.modelCallFacts.totalTokens,
+        pricedCostMicros: schema.modelCallFacts.pricedCostMicros,
+        estimatedProviderCostMicros: schema.modelCallFacts.estimatedProviderCostMicros,
+        pricingSource: schema.modelCallFacts.pricingSource,
+      })
+      .from(schema.modelCallFacts)
+      .leftJoin(
+        factSessions,
+        and(
+          eq(factSessions.workspaceId, schema.modelCallFacts.workspaceId),
+          eq(factSessions.id, schema.modelCallFacts.sessionId),
+        ),
+      )
+      .where(and(...clauses))
+      .orderBy(desc(schema.modelCallFacts.occurredAt), desc(schema.modelCallFacts.id))
+      .limit(Math.max(1, Math.min(input.limit ?? 50, 100)));
+    return rows;
+  });
+}
+
 export async function aggregateScheduleFacts(
   db: Database,
   input: InsightsTimeWindow & {
@@ -457,9 +666,12 @@ export async function aggregateScheduleFacts(
     const rows = await scopedDb
       .select({
         scheduledTaskId: schema.modelCallFacts.scheduledTaskId,
-        pricedCostMicros: sql<number>`coalesce(sum(${schema.modelCallFacts.pricedCostMicros}), 0)`,
-        inputTokens: sql<number>`coalesce(sum(${schema.modelCallFacts.inputTokens}), 0)`,
+        pricedCostMicros: sql<number>`coalesce(sum(${schema.modelCallFacts.pricedCostMicros}) filter (where ${schema.modelCallFacts.billingPath} = 'opengeni_credits'), 0)`,
+        estimatedProviderCostMicros: sql<number>`coalesce(sum(${schema.modelCallFacts.estimatedProviderCostMicros}), 0)`,
+        estimatedProviderCostKnownCalls: sql<number>`count(${schema.modelCallFacts.estimatedProviderCostMicros})::int`,
+        totalTokens: sql<number>`coalesce(sum(${schema.modelCallFacts.totalTokens}), 0)`,
         cachedTokens: sql<number>`coalesce(sum(${schema.modelCallFacts.cachedTokens}), 0)`,
+        cacheInputTokens: sql<number>`coalesce(sum(${schema.modelCallFacts.inputTokens}) filter (where ${schema.modelCallFacts.cachedTokens} is not null and ${schema.modelCallFacts.inputTokens} is not null), 0)`,
         calls: sql<number>`count(*)::int`,
         billingPath: sql<string>`case
           when bool_or(${schema.modelCallFacts.billingPath} = 'opengeni_credits')
@@ -475,8 +687,11 @@ export async function aggregateScheduleFacts(
       .map((row) => ({
         scheduledTaskId: row.scheduledTaskId,
         pricedCostMicros: Number(row.pricedCostMicros),
-        inputTokens: Number(row.inputTokens),
+        estimatedProviderCostMicros: Number(row.estimatedProviderCostMicros),
+        estimatedProviderCostKnownCalls: Number(row.estimatedProviderCostKnownCalls),
+        totalTokens: Number(row.totalTokens),
         cachedTokens: Number(row.cachedTokens),
+        cacheInputTokens: Number(row.cacheInputTokens),
         calls: Number(row.calls),
         billingPath: row.billingPath,
       }));
@@ -605,10 +820,11 @@ export async function countOnlineMachines(
   db: Database,
   workspaceId: string,
   heartbeatFreshMs: number,
+  now = new Date(),
 ): Promise<number> {
   const context = await rlsContextForWorkspace(db, workspaceId);
   return await withRlsContext(db, context, async (scopedDb) => {
-    const cutoff = new Date(Date.now() - heartbeatFreshMs);
+    const cutoff = new Date(now.getTime() - heartbeatFreshMs);
     const [{ n } = { n: 0 }] = await scopedDb
       .select({ n: sql<number>`count(*)::int` })
       .from(schema.enrollments)
@@ -636,6 +852,18 @@ export function enumerateUtcDays(since: Date, until: Date): string[] {
   return days;
 }
 
+export function enumerateUtcHours(since: Date, until: Date): string[] {
+  const hours: string[] = [];
+  const cursor = new Date(since);
+  cursor.setUTCMinutes(0, 0, 0);
+  const end = until.getTime();
+  while (cursor.getTime() < end) {
+    hours.push(hourKeyUtc(cursor));
+    cursor.setUTCHours(cursor.getUTCHours() + 1);
+  }
+  return hours;
+}
+
 /**
  * Idempotent YTD backfill from authoritative agent.model.usage into model_call_facts.
  * Never rewrites billing rows or existing live facts (onConflictDoNothing).