@lastbrain/module-ai 2.0.26 → 2.0.30

package/dist/api/admin/user-monthly-details.js

@@ -0,0 +1,140 @@
+/**
+ * GET /api/ai/admin/user-monthly-details?userId=xxx&month=2026-01
+ * Get detailed monthly usage for a specific user
+ */
+import { NextResponse } from "next/server";
+import { getSupabaseServiceClient } from "@lastbrain/core/server";
+import { logger } from "@lastbrain/core";
+export async function GET(request) {
+    try {
+        const { searchParams } = new URL(request.url);
+        const userId = searchParams.get("userId");
+        const month = searchParams.get("month"); // Format: YYYY-MM
+        if (!userId) {
+            return NextResponse.json({ error: "userId required" }, { status: 400 });
+        }
+        if (!month || !/^\d{4}-\d{2}$/.test(month)) {
+            return NextResponse.json({ error: "month required in format YYYY-MM" }, { status: 400 });
+        }
+        const supabase = await getSupabaseServiceClient();
+        // Calculate month start/end
+        const monthStart = new Date(`${month}-01T00:00:00Z`);
+        const monthEnd = new Date(monthStart);
+        monthEnd.setMonth(monthEnd.getMonth() + 1);
+        // Get all ledger entries for this user in this month
+        const { data: ledgerEntries, error: ledgerError } = await supabase
+            .from("user_token_ledger")
+            .select(`
+        created_at,
+        type,
+        debit_tokens,
+        provider_cost_usd,
+        sell_usd,
+        margin_usd,
+        model,
+        provider,
+        meta,
+        provider_budget_added_usd
+      `)
+            .eq("owner_id", userId)
+            .gte("created_at", monthStart.toISOString())
+            .lt("created_at", monthEnd.toISOString())
+            .order("created_at", { ascending: false });
+        if (ledgerError) {
+            logger.error("[user-monthly-details] Error fetching ledger:", ledgerError);
+            return NextResponse.json({ error: "Failed to fetch ledger entries" }, { status: 500 });
+        }
+        // Separate entry types
+        const purchases = ledgerEntries?.filter((e) => e.type === "purchase") || [];
+        const gifts = ledgerEntries?.filter((e) => e.type === "gift" || e.type === "signup_bonus") || [];
+        const usages = ledgerEntries?.filter((e) => e.type === "use") || [];
+        // CA = uniquement les achats réels (purchases)
+        const totalPurchaseUsd = purchases.reduce((sum, p) => sum + (p.sell_usd || 0), 0);
+        // Coût fournisseur = toutes les utilisations (use)
+        const totalProviderCostUsd = usages.reduce((sum, u) => sum + (u.provider_cost_usd || 0), 0);
+        // Budget total offert (gifts/signup_bonus) - PAS une charge tant que non consommé
+        const totalGiftBudgetUsd = gifts.reduce((sum, g) => sum + (g.provider_budget_added_usd || 0), 0);
+        const totalSellUsd = usages.reduce((sum, u) => sum + (u.sell_usd || 0), 0);
+        const totalMarginUsd = usages.reduce((sum, u) => sum + (u.margin_usd || 0), 0);
+        // Group usages by action type
+        const usageByAction = {};
+        usages.forEach((usage) => {
+            // Extract action type from meta or infer from model
+            let actionType = usage.meta?.action_type || "use";
+            // Get model and provider
+            const modelFull = usage.model || "unknown";
+            let provider = usage.provider || null;
+            let modelName = modelFull;
+            // If model contains "/" extract provider and model
+            if (modelFull.includes("/")) {
+                const parts = modelFull.split("/");
+                provider = parts[0];
+                modelName = parts[1];
+            }
+            // Infer action type from model if not in meta
+            if (actionType === "use") {
+                if (modelName.includes("imagen") || modelName.includes("dall-e")) {
+                    actionType = "generate-image";
+                }
+                else if (modelName.includes("gpt") || modelName.includes("claude")) {
+                    actionType = "generate-text";
+                }
+            }
+            const key = `${actionType} (${provider || "unknown"}/${modelName})`;
+            if (!usageByAction[key]) {
+                usageByAction[key] = {
+                    count: 0,
+                    providerCostUsd: 0,
+                    sellUsd: 0,
+                    marginUsd: 0,
+                };
+            }
+            usageByAction[key].count++;
+            usageByAction[key].providerCostUsd += usage.provider_cost_usd || 0;
+            usageByAction[key].sellUsd += usage.sell_usd || 0;
+            usageByAction[key].marginUsd += usage.margin_usd || 0;
+        });
+        // Get user info
+        const { data: userData } = await supabase.auth.admin.getUserById(userId);
+        // Calcul du vrai CA et marge
+        // CA = Achats uniquement (purchases)
+        // Charges = Coût fournisseur utilisation + Coût crédits offerts
+        // Charges réelles = UNIQUEMENT ce qui a été consommé (usages API)
+        // Les budgets offerts (gifts) ne sont PAS des charges tant qu'ils ne sont pas utilisés
+        const totalCharges = totalProviderCostUsd;
+        const realMarginUsd = totalPurchaseUsd - totalCharges;
+        const realMarginPercent = totalPurchaseUsd > 0 ? (realMarginUsd / totalPurchaseUsd) * 100 : 0;
+        return NextResponse.json({
+            user: {
+                id: userId,
+                email: userData?.user?.email || "Unknown",
+            },
+            month,
+            summary: {
+                totalPurchases: purchases.length,
+                totalGifts: gifts.length,
+                totalUsages: usages.length,
+                totalPurchaseUsd, // CA réel (achats uniquement)
+                totalProviderCostUsd, // Coût utilisation réelle
+                totalGiftBudgetUsd, // Budget offert (non consommé = pas une charge)
+                totalCharges, // = totalProviderCostUsd uniquement
+                realMarginUsd, // Marge réelle = CA - Charges
+                realMarginPercent, // % marge réelle
+                // Anciennes valeurs pour compatibilité
+                totalSellUsd,
+                totalMarginUsd,
+                marginPercent: totalSellUsd > 0 ? (totalMarginUsd / totalSellUsd) * 100 : 0,
+            },
+            usageByAction: Object.entries(usageByAction).map(([key, data]) => ({
+                actionType: key,
+                ...data,
+                avgCostPerCall: data.providerCostUsd / data.count,
+            })),
+            recentEntries: ledgerEntries?.slice(0, 50) || [], // Last 50 entries
+        });
+    }
+    catch (error) {
+        logger.error("[user-monthly-details] Unexpected error:", error);
+        return NextResponse.json({ error: "Internal server error" }, { status: 500 });
+    }
+}

package/dist/api/admin/user-quota.d.ts

@@ -0,0 +1,21 @@
+/**
+ * POST /api/ai/admin/user-quota
+ * Update custom quota for a user (admin only)
+ */
+import { NextRequest, NextResponse } from "next/server";
+export declare function POST(request: NextRequest): Promise<NextResponse<{
+    success: boolean;
+    quota: import("../..").TokenQuotaStatus;
+}> | NextResponse<{
+    error: any;
+}>>;
+/**
+ * GET /api/ai/admin/user-quota?userId=xxx
+ * Get quota status for a specific user (admin only)
+ */
+export declare function GET(request: NextRequest): Promise<NextResponse<{
+    quota: import("../..").TokenQuotaStatus;
+}> | NextResponse<{
+    error: any;
+}>>;
+//# sourceMappingURL=user-quota.d.ts.map

package/dist/api/admin/user-quota.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"user-quota.d.ts","sourceRoot":"","sources":["../../../src/api/admin/user-quota.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAKxD,wBAAsB,IAAI,CAAC,OAAO,EAAE,WAAW;;;;;IA8C9C;AAED;;;GAGG;AACH,wBAAsB,GAAG,CAAC,OAAO,EAAE,WAAW;;;;IAqB7C"}

package/dist/api/admin/user-quota.js

@@ -0,0 +1,59 @@
+/**
+ * POST /api/ai/admin/user-quota
+ * Update custom quota for a user (admin only)
+ */
+import { NextResponse } from "next/server";
+import { getSupabaseServiceClient } from "@lastbrain/core/server";
+import { updateCustomQuota, getUserQuotaStatus } from "../../server/quota";
+import { logger } from "@lastbrain/core";
+export async function POST(request) {
+    try {
+        const supabase = await getSupabaseServiceClient();
+        const body = await request.json();
+        const { userId, customTokens } = body;
+        if (!userId) {
+            return NextResponse.json({ error: "userId requis" }, { status: 400 });
+        }
+        // Validate customTokens (null or positive number)
+        if (customTokens !== null &&
+            (typeof customTokens !== "number" || customTokens < 0)) {
+            return NextResponse.json({ error: "customTokens doit être null ou un nombre positif" }, { status: 400 });
+        }
+        // Update custom quota
+        const result = await updateCustomQuota(userId, customTokens);
+        if (!result.success) {
+            return NextResponse.json({ error: result.error || "Erreur lors de la mise à jour" }, { status: 400 });
+        }
+        // Return updated quota status
+        const updatedStatus = await getUserQuotaStatus(userId);
+        return NextResponse.json({
+            success: true,
+            quota: updatedStatus,
+        });
+    }
+    catch (error) {
+        logger.error("[POST /api/ai/admin/user-quota] Error:", error);
+        return NextResponse.json({ error: error.message || "Erreur serveur" }, { status: 500 });
+    }
+}
+/**
+ * GET /api/ai/admin/user-quota?userId=xxx
+ * Get quota status for a specific user (admin only)
+ */
+export async function GET(request) {
+    try {
+        const searchParams = request.nextUrl.searchParams;
+        const userId = searchParams.get("userId");
+        if (!userId) {
+            return NextResponse.json({ error: "userId requis" }, { status: 400 });
+        }
+        const quotaStatus = await getUserQuotaStatus(userId);
+        return NextResponse.json({
+            quota: quotaStatus,
+        });
+    }
+    catch (error) {
+        logger.error("[GET /api/ai/admin/user-quota] Error:", error);
+        return NextResponse.json({ error: error.message || "Erreur serveur" }, { status: 500 });
+    }
+}

package/dist/api/admin/user-token/[id].d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"[id].d.ts","sourceRoot":"","sources":["../../../../src/api/admin/user-token/[id].ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AASxD,wBAAsB,GAAG,CACvB,OAAO,EAAE,WAAW,EACpB,OAAO,EAAE;IAAE,MAAM,EAAE,OAAO,CAAC;QAAE,EAAE,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;IA4D7C"}
+{"version":3,"file":"[id].d.ts","sourceRoot":"","sources":["../../../../src/api/admin/user-token/[id].ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAUxD,wBAAsB,GAAG,CACvB,OAAO,EAAE,WAAW,EACpB,OAAO,EAAE;IAAE,MAAM,EAAE,OAAO,CAAC;QAAE,EAAE,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;IA4D7C"}

package/dist/api/admin/user-token/[id].js

@@ -1,6 +1,7 @@
 import { NextResponse } from "next/server";
 import { getSupabaseServiceClient } from "@lastbrain/core/server";
 import { getTokenBalance, getTokenHistory, getTokenStats, } from "../../../server";
+import { logger } from "@lastbrain/core";
 // GET /api/ai/admin/user-token/[id] - Détails d'un utilisateur spécifique
 export async function GET(request, context) {
     const { id: userId } = await context.params;
@@ -44,7 +45,7 @@ export async function GET(request, context) {
         });
     }
     catch (error) {
-        console.error("[GET /api/ai/admin/user-token/[id]] Error:", error);
+        logger.error("[GET /api/ai/admin/user-token/[id]] Error:", error);
         return NextResponse.json({ error: error.message || "Erreur serveur" }, { status: 500 });
     }
 }

package/dist/api/admin/user-token.d.ts

@@ -9,15 +9,18 @@ export declare function GET(_request: NextRequest): Promise<NextResponse<{
         totalAdded: number;
         totalUsed: number;
         lastActivity: string | undefined;
+        includedTokens: any;
+        usedIncludedTokens: any;
+        remainingIncludedTokens: number;
     }[];
-    transactions: any;
+    transactions: any[];
     total: number;
 }> | NextResponse<{
     error: any;
 }>>;
 export declare function POST(request: NextRequest): Promise<NextResponse<{
     success: boolean;
-    balance: number;
+    balance: number | undefined;
     message: string;
 }> | NextResponse<{
     error: any;

package/dist/api/admin/user-token.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"user-token.d.ts","sourceRoot":"","sources":["../../../src/api/admin/user-token.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAKxD,wBAAsB,GAAG,CAAC,QAAQ,EAAE,WAAW;;;;;;;;;;;;;;;IA6H9C;AAGD,wBAAsB,IAAI,CAAC,OAAO,EAAE,WAAW;;;;;;IA+C9C"}
+{"version":3,"file":"user-token.d.ts","sourceRoot":"","sources":["../../../src/api/admin/user-token.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AASxD,wBAAsB,GAAG,CAAC,QAAQ,EAAE,WAAW;;;;;;;;;;;;;;;;;;IA4M9C;AAGD,wBAAsB,IAAI,CAAC,OAAO,EAAE,WAAW;;;;;;IAmE9C"}

package/dist/api/admin/user-token.js

@@ -1,6 +1,7 @@
 import { NextResponse } from "next/server";
-import { getSupabaseServiceClient } from "@lastbrain/core/server";
-import { addTokens } from "../../server";
+import { getSupabaseServerClient, getSupabaseServiceClient, } from "@lastbrain/core/server";
+import { addWalletCredits } from "../../server/billing";
+import { logger } from "@lastbrain/core";
 // GET /api/ai/admin/user-token - Liste tous les utilisateurs avec leur balance et transactions
 export async function GET(_request) {
     try {
@@ -13,14 +14,23 @@ export async function GET(_request) {
         // Récupérer toutes les transactions pour calculer les balances et stats
         const { data: transactions, error: txError } = await supabase
             .from("user_token_ledger")
-            .select("*")
-            .order("ts", { ascending: false })
-            .limit(1000);
+            .select("owner_id,ts,type,amount")
+            .order("ts", { ascending: false });
+        logger.error("transactions", txError);
         if (txError)
             throw txError;
         const txList = transactions || [];
+        // Récupérer les usages de quotas (consommation d'abonnement)
+        const { data: quotaRows, error: quotaError } = await supabase
+            .from("user_token_quota_ledger")
+            .select("owner_id,period_start,period_end,tokens_used,model,created_at")
+            .order("created_at", { ascending: false });
+        if (quotaError)
+            throw quotaError;
+        const quotaList = quotaRows || [];
         // Calculer les stats par utilisateur
         const userStatsMap = new Map();
+        // Transactions (achat/cadeau/usage...) affectent le solde
         txList.forEach((tx) => {
             const stats = userStatsMap.get(tx.owner_id) || {
                 balance: 0,
@@ -39,8 +49,28 @@ export async function GET(_request) {
             }
             userStatsMap.set(tx.owner_id, stats);
         });
+        // Usages de quota : ne modifient pas le solde, mais comptent dans le totalUsed et l'activité
+        quotaList.forEach((quota) => {
+            const stats = userStatsMap.get(quota.owner_id) || {
+                balance: 0,
+                totalAdded: 0,
+                totalUsed: 0,
+            };
+            stats.totalUsed += quota.tokens_used; // toujours positif dans la table
+            if (!stats.lastActivity || quota.created_at > stats.lastActivity) {
+                stats.lastActivity = quota.created_at;
+            }
+            userStatsMap.set(quota.owner_id, stats);
+        });
         // Récupérer les profils utilisateurs pour avatar et nom
         const userIds = authUsers.users.map((u) => u.id);
+        const { data: quotaMonthly, error: quotaMonthlyError } = await supabase
+            .from("user_token_quota_monthly")
+            .select("owner_id, effective_included_tokens, used_included_tokens")
+            .in("owner_id", userIds);
+        if (quotaMonthlyError)
+            throw quotaMonthlyError;
+        const quotaMonthlyMap = new Map((quotaMonthly || []).map((row) => [row.owner_id, row]));
         const { data: profiles } = await supabase
             .from("user_profil")
             .select("id, first_name, last_name, avatar_url")
@@ -60,6 +90,10 @@ export async function GET(_request) {
                 totalUsed: 0,
             };
             const profile = profilesMap.get(user.id);
+            const quota = quotaMonthlyMap.get(user.id);
+            const includedTokens = quota?.effective_included_tokens || 0;
+            const usedIncludedTokens = quota?.used_included_tokens || 0;
+            const remainingIncludedTokens = Math.max(0, includedTokens - usedIncludedTokens);
             return {
                 userId: user.id,
                 email: user.email || "Unknown",
@@ -69,9 +103,12 @@ export async function GET(_request) {
                 totalAdded: stats.totalAdded,
                 totalUsed: stats.totalUsed,
                 lastActivity: stats.lastActivity,
+                includedTokens,
+                usedIncludedTokens,
+                remainingIncludedTokens,
             };
         });
-        // Préparer les transactions avec infos utilisateurs
+        // Transactions classiques (achats / cadeaux / usages)
         const transactionsWithUsers = txList.map((tx) => {
             const user = authUsers.users.find((u) => u.id === tx.owner_id);
             const profile = profilesMap.get(tx.owner_id);
@@ -88,44 +125,81 @@ export async function GET(_request) {
                 created_at: tx.ts,
             };
         });
+        // Transactions de quota (consommation d'abonnement)
+        const quotaTransactions = quotaList.map((quota) => {
+            const user = authUsers.users.find((u) => u.id === quota.owner_id);
+            const profile = profilesMap.get(quota.owner_id);
+            return {
+                id: `quota-${quota.id}`,
+                userId: quota.owner_id,
+                email: user?.email || "Unknown",
+                fullName: profile?.fullName,
+                avatarUrl: profile?.avatarUrl,
+                amount: -quota.tokens_used, // on l'affiche en débit
+                type: "quota_use",
+                description: quota.meta?.reason ||
+                    (quota.model
+                        ? `Usage quota ${quota.model}`
+                        : "Usage quota abonnement"),
+                model: quota.model,
+                created_at: quota.created_at,
+            };
+        });
+        // Fusionner et trier par date desc
+        const allTransactions = [
+            ...transactionsWithUsers,
+            ...quotaTransactions,
+        ].sort((a, b) => (a.created_at < b.created_at ? 1 : -1));
         return NextResponse.json({
             users: usersData,
-            transactions: transactionsWithUsers,
+            transactions: allTransactions,
             total: usersData.length,
         });
     }
     catch (error) {
-        console.error("[GET /api/ai/admin/user-token] Error:", error);
+        logger.error("[GET /api/ai/admin/user-token] Error:", error);
         return NextResponse.json({ error: error.message || "Erreur serveur" }, { status: 500 });
     }
 }
-// POST /api/ai/admin/user-token - Ajouter/retirer des tokens à un utilisateur
+// POST /api/ai/admin/user-token - Ajouter/retirer des crédits USD à un utilisateur
 export async function POST(request) {
     try {
         // L'authentification et les droits superadmin sont déjà vérifiés par le middleware
         const body = await request.json();
-        const { userId, amount, type, reason } = body;
+        const { userId, amount, reason } = body;
         if (!userId || !amount) {
             return NextResponse.json({ error: "userId et amount sont requis" }, { status: 400 });
         }
         if (amount === 0) {
             return NextResponse.json({ error: "Le montant ne peut pas être zéro" }, { status: 400 });
         }
-        // Déterminer le type d'opération
-        const operationType = type || (amount > 0 ? "adjust" : "adjust");
-        const result = await addTokens(userId, amount, operationType, { reason: reason || "Ajustement manuel par admin" }, undefined // created_by undefined pour les opérations admin via service role
-        );
+        // Utiliser le nouveau système de wallet en USD
+        const usdAmount = parseFloat(amount);
+        if (usdAmount < 0) {
+            return NextResponse.json({
+                error: "Le débit de crédits n'est pas encore supporté. Utilisez un montant positif pour créditer.",
+            }, { status: 400 });
+        }
+        const result = await addWalletCredits(userId, usdAmount, reason || "Ajustement manuel par admin");
         if (!result.success) {
             return NextResponse.json({ error: result.error }, { status: 500 });
         }
+        const supabase = await getSupabaseServerClient();
+        await supabase.from("user_notifications").insert({
+            owner_id: userId,
+            title: `Crédits IA ajoutés`,
+            body: `$${usdAmount.toFixed(2)} de crédits IA ont été ajoutés à votre compte. ${reason ? `Raison : ${reason}` : ""}`,
+            type: "credit_added",
+            read: false,
+        });
         return NextResponse.json({
             success: true,
-            balance: result.balance,
-            message: `${amount > 0 ? "Ajouté" : "Retiré"} ${Math.abs(amount)} tokens`,
+            balance: result.newBalance,
+            message: `Ajouté $${usdAmount.toFixed(2)} de crédits IA`,
         });
     }
     catch (error) {
-        console.error("[POST /api/ai/admin/user-token] Error:", error);
+        logger.error("[POST /api/ai/admin/user-token] Error:", error);
         return NextResponse.json({ error: error.message || "Erreur serveur" }, { status: 500 });
     }
 }

package/dist/api/admin/user-usage-by-model.d.ts

@@ -0,0 +1,22 @@
+import { NextRequest, NextResponse } from "next/server";
+/**
+ * GET /api/ai/admin/user-usage-by-model
+ * Returns usage statistics grouped by model with costs in USD for a specific user
+ * Supports filtering by month
+ */
+export declare function GET(request: NextRequest): Promise<NextResponse<{
+    data: {
+        avg_cost_per_call: number;
+        model: string;
+        provider: string;
+        endpoint: string;
+        total_cost_usd: number;
+        total_sell_usd: number;
+        call_count: number;
+    }[];
+    period: string;
+    userId: string;
+}> | NextResponse<{
+    error: any;
+}>>;
+//# sourceMappingURL=user-usage-by-model.d.ts.map

package/dist/api/admin/user-usage-by-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"user-usage-by-model.d.ts","sourceRoot":"","sources":["../../../src/api/admin/user-usage-by-model.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAIxD;;;;GAIG;AACH,wBAAsB,GAAG,CAAC,OAAO,EAAE,WAAW;;;eAgD/B,MAAM;kBACH,MAAM;kBACN,MAAM;wBACA,MAAM;wBACN,MAAM;oBACV,MAAM;;;;;;IAiDzB"}

package/dist/api/admin/user-usage-by-model.js

@@ -0,0 +1,78 @@
+import { NextResponse } from "next/server";
+import { getSupabaseServiceClient } from "@lastbrain/core/server";
+import { logger } from "@lastbrain/core";
+/**
+ * GET /api/ai/admin/user-usage-by-model
+ * Returns usage statistics grouped by model with costs in USD for a specific user
+ * Supports filtering by month
+ */
+export async function GET(request) {
+    try {
+        const supabase = getSupabaseServiceClient();
+        // Get query params
+        const searchParams = request.nextUrl.searchParams;
+        const userId = searchParams.get("userId");
+        const month = searchParams.get("month"); // Format: YYYY-MM
+        if (!userId) {
+            return NextResponse.json({ error: "userId parameter required" }, { status: 400 });
+        }
+        // Build query
+        let query = supabase
+            .from("user_token_ledger")
+            .select("model, provider_cost_usd, sell_usd, meta")
+            .eq("owner_id", userId)
+            .eq("type", "use")
+            .order("ts", { ascending: false });
+        // Filter by month if provided
+        if (month && month !== "all") {
+            const startDate = `${month}-01`;
+            const [year, monthNum] = month.split("-");
+            const nextMonth = new Date(parseInt(year), parseInt(monthNum), 1);
+            const endDate = nextMonth.toISOString().split("T")[0];
+            query = query.gte("ts", startDate).lt("ts", endDate);
+        }
+        const { data: ledgerEntries, error } = await query;
+        if (error) {
+            logger.error("[admin/user-usage-by-model] Error fetching ledger:", error);
+            return NextResponse.json({ error: "Failed to fetch usage data" }, { status: 500 });
+        }
+        // Group by model + provider + endpoint
+        const groupedData = new Map();
+        for (const entry of ledgerEntries || []) {
+            const model = entry.model || "unknown";
+            const provider = entry.meta?.provider || "unknown";
+            const endpoint = entry.meta?.endpoint || "unknown";
+            const key = `${model}|${provider}|${endpoint}`;
+            if (!groupedData.has(key)) {
+                groupedData.set(key, {
+                    model,
+                    provider,
+                    endpoint,
+                    total_cost_usd: 0,
+                    total_sell_usd: 0,
+                    call_count: 0,
+                });
+            }
+            const group = groupedData.get(key);
+            group.total_cost_usd += entry.provider_cost_usd || 0;
+            group.total_sell_usd += entry.sell_usd || 0;
+            group.call_count += 1;
+        }
+        // Convert to array and calculate averages
+        const result = Array.from(groupedData.values()).map((group) => ({
+            ...group,
+            avg_cost_per_call: group.call_count > 0 ? group.total_sell_usd / group.call_count : 0,
+        }));
+        // Sort by total_sell_usd descending
+        result.sort((a, b) => b.total_sell_usd - a.total_sell_usd);
+        return NextResponse.json({
+            data: result,
+            period: month || "all",
+            userId,
+        });
+    }
+    catch (error) {
+        logger.error("[admin/user-usage-by-model] Error:", error);
+        return NextResponse.json({ error: error.message || "Internal server error" }, { status: 500 });
+    }
+}

package/dist/api/admin/user-wallet-analytics.d.ts

@@ -0,0 +1,15 @@
+import { NextRequest, NextResponse } from "next/server";
+export declare function GET(request: NextRequest): Promise<NextResponse<{
+    error: string;
+}> | NextResponse<{
+    tokensAdded: any;
+    tokensUsed: any;
+    totalPurchaseUsd: number;
+    totalProviderCostUsd: number;
+    totalSellUsd: number;
+    totalMarginUsd: number;
+    marginPercent: number;
+    walletProviderBudgetUsd: number;
+    walletSellValueUsd: number;
+}>>;
+//# sourceMappingURL=user-wallet-analytics.d.ts.map

package/dist/api/admin/user-wallet-analytics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"user-wallet-analytics.d.ts","sourceRoot":"","sources":["../../../src/api/admin/user-wallet-analytics.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAIxD,wBAAsB,GAAG,CAAC,OAAO,EAAE,WAAW;;;;;;;;;;;;IAmG7C"}

package/dist/api/admin/user-wallet-analytics.js

@@ -0,0 +1,67 @@
+import { NextResponse } from "next/server";
+import { logger } from "@lastbrain/core";
+import { getSupabaseServiceClient } from "@lastbrain/core/server";
+export async function GET(request) {
+    try {
+        const { searchParams } = new URL(request.url);
+        const userId = searchParams.get("userId");
+        if (!userId) {
+            return NextResponse.json({ error: "userId required" }, { status: 400 });
+        }
+        const supabase = getSupabaseServiceClient();
+        // Get ledger for user
+        const { data: ledgerRows, error: ledgerError } = await supabase
+            .from("user_token_ledger")
+            .select("owner_id, type, amount, provider_cost_usd, sell_usd, margin_usd, pack_coef, pack_price_usd")
+            .eq("owner_id", userId);
+        if (ledgerError) {
+            logger.error("[User Wallet Analytics] Failed to fetch ledger:", ledgerError);
+            throw ledgerError;
+        }
+        const ledger = ledgerRows || [];
+        // Get wallet state
+        const { data: walletRow, error: walletError } = await supabase
+            .from("user_token_wallet")
+            .select("wallet_provider_budget_usd, wallet_sell_value_usd")
+            .eq("user_id", userId)
+            .single();
+        if (walletError && walletError.code !== "PGRST116") {
+            logger.error("[User Wallet Analytics] Failed to fetch wallet:", walletError);
+        }
+        const wallet = walletRow || {
+            wallet_provider_budget_usd: 0,
+            wallet_sell_value_usd: 0,
+        };
+        // Calculate stats
+        const purchases = ledger.filter((t) => t.type === "purchase");
+        const consumptions = ledger.filter((t) => t.type === "use");
+        const totalPurchaseUsd = purchases.reduce((sum, t) => {
+            return sum + (parseFloat(t.pack_price_usd) || 0);
+        }, 0);
+        const tokensAdded = purchases.reduce((sum, t) => sum + t.amount, 0);
+        const tokensUsed = consumptions.reduce((sum, t) => sum + Math.abs(t.amount), 0);
+        const totalProviderCostUsd = consumptions.reduce((sum, t) => {
+            return sum + (parseFloat(t.provider_cost_usd) || 0);
+        }, 0);
+        const totalSellUsd = consumptions.reduce((sum, t) => {
+            return sum + (parseFloat(t.sell_usd) || 0);
+        }, 0);
+        const totalMarginUsd = totalSellUsd - totalProviderCostUsd;
+        const marginPercent = totalSellUsd > 0 ? (totalMarginUsd / totalSellUsd) * 100 : 0;
+        return NextResponse.json({
+            tokensAdded,
+            tokensUsed,
+            totalPurchaseUsd: parseFloat(totalPurchaseUsd.toFixed(4)),
+            totalProviderCostUsd: parseFloat(totalProviderCostUsd.toFixed(4)),
+            totalSellUsd: parseFloat(totalSellUsd.toFixed(4)),
+            totalMarginUsd: parseFloat(totalMarginUsd.toFixed(4)),
+            marginPercent: parseFloat(marginPercent.toFixed(2)),
+            walletProviderBudgetUsd: parseFloat((wallet.wallet_provider_budget_usd || 0).toFixed(4)),
+            walletSellValueUsd: parseFloat((wallet.wallet_sell_value_usd || 0).toFixed(4)),
+        }, { status: 200 });
+    }
+    catch (error) {
+        logger.error("[User Wallet Analytics] Error:", error);
+        return NextResponse.json({ error: "Failed to fetch analytics" }, { status: 500 });
+    }
+}