@lastbrain/module-ai 2.0.26 → 2.0.30

package/dist/api/auth/generate-text.js

@@ -1,38 +1,77 @@
 import { NextResponse } from "next/server";
 import { getSupabaseServerClient } from "@lastbrain/core/server";
-import { deductTokens, getTokenBalance } from "../../server";
-import OpenAI from "openai";
-let openai = null;
-function getOpenAIClient() {
-    if (!openai) {
-        openai = new OpenAI({
-            apiKey: process.env.OPENAI_API_KEY,
-        });
-    }
-    return openai;
-}
+import { textAI } from "../../server/ai-client";
+import { logger } from "@lastbrain/core";
+import { computeAndDebitAIUsage, computeProviderCostUsd, getWalletState, } from "../../server/billing";
+import { isModelEnabled } from "../../server/model-filter";
+import { validateTextPricing } from "../../server/pricing-validator";
+import { getDefaultTextModel } from "../../server/global-settings";
 export async function POST(request) {
     try {
-        const supabase = await getSupabaseServerClient();
+        const MAX_CHARS = 1200;
+        const supabaseAuth = await getSupabaseServerClient();
         // Vérifier l'authentification
-        const { data: { user }, } = await supabase.auth.getUser();
+        const { data: { user }, } = await supabaseAuth.auth.getUser();
         // L'utilisateur est déjà authentifié grâce au middleware
         const body = await request.json();
-        const { prompt, model = "gpt-4o-mini", context, maxTokens = 3000, temperature = 0.7, } = body;
+        // Get default model from global settings if not provided
+        const defaultModel = await getDefaultTextModel();
+        const { prompt, promptUser, model = defaultModel, // Use global default instead of hardcoded
+        context, maxTokens = 3000, temperature = 0.7, actionType = "generate-text", // Default to generate-text if not specified
+         } = body;
         if (!prompt) {
             return NextResponse.json({ error: "Le prompt est requis" }, { status: 400 });
         }
+        if (promptUser) {
+            logger.info("promptUser length:", promptUser.length);
+        }
+        if (promptUser && promptUser.length > MAX_CHARS) {
+            return NextResponse.json({ error: "Prompt trop long max 1200 caractères" }, { status: 400 });
+        }
         if (!user) {
             return NextResponse.json({ error: "Non authentifié" }, { status: 401 });
         }
-        // Vérifier le solde de tokens
-        const currentBalance = await getTokenBalance(user.id);
-        const estimatedCost = 0; //Math.ceil(prompt.length / 4) + maxTokens; // Estimation approximative
-        if (currentBalance < estimatedCost || currentBalance <= 0) {
-            return NextResponse.json({
-                error: `Solde insuffisant. Disponible: ${currentBalance}`,
-            }, { status: 402 });
+        // Build model string: "openai/model" or use full if already formatted
+        const fullModel = model.includes("/") ? model : `openai/${model}`;
+        // Parse provider/model from fullModel
+        const [provider, modelName] = fullModel.includes("/")
+            ? fullModel.split("/", 2)
+            : ["openai", fullModel];
+        // Skip model check for recipe and image generation (always allowed)
+        const isRecipeAction = actionType === "generate-recipe-text";
+        // Get model pricing via model-filter (BEFORE generation to check credits)
+        // For recipes, bypass user settings and use default pricing
+        const filterResult = isRecipeAction
+            ? {
+                allowed: true,
+                model: {
+                    pricing: {
+                        input: 0.15 / 1000000, // $0.15 per 1M tokens (gpt-4o-mini default)
+                        output: 0.6 / 1000000, // $0.60 per 1M tokens
+                    },
+                },
+            }
+            : await isModelEnabled(user.id, fullModel);
+        if (!filterResult.allowed) {
+            logger.warn(`[generate-text] Model ${fullModel} not allowed for user ${user.id}`);
+            return NextResponse.json({ error: "Modèle non autorisé" }, { status: 403 });
+        }
+        // Prepare pricing for wallet billing
+        const pricingValidation = validateTextPricing(filterResult.model?.pricing, fullModel);
+        if (!pricingValidation.valid) {
+            return NextResponse.json({ error: pricingValidation.error }, { status: 503 });
+        }
+        const pricing = pricingValidation.pricing;
+        // Get current wallet state
+        const wallet = await getWalletState(user.id);
+        // PRE-CHECK: Simple check - user must have credits (> 0)
+        // The real debit with minimums will be computed post-generation
+        if (!wallet.walletProviderBudgetUsd ||
+            wallet.walletProviderBudgetUsd <= 0) {
+            logger.warn(`[generate-text] No credits for user ${user.id}: wallet=$${wallet.walletProviderBudgetUsd}`);
+            return NextResponse.json({ error: "Crédits insuffisants pour cette opération" }, { status: 402 });
         }
+        logger.info(`[generate-text] Pre-check passed for user ${user.id}: wallet=$${wallet.walletProviderBudgetUsd.toFixed(6)}`);
         // Construire les messages
         const messages = [
             {
@@ -50,56 +89,89 @@ export async function POST(request) {
             role: "user",
             content: prompt,
         });
-        // Appeler OpenAI
-        const openaiClient = getOpenAIClient();
-        const completion = await openaiClient.chat.completions.create({
-            model,
-            messages,
+        logger.info(`[AI] Generating text with model: ${fullModel}`);
+        // Call our simplified AI client
+        const completion = await textAI({
+            prompt,
+            model: fullModel,
+            system: "Tu es un assistant IA qui aide à générer du texte de qualité.",
+            maxTokens,
             temperature,
-            max_tokens: maxTokens,
         });
-        const generatedText = completion.choices[0]?.message?.content || "";
-        const tokensUsed = completion.usage?.total_tokens || 0;
-        // Calculer le coût approximatif (exemple pour gpt-4o-mini: $0.150/1M input, $0.600/1M output)
-        const inputTokens = completion.usage?.prompt_tokens || 0;
-        const outputTokens = completion.usage?.completion_tokens || 0;
-        let cost = 0;
-        if (model.includes("gpt-4o-mini")) {
-            cost =
-                (inputTokens / 1_000_000) * 0.15 + (outputTokens / 1_000_000) * 0.6;
-        }
-        else if (model.includes("gpt-4o")) {
-            cost = (inputTokens / 1_000_000) * 2.5 + (outputTokens / 1_000_000) * 10;
-        }
-        else if (model.includes("gpt-4")) {
-            cost = (inputTokens / 1_000_000) * 30 + (outputTokens / 1_000_000) * 60;
-        }
-        else {
-            cost = (tokensUsed / 1_000_000) * 2; // Fallback
-        }
-        // Déduire les tokens utilisés
-        const tokenResult = await deductTokens(user.id, tokensUsed, model, prompt, {
+        const generatedText = completion.text || "";
+        const inputTokens = completion.usage?.promptTokens || 0;
+        const outputTokens = completion.usage?.completionTokens || 0;
+        const tokensUsedFromAI = completion.usage?.totalTokens || 0;
+        // Prepare usage for actual billing (from API response)
+        const actualUsage = {
             inputTokens,
             outputTokens,
-            cost,
-            generatedText: generatedText.substring(0, 500), // Stocker un extrait
+        };
+        // Compute actual provider cost from API usage
+        const actualProviderCost = computeProviderCostUsd(actualUsage, pricing);
+        // Compute and debit using centralized billing logic
+        const billingResult = computeAndDebitAIUsage({
+            userId: user.id,
+            actionType: actionType, // Use the actionType from request (default: "generate-text")
+            providerCostUsd: actualProviderCost,
+            wallet,
+            metadata: {
+                model: modelName,
+                provider,
+                endpoint: "generate-text",
+                inputTokens,
+                outputTokens,
+                prompt: prompt.substring(0, 32),
+                generatedText: generatedText.substring(0, 500),
+            },
         });
-        if (!tokenResult.success) {
+        // Check if billing failed (insufficient credits post-check)
+        if (!billingResult.success) {
+            logger.error(`[generate-text] Billing failed for user ${user.id}: ${billingResult.error}`, {
+                providerCost: actualProviderCost,
+                walletSellValue: wallet.walletSellValueUsd,
+                walletProviderBudget: wallet.walletProviderBudgetUsd,
+            });
             return NextResponse.json({
-                error: tokenResult.error || "Erreur lors de la déduction des tokens",
-            }, { status: 500 });
+                error: billingResult.error || "Crédits insuffisants pour cette opération",
+            }, { status: 402 } // Payment Required
+            );
+        }
+        // Record consumption in database (ledger)
+        const supabase = await getSupabaseServerClient();
+        const { error: ledgerError } = await supabase.rpc("record_token_consumption", {
+            p_user_id: user.id,
+            p_debit_tokens: 0, // Calculated by wallet system
+            p_provider_cost_usd: billingResult.providerCostUsd || 0,
+            p_sell_usd: billingResult.sellCostUsd || 0,
+            p_margin_usd: billingResult.marginUsd || 0,
+            p_meta: {
+                model: modelName,
+                provider,
+                endpoint: "generate-text",
+                inputTokens,
+                outputTokens,
+                prompt: prompt.substring(0, 32),
+                generatedText: generatedText.substring(0, 500),
+            },
+        });
+        if (ledgerError) {
+            logger.error("[generate-text] Failed to record in ledger:", ledgerError);
+            // Continue anyway - billing logic already validated
         }
+        logger.info(`[generate-text] Text generation completed: cost=$${billingResult.providerCostUsd?.toFixed(6)}, sell=$${billingResult.sellCostUsd?.toFixed(6)}, margin=${billingResult.marginPercent?.toFixed(1)}%`);
         return NextResponse.json({
             text: generatedText,
-            tokensUsed,
-            tokensRemaining: tokenResult.balance,
-            model,
+            model: modelName,
+            provider,
+            inputTokens,
+            outputTokens,
         });
     }
     catch (error) {
-        console.error("Erreur de génération:", error);
+        logger.error("Erreur de génération:", error);
         if (error.code === "insufficient_quota") {
-            return NextResponse.json({ error: "Quota OpenAI dépassé. Contactez l'administrateur." }, { status: 503 });
+            return NextResponse.json({ error: "Quota IA dépassé. Contactez l'administrateur." }, { status: 503 });
         }
         return NextResponse.json({ error: error.message || "Erreur lors de la génération" }, { status: 500 });
     }

package/dist/api/auth/process-ocr.d.ts

@@ -0,0 +1,9 @@
+import { NextRequest, NextResponse } from "next/server";
+/**
+ * POST /api/ai/process-ocr
+ * Process OCR using OpenAI Vision with proper token debit
+ */
+export declare function POST(request: NextRequest): Promise<NextResponse<{
+    error: string | undefined;
+}> | NextResponse<import("../../server").ProcessOCRResponse>>;
+//# sourceMappingURL=process-ocr.d.ts.map

package/dist/api/auth/process-ocr.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"process-ocr.d.ts","sourceRoot":"","sources":["../../../src/api/auth/process-ocr.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAgBxD;;;GAGG;AACH,wBAAsB,IAAI,CAAC,OAAO,EAAE,WAAW;;8DAqD9C"}

package/dist/api/auth/process-ocr.js

@@ -0,0 +1,43 @@
+import { NextResponse } from "next/server";
+import { getSupabaseServerClient } from "@lastbrain/core/server";
+import { processOCRWithTokens } from "../../server/ocr";
+/**
+ * POST /api/ai/process-ocr
+ * Process OCR using OpenAI Vision with proper token debit
+ */
+export async function POST(request) {
+    try {
+        const supabase = await getSupabaseServerClient();
+        // Verify authentication
+        const { data: { user }, } = await supabase.auth.getUser();
+        if (!user) {
+            return NextResponse.json({ error: "Non authentifié" }, { status: 401 });
+        }
+        const body = await request.json();
+        const { files, mode, prompt, extractionSchema } = body;
+        if (!files || files.length === 0) {
+            return NextResponse.json({ error: "Aucun fichier à traiter" }, { status: 400 });
+        }
+        if (!prompt) {
+            return NextResponse.json({ error: "Le prompt est requis" }, { status: 400 });
+        }
+        // Process OCR with token debit
+        const result = await processOCRWithTokens({
+            userId: user.id,
+            files,
+            mode,
+            prompt,
+            extractionSchema,
+            allowOverdraft: false,
+        });
+        if (!result.success) {
+            const status = result.error?.includes("insuffisant") ? 402 : 500;
+            return NextResponse.json({ error: result.error }, { status });
+        }
+        return NextResponse.json(result);
+    }
+    catch (error) {
+        const err = error;
+        return NextResponse.json({ error: err.message || "Erreur lors du traitement OCR" }, { status: 500 });
+    }
+}

package/dist/api/auth/prompts/stats.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Increment prompt stats
+ * POST /api/ai/auth/prompts/stats
+ */
+import type { NextRequest } from "next/server";
+import { NextResponse } from "next/server";
+export declare function POST(req: NextRequest): Promise<NextResponse<{
+    success: boolean;
+    error: string;
+}> | NextResponse<{
+    success: boolean;
+    message: string;
+}>>;
+//# sourceMappingURL=stats.d.ts.map

package/dist/api/auth/prompts/stats.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stats.d.ts","sourceRoot":"","sources":["../../../../src/api/auth/prompts/stats.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAI3C,wBAAsB,IAAI,CAAC,GAAG,EAAE,WAAW;;;;;;IA+D1C"}

package/dist/api/auth/prompts/stats.js

@@ -0,0 +1,46 @@
+/**
+ * Increment prompt stats
+ * POST /api/ai/auth/prompts/stats
+ */
+import { NextResponse } from "next/server";
+import { getSupabaseServiceClient } from "@lastbrain/core/server";
+import { logger } from "@lastbrain/core";
+export async function POST(req) {
+    try {
+        const supabase = getSupabaseServiceClient();
+        // Get authenticated user
+        const { data: { user }, error: authError, } = await supabase.auth.getUser();
+        if (authError || !user) {
+            return NextResponse.json({ success: false, error: "Unauthorized" }, { status: 401 });
+        }
+        const body = await req.json();
+        const { prompt_id, stat_type } = body;
+        if (!prompt_id || !stat_type) {
+            return NextResponse.json({ success: false, error: "Missing prompt_id or stat_type" }, { status: 400 });
+        }
+        // Validate stat_type
+        if (!["views", "used", "picked"].includes(stat_type)) {
+            return NextResponse.json({
+                success: false,
+                error: "Invalid stat_type. Must be views, used, or picked",
+            }, { status: 400 });
+        }
+        // Call function to increment stat
+        const { error } = await supabase.rpc("increment_prompt_stat", {
+            p_prompt_id: prompt_id,
+            p_stat_type: stat_type,
+        });
+        if (error) {
+            logger.error("Failed to increment prompt stat:", error);
+            return NextResponse.json({ success: false, error: "Failed to increment stat" }, { status: 500 });
+        }
+        return NextResponse.json({
+            success: true,
+            message: `${stat_type} incremented`,
+        });
+    }
+    catch (error) {
+        logger.error("Prompt stat increment error:", error);
+        return NextResponse.json({ success: false, error: "Internal server error" }, { status: 500 });
+    }
+}

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

@@ -0,0 +1,26 @@
+/**
+ * GET/POST/PUT/DELETE /api/ai/auth/prompts
+ * CRUD for user's AI prompts
+ */
+import { NextRequest, NextResponse } from "next/server";
+export declare function GET(request: NextRequest): Promise<NextResponse<{
+    prompts: any[];
+}> | NextResponse<{
+    error: any;
+}>>;
+export declare function POST(request: NextRequest): Promise<NextResponse<{
+    prompt: any;
+}> | NextResponse<{
+    error: any;
+}>>;
+export declare function PUT(request: NextRequest): Promise<NextResponse<{
+    prompt: any;
+}> | NextResponse<{
+    error: any;
+}>>;
+export declare function DELETE(request: NextRequest): Promise<NextResponse<{
+    success: boolean;
+}> | NextResponse<{
+    error: any;
+}>>;
+//# sourceMappingURL=prompts.d.ts.map

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

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

package/dist/api/auth/prompts.js

@@ -0,0 +1,175 @@
+/**
+ * GET/POST/PUT/DELETE /api/ai/auth/prompts
+ * CRUD for user's AI prompts
+ */
+import { NextResponse } from "next/server";
+import { getSupabaseServerClient } from "@lastbrain/core/server";
+import { logger } from "@lastbrain/core";
+// GET - List user's prompts
+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: "Unauthorized" }, { status: 401 });
+        }
+        const { searchParams } = new URL(request.url);
+        const type = searchParams.get("type"); // 'text' or 'image'
+        const favorite = searchParams.get("favorite") === "true";
+        let query = supabase
+            .from("user_prompt")
+            .select(`
+        *,
+        prompt_stats (
+          views,
+          used_count,
+          picked_count
+        )
+      `)
+            .eq("owner_id", user.id)
+            .order("favorite", { ascending: false })
+            .order("created_at", { ascending: false });
+        if (type) {
+            query = query.eq("type", type);
+        }
+        if (favorite) {
+            query = query.eq("favorite", true);
+        }
+        const { data: prompts, error } = await query;
+        if (error) {
+            logger.error("[prompts] GET error:", error);
+            return NextResponse.json({ error: error.message }, { status: 500 });
+        }
+        // Flatten stats into prompt object
+        const promptsWithStats = prompts?.map((p) => ({
+            ...p,
+            views: p.prompt_stats?.[0]?.views || 0,
+            used_count: p.prompt_stats?.[0]?.used_count || 0,
+            picked_count: p.prompt_stats?.[0]?.picked_count || 0,
+            prompt_stats: undefined, // Remove nested object
+        }));
+        return NextResponse.json({ prompts: promptsWithStats });
+    }
+    catch (error) {
+        logger.error("[prompts] GET unexpected error:", error);
+        return NextResponse.json({ error: error.message }, { status: 500 });
+    }
+}
+// POST - Create new prompt
+export async function POST(request) {
+    try {
+        const supabase = await getSupabaseServerClient();
+        const { data: { user }, error: authError, } = await supabase.auth.getUser();
+        if (authError || !user) {
+            return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+        }
+        const body = await request.json();
+        const { title, content, type, is_public = false, favorite = false, tags = [], } = body;
+        if (!title || !content || !type) {
+            return NextResponse.json({ error: "Missing required fields: title, content, type" }, { status: 400 });
+        }
+        if (!["text", "image"].includes(type)) {
+            return NextResponse.json({ error: "Invalid type. Must be 'text' or 'image'" }, { status: 400 });
+        }
+        const { data: prompt, error } = await supabase
+            .from("user_prompt")
+            .insert({
+            owner_id: user.id,
+            title,
+            content,
+            type,
+            is_public,
+            favorite,
+            tags,
+        })
+            .select()
+            .single();
+        if (error) {
+            logger.error("[prompts] POST error:", error);
+            return NextResponse.json({ error: error.message }, { status: 500 });
+        }
+        return NextResponse.json({ prompt }, { status: 201 });
+    }
+    catch (error) {
+        logger.error("[prompts] POST unexpected error:", error);
+        return NextResponse.json({ error: error.message }, { status: 500 });
+    }
+}
+// PUT - Update prompt
+export async function PUT(request) {
+    try {
+        const supabase = await getSupabaseServerClient();
+        const { data: { user }, error: authError, } = await supabase.auth.getUser();
+        if (authError || !user) {
+            return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+        }
+        const body = await request.json();
+        const { id, title, content, type, is_public, favorite, tags, lang } = body;
+        if (!id) {
+            return NextResponse.json({ error: "Missing required field: id" }, { status: 400 });
+        }
+        const updates = {};
+        if (title !== undefined)
+            updates.title = title;
+        if (content !== undefined)
+            updates.content = content;
+        if (type !== undefined)
+            updates.type = type;
+        if (is_public !== undefined)
+            updates.is_public = is_public;
+        if (favorite !== undefined)
+            updates.favorite = favorite;
+        if (tags !== undefined)
+            updates.tags = tags;
+        if (lang)
+            updates.lang = lang;
+        const { data: prompt, error } = await supabase
+            .from("user_prompt")
+            .update(updates)
+            .eq("id", id)
+            .eq("owner_id", user.id)
+            .select()
+            .single();
+        if (error) {
+            logger.error("[prompts] PUT error:", error);
+            return NextResponse.json({ error: error.message }, { status: 500 });
+        }
+        if (!prompt) {
+            return NextResponse.json({ error: "Prompt not found" }, { status: 404 });
+        }
+        return NextResponse.json({ prompt });
+    }
+    catch (error) {
+        logger.error("[prompts] PUT unexpected error:", error);
+        return NextResponse.json({ error: error.message }, { status: 500 });
+    }
+}
+// DELETE - Delete prompt
+export async function DELETE(request) {
+    try {
+        const supabase = await getSupabaseServerClient();
+        const { data: { user }, error: authError, } = await supabase.auth.getUser();
+        if (authError || !user) {
+            return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+        }
+        const { searchParams } = new URL(request.url);
+        const id = searchParams.get("id");
+        if (!id) {
+            return NextResponse.json({ error: "Missing required parameter: id" }, { status: 400 });
+        }
+        const { error } = await supabase
+            .from("user_prompt")
+            .delete()
+            .eq("id", id)
+            .eq("owner_id", user.id);
+        if (error) {
+            logger.error("[prompts] DELETE error:", error);
+            return NextResponse.json({ error: error.message }, { status: 500 });
+        }
+        return NextResponse.json({ success: true });
+    }
+    catch (error) {
+        logger.error("[prompts] DELETE unexpected error:", error);
+        return NextResponse.json({ error: error.message }, { status: 500 });
+    }
+}

package/dist/api/auth/token-balance.d.ts

@@ -0,0 +1,26 @@
+/**
+ * GET /api/ai/auth/token-balance
+ * Returns combined token balance: quota + purchased tokens
+ */
+import { NextRequest, NextResponse } from "next/server";
+export declare function GET(request: NextRequest): Promise<NextResponse<{
+    quota: {
+        hasQuota: boolean;
+        plan: import("../..").PlanType;
+        effectiveQuota: number;
+        usedQuota: number;
+        remainingQuota: number;
+        periodStart: string | null;
+        periodEnd: string | null;
+        isActive: boolean;
+    };
+    purchased: {
+        balance: number;
+        totalAdded: number;
+        totalUsed: number;
+    };
+    balance: number;
+}> | NextResponse<{
+    error: any;
+}>>;
+//# sourceMappingURL=token-balance.d.ts.map

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

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

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

@@ -0,0 +1,47 @@
+/**
+ * GET /api/ai/auth/token-balance
+ * Returns combined token balance: quota + purchased tokens
+ */
+import { NextResponse } from "next/server";
+import { getSupabaseServerClient } from "@lastbrain/core/server";
+import { getUserQuotaStatus } from "../../server/quota";
+import { getTokenBalance, getTokenStats } from "../../server";
+import { logger } from "@lastbrain/core";
+export async function GET(request) {
+    try {
+        const supabase = await getSupabaseServerClient();
+        // Auth check
+        const { data: { user }, error: authError, } = await supabase.auth.getUser();
+        if (authError || !user) {
+            return NextResponse.json({ error: "Non authentifié" }, { status: 401 });
+        }
+        // Get quota status
+        const quotaStatus = await getUserQuotaStatus(user.id);
+        // Get purchased tokens balance
+        const purchasedBalance = await getTokenBalance(user.id);
+        const purchasedStats = await getTokenStats(user.id);
+        return NextResponse.json({
+            quota: {
+                hasQuota: quotaStatus.hasQuota,
+                plan: quotaStatus.plan,
+                effectiveQuota: quotaStatus.effectiveQuota,
+                usedQuota: quotaStatus.usedQuota,
+                remainingQuota: quotaStatus.remainingQuota,
+                periodStart: quotaStatus.periodStart,
+                periodEnd: quotaStatus.periodEnd,
+                isActive: quotaStatus.isActive,
+            },
+            purchased: {
+                balance: purchasedBalance,
+                totalAdded: purchasedStats.totalPurchased + purchasedStats.totalGifted,
+                totalUsed: purchasedStats.totalUsed,
+            },
+            // For backward compatibility
+            balance: purchasedBalance,
+        });
+    }
+    catch (error) {
+        logger.error("[GET /api/ai/auth/token-balance] Error:", error);
+        return NextResponse.json({ error: error.message || "Erreur serveur" }, { status: 500 });
+    }
+}

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

@@ -1 +1 @@
-{"version":3,"file":"token-checkout.d.ts","sourceRoot":"","sources":["../../../src/api/auth/token-checkout.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAIxD;;;GAGG;AACH,wBAAsB,IAAI,CAAC,OAAO,EAAE,WAAW;;;;;IAiE9C"}
+{"version":3,"file":"token-checkout.d.ts","sourceRoot":"","sources":["../../../src/api/auth/token-checkout.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAKxD;;;GAGG;AACH,wBAAsB,IAAI,CAAC,OAAO,EAAE,WAAW;;;;;IAuF9C"}