@lastbrain/module-ai 2.0.26 → 2.0.30

package/dist/api/auth/token-checkout.js

@@ -1,6 +1,7 @@
 import { NextResponse } from "next/server";
 import { getSupabaseServerClient, getApiBaseUrl } from "@lastbrain/core/server";
 import { createOneTimeCheckout } from "@lastbrain-labs/module-core-payment-pro/server";
+import { logger } from "@lastbrain/core";
 /**
  * POST /api/ai/auth/token-checkout
  * Create a Stripe checkout session for token purchase
@@ -18,7 +19,11 @@ export async function POST(request) {
         if (!pack_id) {
             return NextResponse.json({ error: "Pack ID requis" }, { status: 400 });
         }
-        // Get token pack details
+        // Extract locale from referer header
+        const referer = request.headers.get("referer") || "";
+        const localeMatch = referer.match(/\/([a-z]{2})(?:\/|$)/);
+        const locale = localeMatch ? localeMatch[1] : "fr";
+        // Get token pack details including pack_coef
         const { data: pack, error: packError } = await supabase
             .from("token_packs")
             .select("*")
@@ -28,6 +33,11 @@ export async function POST(request) {
         if (packError || !pack) {
             return NextResponse.json({ error: "Pack non trouvé" }, { status: 404 });
         }
+        // Use pack_coef from DB (fallback to 1.35 if not set)
+        const packCoef = pack.pack_coef || 1.35;
+        const packTokens = pack.tokens;
+        const packPriceUsd = pack.price_cents / 100;
+        logger.info(`[Token Checkout] Pack ${pack.name}: ${packTokens} tokens @ $${packPriceUsd} (coef: ${packCoef})`);
         // Build absolute URLs with a fully-qualified base (works on Vercel, custom domains, local)
         const baseUrl = getApiBaseUrl();
         const successUrl = `${baseUrl.replace(/\/$/, "")}${"/cart/success"}`;
@@ -41,9 +51,17 @@ export async function POST(request) {
             user_id: user.id,
             resourceType: "token_packs",
             resourceId: pack.id,
-            successPath: "/cart/success",
-            cancelPath: "/cart/cancel",
+            successPath: `/${locale}/auth/ai/tokens?success=true`,
+            cancelPath: `/${locale}/auth/ai/tokens?cancelled=true`,
             description: `${pack.tokens} tokens IA`,
+            email: user.email, // Pass email to link to existing Stripe customer
+            // Wallet-specific metadata for billing (passed via base type)
+            token_amount: packTokens,
+            token_pack_id: pack.id,
+            pack_tokens: packTokens.toString(),
+            pack_price_usd: packPriceUsd.toString(),
+            pack_coef: packCoef.toString(),
+            pack_name: pack.name,
         });
         return NextResponse.json({
             checkout_url: checkoutResult.url,
@@ -51,7 +69,7 @@ export async function POST(request) {
         }, { status: 200 });
     }
     catch (error) {
-        console.error("[Token Checkout] Error:", error);
+        logger.error("[Token Checkout] Error:", error);
         return NextResponse.json({ error: error.message || "Erreur lors du checkout" }, { status: 500 });
     }
 }

package/dist/api/auth/token-packs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"token-packs.d.ts","sourceRoot":"","sources":["../../../src/api/auth/token-packs.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,YAAY,EAAE,MAAM,aAAa,CAAC;AAGxD;;;GAGG;AACH,wBAAsB,GAAG;;;;IA8BxB"}
+{"version":3,"file":"token-packs.d.ts","sourceRoot":"","sources":["../../../src/api/auth/token-packs.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,YAAY,EAAE,MAAM,aAAa,CAAC;AAIxD;;;GAGG;AACH,wBAAsB,GAAG;;;;IA8BxB"}

package/dist/api/auth/token-packs.js

@@ -1,5 +1,6 @@
 import { NextResponse } from "next/server";
 import { getSupabaseServerClient } from "@lastbrain/core/server";
+import { logger } from "@lastbrain/core";
 /**
  * GET /api/ai/auth/token-packs
  * Get active token packs available for purchase
@@ -23,7 +24,7 @@ export async function GET() {
         return NextResponse.json({ data }, { status: 200 });
     }
     catch (error) {
-        console.error("[Token Packs] GET error:", error);
+        logger.error("[Token Packs] GET error:", error);
         return NextResponse.json({ error: error.message || "Erreur lors de la récupération des packs" }, { status: 500 });
     }
 }

package/dist/api/auth/usage-by-model.d.ts

@@ -0,0 +1,25 @@
+import { NextRequest, NextResponse } from "next/server";
+/**
+ * GET /api/ai/auth/usage-by-model
+ * Returns usage statistics grouped by model with costs in USD
+ * Supports filtering by month and API key
+ */
+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;
+    }[];
+    total_entries: number;
+    filters: {
+        month: string;
+        api_key_id: string;
+    };
+}> | NextResponse<{
+    error: any;
+}>>;
+//# sourceMappingURL=usage-by-model.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"usage-by-model.d.ts","sourceRoot":"","sources":["../../../src/api/auth/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;;;eAkE/B,MAAM;kBACH,MAAM;kBACN,MAAM;wBACA,MAAM;wBACN,MAAM;oBACV,MAAM;;;;;;;;;IAmDzB"}

package/dist/api/auth/usage-by-model.js

@@ -0,0 +1,95 @@
+import { NextResponse } from "next/server";
+import { getSupabaseServerClient } from "@lastbrain/core/server";
+import { logger } from "@lastbrain/core";
+/**
+ * GET /api/ai/auth/usage-by-model
+ * Returns usage statistics grouped by model with costs in USD
+ * Supports filtering by month and API key
+ */
+export async function GET(request) {
+    try {
+        const supabase = await getSupabaseServerClient();
+        const { data: { user }, } = await supabase.auth.getUser();
+        if (!user) {
+            return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+        }
+        // Get query params
+        const searchParams = request.nextUrl.searchParams;
+        const month = searchParams.get("month"); // Format: YYYY-MM
+        const apiKeyId = searchParams.get("api_key_id");
+        // Build query
+        let query = supabase
+            .from("user_token_ledger")
+            .select("model, provider_cost_usd, sell_usd, meta")
+            .eq("owner_id", user.id)
+            .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("[usage-by-model] Error fetching ledger:", error);
+            return NextResponse.json({ error: "Failed to fetch usage data" }, { status: 500 });
+        }
+        // Filter by API key if provided
+        // Note: Web interface calls don't have api_key_id in meta, only API calls do
+        let filteredEntries = ledgerEntries || [];
+        if (apiKeyId && apiKeyId !== "all") {
+            if (apiKeyId === "web") {
+                // Show only web interface calls (no api_key_id)
+                filteredEntries = filteredEntries.filter((entry) => !entry.meta?.api_key_id);
+            }
+            else {
+                // Show only calls from specific API key
+                filteredEntries = filteredEntries.filter((entry) => entry.meta?.api_key_id === apiKeyId);
+            }
+        }
+        // Group by model + provider + endpoint
+        const groupedData = new Map();
+        for (const entry of filteredEntries) {
+            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((item) => ({
+            ...item,
+            avg_cost_per_call: item.call_count > 0 ? item.total_sell_usd / item.call_count : 0,
+        }))
+            .sort((a, b) => b.total_sell_usd - a.total_sell_usd); // Sort by cost DESC
+        return NextResponse.json({
+            data: result,
+            total_entries: filteredEntries.length,
+            filters: {
+                month: month || "all",
+                api_key_id: apiKeyId || "all",
+            },
+        });
+    }
+    catch (error) {
+        logger.error("[usage-by-model] Unexpected error:", error);
+        return NextResponse.json({ error: error.message || "Internal server error" }, { status: 500 });
+    }
+}

package/dist/api/auth/usage.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Auth API for usage analytics
+ * GET /api/ai/auth/usage - Get user's API usage logs and statistics
+ */
+import { NextRequest, NextResponse } from "next/server";
+export declare function GET(request: NextRequest): Promise<NextResponse<{
+    data: {
+        logs: never[];
+        stats: {
+            total_calls: number;
+            total_tokens: number;
+            success_rate: number;
+            by_endpoint: Record<string, number>;
+            by_provider: Record<string, number>;
+        };
+        usage_by_model: {
+            model: string;
+            tokens: number;
+            calls: number;
+        }[];
+        usage_by_day: Record<string, string | number>[];
+    };
+}> | NextResponse<{
+    error: any;
+}>>;
+//# sourceMappingURL=usage.d.ts.map

package/dist/api/auth/usage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"usage.d.ts","sourceRoot":"","sources":["../../../src/api/auth/usage.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAIxD,wBAAsB,GAAG,CAAC,OAAO,EAAE,WAAW;;;;;;;;;;;;;;;;;;;IA+J7C"}

package/dist/api/auth/usage.js

@@ -0,0 +1,127 @@
+/**
+ * Auth API for usage analytics
+ * GET /api/ai/auth/usage - Get user's API usage logs and statistics
+ */
+import { NextResponse } from "next/server";
+import { getSupabaseServerClient } from "@lastbrain/core/server";
+import { logger } from "@lastbrain/core";
+export async function GET(request) {
+    try {
+        const supabase = await getSupabaseServerClient();
+        const { data: { user }, } = await supabase.auth.getUser();
+        if (!user) {
+            return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+        }
+        // Get optional API key filter from query params
+        const searchParams = request.nextUrl.searchParams;
+        const apiKeyId = searchParams.get("api_key_id");
+        const month = searchParams.get("month"); // Format: YYYY-MM
+        logger.debug("[Usage API] Fetching usage for user:", user.id, "with apiKeyId:", apiKeyId, "month:", month);
+        // Build query for user_token_ledger (new billing system)
+        let ledgerQuery = supabase
+            .from("user_token_ledger")
+            .select("model, sell_usd, provider_cost_usd, ts, meta")
+            .eq("owner_id", user.id)
+            .eq("type", "use")
+            .order("ts", { ascending: false })
+            .limit(100);
+        // 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];
+            ledgerQuery = ledgerQuery.gte("ts", startDate).lt("ts", endDate);
+        }
+        // Filter by API key if provided
+        // Note: "web" means no api_key_id (web interface calls)
+        let ledgerEntries = [];
+        const { data: allLedgerEntries, error: ledgerError } = await ledgerQuery;
+        if (ledgerError) {
+            logger.error("[usage] Error fetching ledger", ledgerError);
+            return NextResponse.json({ error: ledgerError.message }, { status: 500 });
+        }
+        // Filter by API key in meta
+        if (apiKeyId && apiKeyId !== "all") {
+            if (apiKeyId === "web") {
+                ledgerEntries = (allLedgerEntries || []).filter((entry) => !entry.meta?.api_key_id);
+            }
+            else {
+                ledgerEntries = (allLedgerEntries || []).filter((entry) => entry.meta?.api_key_id === apiKeyId);
+            }
+        }
+        else {
+            ledgerEntries = allLedgerEntries || [];
+        }
+        logger.info("[Usage API] Ledger entries fetched:", ledgerEntries.length, "entries");
+        // Calculate statistics
+        const totalCalls = ledgerEntries.length;
+        const totalUsd = ledgerEntries.reduce((sum, entry) => sum + (entry.sell_usd || 0), 0);
+        const byEndpoint = {};
+        const byProvider = {};
+        ledgerEntries.forEach((entry) => {
+            const endpoint = entry.meta?.endpoint || "unknown";
+            const provider = entry.meta?.provider || "unknown";
+            byEndpoint[endpoint] = (byEndpoint[endpoint] || 0) + 1;
+            byProvider[provider] = (byProvider[provider] || 0) + 1;
+        });
+        // Group by model for chart (use sell_usd directly)
+        const modelUsage = new Map();
+        ledgerEntries.forEach((entry) => {
+            if (entry.model && entry.sell_usd) {
+                const current = modelUsage.get(entry.model) || { tokens: 0, calls: 0 };
+                modelUsage.set(entry.model, {
+                    tokens: current.tokens + entry.sell_usd, // Store USD value in tokens field for compatibility
+                    calls: current.calls + 1,
+                });
+            }
+        });
+        const usageByModel = Array.from(modelUsage.entries()).map(([model, data]) => ({
+            model,
+            tokens: data.tokens, // Actually USD value
+            calls: data.calls,
+        }));
+        // Group by day and model for daily chart
+        const dailyUsageMap = new Map();
+        ledgerEntries.forEach((entry) => {
+            if (entry.model && entry.sell_usd && entry.ts) {
+                const date = new Date(entry.ts).toISOString().split("T")[0]; // YYYY-MM-DD
+                if (!dailyUsageMap.has(date)) {
+                    dailyUsageMap.set(date, new Map());
+                }
+                const dayMap = dailyUsageMap.get(date);
+                const currentUsd = dayMap.get(entry.model) || 0;
+                dayMap.set(entry.model, currentUsd + entry.sell_usd); // Store USD directly
+            }
+        });
+        // Convert to array format for chart
+        const usageByDay = Array.from(dailyUsageMap.entries())
+            .map(([date, modelMap]) => {
+            const dayData = { date };
+            modelMap.forEach((usdValue, model) => {
+                dayData[model] = usdValue;
+            });
+            return dayData;
+        })
+            .sort((a, b) => a.date.localeCompare(b.date));
+        const stats = {
+            total_calls: totalCalls,
+            total_tokens: totalUsd, // Actually USD value for backward compatibility
+            success_rate: 100, // All ledger entries are successful
+            by_endpoint: byEndpoint,
+            by_provider: byProvider,
+        };
+        return NextResponse.json({
+            data: {
+                logs: [], // Empty for backward compatibility
+                stats,
+                usage_by_model: usageByModel,
+                usage_by_day: usageByDay,
+            },
+        });
+    }
+    catch (error) {
+        logger.error("[usage] Unexpected error", error);
+        return NextResponse.json({ error: error.message }, { status: 500 });
+    }
+}

package/dist/api/auth/user-tokens.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"user-tokens.d.ts","sourceRoot":"","sources":["../../../src/api/auth/user-tokens.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAKxD,wBAAsB,GAAG,CAAC,OAAO,EAAE,WAAW;;;;;;;;;;;;;;IA0C7C"}
+{"version":3,"file":"user-tokens.d.ts","sourceRoot":"","sources":["../../../src/api/auth/user-tokens.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAMxD,wBAAsB,GAAG,CAAC,OAAO,EAAE,WAAW;;;;;;;;;;;;;;IAmF7C"}

package/dist/api/auth/user-tokens.js

@@ -1,6 +1,7 @@
 import { NextResponse } from "next/server";
 import { getSupabaseServerClient } from "@lastbrain/core/server";
 import { getTokenBalance, getTokenHistory, getTokenStats } from "../../server";
+import { logger } from "@lastbrain/core";
 // GET /api/ai/user/tokens - Récupérer le solde et l'historique de l'utilisateur courant
 export async function GET(request) {
     try {
@@ -18,7 +19,40 @@ export async function GET(request) {
         // Récupérer l'historique complet (12 derniers mois)
         const searchParams = request.nextUrl.searchParams;
         const limit = parseInt(searchParams.get("limit") || "500");
-        const history = await getTokenHistory(userId, limit, 0);
+        const apiKeyId = searchParams.get("api_key_id");
+        let history = await getTokenHistory(userId, limit, 0);
+        // Filtrer par api_key_id si fourni
+        // Si une clé spécifique est sélectionnée, récupérer les logs depuis ai_call_log
+        if (apiKeyId && apiKeyId !== "all") {
+            logger.debug(`[user-tokens] Fetching logs for api_key_id: ${apiKeyId}`);
+            // Récupérer les logs d'utilisation depuis ai_call_log
+            const { data: logs, error: logsError } = await supabase
+                .from("ai_call_log")
+                .select("*")
+                .eq("owner_id", userId)
+                .eq("api_key_id", apiKeyId)
+                .order("created_at", { ascending: false })
+                .limit(limit);
+            if (logsError) {
+                logger.error("[user-tokens] Error fetching logs:", logsError);
+            }
+            // Convertir les logs en format transaction
+            history = (logs || []).map((log) => ({
+                id: log.id,
+                owner_id: userId,
+                amount: -(log.tokens_total || 0), // Négatif car c'est une consommation
+                type: "use",
+                source: log.quota_used ? "quota" : "purchased",
+                description: log.endpoint || log.model,
+                model: log.model,
+                prompt: log.request_body?.prompt || log.request_body?.messages?.[0]?.content,
+                created_at: log.created_at,
+                ts: log.created_at,
+                running_balance: 0, // Non calculé pour les transactions filtrées
+                api_key_id: log.api_key_id,
+            }));
+            logger.debug(`[user-tokens] Converted ${history.length} logs to transactions`);
+        }
         return NextResponse.json({
             userId,
             balance,
@@ -28,7 +62,7 @@ export async function GET(request) {
         });
     }
     catch (error) {
-        console.error("[GET /api/ai/user/tokens] Error:", error);
+        logger.error("[GET /api/ai/user/tokens] Error:", error);
         return NextResponse.json({ error: error.message || "Erreur serveur" }, { status: 500 });
     }
 }

package/dist/api/auth/wallet/route.d.ts

@@ -0,0 +1,17 @@
+/**
+ * GET /api/ai/auth/wallet
+ * Returns user's wallet state (balance + USD values)
+ */
+import { NextRequest, NextResponse } from "next/server";
+export declare function GET(request: NextRequest): Promise<NextResponse<{
+    tokenBalance: number;
+    walletProviderBudgetUsd: number;
+    walletSellValueUsd: number;
+    percentRemaining: number;
+    status: "warning" | "ok" | "critical";
+    usdProviderPerToken: number;
+    usdSellPerToken: number;
+}> | NextResponse<{
+    error: any;
+}>>;
+//# sourceMappingURL=route.d.ts.map

package/dist/api/auth/wallet/route.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"route.d.ts","sourceRoot":"","sources":["../../../../src/api/auth/wallet/route.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAKxD,wBAAsB,GAAG,CAAC,OAAO,EAAE,WAAW;;;;;;;;;;IA4E7C"}

package/dist/api/auth/wallet/route.js

@@ -0,0 +1,68 @@
+/**
+ * GET /api/ai/auth/wallet
+ * Returns user's wallet state (balance + USD values)
+ */
+import { NextResponse } from "next/server";
+import { logger } from "@lastbrain/core";
+import { getSupabaseServerClient } from "@lastbrain/core/server";
+import { getWalletState } from "../../../server/billing";
+export async function GET(request) {
+    try {
+        const supabase = await getSupabaseServerClient();
+        const { data: { user }, error: authError, } = await supabase.auth.getUser();
+        if (authError || !user) {
+            return NextResponse.json({ error: "Non authentifié" }, { status: 401 });
+        }
+        // Get wallet state
+        const wallet = await getWalletState(user.id);
+        // Calculate total purchased (from ledger - type 'purchase')
+        const { data: purchases, error: purchaseError } = await supabase
+            .from("user_token_ledger")
+            .select("sell_value_added_usd, pack_price_usd")
+            .eq("owner_id", user.id)
+            .eq("type", "purchase");
+        logger.info("[Wallet API] Purchase query:", {
+            userId: user.id,
+            purchases,
+            error: purchaseError,
+        });
+        // Sum all purchases (use sell_value_added_usd or pack_price_usd as fallback)
+        const totalPurchased = (purchases || []).reduce((sum, p) => {
+            const amount = parseFloat(p.sell_value_added_usd || "0") ||
+                parseFloat(p.pack_price_usd || "0");
+            return sum + amount;
+        }, 0);
+        logger.info("[Wallet API] Total purchased:", totalPurchased);
+        logger.info("[Wallet API] Current balance:", wallet.walletSellValueUsd);
+        // Calculate percent remaining
+        const percentRemaining = totalPurchased > 0
+            ? (wallet.walletSellValueUsd / totalPurchased) * 100
+            : 100;
+        // Determine status
+        let status = "ok";
+        if (percentRemaining < 10) {
+            status = "critical";
+        }
+        else if (percentRemaining < 25) {
+            status = "warning";
+        }
+        return NextResponse.json({
+            tokenBalance: wallet.tokenBalance,
+            walletProviderBudgetUsd: wallet.walletProviderBudgetUsd,
+            walletSellValueUsd: wallet.walletSellValueUsd,
+            percentRemaining,
+            status,
+            // Computed rates
+            usdProviderPerToken: wallet.tokenBalance > 0
+                ? wallet.walletProviderBudgetUsd / wallet.tokenBalance
+                : 0,
+            usdSellPerToken: wallet.tokenBalance > 0
+                ? wallet.walletSellValueUsd / wallet.tokenBalance
+                : 0,
+        });
+    }
+    catch (error) {
+        logger.error("[auth/wallet] Error:", error);
+        return NextResponse.json({ error: error.message || "Internal server error" }, { status: 500 });
+    }
+}

package/dist/api/auth/wallet.d.ts

@@ -0,0 +1,16 @@
+/**
+ * GET /api/ai/auth/wallet
+ * Get user's wallet state for UI display
+ */
+import { NextResponse } from "next/server";
+export declare function GET(): Promise<NextResponse<{
+    walletSellValueUsd: number;
+    totalAdded: number;
+    totalUsed: number;
+    percentage: number;
+    tokenBalance: number;
+    status: string;
+}> | NextResponse<{
+    error: any;
+}>>;
+//# sourceMappingURL=wallet.d.ts.map

package/dist/api/auth/wallet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wallet.d.ts","sourceRoot":"","sources":["../../../src/api/auth/wallet.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAK3C,wBAAsB,GAAG;;;;;;;;;IAiFxB"}

package/dist/api/auth/wallet.js

@@ -0,0 +1,71 @@
+/**
+ * GET /api/ai/auth/wallet
+ * Get user's wallet state for UI display
+ */
+import { NextResponse } from "next/server";
+import { getSupabaseServerClient } from "@lastbrain/core/server";
+import { getWalletState } from "../../server/billing";
+import { logger } from "@lastbrain/core";
+export async function GET() {
+    try {
+        const supabase = await getSupabaseServerClient();
+        const { data: { user }, } = await supabase.auth.getUser();
+        if (!user) {
+            return NextResponse.json({ error: "Non authentifié" }, { status: 401 });
+        }
+        const wallet = await getWalletState(user.id);
+        // Get all credit additions (purchases + manual adds) to calculate total initial balance
+        const { data: additions, error: additionsError } = await supabase
+            .from("user_token_ledger")
+            .select("sell_value_added_usd, pack_price_usd, type, created_at")
+            .eq("owner_id", user.id)
+            .in("type", ["purchase", "gift"]); // Include both purchases and gifts from admin
+        logger.info("[Wallet API] Credit additions query:", {
+            userId: user.id,
+            additions,
+            error: additionsError,
+        });
+        // Calculate total credits added (sum of sell_value_added_usd OR pack_price_usd as fallback)
+        const totalAdded = (additions || []).reduce((sum, p) => {
+            const amount = parseFloat(p.sell_value_added_usd || "0") ||
+                parseFloat(p.pack_price_usd || "0");
+            return sum + amount;
+        }, 0);
+        logger.info("[Wallet API] Total credits added:", totalAdded);
+        logger.info("[Wallet API] Current balance:", wallet.walletSellValueUsd);
+        // Calculate percent remaining: current / initial * 100
+        const percentRemaining = totalAdded > 0 ? (wallet.walletSellValueUsd / totalAdded) * 100 : 100; // If no credits added, show 100%
+        logger.info("[Wallet API] Percent calculation:", {
+            totalAdded,
+            currentBalance: wallet.walletSellValueUsd,
+            percentRemaining,
+            formula: `${wallet.walletSellValueUsd} / ${totalAdded} * 100 = ${percentRemaining}`,
+        });
+        // Get total spent from ledger (for UI display)
+        const { data: usageEntries } = await supabase
+            .from("user_token_ledger")
+            .select("cost_usd")
+            .eq("owner_id", user.id)
+            .eq("type", "use");
+        const totalUsed = (usageEntries || []).reduce((sum, entry) => {
+            return sum + (parseFloat(entry.cost_usd || "0") || 0);
+        }, 0);
+        return NextResponse.json({
+            walletSellValueUsd: wallet.walletSellValueUsd,
+            totalAdded,
+            totalUsed,
+            percentage: percentRemaining,
+            tokenBalance: wallet.tokenBalance, // For backward compat
+            status: percentRemaining > 50
+                ? "ok"
+                : percentRemaining > 25
+                    ? "warning"
+                    : "critical",
+            // walletProviderBudgetUsd is NOT included - internal use only
+        });
+    }
+    catch (error) {
+        logger.error("[Wallet API] Error:", error);
+        return NextResponse.json({ error: error.message || "Failed to fetch wallet" }, { status: 500 });
+    }
+}

package/dist/api/public/gateway-models.d.ts

@@ -0,0 +1,25 @@
+/**
+ * GET /api/ai/public/gateway-models
+ * Public route to list available AI models from Vercel AI Gateway
+ * No authentication required
+ */
+import { NextRequest, NextResponse } from "next/server";
+export declare function GET(request: NextRequest): Promise<NextResponse<{
+    providers: {
+        models: {
+            id: string;
+            name: string;
+            type: "audio" | "video" | "image" | "text" | "embedding" | "language";
+            provider: string;
+            max_tokens: number | undefined;
+            tags: string[] | undefined;
+        }[];
+        name: string;
+        display_name: string;
+    }[];
+    stale: boolean | undefined;
+    cached_at: string | undefined;
+}> | NextResponse<{
+    error: any;
+}>>;
+//# sourceMappingURL=gateway-models.d.ts.map

package/dist/api/public/gateway-models.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gateway-models.d.ts","sourceRoot":"","sources":["../../../src/api/public/gateway-models.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAIxD,wBAAsB,GAAG,CAAC,OAAO,EAAE,WAAW;;;;;;;;;;;;;;;;;IA+C7C"}