@lastbrain/module-ai 2.0.26 → 2.0.30

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

@@ -1,40 +1,11 @@
 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;
-}
-// Coûts des images selon le modèle et la taille
-const IMAGE_COSTS = {
-    "dall-e-2-256x256": 0.016,
-    "dall-e-2-512x512": 0.018,
-    "dall-e-2-1024x1024": 0.02,
-    "dall-e-3-1024x1024-standard": 0.04,
-    "dall-e-3-1024x1024-hd": 0.08,
-    "dall-e-3-1024x1792-standard": 0.08,
-    "dall-e-3-1024x1792-hd": 0.12,
-    "dall-e-3-1792x1024-standard": 0.08,
-    "dall-e-3-1792x1024-hd": 0.12,
-};
-// Coût en tokens par combinaison modèle/taille(/qualité)
-const TOKENS_PER_IMAGE_KEY = {
-    "dall-e-2-256x256": 3000,
-    "dall-e-2-512x512": 4000,
-    "dall-e-2-1024x1024": 5000,
-    "dall-e-3-1024x1024-standard": 6000,
-    "dall-e-3-1024x1024-hd": 8000,
-    "dall-e-3-1024x1792-standard": 8000,
-    "dall-e-3-1024x1792-hd": 10000,
-    "dall-e-3-1792x1024-standard": 8000,
-    "dall-e-3-1792x1024-hd": 10000,
-};
+import { getSupabaseServerClient, getSupabaseServiceClient, } from "@lastbrain/core/server";
+import { imageAI } from "../../server/ai-client";
+import { logger } from "@lastbrain/core";
+import { computeAndDebitAIUsage, computeProviderCostUsd, getWalletState, } from "../../server/billing";
+import { isModelEnabled } from "../../server/model-filter";
+import { validateImagePricing } from "../../server/pricing-validator";
+import { getDefaultImageModel } from "../../server/global-settings";
 export async function POST(request) {
     try {
         const supabase = await getSupabaseServerClient();
@@ -45,97 +16,426 @@ export async function POST(request) {
         }
         // L'utilisateur est déjà authentifié grâce au middleware
         const body = await request.json();
-        const { prompt, model = "dall-e-3", size = "1024x1024", quality = "standard", uploadPath, } = body;
+        // Get default image model from global settings if not provided
+        const defaultModel = await getDefaultImageModel();
+        const { prompt, model = defaultModel, // Use global default instead of hardcoded
+        size = "1024x1024", quality = "standard", uploadPath, recipeId, isPublic, } = body;
         if (!prompt) {
             return NextResponse.json({ error: "Le prompt est requis" }, { status: 400 });
         }
-        // Calculer le coût et les tokens
-        const costKey = model === "dall-e-3" ? `${model}-${size}-${quality}` : `${model}-${size}`;
-        const cost = IMAGE_COSTS[costKey] || 0.04;
-        const tokensRequired = TOKENS_PER_IMAGE_KEY[costKey] ?? 6000; // fallback safe
-        // Vérifier le solde de tokens
-        const currentBalance = await getTokenBalance(user.id);
-        // Autoriser la génération tant que le solde est positif, même si la déduction rend le solde négatif
-        if (currentBalance <= 0) {
-            return NextResponse.json({
-                error: "Solde insuffisant. Votre solde de tokens est nul ou négatif.",
-            }, { status: 402 });
-        }
-        let imageParams;
-        if (model === "dall-e-3") {
-            imageParams = {
-                model: "dall-e-3",
-                prompt,
-                n: 1,
-                response_format: "url",
-                size: size,
-                quality: quality,
+        // Vérifier que l'utilisateur n'est pas déjà en solde négatif
+        const { data: balanceData } = await supabase
+            .from("user_token_balance_v")
+            .select("balance")
+            .eq("owner_id", user.id)
+            .single();
+        const purchasedBalance = balanceData?.balance || 0;
+        if (purchasedBalance < 0) {
+            return NextResponse.json({ error: "Solde insuffisant (compte en négatif). Veuillez recharger." }, { status: 402 });
+        }
+        // Build full model string
+        const fullModel = model.includes("/") ? model : `openai/${model}`;
+        // Parse provider/model from fullModel
+        const [provider, modelName] = fullModel.includes("/")
+            ? fullModel.split("/", 2)
+            : ["openai", fullModel];
+        // Get real model pricing from gateway for accurate billing
+        // Images are always allowed (bypass user settings) but we need real pricing
+        const filterResult = await isModelEnabled(user.id, fullModel);
+        // If model not in user settings or not found, still allow but use fallback pricing
+        if (!filterResult.allowed || !filterResult.model?.pricing?.image) {
+            logger.warn(`[generate-image] Model ${fullModel} not found in gateway or missing pricing, using fallback`);
+            filterResult.allowed = true;
+            filterResult.model = {
+                pricing: {
+                    input: 0,
+                    output: 0,
+                    image: 0.02, // Fallback: $0.02 per image (dall-e-3 standard)
+                },
             };
         }
         else {
-            // DALL-E 2
-            const validSizes = ["256x256", "512x512", "1024x1024"];
-            imageParams = {
-                model: "dall-e-2",
-                prompt,
-                n: 1,
-                response_format: "url",
-                size: validSizes.includes(size)
-                    ? size
-                    : "1024x1024",
-            };
+            // Model found with real pricing from gateway
+            filterResult.allowed = true;
+            logger.info(`[generate-image] Using real pricing from gateway for ${fullModel}: $${filterResult.model.pricing.image} per image`);
+        }
+        // Prepare pricing for wallet billing
+        const pricingValidation = validateImagePricing(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-image] No credits for user ${user.id}: wallet=$${wallet.walletProviderBudgetUsd}`);
+            return NextResponse.json({ error: "Crédits insuffisants pour cette opération" }, { status: 402 });
         }
-        // Appeler OpenAI
-        const openaiClient = getOpenAIClient();
-        const response = await openaiClient.images.generate(imageParams);
-        const imageUrl = response.data?.[0]?.url;
+        logger.info(`[generate-image] Pre-check passed for user ${user.id}: wallet=$${wallet.walletProviderBudgetUsd.toFixed(6)}`);
+        // Call our simplified AI client for image generation
+        const imageResult = await imageAI({
+            prompt,
+            model: fullModel,
+            size,
+        });
+        if (!imageResult.imageUrl) {
+            return NextResponse.json({ error: "No image generated" }, { status: 500 });
+        }
+        const returnedImageUrl = imageResult.imageUrl;
         let supabaseImageUrl = null;
-        if (imageUrl && uploadPath) {
-            // Générer un nom de fichier si uploadPath se termine par '/'
+        let imageBytes = null;
+        // If we have a base64 data URL, we can convert and upload
+        if (returnedImageUrl.startsWith("data:image")) {
+            // Extract base64 from data URL
+            const base64Data = returnedImageUrl.split(",")[1] || "";
+            if (uploadPath) {
+                let finalPath = uploadPath;
+                if (uploadPath.endsWith("/")) {
+                    const filename = `recipe-${Date.now()}.png`;
+                    finalPath = uploadPath + filename;
+                }
+                const buffer = Buffer.from(base64Data, "base64");
+                imageBytes = buffer;
+                const contentType = "image/png";
+                const bucket = finalPath.split("/")[0] || "app";
+                const { error: uploadError } = await supabase.storage
+                    .from(bucket)
+                    .upload(finalPath.split("/").slice(1).join("/"), buffer, {
+                    contentType,
+                    upsert: true,
+                });
+                if (uploadError)
+                    throw new Error("Erreur upload Supabase: " + uploadError.message);
+                supabaseImageUrl = finalPath;
+            }
+            // returnedImageUrl is already in data URL format
+        }
+        else if (returnedImageUrl && uploadPath) {
+            // Télécharger depuis l'URL (OpenAI ou Supabase) puis uploader vers Supabase
             let finalPath = uploadPath;
             if (uploadPath.endsWith("/")) {
-                const ext = (imageUrl.split(".").pop() || "png").split("?")[0];
+                const ext = (returnedImageUrl.split(".").pop() || "png").split("?")[0];
                 const filename = `recipe-${Date.now()}.${ext}`;
                 finalPath = uploadPath + filename;
             }
-            // 1. Télécharger l'image depuis OpenAI
-            const imageRes = await fetch(imageUrl);
-            if (!imageRes.ok)
-                throw new Error("Erreur lors du téléchargement de l'image OpenAI");
-            const arrayBuffer = await imageRes.arrayBuffer();
-            const contentType = imageRes.headers.get("content-type") || "image/png";
-            // 2. Uploader dans Supabase Storage (bucket à adapter si besoin)
+            // Si l'URL provient d'un endpoint Supabase Storage, utiliser l'API storage.download
+            // Exemple d'URL public: https://<project>.supabase.co/storage/v1/object/public/<bucket>/<path>
+            // Exemple d'URL privée: https://<project>.supabase.co/storage/v1/object/<bucket>/<path>
+            let arrayBuffer = null;
+            let contentType = "image/png";
+            try {
+                const parsed = new URL(returnedImageUrl);
+                const storagePrefix = "/storage/v1/object/";
+                if (parsed.pathname.includes(storagePrefix)) {
+                    // extraire la partie après /storage/v1/object/
+                    const after = parsed.pathname.split(storagePrefix)[1] || ""; // e.g. "public/recipes/foo.png" or "app/3561/..."
+                    const parts = after.split("/");
+                    // support: optional 'public' segment
+                    let bucket = parts[0] || "";
+                    let objectPathParts = parts.slice(1);
+                    if (bucket === "public") {
+                        // URL like /object/public/<bucket>/<path>
+                        bucket = parts[1] || "";
+                        objectPathParts = parts.slice(2);
+                    }
+                    const objectPath = objectPathParts.join("/");
+                    logger.debug("[generate-image] Detected supabase storage URL", {
+                        url: returnedImageUrl,
+                        bucket,
+                        objectPath,
+                    });
+                    // tenter d'utiliser le service client (requiert SUPABASE_SERVICE_ROLE_KEY)
+                    let supabaseService;
+                    try {
+                        supabaseService = await getSupabaseServiceClient();
+                    }
+                    catch (err) {
+                        logger.error("[generate-image] getSupabaseServiceClient() failed — ensure SUPABASE_SERVICE_ROLE_KEY is set", err);
+                        throw new Error(JSON.stringify({
+                            message: "Supabase service client non disponible — vérifiez la variable SUPABASE_SERVICE_ROLE_KEY",
+                            url: returnedImageUrl,
+                            bucket,
+                            objectPath,
+                            inner: err instanceof Error ? err.message : String(err),
+                        }));
+                    }
+                    const { data: downloaded, error: downloadError } = await supabaseService.storage.from(bucket).download(objectPath);
+                    if (downloadError || !downloaded) {
+                        const msg = JSON.stringify({
+                            message: "Supabase storage download failed (service)",
+                            bucket,
+                            objectPath,
+                            error: downloadError
+                                ? downloadError.message || downloadError
+                                : null,
+                        });
+                        logger.error("[generate-image] " + msg);
+                        throw new Error(msg);
+                    }
+                    arrayBuffer = await downloaded.arrayBuffer();
+                    contentType = downloaded.type || contentType;
+                }
+            }
+            catch (e) {
+                // Si parsing/échec service client -> laisser tomber au fetch plus bas
+                logger.debug("[generate-image] supabase storage handling skipped or failed, will fallback to fetch", {
+                    url: returnedImageUrl,
+                    error: e instanceof Error ? e.message : String(e),
+                });
+            }
+            // Si on n'a pas réussi à récupérer via storage.download, retomber sur fetch
+            if (!arrayBuffer) {
+                const imageRes = await fetch(returnedImageUrl);
+                if (!imageRes.ok) {
+                    throw new Error(JSON.stringify({
+                        message: "Erreur lors du téléchargement",
+                        url: returnedImageUrl,
+                        status: imageRes.status,
+                    }));
+                }
+                arrayBuffer = await imageRes.arrayBuffer();
+                contentType = imageRes.headers.get("content-type") || contentType;
+            }
             const bucket = finalPath.split("/")[0] || "app";
+            const bytes = new Uint8Array(arrayBuffer);
+            imageBytes = bytes;
             const { error: uploadError } = await supabase.storage
                 .from(bucket)
-                .upload(finalPath.split("/").slice(1).join("/"), new Uint8Array(arrayBuffer), { contentType, upsert: true });
+                .upload(finalPath.split("/").slice(1).join("/"), bytes, {
+                contentType,
+                upsert: true,
+            });
             if (uploadError)
                 throw new Error("Erreur upload Supabase: " + uploadError.message);
-            // 3. Générer l'URL publique
             supabaseImageUrl = finalPath;
         }
-        if (!imageUrl) {
+        if (!returnedImageUrl) {
             throw new Error("Aucune image générée");
         }
-        // Déduire les tokens utilisés
-        const tokenResult = await deductTokens(user.id, tokensRequired, model, prompt, {
-            size,
-            quality,
-            cost,
-            imageUrl,
-        });
-        if (!tokenResult.success) {
+        // Token debit is done AFTER recipe/image persistence so we never lose the image update.
+        const tokenResult = null;
+        // Si la requête demande d'associer l'image à une recette, reproduire
+        // le comportement du flux de sélection d'image: copier dans
+        // app/{userId}/recipe/{parentId}/{filename} et si public copier vers recipes/{...}
+        let imagePathForRecipe = null;
+        let publicImagePath = null;
+        if (recipeId && imageBytes) {
+            try {
+                // Récupérer la recette (id ou parent)
+                const { data: existingRecipe, error: fetchError } = await supabase
+                    .from("recipes")
+                    .select("id, image_path, public_image_path, is_public, slug, parent_recipe_id")
+                    .or(`id.eq.${recipeId},parent_recipe_id.eq.${recipeId}`)
+                    .eq("owner_id", user.id)
+                    .limit(1)
+                    .single();
+                if (!fetchError && existingRecipe) {
+                    const parentId = existingRecipe.parent_recipe_id || existingRecipe.id;
+                    // 1. Nettoyer le dossier recipe privé
+                    const recipeFolder = `${user.id}/recipe/${parentId}`;
+                    try {
+                        const { data: existingFiles } = await supabase.storage
+                            .from("app")
+                            .list(recipeFolder, { limit: 100 });
+                        if (existingFiles && existingFiles.length > 0) {
+                            const filesToDelete = existingFiles
+                                .filter((f) => f.name)
+                                .map((f) => `${recipeFolder}/${f.name}`);
+                            if (filesToDelete.length > 0) {
+                                await supabase.storage.from("app").remove(filesToDelete);
+                            }
+                        }
+                    }
+                    catch (e) {
+                        logger.warn("[generate-image] Could not list/remove old recipe files", e);
+                    }
+                    // 2. Uploader dans app/{user}/recipe/{parentId}/{filename}
+                    const filename = (supabaseImageUrl || "").split("/").pop() ||
+                        `recipe-${Date.now()}.png`;
+                    const privateDestinationPath = `${user.id}/recipe/${parentId}/${filename}`;
+                    try {
+                        const { error: uploadError } = await supabase.storage
+                            .from("app")
+                            .upload(privateDestinationPath, imageBytes, {
+                            contentType: "image/png",
+                            upsert: true,
+                        });
+                        if (!uploadError) {
+                            imagePathForRecipe = `/recipe/${parentId}/${filename}`;
+                        }
+                        else {
+                            logger.error("[generate-image] Upload to recipe folder failed", uploadError);
+                        }
+                    }
+                    catch (e) {
+                        logger.error("[generate-image] Upload to recipe folder exception", e);
+                    }
+                    // 3. Si AU MOINS UNE recette de la famille est publique, copier vers recipes bucket
+                    try {
+                        const { data: publicRecipes } = await supabase
+                            .from("recipes")
+                            .select("id, is_public")
+                            .or(`id.eq.${parentId},parent_recipe_id.eq.${parentId}`)
+                            .eq("is_public", true)
+                            .limit(1);
+                        const isAnyRecipePublic = existingRecipe.is_public ||
+                            (publicRecipes && publicRecipes.length > 0);
+                        if (isAnyRecipePublic) {
+                            const timestamp = Date.now();
+                            const publicDestinationPath = `${parentId}-${timestamp}.png`;
+                            try {
+                                const { error: publicUploadError } = await supabase.storage
+                                    .from("recipes")
+                                    .upload(publicDestinationPath, imageBytes, {
+                                    contentType: "image/png",
+                                    upsert: true,
+                                });
+                                if (!publicUploadError) {
+                                    publicImagePath = publicDestinationPath;
+                                }
+                                else {
+                                    logger.error("[generate-image] Public upload failed", publicUploadError);
+                                }
+                            }
+                            catch (e) {
+                                logger.error("[generate-image] Public upload exception", e);
+                            }
+                        }
+                    }
+                    catch (e) {
+                        logger.error("[generate-image] Public recipes check failed", e);
+                    }
+                    // 4. Mettre à jour les recipes (parent + traductions) si on a une imagePath
+                    if (imagePathForRecipe) {
+                        const updateData = {
+                            image_path: imagePathForRecipe,
+                        };
+                        if (publicImagePath)
+                            updateData.public_image_path = publicImagePath;
+                        try {
+                            const { error: updateError } = await supabase
+                                .from("recipes")
+                                .update(updateData)
+                                .or(`id.eq.${parentId},parent_recipe_id.eq.${parentId}`)
+                                .eq("owner_id", user.id);
+                            if (updateError) {
+                                logger.error("[generate-image] Failed to update recipes rows", updateError);
+                            }
+                        }
+                        catch (e) {
+                            logger.error("[generate-image] Exception updating recipes", e);
+                        }
+                    }
+                }
+                else {
+                    logger.debug("[generate-image] Recipe not found or not owned, skipping recipe copy", { recipeId, fetchError });
+                }
+            }
+            catch (e) {
+                logger.error("[generate-image] Error while copying image to recipe flow", e);
+            }
+        }
+        // Déduire les tokens utilisés via wallet-service (calcul basé sur le coût USD réel)
+        try {
+            // Parse provider/model from fullModel
+            const [provider, modelName] = fullModel.includes("/")
+                ? fullModel.split("/", 2)
+                : ["openai", fullModel];
+            // Get model pricing
+            const filterResult = await isModelEnabled(user.id, fullModel);
+            if (!filterResult.allowed) {
+                logger.warn(`[generate-image] Model ${fullModel} not allowed for user ${user.id}`);
+            }
+            // Prepare usage and pricing for wallet billing
+            const usage = {
+                images: 1,
+            };
+            const pricing = {
+                imageUsdPerImage: filterResult.model?.pricing?.image
+                    ? parseFloat(filterResult.model.pricing.image.toString())
+                    : undefined,
+            };
+            // Compute provider cost from actual API usage
+            const providerCostUsd = computeProviderCostUsd(usage, pricing);
+            // Get current wallet state
+            const wallet = await getWalletState(user.id);
+            // Compute and debit using centralized billing logic
+            const billingResult = computeAndDebitAIUsage({
+                userId: user.id,
+                actionType: "generate-image",
+                providerCostUsd,
+                wallet,
+                metadata: {
+                    model: modelName,
+                    provider,
+                    endpoint: "generate-image",
+                    images: 1,
+                    size,
+                    quality,
+                    prompt: prompt.substring(0, 32),
+                    imageUrl: returnedImageUrl,
+                },
+            });
+            // Check if billing succeeded
+            if (!billingResult.success) {
+                logger.error(`[generate-image] Billing failed: ${billingResult.error}`, {
+                    providerCostUsd,
+                    walletSellValue: wallet.walletSellValueUsd,
+                    walletProviderBudget: wallet.walletProviderBudgetUsd,
+                });
+                return NextResponse.json({
+                    error: billingResult.error ||
+                        "Crédits insuffisants pour cette opération",
+                }, { status: 402 } // Payment Required
+                );
+            }
+            // Record consumption in database (ledger)
+            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-image",
+                    images: 1,
+                    size,
+                    quality,
+                    prompt: prompt.substring(0, 32),
+                    imageUrl: returnedImageUrl,
+                },
+            });
+            if (ledgerError) {
+                logger.error("[generate-image] Failed to record in ledger:", ledgerError);
+                // Continue anyway - billing logic already validated
+            }
+            logger.info(`[generate-image] Image generation completed: cost=$${billingResult.providerCostUsd?.toFixed(6)}, sell=$${billingResult.sellCostUsd?.toFixed(6)}, margin=${billingResult.marginPercent?.toFixed(1)}%`);
+            // Return with billing information (wallet-based)
             return NextResponse.json({
-                error: tokenResult.error || "Erreur lors de la déduction des tokens",
-            }, { status: 500 });
-        }
-        return NextResponse.json({
-            imageUrl,
-            supabaseImageUrl,
-            tokensUsed: tokensRequired,
-            tokensRemaining: tokenResult.balance,
-            model,
-        });
+                imageUrl: returnedImageUrl,
+                supabaseImageUrl,
+                model,
+                tokensUsed: billingResult.tokensDebited || 0,
+                tokensRemaining: billingResult.newWallet?.walletSellValueUsd || 0,
+                cost: billingResult.sellCostUsd || 0,
+            });
+        }
+        catch (e) {
+            logger.error("[generate-image] Billing exception:", e);
+            // Return anyway but without billing info
+            return NextResponse.json({
+                imageUrl: returnedImageUrl,
+                supabaseImageUrl,
+                model,
+                tokensUsed: 0,
+                tokensRemaining: 0,
+            });
+        }
     }
     catch (error) {
         const err = error;

package/dist/api/auth/generate-text.d.ts

@@ -1,9 +1,10 @@
 import { NextRequest, NextResponse } from "next/server";
 export declare function POST(request: NextRequest): Promise<NextResponse<{
     text: string;
-    tokensUsed: number;
-    tokensRemaining: number;
     model: string;
+    provider: string;
+    inputTokens: number;
+    outputTokens: number;
 }> | NextResponse<{
     error: any;
 }>>;

package/dist/api/auth/generate-text.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"generate-text.d.ts","sourceRoot":"","sources":["../../../src/api/auth/generate-text.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAwBxD,wBAAsB,IAAI,CAAC,OAAO,EAAE,WAAW;;;;;;;IAuI9C"}
+{"version":3,"file":"generate-text.d.ts","sourceRoot":"","sources":["../../../src/api/auth/generate-text.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAwBxD,wBAAsB,IAAI,CAAC,OAAO,EAAE,WAAW;;;;;;;;IA8P9C"}