Skip to content

A desktop coding agent with free access to frontier models.

TypeScript
7.8 KB
Raw Blame
import { and, desc, eq, gte, inArray, sql } from "@omnirush-ee/den-db/drizzle"
import { ModelsAnalyticsEventTable as Event, ModelsAnalyticsSettingsTable as Settings } from "@omnirush-ee/den-db/schema"
import {
  appendModelsAnalyticsEvents, readModelsAnalyticsSettings, modelsAnalyticsActivitySchema,
  modelsAnalyticsChoiceSchema, modelsAnalyticsQuerySchema, modelsAnalyticsRecordSchema,
  modelsAnalyticsSettingsSchema, modelsConsumptionSchema, modelsTaskBatchSchema,
} from "@omnirush-ee/telemetry"
import type { Hono } from "hono"
import { describeRoute } from "hono-openapi"
import { db } from "../../db.js"
import { jsonValidator, orgMemberRoute, orgRoleRoute, queryValidator } from "../../middleware/index.js"
import { jsonResponse } from "../../openapi.js"
import { ensureOrganizationAdmin, orgAccessFailureStatus, type OrgRouteVariables } from "./shared.js"

export function registerModelsAnalyticsRoutes<T extends { Variables: OrgRouteVariables }>(app: Hono<T>) {
  app.get("/v1/inference/analytics/settings", describeRoute({
    tags: ["Inference"], summary: "Read the OmniRush.ai Models task analytics choice",
    responses: { 200: jsonResponse("Task analytics settings", modelsAnalyticsSettingsSchema) },
  }), orgMemberRoute(), async (c) => {
    const context = c.get("organizationContext")
    return c.json(await readModelsAnalyticsSettings(db, context.organization.id))
  })

  app.patch("/v1/inference/analytics/settings", describeRoute({
    tags: ["Inference"], summary: "Choose whether to collect task analytics included with OmniRush.ai Models",
    responses: { 200: jsonResponse("Updated task analytics choice", modelsAnalyticsSettingsSchema) },
  }), orgRoleRoute(["admin"]), jsonValidator(modelsAnalyticsChoiceSchema), async (c) => {
    const permission = ensureOrganizationAdmin(c, "Only workspace admins can change task analytics.")
    if (!permission.ok) return c.json(permission.response, orgAccessFailureStatus(permission.response))
    const context = c.get("organizationContext")
    const orgId = context.organization.id
    const choice = c.req.valid("json")
    const settings = await readModelsAnalyticsSettings(db, orgId)
    if (choice.enabled && (!settings.available || !settings.subscribed || !settings.modelsEnabled)) {
      return c.json({ error: "models_analytics_unavailable", message: "Task analytics requires access to this feature and an active OmniRush.ai Models subscription." }, 403)
    }
    // Repeating the same choice must not move the collection cutoff forward.
    const consentedAt = choice.enabled && settings.enabled && settings.consentedAt ? new Date(settings.consentedAt) : new Date()
    const values = {
      enabled: choice.enabled, consented_at: consentedAt,
      consented_by: context.currentMember.id, consent_version: 1,
      ...(!choice.enabled ? { export_enabled: false } : {}),
    }
    await db.insert(Settings).values({ org_id: orgId, ...values }).onDuplicateKeyUpdate({ set: values })
    return c.json(await readModelsAnalyticsSettings(db, orgId))
  })

  app.post("/v1/inference/analytics/events", orgMemberRoute(), jsonValidator(modelsTaskBatchSchema), async (c) => {
    const context = c.get("organizationContext")
    const orgId = context.organization.id
    const memberId = context.currentMember.id
    const settings = await readModelsAnalyticsSettings(db, orgId)
    if (!settings.enabled) return c.body(null, 204)
    const { events } = c.req.valid("json")
    // Runtime metadata is accepted only for this member's actual Models calls.
    // A client cannot attach events to another member's task or a BYOK call.
    const calls = await db.select({ sessionId: Event.session_id, taskId: Event.task_id }).from(Event).where(and(
      eq(Event.org_id, orgId), eq(Event.member_id, memberId), eq(Event.source, "inference"),
      inArray(Event.task_id, events.map((event) => event.taskId)),
    ))
    const matched = events.filter((event) => calls.some((call) => call.taskId === event.taskId && call.sessionId === event.sessionId))
    await appendModelsAnalyticsEvents(db, { orgId, memberId, source: "app", events: matched })
    return c.json({ acceptedIds: matched.map((event) => event.id) }, 202)
  })

  app.get("/v1/inference/analytics/activity", describeRoute({
    tags: ["Inference"], summary: "Read task activity collected after the analytics choice",
    responses: { 200: jsonResponse("Task activity", modelsAnalyticsActivitySchema) },
  }), orgRoleRoute(["admin"]), queryValidator(modelsAnalyticsQuerySchema), async (c) => {
    const orgId = c.get("organizationContext").organization.id
    if (!(await readModelsAnalyticsSettings(db, orgId)).enabled) return c.json({ error: "models_analytics_unavailable" }, 403)
    const query = c.req.valid("query")
    const conditions = [eq(Event.org_id, orgId), gte(Event.timestamp, new Date(Date.now() - query.days * 86_400_000))]
    if (query.memberId) conditions.push(sql`${Event.member_id} = ${query.memberId}`)
    if (query.taskId) conditions.push(eq(Event.task_id, query.taskId))
    if (query.sessionId) conditions.push(eq(Event.session_id, query.sessionId))
    if (query.before && query.beforeId) conditions.push(sql`(${Event.timestamp}, ${Event.id}) < (${new Date(query.before)}, ${query.beforeId})`)
    const rows = await db.select().from(Event).where(and(...conditions)).orderBy(desc(Event.timestamp), desc(Event.id)).limit(201)
    const page = rows.slice(0, 200)
    const last = page.at(-1)
    return c.json({
      events: page.map((row) => modelsAnalyticsRecordSchema.parse({ ...row.payload, memberId: row.member_id, source: row.source })),
      next: rows.length > 200 && last ? { before: last.timestamp.toISOString(), beforeId: last.id } : null,
    })
  })

  app.get("/v1/inference/analytics/consumption", describeRoute({
    tags: ["Inference"], summary: "Read provider-reported consumption for OmniRush.ai Models",
    responses: { 200: jsonResponse("Model consumption", modelsConsumptionSchema) },
  }), orgRoleRoute(["admin"]), queryValidator(modelsAnalyticsQuerySchema), async (c) => {
    const orgId = c.get("organizationContext").organization.id
    if (!(await readModelsAnalyticsSettings(db, orgId)).enabled) return c.json({ error: "models_analytics_unavailable" }, 403)
    const query = c.req.valid("query")
    const conditions = [eq(Event.org_id, orgId), eq(Event.type, "model.call"), eq(Event.source, "inference"), gte(Event.timestamp, new Date(Date.now() - query.days * 86_400_000))]
    if (query.memberId) conditions.push(sql`${Event.member_id} = ${query.memberId}`)
    const day = sql<string>`date_format(${Event.timestamp}, '%Y-%m-%d')`
    const rows = await db.select({
      model: Event.model, provider: Event.provider, memberId: Event.member_id, day,
      calls: sql<number>`count(*)`,
      failedCalls: sql<number>`sum(json_unquote(json_extract(${Event.payload}, '$.status')) = 'failed')`,
      incompleteCalls: sql<number>`sum(${Event.usage_complete} is null or ${Event.usage_complete} = false)`,
      inputTokens: sql<number | null>`sum(${Event.input_tokens})`, outputTokens: sql<number | null>`sum(${Event.output_tokens})`,
      cacheReadTokens: sql<number | null>`sum(${Event.cache_read_tokens})`, costUsd: sql<number | null>`sum(${Event.cost_usd})`,
    }).from(Event).where(and(...conditions)).groupBy(Event.model, Event.provider, Event.member_id, day).orderBy(desc(day)).limit(10_001)
    if (rows.length > 10_000) return c.json({ error: "narrow_date_range", message: "Choose a shorter date range to see consumption." }, 400)
    return c.json({ groups: rows.map((row) => ({ ...row, calls: Number(row.calls), failedCalls: Number(row.failedCalls), incompleteCalls: Number(row.incompleteCalls),
      inputTokens: row.inputTokens === null ? null : Number(row.inputTokens), outputTokens: row.outputTokens === null ? null : Number(row.outputTokens),
      cacheReadTokens: row.cacheReadTokens === null ? null : Number(row.cacheReadTokens), costUsd: row.costUsd === null ? null : Number(row.costUsd),
    })) })
  })
}