@hasna/economy 0.2.23 → 0.2.25

package/dist/mcp/index.js

@@ -1057,23 +1057,20 @@ function labelForPath(projectPath, projectName) {
   return segments[segments.length - 1] ?? projectPath;
 }
 function queryProjectBreakdown(db, period = "all") {
-  const where = sessionPeriodWhere(period);
+  const requestWhere = requestPeriodWhere(period);
+  const sessionWhere = sessionPeriodWhere(period);
   const sessions = db.prepare(`
     SELECT id, project_path, project_name, total_cost_usd, started_at
     FROM sessions
-    WHERE ${where}
-      AND (project_path != '' OR project_name != '')
+    WHERE project_path != '' OR project_name != ''
   `).all();
   const groups = new Map;
   for (const s of sessions) {
     const label = labelForPath(s.project_path, s.project_name);
     if (!label)
       continue;
-    const g = groups.get(label) ?? { sessionIds: [], samplePath: s.project_path, totalCost: 0, lastActive: "" };
+    const g = groups.get(label) ?? { sessionIds: [], samplePath: s.project_path };
     g.sessionIds.push(s.id);
-    g.totalCost += s.total_cost_usd || 0;
-    if (!g.lastActive || s.started_at > g.lastActive)
-      g.lastActive = s.started_at;
     if (!g.samplePath)
       g.samplePath = s.project_path;
     groups.set(label, g);
@@ -1083,32 +1080,52 @@ function queryProjectBreakdown(db, period = "all") {
     const placeholders = g.sessionIds.map(() => "?").join(",");
     const reqStats = placeholders.length ? db.prepare(`
           SELECT
+            COUNT(DISTINCT session_id) as sessions,
             COUNT(*) as requests,
             COALESCE(SUM(cost_usd), 0) as cost_usd,
-            COALESCE(SUM(input_tokens + output_tokens + cache_read_tokens + cache_create_tokens), 0) as total_tokens
-          FROM requests WHERE session_id IN (${placeholders})
-        `).get(...g.sessionIds) : { requests: 0, cost_usd: 0, total_tokens: 0 };
+            COALESCE(SUM(input_tokens + output_tokens + cache_read_tokens + cache_create_tokens), 0) as total_tokens,
+            MAX(timestamp) as last_active
+          FROM requests
+          WHERE session_id IN (${placeholders})
+            AND ${requestWhere}
+        `).get(...g.sessionIds) : { sessions: 0, requests: 0, cost_usd: 0, total_tokens: 0, last_active: null };
+    const sessionOnlyStats = placeholders.length ? db.prepare(`
+          SELECT
+            COUNT(*) as sessions,
+            COALESCE(SUM(request_count), 0) as requests,
+            COALESCE(SUM(total_tokens), 0) as total_tokens,
+            COALESCE(SUM(total_cost_usd), 0) as cost_usd,
+            MAX(started_at) as last_active
+          FROM sessions
+          WHERE id IN (${placeholders})
+            AND ${sessionWhere}
+            AND id NOT IN (SELECT DISTINCT session_id FROM requests)
+        `).get(...g.sessionIds) : { sessions: 0, requests: 0, total_tokens: 0, cost_usd: 0, last_active: null };
+    const totalSessions = reqStats.sessions + sessionOnlyStats.sessions;
+    if (totalSessions === 0)
+      continue;
+    const lastActive = [reqStats.last_active, sessionOnlyStats.last_active].filter(Boolean).sort().at(-1) ?? "";
     result.push({
       project_path: g.samplePath,
       project_name: label,
-      sessions: g.sessionIds.length,
-      requests: reqStats.requests,
-      total_tokens: reqStats.total_tokens,
-      cost_usd: reqStats.cost_usd > 0 ? reqStats.cost_usd : g.totalCost,
-      last_active: g.lastActive
+      sessions: totalSessions,
+      requests: reqStats.requests + sessionOnlyStats.requests,
+      total_tokens: reqStats.total_tokens + sessionOnlyStats.total_tokens,
+      cost_usd: reqStats.cost_usd + sessionOnlyStats.cost_usd,
+      last_active: lastActive
     });
   }
   result.sort((a, b) => b.cost_usd - a.cost_usd);
   return result;
 }
 function queryAccountBreakdown(db, period = "all") {
-  const sWhere = sessionPeriodWhere(period);
+  const requestWhere = requestPeriodWhere(period);
+  const sessionWhere = sessionPeriodWhere(period);
   const sessions = db.prepare(`
     SELECT id, account_key, account_tool, account_name, account_email, account_source,
            total_cost_usd, total_tokens, request_count, started_at
     FROM sessions
-    WHERE ${sWhere}
-      AND (account_key != '' OR account_tool != '' OR account_name != '' OR account_email != '')
+    WHERE account_key != '' OR account_tool != '' OR account_name != '' OR account_email != ''
   `).all();
   const groups = new Map;
   for (const session of sessions) {
@@ -1120,18 +1137,9 @@ function queryAccountBreakdown(db, period = "all") {
       account_tool: session.account_tool,
       account_name: session.account_name,
       account_email: session.account_email || null,
-      account_source: session.account_source || "unknown",
-      totalCost: 0,
-      totalTokens: 0,
-      requests: 0,
-      lastActive: ""
+      account_source: session.account_source || "unknown"
     };
     group.sessionIds.push(session.id);
-    group.totalCost += session.total_cost_usd || 0;
-    group.totalTokens += session.total_tokens || 0;
-    group.requests += session.request_count || 0;
-    if (!group.lastActive || session.started_at > group.lastActive)
-      group.lastActive = session.started_at;
     groups.set(key, group);
   }
   const result = [];
@@ -1139,36 +1147,57 @@ function queryAccountBreakdown(db, period = "all") {
     const placeholders = group.sessionIds.map(() => "?").join(",");
     const reqStats = placeholders ? db.prepare(`
           SELECT
+            COUNT(DISTINCT session_id) as sessions,
             COUNT(*) as requests,
             COALESCE(SUM(cost_usd), 0) as cost_usd,
             COALESCE(SUM(input_tokens + output_tokens + cache_read_tokens + cache_create_tokens), 0) as total_tokens,
             COALESCE(SUM(CASE WHEN cost_basis = 'metered_api' THEN cost_usd ELSE 0 END), 0) as metered_api_usd,
             COALESCE(SUM(CASE WHEN cost_basis = 'subscription_included' THEN cost_usd ELSE 0 END), 0) as subscription_included_usd,
             COALESCE(SUM(CASE WHEN COALESCE(cost_basis, 'estimated') = 'estimated' THEN cost_usd ELSE 0 END), 0) as estimated_usd,
-            COALESCE(SUM(CASE WHEN cost_basis = 'unknown' THEN cost_usd ELSE 0 END), 0) as unknown_usd
-          FROM requests WHERE session_id IN (${placeholders})
+            COALESCE(SUM(CASE WHEN cost_basis = 'unknown' THEN cost_usd ELSE 0 END), 0) as unknown_usd,
+            MAX(timestamp) as last_active
+          FROM requests
+          WHERE session_id IN (${placeholders})
+            AND ${requestWhere}
         `).get(...group.sessionIds) : {
+      sessions: 0,
       requests: 0,
       cost_usd: 0,
       total_tokens: 0,
       metered_api_usd: 0,
       subscription_included_usd: 0,
       estimated_usd: 0,
-      unknown_usd: 0
+      unknown_usd: 0,
+      last_active: null
     };
-    const hasRequestCosts = reqStats.requests > 0;
-    const apiEquivalentUsd = hasRequestCosts ? reqStats.cost_usd : group.totalCost;
-    const estimatedUsd = hasRequestCosts ? reqStats.estimated_usd : group.totalCost;
+    const sessionOnlyStats = placeholders ? db.prepare(`
+          SELECT
+            COUNT(*) as sessions,
+            COALESCE(SUM(request_count), 0) as requests,
+            COALESCE(SUM(total_tokens), 0) as total_tokens,
+            COALESCE(SUM(total_cost_usd), 0) as cost_usd,
+            MAX(started_at) as last_active
+          FROM sessions
+          WHERE id IN (${placeholders})
+            AND ${sessionWhere}
+            AND id NOT IN (SELECT DISTINCT session_id FROM requests)
+        `).get(...group.sessionIds) : { sessions: 0, requests: 0, total_tokens: 0, cost_usd: 0, last_active: null };
+    const sessionsTotal = reqStats.sessions + sessionOnlyStats.sessions;
+    if (sessionsTotal === 0)
+      continue;
+    const apiEquivalentUsd = reqStats.cost_usd + sessionOnlyStats.cost_usd;
+    const estimatedUsd = reqStats.estimated_usd + sessionOnlyStats.cost_usd;
     const billableUsd = reqStats.metered_api_usd;
+    const lastActive = [reqStats.last_active, sessionOnlyStats.last_active].filter(Boolean).sort().at(-1) ?? "";
     result.push({
       account_key: key,
       account_tool: group.account_tool,
       account_name: group.account_name,
       account_email: group.account_email,
       account_source: group.account_source,
-      sessions: group.sessionIds.length,
-      requests: reqStats.requests || group.requests,
-      total_tokens: reqStats.total_tokens || group.totalTokens,
+      sessions: sessionsTotal,
+      requests: reqStats.requests + sessionOnlyStats.requests,
+      total_tokens: reqStats.total_tokens + sessionOnlyStats.total_tokens,
       api_equivalent_usd: apiEquivalentUsd,
       billable_usd: billableUsd,
       metered_api_usd: reqStats.metered_api_usd,
@@ -1176,7 +1205,7 @@ function queryAccountBreakdown(db, period = "all") {
       estimated_usd: estimatedUsd,
       unknown_usd: reqStats.unknown_usd,
       cost_usd: apiEquivalentUsd,
-      last_active: group.lastActive
+      last_active: lastActive
     });
   }
   result.sort((a, b) => b.cost_usd - a.cost_usd);
@@ -1632,6 +1661,10 @@ function prorateMonthlyFee(monthlyFee, period) {
       return monthlyFee;
   }
 }
+function proratedIncludedConsumed(includedUsage, includedCap, period) {
+  const cap = prorateMonthlyFee(includedCap, period);
+  return cap > 0 ? Math.min(includedUsage, cap) : includedUsage;
+}
 function computeSavedUsd(apiEquivalent, onDemand, subscriptionFee) {
   return Math.max(0, apiEquivalent - onDemand - subscriptionFee);
 }
@@ -1659,24 +1692,74 @@ function querySavingsSummary(db, period, agent) {
       AND metric = 'on_demand_usd'
   `).get(...params);
   const subs = db.prepare(`
-    SELECT COALESCE(SUM(monthly_fee_usd), 0) as total
+    SELECT
+      COALESCE(SUM(monthly_fee_usd), 0) as fee,
+      COALESCE(SUM(included_usage_usd), 0) as included
     FROM subscriptions
-    WHERE active = 1${agent ? " AND agent = ?" : ""}
+    WHERE active = 1${agent ? " AND (agent = ? OR agent IS NULL)" : ""}
   `).get(...agent ? [agent] : []);
-  const subscriptionFee = prorateMonthlyFee(subs.total, period);
+  const subscriptionFee = prorateMonthlyFee(subs.fee, period);
   const apiEquivalent = apiRow.total + includedRow.total;
+  const includedConsumed = proratedIncludedConsumed(includedRow.total, subs.included, period);
   const onDemand = onDemandRow.total;
   const saved = computeSavedUsd(apiEquivalent, onDemand, subscriptionFee);
   const byAgent = {};
   if (!agent) {
+    const onDemandByAgent = new Map;
+    for (const row of db.prepare(`
+      SELECT agent, COALESCE(SUM(value), 0) as total
+      FROM usage_snapshots
+      WHERE ${subWhere}
+        AND metric = 'on_demand_usd'
+      GROUP BY agent
+    `).all()) {
+      onDemandByAgent.set(row.agent, row.total);
+    }
+    const subscriptionByAgent = new Map;
     for (const row of db.prepare(`
-      SELECT agent, COALESCE(SUM(cost_usd), 0) as api_eq
+      SELECT agent,
+             COALESCE(SUM(monthly_fee_usd), 0) as fee,
+             COALESCE(SUM(included_usage_usd), 0) as included
+      FROM subscriptions
+      WHERE active = 1 AND agent IS NOT NULL
+      GROUP BY agent
+    `).all()) {
+      subscriptionByAgent.set(row.agent, row);
+    }
+    const globalSubs = db.prepare(`
+      SELECT
+        COALESCE(SUM(monthly_fee_usd), 0) as fee,
+        COALESCE(SUM(included_usage_usd), 0) as included
+      FROM subscriptions
+      WHERE active = 1 AND agent IS NULL
+    `).get();
+    const rows = db.prepare(`
+      SELECT agent,
+             COALESCE(SUM(cost_usd), 0) as api_eq,
+             COALESCE(SUM(CASE WHEN cost_basis = 'subscription_included' THEN cost_usd ELSE 0 END), 0) as included
+      FROM requests WHERE ${where}
+      GROUP BY agent
+    `).all();
+    const totalAgentApiEq = rows.reduce((sum, row) => sum + row.api_eq, 0);
+    for (const row of db.prepare(`
+      SELECT agent,
+             COALESCE(SUM(cost_usd), 0) as api_eq,
+             COALESCE(SUM(CASE WHEN cost_basis = 'subscription_included' THEN cost_usd ELSE 0 END), 0) as included
       FROM requests WHERE ${where}
       GROUP BY agent
     `).all()) {
+      const agentSubs = subscriptionByAgent.get(row.agent) ?? { fee: 0, included: 0 };
+      const globalShare = totalAgentApiEq > 0 ? row.api_eq / totalAgentApiEq : 0;
+      const agentFee = prorateMonthlyFee(agentSubs.fee + globalSubs.fee * globalShare, period);
+      const agentIncludedCap = agentSubs.included + globalSubs.included * globalShare;
+      const agentIncludedConsumed = proratedIncludedConsumed(row.included, agentIncludedCap, period);
+      const agentOnDemand = onDemandByAgent.get(row.agent) ?? 0;
       byAgent[row.agent] = {
         api_equivalent_usd: row.api_eq,
-        saved_usd: row.api_eq
+        subscription_fee_usd: agentFee,
+        included_consumed_usd: agentIncludedConsumed,
+        on_demand_usd: agentOnDemand,
+        saved_usd: computeSavedUsd(row.api_eq, agentOnDemand, agentFee)
       };
     }
   }
@@ -1684,7 +1767,7 @@ function querySavingsSummary(db, period, agent) {
     period,
     api_equivalent_usd: apiEquivalent,
     subscription_fee_usd: subscriptionFee,
-    included_consumed_usd: includedRow.total,
+    included_consumed_usd: includedConsumed,
     on_demand_usd: onDemand,
     saved_usd: saved,
     by_agent: byAgent
@@ -3272,6 +3355,34 @@ var AGENTS = [
   "hermes"
 ];
 
+// src/lib/periods.ts
+function ymd(date) {
+  return date.toISOString().substring(0, 10);
+}
+function usageSnapshotFilterForPeriod(period) {
+  const now = new Date;
+  switch (period) {
+    case "today":
+      return { date: ymd(now) };
+    case "yesterday": {
+      const yesterday = new Date(now);
+      yesterday.setUTCDate(yesterday.getUTCDate() - 1);
+      return { date: ymd(yesterday) };
+    }
+    case "week": {
+      const weekAgo = new Date(now);
+      weekAgo.setUTCDate(weekAgo.getUTCDate() - 7);
+      return { since: ymd(weekAgo) };
+    }
+    case "month":
+      return { since: ymd(new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), 1))) };
+    case "year":
+      return { since: ymd(new Date(Date.UTC(now.getUTCFullYear(), 0, 1))) };
+    case "all":
+      return {};
+  }
+}
+
 // src/mcp/index.ts
 init_database();
 init_pricing();
@@ -3339,7 +3450,7 @@ var TOOL_NAMES = [
 ];
 var TOOL_DESCRIPTIONS = {
   get_cost_summary: "period(today|week|month|year|all), machine?(hostname) -> {total_usd, sessions, requests, tokens, summary}",
-  get_sessions: `agent(${AGENTS.join("|")}), project(partial), machine?(hostname), limit(20) -> compact session table`,
+  get_sessions: `agent(${AGENTS.join("|")}), project(partial), account?(key/name/email), machine?(hostname), limit(20) -> compact session table`,
   get_top_sessions: `n(10), agent(${AGENTS.join("|")}) -> top sessions by cost`,
   list_machines: "no params -> machine_id, sessions, requests, cost, last_active",
   get_model_breakdown: "no params -> model, requests, tokens, cost",
@@ -3355,7 +3466,7 @@ var TOOL_DESCRIPTIONS = {
   get_daily: "days(30) -> daily cost table grouped by date and agent",
   get_billing_summary: "period(today|yesterday|week|month|year|all) -> actual provider billing totals",
   get_session_detail: "session_id(prefix ok) -> per-request breakdown with model, tokens, cost",
-  get_usage: `period(today|week|month), agent?(${AGENTS.join("|")}) -> usage snapshots and all-machine summary`,
+  get_usage: `period(today|week|month|year|all), agent?(${AGENTS.join("|")}) -> usage snapshots and all-machine summary`,
   get_savings: `period(today|week|month|year|all), agent?(${AGENTS.join("|")}) -> subscription/API-equivalent savings`,
   list_subscriptions: "no params -> configured subscription plans and included usage",
   set_subscription: `provider, plan, monthly_fee_usd?, included_usage_usd?, agent?(${AGENTS.join("|")}) -> create/update subscription plan`,
@@ -3413,15 +3524,17 @@ server.tool("get_cost_summary", "Cost summary (total_usd, sessions, requests, to
   ].join(`
 `));
 });
-server.tool("get_sessions", "List sessions. Returns compact table. Params: agent, project, machine, limit(20)", {
+server.tool("get_sessions", "List sessions. Returns compact table. Params: agent, project, account, machine, limit(20)", {
   agent: z.enum(AGENTS).optional(),
   project: z.string().optional(),
+  account: z.string().optional(),
   machine: z.string().optional(),
   limit: z.number().int().positive().max(100).optional()
-}, async ({ agent, project, machine, limit }) => {
+}, async ({ agent, project, account, machine, limit }) => {
   const sessions = querySessions(db, {
     agent,
     project,
+    account,
     machine,
     limit: limit ?? 20
   });
@@ -3611,9 +3724,9 @@ server.tool("sync", `Ingest new cost data. sources: all|${AGENTS.join("|")}`, {
   const result = await syncAll(db, opts);
   return text(JSON.stringify(result, null, 2));
 });
-server.tool("get_usage", "Usage snapshots and fleet summary. period: today|week|month", { period: z.enum(["today", "week", "month"]).optional(), agent: z.enum(AGENTS).optional() }, async ({ period, agent }) => {
+server.tool("get_usage", "Usage snapshots and fleet summary. period: today|week|month|year|all", { period: z.enum(["today", "week", "month", "year", "all"]).optional(), agent: z.enum(AGENTS).optional() }, async ({ period, agent }) => {
   const p = period ?? "month";
-  const snaps = queryUsageSnapshots(db, { agent });
+  const snaps = queryUsageSnapshots(db, { agent, ...usageSnapshotFilterForPeriod(p) });
   const summary = querySummary(db, p, undefined, true);
   return text(JSON.stringify({ snapshots: snaps, summary }, null, 2));
 });