@lastbrain/module-ai 2.0.26 → 2.0.30

package/dist/api/admin/wallet-repair/route.d.ts

@@ -0,0 +1,30 @@
+import { NextResponse } from "next/server";
+/**
+ * POST /api/ai/admin/wallet-repair
+ * Repair wallets that have tokens but 0 USD budget
+ * Query params:
+ *   - userId: repair specific user (optional)
+ *   - all: repair all wallets (optional)
+ */
+export declare function POST(request: Request): Promise<NextResponse<{
+    success: boolean;
+    userId: string;
+    before: {
+        balance: number;
+        providerBudget: number;
+        sellValue: number;
+    } | undefined;
+    after: {
+        balance: number;
+        providerBudget: number;
+        sellValue: number;
+    } | undefined;
+}> | NextResponse<{
+    success: boolean;
+    repaired: number;
+    failed: number;
+    errors: string[];
+}> | NextResponse<{
+    error: any;
+}>>;
+//# sourceMappingURL=route.d.ts.map

package/dist/api/admin/wallet-repair/route.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"route.d.ts","sourceRoot":"","sources":["../../../../src/api/admin/wallet-repair/route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAS3C;;;;;;GAMG;AACH,wBAAsB,IAAI,CAAC,OAAO,EAAE,OAAO;;;;;;;;;;;;;;;;;;;;IAgE1C"}

package/dist/api/admin/wallet-repair/route.js

@@ -0,0 +1,63 @@
+import { NextResponse } from "next/server";
+import { getSupabaseServerClient } from "@lastbrain/core/server";
+import { repairUserWallet, repairAllWallets, } from "../../../server/wallet-repair";
+import { logger } from "@lastbrain/core";
+/**
+ * POST /api/ai/admin/wallet-repair
+ * Repair wallets that have tokens but 0 USD budget
+ * Query params:
+ *   - userId: repair specific user (optional)
+ *   - all: repair all wallets (optional)
+ */
+export async function POST(request) {
+    try {
+        // 1. Check admin auth
+        const supabase = await getSupabaseServerClient();
+        const { data: { user }, error: authError, } = await supabase.auth.getUser();
+        if (authError || !user) {
+            return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+        }
+        // TODO: Check if user is admin (for now, any authenticated user can repair)
+        // const isAdmin = await checkAdminRole(user.id);
+        // if (!isAdmin) {
+        //   return NextResponse.json({ error: "Forbidden" }, { status: 403 });
+        // }
+        // 2. Parse request
+        const { searchParams } = new URL(request.url);
+        const userId = searchParams.get("userId");
+        const all = searchParams.get("all") === "true";
+        if (!userId && !all) {
+            return NextResponse.json({ error: "Missing userId or all=true parameter" }, { status: 400 });
+        }
+        // 3. Repair wallet(s)
+        if (userId) {
+            logger.info(`[wallet-repair] Repairing wallet for user ${userId}`);
+            const result = await repairUserWallet(userId);
+            if (result.success) {
+                return NextResponse.json({
+                    success: true,
+                    userId,
+                    before: result.before,
+                    after: result.after,
+                });
+            }
+            else {
+                return NextResponse.json({ error: result.error }, { status: 500 });
+            }
+        }
+        else {
+            logger.info("[wallet-repair] Repairing all wallets");
+            const result = await repairAllWallets();
+            return NextResponse.json({
+                success: true,
+                repaired: result.repaired,
+                failed: result.failed,
+                errors: result.errors,
+            });
+        }
+    }
+    catch (error) {
+        logger.error("[wallet-repair] Error:", error);
+        return NextResponse.json({ error: error.message || "Wallet repair failed" }, { status: 500 });
+    }
+}

package/dist/api/auth/ai-model-settings.d.ts

@@ -0,0 +1,21 @@
+/**
+ * POST /api/auth/ai-model-settings
+ * Update user's enabled AI models settings
+ */
+import { NextRequest, NextResponse } from "next/server";
+export declare function POST(request: NextRequest): Promise<NextResponse<{
+    success: boolean;
+    enabled_models: any;
+}> | NextResponse<{
+    error: any;
+}>>;
+/**
+ * GET /api/auth/ai-model-settings
+ * Get user's enabled models settings
+ */
+export declare function GET(request: NextRequest): Promise<NextResponse<{
+    enabled_models: any;
+}> | NextResponse<{
+    error: any;
+}>>;
+//# sourceMappingURL=ai-model-settings.d.ts.map

package/dist/api/auth/ai-model-settings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ai-model-settings.d.ts","sourceRoot":"","sources":["../../../src/api/auth/ai-model-settings.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAIxD,wBAAsB,IAAI,CAAC,OAAO,EAAE,WAAW;;;;;IA4E9C;AAED;;;GAGG;AACH,wBAAsB,GAAG,CAAC,OAAO,EAAE,WAAW;;;;IAyC7C"}

package/dist/api/auth/ai-model-settings.js

@@ -0,0 +1,86 @@
+/**
+ * POST /api/auth/ai-model-settings
+ * Update user's enabled AI models settings
+ */
+import { NextResponse } from "next/server";
+import { getSupabaseServerClient } from "@lastbrain/core/server";
+import { logger } from "@lastbrain/core";
+export async function POST(request) {
+    try {
+        const supabase = await getSupabaseServerClient();
+        // Get current user
+        const { data: { user }, error: userError, } = await supabase.auth.getUser();
+        if (userError || !user) {
+            return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+        }
+        // Parse request body
+        const body = await request.json();
+        const { enabled_models, enabled_providers } = body;
+        // Validate input
+        if (!Array.isArray(enabled_models)) {
+            return NextResponse.json({ error: "enabled_models must be an array" }, { status: 400 });
+        }
+        if (enabled_providers !== undefined &&
+            enabled_providers !== null &&
+            !Array.isArray(enabled_providers)) {
+            return NextResponse.json({ error: "enabled_providers must be an array or null" }, { status: 400 });
+        }
+        // Upsert settings in user_ai_settings.allowed_models
+        const { data, error } = await supabase
+            .from("user_ai_settings")
+            .upsert({
+            owner_id: user.id,
+            allowed_models: enabled_models,
+            updated_at: new Date().toISOString(),
+        }, {
+            onConflict: "owner_id",
+        })
+            .select()
+            .single();
+        if (error) {
+            logger.error("[ai-model-settings] Error upserting settings:", error);
+            return NextResponse.json({ error: "Failed to update settings" }, { status: 500 });
+        }
+        logger.info(`[ai-model-settings] Updated for user ${user.id}: ${enabled_models.length} models`);
+        return NextResponse.json({
+            success: true,
+            enabled_models: data.allowed_models || [],
+        });
+    }
+    catch (error) {
+        logger.error("[ai-model-settings] Error:", error);
+        return NextResponse.json({ error: error.message || "Internal server error" }, { status: 500 });
+    }
+}
+/**
+ * GET /api/auth/ai-model-settings
+ * Get user's enabled models settings
+ */
+export async function GET(request) {
+    try {
+        const supabase = await getSupabaseServerClient();
+        const { data: { user }, error: userError, } = await supabase.auth.getUser();
+        if (userError || !user) {
+            return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+        }
+        // Fetch settings from user_ai_settings
+        const { data: settings, error } = await supabase
+            .from("user_ai_settings")
+            .select("allowed_models")
+            .eq("owner_id", user.id)
+            .single();
+        if (error && error.code !== "PGRST116") {
+            logger.error("[ai-model-settings] Error fetching:", error);
+            return NextResponse.json({ error: "Failed to fetch settings" }, { status: 500 });
+        }
+        // Return allowed_models array
+        const result = {
+            enabled_models: settings?.allowed_models || [],
+        };
+        return NextResponse.json(result);
+    }
+    catch (error) {
+        logger.error("[ai-model-settings] Error:", error);
+        return NextResponse.json({ error: error.message || "Internal server error" }, { status: 500 });
+    }
+}

package/dist/api/auth/ai-settings.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Auth API for user_ai_settings
+ * GET /api/ai/auth/ai-settings - Get user settings
+ * PUT /api/ai/auth/ai-settings - Update user settings
+ */
+import { NextRequest, NextResponse } from "next/server";
+export declare function GET(request: NextRequest): Promise<NextResponse<{
+    data: any;
+}> | NextResponse<{
+    error: any;
+}>>;
+export declare function PUT(request: NextRequest): Promise<NextResponse<{
+    data: any;
+}> | NextResponse<{
+    error: any;
+}>>;
+//# sourceMappingURL=ai-settings.d.ts.map

package/dist/api/auth/ai-settings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ai-settings.d.ts","sourceRoot":"","sources":["../../../src/api/auth/ai-settings.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAcxD,wBAAsB,GAAG,CAAC,OAAO,EAAE,WAAW;;;;IA2C7C;AAED,wBAAsB,GAAG,CAAC,OAAO,EAAE,WAAW;;;;IA8C7C"}

package/dist/api/auth/ai-settings.js

@@ -0,0 +1,87 @@
+/**
+ * Auth API for user_ai_settings
+ * GET /api/ai/auth/ai-settings - Get user settings
+ * PUT /api/ai/auth/ai-settings - Update user settings
+ */
+import { NextResponse } from "next/server";
+import { getSupabaseServerClient } from "@lastbrain/core/server";
+import { logger } from "@lastbrain/core";
+import { z } from "zod";
+const SettingsSchema = z.object({
+    mode: z.enum(["auto", "manual"]),
+    default_text_provider: z.string().nullable().optional(),
+    default_text_model: z.string().nullable().optional(),
+    default_image_provider: z.string().nullable().optional(),
+    default_image_model: z.string().nullable().optional(),
+    max_tokens_per_call: z.number().int().nullable().optional(),
+});
+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 });
+        }
+        const { data, error } = await supabase
+            .from("user_ai_settings")
+            .select("*")
+            .eq("owner_id", user.id)
+            .single();
+        if (error && error.code !== "PGRST116") {
+            logger.error("[ai-settings] Error fetching settings", error);
+            return NextResponse.json({ error: error.message }, { status: 500 });
+        }
+        // Return default settings if none exist
+        if (!data) {
+            return NextResponse.json({
+                data: {
+                    owner_id: user.id,
+                    mode: "auto",
+                    default_text_provider: null,
+                    default_text_model: null,
+                    default_image_provider: null,
+                    default_image_model: null,
+                    max_tokens_per_call: null,
+                },
+            });
+        }
+        return NextResponse.json({ data });
+    }
+    catch (error) {
+        logger.error("[ai-settings] Unexpected error", error);
+        return NextResponse.json({ error: error.message }, { status: 500 });
+    }
+}
+export async function PUT(request) {
+    try {
+        const supabase = await getSupabaseServerClient();
+        const { data: { user }, } = await supabase.auth.getUser();
+        if (!user) {
+            return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+        }
+        const body = await request.json();
+        const validation = SettingsSchema.safeParse(body);
+        if (!validation.success) {
+            return NextResponse.json({ error: validation.error.errors.map((e) => e.message).join(", ") }, { status: 400 });
+        }
+        const { data, error } = await supabase
+            .from("user_ai_settings")
+            .upsert({
+            owner_id: user.id,
+            ...validation.data,
+        }, {
+            onConflict: "owner_id",
+        })
+            .select()
+            .single();
+        if (error) {
+            logger.error("[ai-settings] Error saving settings", error);
+            return NextResponse.json({ error: error.message }, { status: 500 });
+        }
+        return NextResponse.json({ data });
+    }
+    catch (error) {
+        logger.error("[ai-settings] Unexpected error", error);
+        return NextResponse.json({ error: error.message }, { status: 500 });
+    }
+}

package/dist/api/auth/api-keys/[id].d.ts

@@ -0,0 +1,17 @@
+/**
+ * Auth API for single api_key operations
+ * DELETE /api/ai/auth/api-keys/[id] - Revoke/delete API key
+ * DELETE /api/ai/auth/api-keys/[id]?permanent=true - Permanently delete API key
+ */
+import { NextRequest, NextResponse } from "next/server";
+export declare function DELETE(request: NextRequest, { params }: {
+    params: Promise<{
+        id: string;
+    }>;
+}): Promise<NextResponse<{
+    success: boolean;
+    message: string;
+}> | NextResponse<{
+    error: any;
+}>>;
+//# sourceMappingURL=%5Bid%5D.d.ts.map

package/dist/api/auth/api-keys/[id].d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"[id].d.ts","sourceRoot":"","sources":["../../../../src/api/auth/api-keys/[id].ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAIxD,wBAAsB,MAAM,CAC1B,OAAO,EAAE,WAAW,EACpB,EAAE,MAAM,EAAE,EAAE;IAAE,MAAM,EAAE,OAAO,CAAC;QAAE,EAAE,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CAAE;;;;;IA6EhD"}

package/dist/api/auth/api-keys/[id].js

@@ -0,0 +1,66 @@
+/**
+ * Auth API for single api_key operations
+ * DELETE /api/ai/auth/api-keys/[id] - Revoke/delete API key
+ * DELETE /api/ai/auth/api-keys/[id]?permanent=true - Permanently delete API key
+ */
+import { NextResponse } from "next/server";
+import { getSupabaseServerClient } from "@lastbrain/core/server";
+import { logger } from "@lastbrain/core";
+export async function DELETE(request, { params }) {
+    try {
+        const { id } = await params;
+        const supabase = await getSupabaseServerClient();
+        const { searchParams } = new URL(request.url);
+        const permanent = searchParams.get("permanent") === "true";
+        const { data: { user }, } = await supabase.auth.getUser();
+        if (!user) {
+            return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+        }
+        // Verify ownership before deleting
+        const { data: apiKey, error: fetchError } = await supabase
+            .from("api_keys")
+            .select("owner_id, is_active")
+            .eq("id", id)
+            .single();
+        if (fetchError || !apiKey) {
+            return NextResponse.json({ error: "API key not found" }, { status: 404 });
+        }
+        if (apiKey.owner_id !== user.id) {
+            return NextResponse.json({ error: "Unauthorized" }, { status: 403 });
+        }
+        // Permanent delete only allowed for inactive keys
+        if (permanent) {
+            if (apiKey.is_active) {
+                return NextResponse.json({ error: "Cannot delete active API key. Revoke it first." }, { status: 400 });
+            }
+            const { error: deleteError } = await supabase
+                .from("api_keys")
+                .delete()
+                .eq("id", id);
+            if (deleteError) {
+                logger.error("[api-keys] Error deleting key", deleteError);
+                return NextResponse.json({ error: deleteError.message }, { status: 500 });
+            }
+            logger.info("[api-keys] Permanently deleted key", { id });
+            return NextResponse.json({
+                success: true,
+                message: "API key permanently deleted",
+            });
+        }
+        // Soft delete (set is_active = false)
+        const { error: updateError } = await supabase
+            .from("api_keys")
+            .update({ is_active: false })
+            .eq("id", id);
+        if (updateError) {
+            logger.error("[api-keys] Error revoking key", updateError);
+            return NextResponse.json({ error: updateError.message }, { status: 500 });
+        }
+        logger.info("[api-keys] Revoked key", { id });
+        return NextResponse.json({ success: true, message: "API key revoked" });
+    }
+    catch (error) {
+        logger.error("[api-keys] Unexpected error", error);
+        return NextResponse.json({ error: error.message }, { status: 500 });
+    }
+}

package/dist/api/auth/api-keys.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Auth API for api_keys CRUD
+ * GET /api/ai/auth/api-keys - List user's API keys
+ * POST /api/ai/auth/api-keys - Create new API key
+ */
+import { NextRequest, NextResponse } from "next/server";
+export declare function GET(request: NextRequest): Promise<NextResponse<{
+    data: any[];
+}> | NextResponse<{
+    error: any;
+}>>;
+export declare function POST(request: NextRequest): Promise<NextResponse<{
+    data: any;
+    api_key: string;
+    message: string;
+}> | NextResponse<{
+    error: any;
+}>>;
+//# sourceMappingURL=api-keys.d.ts.map

package/dist/api/auth/api-keys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api-keys.d.ts","sourceRoot":"","sources":["../../../src/api/auth/api-keys.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAwBxD,wBAAsB,GAAG,CAAC,OAAO,EAAE,WAAW;;;;IA4B7C;AAED,wBAAsB,IAAI,CAAC,OAAO,EAAE,WAAW;;;;;;IAwD9C"}

package/dist/api/auth/api-keys.js

@@ -0,0 +1,94 @@
+/**
+ * Auth API for api_keys CRUD
+ * GET /api/ai/auth/api-keys - List user's API keys
+ * POST /api/ai/auth/api-keys - Create new API key
+ */
+import { NextResponse } from "next/server";
+import { getSupabaseServerClient } from "@lastbrain/core/server";
+import { logger } from "@lastbrain/core";
+import { z } from "zod";
+import { randomBytes, createHash } from "crypto";
+const ApiKeySchema = z.object({
+    name: z.string().min(1).max(200),
+    env: z.enum(["dev", "prod"]),
+    scopes: z.array(z.string()),
+    rate_limit_rpm: z.number().int().min(1).max(1000),
+    daily_token_limit: z.number().int().nullable().optional(),
+});
+/**
+ * Generate a random API key
+ */
+function generateApiKey() {
+    const key = `lb_${randomBytes(32).toString("hex")}`;
+    const prefix = key.substring(0, 10);
+    const hash = createHash("sha256").update(key).digest("hex");
+    return { key, prefix, hash };
+}
+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 });
+        }
+        const { data, error } = await supabase
+            .from("api_keys")
+            .select("*")
+            .eq("owner_id", user.id)
+            .order("created_at", { ascending: false });
+        if (error) {
+            logger.error("[api-keys] Error fetching keys", error);
+            return NextResponse.json({ error: error.message }, { status: 500 });
+        }
+        return NextResponse.json({ data });
+    }
+    catch (error) {
+        logger.error("[api-keys] Unexpected error", error);
+        return NextResponse.json({ error: error.message }, { status: 500 });
+    }
+}
+export async function POST(request) {
+    try {
+        const supabase = await getSupabaseServerClient();
+        const { data: { user }, } = await supabase.auth.getUser();
+        if (!user) {
+            return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+        }
+        const body = await request.json();
+        const validation = ApiKeySchema.safeParse(body);
+        if (!validation.success) {
+            return NextResponse.json({ error: validation.error.errors.map((e) => e.message).join(", ") }, { status: 400 });
+        }
+        // Generate new API key
+        const { key: rawKey, prefix, hash } = generateApiKey();
+        const { data, error } = await supabase
+            .from("api_keys")
+            .insert({
+            owner_id: user.id,
+            name: validation.data.name,
+            key_hash: hash,
+            prefix,
+            env: validation.data.env,
+            scopes: validation.data.scopes,
+            rate_limit_rpm: validation.data.rate_limit_rpm,
+            daily_token_limit: validation.data.daily_token_limit || null,
+            is_active: true,
+        })
+            .select()
+            .single();
+        if (error) {
+            logger.error("[api-keys] Error creating key", error);
+            return NextResponse.json({ error: error.message }, { status: 500 });
+        }
+        // Return the raw key (ONLY TIME IT'S SHOWN)
+        return NextResponse.json({
+            data,
+            api_key: rawKey,
+            message: "Store this key securely. It will not be shown again.",
+        });
+    }
+    catch (error) {
+        logger.error("[api-keys] Unexpected error", error);
+        return NextResponse.json({ error: error.message }, { status: 500 });
+    }
+}

package/dist/api/auth/create-checkout.d.ts

@@ -16,7 +16,7 @@ export declare function POST(request: NextRequest): Promise<NextResponse<{
 }> | NextResponse<{
     url: string;
     sessionId: string;
-    paymentId: string;
+    paymentId: string | null;
 }>>;
 /**
  * GET /api/ai/create-checkout - Get available token packs

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

@@ -1 +1 @@
-{"version":3,"file":"create-checkout.d.ts","sourceRoot":"","sources":["../../../src/api/auth/create-checkout.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAGxD;;;;;;;;;;;GAWG;AACH,wBAAsB,IAAI,CAAC,OAAO,EAAE,WAAW;;;;;;IAsE9C;AAED;;;;GAIG;AACH,wBAAsB,GAAG;;;;IAuBxB"}
+{"version":3,"file":"create-checkout.d.ts","sourceRoot":"","sources":["../../../src/api/auth/create-checkout.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAIxD;;;;;;;;;;;GAWG;AACH,wBAAsB,IAAI,CAAC,OAAO,EAAE,WAAW;;;;;;IAuE9C;AAED;;;;GAIG;AACH,wBAAsB,GAAG;;;;IAuBxB"}

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

@@ -5,6 +5,7 @@
 // ============================================================================
 import { NextResponse } from "next/server";
 import { getSupabaseServerClient } from "@lastbrain/core/server";
+import { logger } from "@lastbrain/core";
 /**
  * POST /api/ai/create-checkout
  *
@@ -34,7 +35,7 @@ export async function POST(request) {
         // Validate environment
         const frontendUrl = process.env.FRONTEND_URL || process.env.NEXT_PUBLIC_APP_URL;
         if (!frontendUrl) {
-            console.error("FRONTEND_URL or NEXT_PUBLIC_APP_URL not set");
+            logger.error("FRONTEND_URL or NEXT_PUBLIC_APP_URL not set");
             return NextResponse.json({ error: "Configuration serveur manquante" }, { status: 500 });
         }
         // Import central payment service dynamically to avoid circular deps
@@ -49,9 +50,10 @@ export async function POST(request) {
             user_id: user.id,
             resourceType: "token_packs",
             resourceId: token_pack_id,
-            successPath: "/auth/ai/token?success=true",
-            cancelPath: "/auth/ai/token?cancelled=true",
+            successPath: "/auth/ai/tokens?success=true",
+            cancelPath: "/auth/ai/tokens?cancelled=true",
             description: "Achat de tokens IA",
+            email: user.email, // Pass email to link to existing Stripe customer
         });
         return NextResponse.json({
             url: result.url,
@@ -60,7 +62,7 @@ export async function POST(request) {
         });
     }
     catch (error) {
-        console.error("[POST /api/ai/create-checkout] Error:", error);
+        logger.error("[POST /api/ai/create-checkout] Error:", error);
         const message = error instanceof Error
             ? error.message
             : "Erreur lors de la création du paiement";
@@ -81,13 +83,13 @@ export async function GET() {
             .eq("is_active", true)
             .order("sort_order", { ascending: true });
         if (error) {
-            console.error("[GET /api/ai/create-checkout] Error:", error);
+            logger.error("[GET /api/ai/create-checkout] Error:", error);
             return NextResponse.json({ error: "Erreur lors de la récupération des packs" }, { status: 500 });
         }
         return NextResponse.json({ packs: packs || [] });
     }
     catch (error) {
-        console.error("[GET /api/ai/create-checkout] Error:", error);
+        logger.error("[GET /api/ai/create-checkout] Error:", error);
         return NextResponse.json({ error: "Erreur serveur" }, { status: 500 });
     }
 }

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

@@ -1,11 +1,11 @@
 import { NextRequest, NextResponse } from "next/server";
 export declare function POST(request: NextRequest): Promise<NextResponse<{
-    error: string;
+    error: string | undefined;
 }> | NextResponse<{
     imageUrl: string;
     supabaseImageUrl: string | null;
+    model: string;
     tokensUsed: number;
     tokensRemaining: number;
-    model: "dall-e-3" | "dall-e-2";
 }>>;
 //# sourceMappingURL=generate-image.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"generate-image.d.ts","sourceRoot":"","sources":["../../../src/api/auth/generate-image.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAiDxD,wBAAsB,IAAI,CAAC,OAAO,EAAE,WAAW;;;;;;;;IA0L9C"}
+{"version":3,"file":"generate-image.d.ts","sourceRoot":"","sources":["../../../src/api/auth/generate-image.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AA0BxD,wBAAsB,IAAI,CAAC,OAAO,EAAE,WAAW;;;;;;;;IA+kB9C"}