Agent store: Return aggregated stats AND per version stats so it's accurate on the agent page

jahooma · jahooma · commit fee20f91fb54 · 2025-09-11T16:56:52.000-07:00
diff --git a/web/src/app/api/agents/route.ts b/web/src/app/api/agents/route.ts
@@ -29,7 +29,7 @@ export async function GET() {
       )
       .orderBy(sql`${schema.agentConfig.created_at} DESC`)
 
-    // Get all-time usage metrics for published agents only (those with publisher_id and agent_name)
+    // Get aggregated all-time usage metrics across all versions
     const usageMetrics = await db
       .select({
         publisher_id: schema.agentRun.publisher_id,
@@ -51,7 +51,7 @@ export async function GET() {
       )
       .groupBy(schema.agentRun.publisher_id, schema.agentRun.agent_name)
 
-    // Get weekly usage metrics for published agents only
+    // Get aggregated weekly usage metrics across all versions
     const weeklyMetrics = await db
       .select({
         publisher_id: schema.agentRun.publisher_id,
@@ -70,6 +70,59 @@ export async function GET() {
       )
       .groupBy(schema.agentRun.publisher_id, schema.agentRun.agent_name)
 
+    // Get per-version usage metrics for all-time
+    const perVersionMetrics = await db
+      .select({
+        publisher_id: schema.agentRun.publisher_id,
+        agent_name: schema.agentRun.agent_name,
+        agent_version: schema.agentRun.agent_version,
+        total_invocations: sql<number>`COUNT(*)`,
+        total_dollars: sql<number>`COALESCE(SUM(${schema.agentRun.total_credits}) / 100.0, 0)`,
+        avg_cost_per_run: sql<number>`COALESCE(AVG(${schema.agentRun.total_credits}) / 100.0, 0)`,
+        unique_users: sql<number>`COUNT(DISTINCT ${schema.agentRun.user_id})`,
+        last_used: sql<Date>`MAX(${schema.agentRun.created_at})`,
+      })
+      .from(schema.agentRun)
+      .where(
+        and(
+          eq(schema.agentRun.status, 'completed'),
+          sql`${schema.agentRun.agent_id} != 'test-agent'`,
+          sql`${schema.agentRun.publisher_id} IS NOT NULL`,
+          sql`${schema.agentRun.agent_name} IS NOT NULL`,
+          sql`${schema.agentRun.agent_version} IS NOT NULL`
+        )
+      )
+      .groupBy(
+        schema.agentRun.publisher_id,
+        schema.agentRun.agent_name,
+        schema.agentRun.agent_version
+      )
+
+    // Get per-version weekly usage metrics
+    const perVersionWeeklyMetrics = await db
+      .select({
+        publisher_id: schema.agentRun.publisher_id,
+        agent_name: schema.agentRun.agent_name,
+        agent_version: schema.agentRun.agent_version,
+        weekly_dollars: sql<number>`COALESCE(SUM(${schema.agentRun.total_credits}) / 100.0, 0)`,
+      })
+      .from(schema.agentRun)
+      .where(
+        and(
+          eq(schema.agentRun.status, 'completed'),
+          gte(schema.agentRun.created_at, oneWeekAgo),
+          sql`${schema.agentRun.agent_id} != 'test-agent'`,
+          sql`${schema.agentRun.publisher_id} IS NOT NULL`,
+          sql`${schema.agentRun.agent_name} IS NOT NULL`,
+          sql`${schema.agentRun.agent_version} IS NOT NULL`
+        )
+      )
+      .groupBy(
+        schema.agentRun.publisher_id,
+        schema.agentRun.agent_name,
+        schema.agentRun.agent_version
+      )
+
     // Create weekly metrics map by publisher/agent_name
     const weeklyMap = new Map()
     weeklyMetrics.forEach((metric) => {
@@ -79,7 +132,7 @@ export async function GET() {
       }
     })
 
-    // Create a map of usage metrics by publisher/agent_name
+    // Create a map of aggregated usage metrics by publisher/agent_name
     const metricsMap = new Map()
     usageMetrics.forEach((metric) => {
       if (metric.publisher_id && metric.agent_name) {
@@ -95,6 +148,41 @@ export async function GET() {
       }
     })
 
+    // Create per-version weekly metrics map
+    const perVersionWeeklyMap = new Map()
+    perVersionWeeklyMetrics.forEach((metric) => {
+      if (metric.publisher_id && metric.agent_name && metric.agent_version) {
+        const key = `${metric.publisher_id}/${metric.agent_name}@${metric.agent_version}`
+        perVersionWeeklyMap.set(key, Number(metric.weekly_dollars))
+      }
+    })
+
+    // Create per-version metrics map
+    const perVersionMetricsMap = new Map()
+    perVersionMetrics.forEach((metric) => {
+      if (metric.publisher_id && metric.agent_name && metric.agent_version) {
+        const key = `${metric.publisher_id}/${metric.agent_name}@${metric.agent_version}`
+        perVersionMetricsMap.set(key, {
+          weekly_dollars: perVersionWeeklyMap.get(key) || 0,
+          total_dollars: Number(metric.total_dollars),
+          total_invocations: Number(metric.total_invocations),
+          avg_cost_per_run: Number(metric.avg_cost_per_run),
+          unique_users: Number(metric.unique_users),
+          last_used: metric.last_used,
+        })
+      }
+    })
+
+    // Group per-version metrics by agent
+    const versionMetricsByAgent = new Map()
+    perVersionMetricsMap.forEach((metrics, key) => {
+      const [publisherAgentKey, version] = key.split('@')
+      if (!versionMetricsByAgent.has(publisherAgentKey)) {
+        versionMetricsByAgent.set(publisherAgentKey, {})
+      }
+      versionMetricsByAgent.get(publisherAgentKey)[version] = metrics
+    })
+
     // First, group agents by publisher/name to get the latest version of each
     const latestAgents = new Map()
     agents.forEach((agent) => {
@@ -125,19 +213,26 @@ export async function GET() {
           last_used: null,
         }
 
+        // Use agent.id (config ID) to get version stats since that's what the runs table uses as agent_name
+        const versionStatsKey = `${agent.publisher.id}/${agent.id}`
+        const version_stats = versionMetricsByAgent.get(versionStatsKey) || {}
+
         return {
           id: agent.id,
           name: agentName,
           description: agentData.description,
           publisher: agent.publisher,
           version: agent.version,
           created_at: agent.created_at,
+          // Aggregated stats across all versions (for agent store)
           usage_count: metrics.total_invocations,
           weekly_spent: metrics.weekly_dollars,
           total_spent: metrics.total_dollars,
           avg_cost_per_invocation: metrics.avg_cost_per_run,
           unique_users: metrics.unique_users,
           last_used: metrics.last_used,
+          // Per-version stats for agent detail pages
+          version_stats,
           tags: agentData.tags || [],
         }
       }
diff --git a/web/src/app/publishers/[id]/agents/[agentId]/[version]/agent-usage-metrics.tsx b/web/src/app/publishers/[id]/agents/[agentId]/[version]/agent-usage-metrics.tsx
@@ -8,6 +8,7 @@ import { Skeleton } from '@/components/ui/skeleton'
 interface AgentUsageMetricsProps {
   publisherId: string
   agentId: string
+  version?: string
 }
 
 interface AgentData {
@@ -20,6 +21,17 @@ interface AgentData {
   avg_cost_per_invocation?: number
   unique_users?: number
   last_used?: string
+  version_stats?: Record<
+    string,
+    {
+      weekly_dollars: number
+      total_dollars: number
+      total_invocations: number
+      avg_cost_per_run: number
+      unique_users: number
+      last_used?: Date
+    }
+  >
 }
 
 const formatCurrency = (amount?: number) => {
@@ -38,6 +50,7 @@ const formatUsageCount = (count?: number) => {
 export const AgentUsageMetrics = ({
   publisherId,
   agentId,
+  version,
 }: AgentUsageMetricsProps) => {
   const { data: agents, isLoading } = useQuery<AgentData[]>({
     queryKey: ['agents'],
@@ -50,10 +63,30 @@ export const AgentUsageMetrics = ({
     },
   })
 
-  const usageMetrics = agents?.find(
+  const agent = agents?.find(
     (agent) => agent.id === agentId && agent.publisher.id === publisherId
   )
 
+  // Use version-specific stats if version is provided and exists, otherwise use zero stats
+  const usageMetrics = version
+    ? agent?.version_stats?.[version]
+      ? {
+          weekly_spent: agent.version_stats[version].weekly_dollars,
+          usage_count: agent.version_stats[version].total_invocations,
+          avg_cost_per_invocation:
+            agent.version_stats[version].avg_cost_per_run,
+          unique_users: agent.version_stats[version].unique_users,
+          last_used: agent.version_stats[version].last_used?.toString(),
+        }
+      : {
+          weekly_spent: 0,
+          usage_count: 0,
+          avg_cost_per_invocation: 0,
+          unique_users: 0,
+          last_used: undefined,
+        }
+    : agent
+
   if (isLoading) {
     return (
       <Card className="mb-6">
diff --git a/web/src/app/publishers/[id]/agents/[agentId]/[version]/page.tsx b/web/src/app/publishers/[id]/agents/[agentId]/[version]/page.tsx
@@ -189,7 +189,11 @@ const AgentDetailPage = async ({ params }: AgentDetailPageProps) => {
         </Card>
 
         {/* Usage Metrics */}
-        <AgentUsageMetrics publisherId={params.id} agentId={params.agentId} />
+        <AgentUsageMetrics
+          publisherId={params.id}
+          agentId={params.agentId}
+          version={params.version}
+        />
 
         <div className="grid grid-cols-1 lg:grid-cols-4 gap-6">
           {/* Version Navigation */}
diff --git a/web/src/app/store/page.tsx b/web/src/app/store/page.tsx
@@ -45,6 +45,17 @@ interface AgentData {
   avg_cost_per_invocation?: number // In dollars
   unique_users?: number
   last_used?: string
+  version_stats?: Record<
+    string,
+    {
+      weekly_dollars: number
+      total_dollars: number
+      total_invocations: number
+      avg_cost_per_run: number
+      unique_users: number
+      last_used?: Date
+    }
+  >
   tags?: string[]
 }
 
