agentfit 0.1.5 → 0.1.7

package/generated/prisma/models.ts

@@ -9,6 +9,7 @@
  * 🟢 You can import this file directly.
  */
 export type * from './models/Session'
+export type * from './models/MessageUsage'
 export type * from './models/Image'
 export type * from './models/SyncLog'
 export type * from './models/Report'

package/lib/db.ts

@@ -3,7 +3,7 @@ import { PrismaLibSql } from '@prisma/adapter-libsql'
 import path from 'path'
 
 function createPrisma() {
-  const dbUrl = `file:${path.resolve(process.cwd(), 'agentfit.db')}`
+  const dbUrl = process.env.DATABASE_URL || `file:${path.resolve(process.cwd(), 'agentfit.db')}`
   const adapter = new PrismaLibSql({ url: dbUrl })
   return new PrismaClient({ adapter })
 }

package/lib/parse-logs.ts

@@ -49,6 +49,15 @@ export interface ProjectSummary {
   toolCalls: Record<string, number>
 }
 
+export interface ModelBreakdown {
+  model: string
+  inputTokens: number
+  outputTokens: number
+  cacheCreationTokens: number
+  cacheReadTokens: number
+  costUSD: number
+}
+
 export interface DailyUsage {
   date: string
   sessions: number
@@ -65,6 +74,7 @@ export interface DailyUsage {
   toolCallsDetail: Record<string, number>
   interruptions: number
   rateLimitErrors: number
+  modelBreakdowns: ModelBreakdown[]
 }
 
 export interface OverviewStats {
@@ -359,6 +369,7 @@ export async function parseAllLogs(): Promise<UsageData> {
             toolCallsDetail: {},
             interruptions: 0,
             rateLimitErrors: 0,
+            modelBreakdowns: [],
           })
         }
         const daily = dailyMap.get(date)!

package/lib/pricing.ts

@@ -1,15 +1,27 @@
-// Fetches pricing from LiteLLM's model pricing database (same source as ccusage)
+// Fetches pricing from LiteLLM's model pricing database (same source as ccusage).
+// Tiered (>200k) pricing and the speed=fast multiplier are ported from ccusage
+// (MIT, © 2025 ryoppippi) — see packages/internal/src/pricing.ts in that repo.
 
 const LITELLM_PRICING_URL =
   'https://raw.githubusercontent.com/BerriAI/litellm/main/model_prices_and_context_window.json'
 
+const TIERED_THRESHOLD = 200_000
+
 export interface ModelPricing {
   input_cost_per_token?: number
   output_cost_per_token?: number
   cache_creation_input_token_cost?: number
   cache_read_input_token_cost?: number
+  // 1M-context tiered prices (Claude/Anthropic only)
+  input_cost_per_token_above_200k_tokens?: number
+  output_cost_per_token_above_200k_tokens?: number
+  cache_creation_input_token_cost_above_200k_tokens?: number
+  cache_read_input_token_cost_above_200k_tokens?: number
+  provider_specific_entry?: { fast?: number }
 }
 
+export type Speed = 'standard' | 'fast'
+
 let pricingCache: Record<string, ModelPricing> | null = null
 
 export async function loadPricing(): Promise<Record<string, ModelPricing>> {
@@ -18,32 +30,46 @@ export async function loadPricing(): Promise<Record<string, ModelPricing>> {
   try {
     const res = await fetch(LITELLM_PRICING_URL, { next: { revalidate: 86400 } })
     const data = await res.json()
-    // Filter to Claude/Anthropic models only
     const filtered: Record<string, ModelPricing> = {}
     for (const [key, value] of Object.entries(data)) {
-      if (
-        key.includes('claude') ||
-        key.includes('anthropic')
-      ) {
-        const v = value as Record<string, unknown>
-        filtered[key] = {
-          input_cost_per_token: v.input_cost_per_token as number | undefined,
-          output_cost_per_token: v.output_cost_per_token as number | undefined,
-          cache_creation_input_token_cost: v.cache_creation_input_token_cost as number | undefined,
-          cache_read_input_token_cost: v.cache_read_input_token_cost as number | undefined,
-        }
+      if (!key.includes('claude') && !key.includes('anthropic')) continue
+      const v = value as Record<string, unknown>
+      filtered[key] = {
+        input_cost_per_token: v.input_cost_per_token as number | undefined,
+        output_cost_per_token: v.output_cost_per_token as number | undefined,
+        cache_creation_input_token_cost: v.cache_creation_input_token_cost as number | undefined,
+        cache_read_input_token_cost: v.cache_read_input_token_cost as number | undefined,
+        input_cost_per_token_above_200k_tokens: v.input_cost_per_token_above_200k_tokens as
+          | number
+          | undefined,
+        output_cost_per_token_above_200k_tokens: v.output_cost_per_token_above_200k_tokens as
+          | number
+          | undefined,
+        cache_creation_input_token_cost_above_200k_tokens:
+          v.cache_creation_input_token_cost_above_200k_tokens as number | undefined,
+        cache_read_input_token_cost_above_200k_tokens:
+          v.cache_read_input_token_cost_above_200k_tokens as number | undefined,
+        provider_specific_entry:
+          v.provider_specific_entry && typeof v.provider_specific_entry === 'object'
+            ? { fast: (v.provider_specific_entry as Record<string, unknown>).fast as number | undefined }
+            : undefined,
       }
     }
     pricingCache = filtered
     return filtered
   } catch {
-    // Fallback pricing if fetch fails
     return getFallbackPricing()
   }
 }
 
 function getFallbackPricing(): Record<string, ModelPricing> {
   return {
+    'claude-opus-4-7': {
+      input_cost_per_token: 15e-6,
+      output_cost_per_token: 75e-6,
+      cache_creation_input_token_cost: 18.75e-6,
+      cache_read_input_token_cost: 1.5e-6,
+    },
     'claude-opus-4-6': {
       input_cost_per_token: 15e-6,
       output_cost_per_token: 75e-6,
@@ -55,12 +81,16 @@ function getFallbackPricing(): Record<string, ModelPricing> {
       output_cost_per_token: 15e-6,
       cache_creation_input_token_cost: 3.75e-6,
       cache_read_input_token_cost: 0.3e-6,
+      input_cost_per_token_above_200k_tokens: 6e-6,
+      output_cost_per_token_above_200k_tokens: 22.5e-6,
+      cache_creation_input_token_cost_above_200k_tokens: 7.5e-6,
+      cache_read_input_token_cost_above_200k_tokens: 0.6e-6,
     },
     'claude-haiku-4-5-20251001': {
-      input_cost_per_token: 0.8e-6,
-      output_cost_per_token: 4e-6,
-      cache_creation_input_token_cost: 1e-6,
-      cache_read_input_token_cost: 0.08e-6,
+      input_cost_per_token: 1e-6,
+      output_cost_per_token: 5e-6,
+      cache_creation_input_token_cost: 1.25e-6,
+      cache_read_input_token_cost: 0.1e-6,
     },
   }
 }
@@ -68,28 +98,43 @@ function getFallbackPricing(): Record<string, ModelPricing> {
 export function findPricing(
   model: string,
   allPricing: Record<string, ModelPricing>
-): ModelPricing {
-  // Try exact match
+): ModelPricing | null {
   if (allPricing[model]) return allPricing[model]
-
-  // Try with anthropic/ prefix
   if (allPricing[`anthropic/${model}`]) return allPricing[`anthropic/${model}`]
 
-  // Try partial match
   for (const [key, pricing] of Object.entries(allPricing)) {
     const normalizedKey = key.replace('anthropic/', '').replace('anthropic.', '')
-    if (normalizedKey === model || normalizedKey.startsWith(model) || model.startsWith(normalizedKey)) {
+    if (
+      normalizedKey === model ||
+      normalizedKey.startsWith(model) ||
+      model.startsWith(normalizedKey)
+    ) {
       return pricing
     }
   }
 
-  // Default to Sonnet pricing
-  return allPricing['claude-sonnet-4-6'] || allPricing['anthropic/claude-sonnet-4-6'] || {
-    input_cost_per_token: 3e-6,
-    output_cost_per_token: 15e-6,
-    cache_creation_input_token_cost: 3.75e-6,
-    cache_read_input_token_cost: 0.3e-6,
+  // Substring fallback (mirrors ccusage's behaviour at packages/internal/src/pricing.ts:232-238)
+  const lower = model.toLowerCase()
+  for (const [key, pricing] of Object.entries(allPricing)) {
+    const k = key.toLowerCase()
+    if (k.includes(lower) || lower.includes(k)) return pricing
   }
+
+  return null
+}
+
+function tieredCost(
+  total: number | undefined,
+  base: number | undefined,
+  tiered: number | undefined
+): number {
+  if (total == null || total <= 0) return 0
+  if (total > TIERED_THRESHOLD && tiered != null) {
+    const below = Math.min(total, TIERED_THRESHOLD)
+    const above = Math.max(0, total - TIERED_THRESHOLD)
+    return above * tiered + (base != null ? below * base : 0)
+  }
+  return base != null ? total * base : 0
 }
 
 export function calculateCost(
@@ -100,13 +145,34 @@ export function calculateCost(
     cache_creation_input_tokens?: number
     cache_read_input_tokens?: number
   },
-  allPricing: Record<string, ModelPricing>
+  allPricing: Record<string, ModelPricing>,
+  speed: Speed = 'standard'
 ): number {
   const pricing = findPricing(model, allPricing)
-  return (
-    (usage.input_tokens || 0) * (pricing.input_cost_per_token || 0) +
-    (usage.output_tokens || 0) * (pricing.output_cost_per_token || 0) +
-    (usage.cache_creation_input_tokens || 0) * (pricing.cache_creation_input_token_cost || 0) +
-    (usage.cache_read_input_tokens || 0) * (pricing.cache_read_input_token_cost || 0)
-  )
+  if (!pricing) return 0
+
+  const base =
+    tieredCost(
+      usage.input_tokens,
+      pricing.input_cost_per_token,
+      pricing.input_cost_per_token_above_200k_tokens
+    ) +
+    tieredCost(
+      usage.output_tokens,
+      pricing.output_cost_per_token,
+      pricing.output_cost_per_token_above_200k_tokens
+    ) +
+    tieredCost(
+      usage.cache_creation_input_tokens,
+      pricing.cache_creation_input_token_cost,
+      pricing.cache_creation_input_token_cost_above_200k_tokens
+    ) +
+    tieredCost(
+      usage.cache_read_input_tokens,
+      pricing.cache_read_input_token_cost,
+      pricing.cache_read_input_token_cost_above_200k_tokens
+    )
+
+  const multiplier = speed === 'fast' ? pricing.provider_specific_entry?.fast ?? 1 : 1
+  return base * multiplier
 }

package/lib/queries-codex.ts

@@ -64,6 +64,7 @@ export function getCodexUsageData(): UsageData {
         toolCallsDetail: {},
         interruptions: 0,
         rateLimitErrors: 0,
+        modelBreakdowns: [],
       })
     }
     const daily = dailyMap.get(date)!

package/lib/queries.ts

@@ -4,15 +4,28 @@ import type {
   SessionSummary,
   ProjectSummary,
   DailyUsage,
+  ModelBreakdown,
   OverviewStats,
 } from './parse-logs'
 
 export async function getUsageData(): Promise<UsageData> {
-  const dbSessions = await prisma.session.findMany({
-    orderBy: { startTime: 'desc' },
-  })
+  const [dbSessions, dbMessageUsages] = await Promise.all([
+    prisma.session.findMany({ orderBy: { startTime: 'desc' } }),
+    prisma.messageUsage.findMany({
+      select: {
+        date: true,
+        model: true,
+        speed: true,
+        inputTokens: true,
+        outputTokens: true,
+        cacheCreationTokens: true,
+        cacheReadTokens: true,
+        costUSD: true,
+      },
+    }),
+  ])
 
-  if (dbSessions.length === 0) {
+  if (dbSessions.length === 0 && dbMessageUsages.length === 0) {
     return emptyUsageData()
   }
 
@@ -47,13 +60,12 @@ export async function getUsageData(): Promise<UsageData> {
     modelCounts: JSON.parse(s.modelCountsJson || '{}') as Record<string, number>,
   }))
 
-  // Aggregate projects
+  // Aggregate projects (per-session — unaffected by message-level dedup since
+  // a session belongs to one project)
   const projectMap = new Map<string, ProjectSummary>()
-  const dailyMap = new Map<string, DailyUsage>()
   const toolUsage: Record<string, number> = {}
 
   for (const s of sessions) {
-    // Projects
     if (!projectMap.has(s.project)) {
       projectMap.set(s.project, {
         name: s.project,
@@ -75,12 +87,23 @@ export async function getUsageData(): Promise<UsageData> {
     for (const [tool, count] of Object.entries(s.toolCalls)) {
       proj.toolCalls[tool] = (proj.toolCalls[tool] || 0) + count
     }
+    for (const [tool, count] of Object.entries(s.toolCalls)) {
+      toolUsage[tool] = (toolUsage[tool] || 0) + count
+    }
+  }
 
-    // Daily
-    const date = s.startTime.slice(0, 10)
-    if (!dailyMap.has(date)) {
-      dailyMap.set(date, {
-        date,
+  // Daily aggregation comes from MessageUsage so totals match ccusage:
+  //   • per-message timestamp → correct date bucket across midnight
+  //   • (messageId, requestId) dedup → no double-counting on session resumes
+  //   • per-(date, model) breakdown → opus + haiku stack on the same day
+  // Mirrors ccusage data-loader.ts:760-901 (loadDailyUsageData).
+  const dailyMap = new Map<string, DailyUsage>()
+  const breakdownMap = new Map<string, Map<string, ModelBreakdown>>()
+
+  for (const m of dbMessageUsages) {
+    if (!dailyMap.has(m.date)) {
+      dailyMap.set(m.date, {
+        date: m.date,
         sessions: 0,
         messages: 0,
         userMessages: 0,
@@ -95,32 +118,84 @@ export async function getUsageData(): Promise<UsageData> {
         toolCallsDetail: {},
         interruptions: 0,
         rateLimitErrors: 0,
+        modelBreakdowns: [],
       })
+      breakdownMap.set(m.date, new Map())
     }
-    const daily = dailyMap.get(date)!
-    daily.sessions++
-    daily.messages += s.totalMessages
-    daily.userMessages += s.userMessages
-    daily.assistantMessages += s.assistantMessages
-    daily.inputTokens += s.inputTokens
-    daily.outputTokens += s.outputTokens
-    daily.cacheCreationTokens += s.cacheCreationTokens
-    daily.cacheReadTokens += s.cacheReadTokens
-    daily.totalTokens += s.totalTokens
-    daily.costUSD += s.costUSD
-    daily.toolCalls += s.toolCallsTotal
-    daily.interruptions += s.userInterruptions
-    daily.rateLimitErrors += s.rateLimitErrors
-    for (const [tool, count] of Object.entries(s.toolCalls)) {
-      daily.toolCallsDetail[tool] = (daily.toolCallsDetail[tool] || 0) + count
+    const d = dailyMap.get(m.date)!
+    d.inputTokens += m.inputTokens
+    d.outputTokens += m.outputTokens
+    d.cacheCreationTokens += m.cacheCreationTokens
+    d.cacheReadTokens += m.cacheReadTokens
+    d.totalTokens +=
+      m.inputTokens + m.outputTokens + m.cacheCreationTokens + m.cacheReadTokens
+    d.costUSD += m.costUSD
+
+    const modelKey = m.speed === 'fast' ? `${m.model}-fast` : m.model
+    const perModel = breakdownMap.get(m.date)!
+    if (!perModel.has(modelKey)) {
+      perModel.set(modelKey, {
+        model: modelKey,
+        inputTokens: 0,
+        outputTokens: 0,
+        cacheCreationTokens: 0,
+        cacheReadTokens: 0,
+        costUSD: 0,
+      })
     }
+    const mb = perModel.get(modelKey)!
+    mb.inputTokens += m.inputTokens
+    mb.outputTokens += m.outputTokens
+    mb.cacheCreationTokens += m.cacheCreationTokens
+    mb.cacheReadTokens += m.cacheReadTokens
+    mb.costUSD += m.costUSD
+  }
 
-    // Tool usage
+  // Layer per-session counters that MessageUsage doesn't track: sessions count,
+  // user/assistant message counts, tool calls, interruptions.
+  for (const s of sessions) {
+    const date = s.startTime.slice(0, 10)
+    let d = dailyMap.get(date)
+    if (!d) {
+      d = {
+        date,
+        sessions: 0,
+        messages: 0,
+        userMessages: 0,
+        assistantMessages: 0,
+        inputTokens: 0,
+        outputTokens: 0,
+        cacheCreationTokens: 0,
+        cacheReadTokens: 0,
+        totalTokens: 0,
+        costUSD: 0,
+        toolCalls: 0,
+        toolCallsDetail: {},
+        interruptions: 0,
+        rateLimitErrors: 0,
+        modelBreakdowns: [],
+      }
+      dailyMap.set(date, d)
+      breakdownMap.set(date, new Map())
+    }
+    d.sessions++
+    d.messages += s.totalMessages
+    d.userMessages += s.userMessages
+    d.assistantMessages += s.assistantMessages
+    d.toolCalls += s.toolCallsTotal
+    d.interruptions += s.userInterruptions
+    d.rateLimitErrors += s.rateLimitErrors
     for (const [tool, count] of Object.entries(s.toolCalls)) {
-      toolUsage[tool] = (toolUsage[tool] || 0) + count
+      d.toolCallsDetail[tool] = (d.toolCallsDetail[tool] || 0) + count
     }
   }
 
+  for (const [date, perModel] of breakdownMap) {
+    dailyMap.get(date)!.modelBreakdowns = Array.from(perModel.values()).sort((a, b) =>
+      a.model.localeCompare(b.model)
+    )
+  }
+
   const dailyArr = Array.from(dailyMap.values()).sort((a, b) => a.date.localeCompare(b.date))
   const projects = Array.from(projectMap.values()).sort((a, b) => b.totalCost - a.totalCost)
 
@@ -139,18 +214,31 @@ export async function getUsageData(): Promise<UsageData> {
     }
   }
 
+  // Overview token + cost totals come from the deduped MessageUsage rows so
+  // the overview matches the daily breakdown (which also reads MessageUsage).
+  const tokenTotals = dailyArr.reduce(
+    (acc, d) => ({
+      input: acc.input + d.inputTokens,
+      output: acc.output + d.outputTokens,
+      cc: acc.cc + d.cacheCreationTokens,
+      cr: acc.cr + d.cacheReadTokens,
+      cost: acc.cost + d.costUSD,
+    }),
+    { input: 0, output: 0, cc: 0, cr: 0, cost: 0 }
+  )
+
   const overview: OverviewStats = {
     totalSessions: sessions.length,
     totalProjects: projects.length,
     totalMessages: sessions.reduce((a, s) => a + s.totalMessages, 0),
     totalUserMessages: sessions.reduce((a, s) => a + s.userMessages, 0),
     totalAssistantMessages: sessions.reduce((a, s) => a + s.assistantMessages, 0),
-    totalInputTokens: sessions.reduce((a, s) => a + s.inputTokens, 0),
-    totalOutputTokens: sessions.reduce((a, s) => a + s.outputTokens, 0),
-    totalCacheCreationTokens: sessions.reduce((a, s) => a + s.cacheCreationTokens, 0),
-    totalCacheReadTokens: sessions.reduce((a, s) => a + s.cacheReadTokens, 0),
-    totalTokens: sessions.reduce((a, s) => a + s.totalTokens, 0),
-    totalCostUSD: sessions.reduce((a, s) => a + s.costUSD, 0),
+    totalInputTokens: tokenTotals.input,
+    totalOutputTokens: tokenTotals.output,
+    totalCacheCreationTokens: tokenTotals.cc,
+    totalCacheReadTokens: tokenTotals.cr,
+    totalTokens: tokenTotals.input + tokenTotals.output + tokenTotals.cc + tokenTotals.cr,
+    totalCostUSD: tokenTotals.cost,
     totalDurationMinutes: sessions.reduce((a, s) => a + s.durationMinutes, 0),
     totalToolCalls: sessions.reduce((a, s) => a + s.toolCallsTotal, 0),
     totalApiErrors: sessions.reduce((a, s) => a + s.apiErrors, 0),