@lastbrain/module-ai 0.1.0

package/dist/ai.build.config.d.ts

@@ -0,0 +1,4 @@
+import type { ModuleBuildConfig } from "@lastbrain/core";
+declare const buildConfig: ModuleBuildConfig;
+export default buildConfig;
+//# sourceMappingURL=ai.build.config.d.ts.map

package/dist/ai.build.config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ai.build.config.d.ts","sourceRoot":"","sources":["../src/ai.build.config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAEzD,QAAA,MAAM,WAAW,EAAE,iBAoFlB,CAAC;AAEF,eAAe,WAAW,CAAC"}

package/dist/ai.build.config.js

@@ -0,0 +1,86 @@
+const buildConfig = {
+    moduleName: "@lastbrain/module-ai",
+    pages: [
+        {
+            section: "auth",
+            path: "/token",
+            componentExport: "TokenPage",
+        },
+        {
+            section: "admin",
+            path: "/user-token",
+            componentExport: "UserTokenPage",
+        },
+        {
+            section: "admin",
+            path: "/user-token/[id]",
+            componentExport: "UserTokenIdPage",
+        }
+    ],
+    apis: [
+        // Routes de génération IA
+        {
+            method: "POST",
+            path: "/api/auth/generate-text",
+            handlerExport: "POST",
+            entryPoint: "api/auth/generate-text",
+            authRequired: true,
+        },
+        {
+            method: "POST",
+            path: "/api/auth/generate-image",
+            handlerExport: "POST",
+            entryPoint: "api/auth/generate-image",
+            authRequired: true,
+        },
+        // Routes admin pour la gestion des tokens
+        {
+            method: "GET",
+            path: "/api/admin/user-token",
+            handlerExport: "GET",
+            entryPoint: "api/admin/user-token",
+            authRequired: true,
+        },
+        {
+            method: "POST",
+            path: "/api/admin/user-token",
+            handlerExport: "POST",
+            entryPoint: "api/admin/user-token",
+            authRequired: true,
+        },
+        {
+            method: "GET",
+            path: "/api/admin/user-token/[id]",
+            handlerExport: "GET",
+            entryPoint: "api/admin/user-token/[id]",
+            authRequired: true,
+        },
+    ],
+    migrations: {
+        enabled: true,
+        priority: 30,
+        path: "supabase/migrations",
+        files: ["20251121000000_ai_tokens.sql"],
+    },
+    menu: {
+        auth: [
+            {
+                title: "Mes Tokens",
+                description: "Historique et balance des tokens IA",
+                icon: "Coins",
+                path: "/auth/token",
+                order: 100,
+            }
+        ],
+        admin: [
+            {
+                title: "Gestion Tokens",
+                description: "Gestion des tokens utilisateurs",
+                icon: "DatabaseZap",
+                path: "/admin/user-token",
+                order: 100,
+            }
+        ]
+    },
+};
+export default buildConfig;

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

@@ -0,0 +1,29 @@
+import { NextRequest, NextResponse } from "next/server";
+export declare function GET(request: NextRequest, props: {
+    params: Promise<{
+        id: string;
+    }>;
+}): Promise<NextResponse<{
+    user: {
+        id: string;
+        email: string | undefined;
+        createdAt: string;
+    };
+    balance: number;
+    stats: {
+        balance: number;
+        totalPurchased: number;
+        totalGifted: number;
+        totalUsed: number;
+        totalAdjusted: number;
+    };
+    history: import("../../../server").TokenLedgerEntry[];
+    pagination: {
+        limit: number;
+        offset: number;
+        hasMore: boolean;
+    };
+}> | NextResponse<{
+    error: any;
+}>>;
+//# sourceMappingURL=%5Bid%5D.d.ts.map

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

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

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

@@ -0,0 +1,57 @@
+import { NextResponse } from "next/server";
+import { getSupabaseServerClient } from "@lastbrain/core/server";
+import { getTokenBalance, getTokenHistory, getTokenStats } from "../../../server";
+// GET /api/admin/user-token/[id] - Détails d'un utilisateur spécifique
+export async function GET(request, props) {
+    const params = await props.params;
+    const { id } = params;
+    try {
+        const supabase = await getSupabaseServerClient();
+        // Vérifier l'authentification et les permissions admin
+        const { data: { user }, error: authError, } = await supabase.auth.getUser();
+        if (authError || !user) {
+            return NextResponse.json({ error: "Non autorisé" }, { status: 401 });
+        }
+        // Vérifier si l'utilisateur est superadmin
+        const { data: isSuperAdmin } = await supabase.rpc("is_superadmin", {
+            user_id: user.id,
+        });
+        if (!isSuperAdmin) {
+            return NextResponse.json({ error: "Accès refusé. Droits administrateur requis." }, { status: 403 });
+        }
+        const targetUserId = id;
+        // Récupérer les informations de l'utilisateur
+        const { data: targetUser, error: userError } = await supabase.auth.admin.getUserById(targetUserId);
+        if (userError || !targetUser) {
+            return NextResponse.json({ error: "Utilisateur non trouvé" }, { status: 404 });
+        }
+        // Récupérer le solde
+        const balance = await getTokenBalance(targetUserId);
+        // Récupérer les statistiques
+        const stats = await getTokenStats(targetUserId);
+        // Récupérer l'historique (limit depuis query params)
+        const searchParams = request.nextUrl.searchParams;
+        const limit = parseInt(searchParams.get("limit") || "50");
+        const offset = parseInt(searchParams.get("offset") || "0");
+        const history = await getTokenHistory(targetUserId, limit, offset);
+        return NextResponse.json({
+            user: {
+                id: targetUser.user.id,
+                email: targetUser.user.email,
+                createdAt: targetUser.user.created_at,
+            },
+            balance,
+            stats,
+            history,
+            pagination: {
+                limit,
+                offset,
+                hasMore: history.length === limit,
+            },
+        });
+    }
+    catch (error) {
+        console.error("[GET /api/admin/user-token/[id]] Error:", error);
+        return NextResponse.json({ error: error.message || "Erreur serveur" }, { status: 500 });
+    }
+}

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

@@ -0,0 +1,20 @@
+import { NextRequest, NextResponse } from "next/server";
+export declare function GET(request: NextRequest): Promise<NextResponse<{
+    users: {
+        id: any;
+        email: string;
+        balance: any;
+        createdAt: string | undefined;
+    }[];
+    total: number;
+}> | NextResponse<{
+    error: any;
+}>>;
+export declare function POST(request: NextRequest): Promise<NextResponse<{
+    success: boolean;
+    balance: number;
+    message: string;
+}> | NextResponse<{
+    error: any;
+}>>;
+//# sourceMappingURL=user-token.d.ts.map

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

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

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

@@ -0,0 +1,92 @@
+import { NextResponse } from "next/server";
+import { getSupabaseServerClient } from "@lastbrain/core/server";
+import { addTokens } from "../../server";
+// GET /api/admin/user-token - Liste tous les utilisateurs avec leur balance
+export async function GET(request) {
+    try {
+        const supabase = await getSupabaseServerClient();
+        // Vérifier l'authentification et les permissions admin
+        const { data: { user }, error: authError, } = await supabase.auth.getUser();
+        if (authError || !user) {
+            return NextResponse.json({ error: "Non autorisé" }, { status: 401 });
+        }
+        // Vérifier si l'utilisateur est superadmin
+        const { data: isSuperAdmin } = await supabase.rpc("is_superadmin", {
+            user_id: user.id,
+        });
+        if (!isSuperAdmin) {
+            return NextResponse.json({ error: "Accès refusé. Droits administrateur requis." }, { status: 403 });
+        }
+        // Récupérer tous les utilisateurs avec leur balance
+        const { data: balances, error: balanceError } = await supabase
+            .from("user_token_balance_v")
+            .select("owner_id, balance")
+            .order("balance", { ascending: false });
+        if (balanceError)
+            throw balanceError;
+        // Récupérer les informations des utilisateurs
+        const userIds = balances?.map((b) => b.owner_id) || [];
+        const { data: users, error: usersError } = await supabase.auth.admin.listUsers();
+        if (usersError)
+            throw usersError;
+        // Combiner les données
+        const usersWithBalance = balances?.map((balance) => {
+            const userInfo = users.users.find((u) => u.id === balance.owner_id);
+            return {
+                id: balance.owner_id,
+                email: userInfo?.email || "Unknown",
+                balance: balance.balance,
+                createdAt: userInfo?.created_at,
+            };
+        });
+        return NextResponse.json({
+            users: usersWithBalance,
+            total: usersWithBalance?.length || 0,
+        });
+    }
+    catch (error) {
+        console.error("[GET /api/admin/user-token] Error:", error);
+        return NextResponse.json({ error: error.message || "Erreur serveur" }, { status: 500 });
+    }
+}
+// POST /api/admin/user-token - Ajouter/retirer des tokens à un utilisateur
+export async function POST(request) {
+    try {
+        const supabase = await getSupabaseServerClient();
+        // Vérifier l'authentification et les permissions admin
+        const { data: { user }, error: authError, } = await supabase.auth.getUser();
+        if (authError || !user) {
+            return NextResponse.json({ error: "Non autorisé" }, { status: 401 });
+        }
+        // Vérifier si l'utilisateur est superadmin
+        const { data: isSuperAdmin } = await supabase.rpc("is_superadmin", {
+            user_id: user.id,
+        });
+        if (!isSuperAdmin) {
+            return NextResponse.json({ error: "Accès refusé. Droits administrateur requis." }, { status: 403 });
+        }
+        const body = await request.json();
+        const { userId, amount, type, reason } = body;
+        if (!userId || !amount) {
+            return NextResponse.json({ error: "userId et amount sont requis" }, { status: 400 });
+        }
+        if (amount === 0) {
+            return NextResponse.json({ error: "Le montant ne peut pas être zéro" }, { status: 400 });
+        }
+        // Déterminer le type d'opération
+        const operationType = type || (amount > 0 ? "adjust" : "adjust");
+        const result = await addTokens(userId, amount, operationType, { reason: reason || "Ajustement manuel par admin", admin_id: user.id }, user.id);
+        if (!result.success) {
+            return NextResponse.json({ error: result.error }, { status: 500 });
+        }
+        return NextResponse.json({
+            success: true,
+            balance: result.balance,
+            message: `${amount > 0 ? "Ajouté" : "Retiré"} ${Math.abs(amount)} tokens`,
+        });
+    }
+    catch (error) {
+        console.error("[POST /api/admin/user-token] Error:", error);
+        return NextResponse.json({ error: error.message || "Erreur serveur" }, { status: 500 });
+    }
+}

package/dist/api/admin/user_prompts.d.ts

@@ -0,0 +1,17 @@
+/**
+ * GET - Liste tous les enregistrements de user_prompts
+ */
+export declare function GET(request: Request): Promise<Response>;
+/**
+ * POST - Crée un nouvel enregistrement dans user_prompts
+ */
+export declare function POST(request: Request): Promise<Response>;
+/**
+ * PUT - Met à jour un enregistrement dans user_prompts
+ */
+export declare function PUT(request: Request): Promise<Response>;
+/**
+ * DELETE - Supprime un enregistrement de user_prompts
+ */
+export declare function DELETE(request: Request): Promise<Response>;
+//# sourceMappingURL=user_prompts.d.ts.map

package/dist/api/admin/user_prompts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"user_prompts.d.ts","sourceRoot":"","sources":["../../../src/api/admin/user_prompts.ts"],"names":[],"mappings":"AAWA;;GAEG;AACH,wBAAsB,GAAG,CAAC,OAAO,EAAE,OAAO,qBAkBzC;AAED;;GAEG;AACH,wBAAsB,IAAI,CAAC,OAAO,EAAE,OAAO,qBAsB1C;AAED;;GAEG;AACH,wBAAsB,GAAG,CAAC,OAAO,EAAE,OAAO,qBA4BzC;AAED;;GAEG;AACH,wBAAsB,MAAM,CAAC,OAAO,EAAE,OAAO,qBA0B5C"}

package/dist/api/admin/user_prompts.js

@@ -0,0 +1,94 @@
+import { getSupabaseServerClient } from "@lastbrain/core/server";
+const jsonResponse = (payload, status = 200) => {
+    return new Response(JSON.stringify(payload), {
+        headers: {
+            "content-type": "application/json"
+        },
+        status
+    });
+};
+/**
+ * GET - Liste tous les enregistrements de user_prompts
+ */
+export async function GET(request) {
+    const supabase = await getSupabaseServerClient();
+    const { data: { user }, error: authError } = await supabase.auth.getUser();
+    if (authError || !user) {
+        return jsonResponse({ error: "Non authentifié" }, 401);
+    }
+    const { data, error } = await supabase
+        .from("user_prompts")
+        .select("*");
+    if (error) {
+        return jsonResponse({ error: error.message }, 400);
+    }
+    return jsonResponse({ data });
+}
+/**
+ * POST - Crée un nouvel enregistrement dans user_prompts
+ */
+export async function POST(request) {
+    const supabase = await getSupabaseServerClient();
+    const { data: { user }, error: authError } = await supabase.auth.getUser();
+    if (authError || !user) {
+        return jsonResponse({ error: "Non authentifié" }, 401);
+    }
+    const body = await request.json();
+    const { data, error } = await supabase
+        .from("user_prompts")
+        .insert(body)
+        .select()
+        .single();
+    if (error) {
+        return jsonResponse({ error: error.message }, 400);
+    }
+    return jsonResponse({ data }, 201);
+}
+/**
+ * PUT - Met à jour un enregistrement dans user_prompts
+ */
+export async function PUT(request) {
+    const supabase = await getSupabaseServerClient();
+    const { data: { user }, error: authError } = await supabase.auth.getUser();
+    if (authError || !user) {
+        return jsonResponse({ error: "Non authentifié" }, 401);
+    }
+    const body = await request.json();
+    const { id, ...updateData } = body;
+    if (!id) {
+        return jsonResponse({ error: "ID requis pour la mise à jour" }, 400);
+    }
+    const { data, error } = await supabase
+        .from("user_prompts")
+        .update(updateData)
+        .eq("id", id)
+        .select()
+        .single();
+    if (error) {
+        return jsonResponse({ error: error.message }, 400);
+    }
+    return jsonResponse({ data });
+}
+/**
+ * DELETE - Supprime un enregistrement de user_prompts
+ */
+export async function DELETE(request) {
+    const supabase = await getSupabaseServerClient();
+    const { data: { user }, error: authError } = await supabase.auth.getUser();
+    if (authError || !user) {
+        return jsonResponse({ error: "Non authentifié" }, 401);
+    }
+    const { searchParams } = new URL(request.url);
+    const id = searchParams.get("id");
+    if (!id) {
+        return jsonResponse({ error: "ID requis pour la suppression" }, 400);
+    }
+    const { error } = await supabase
+        .from("user_prompts")
+        .delete()
+        .eq("id", id);
+    if (error) {
+        return jsonResponse({ error: error.message }, 400);
+    }
+    return jsonResponse({ success: true });
+}

package/dist/api/admin/user_token_ledger.d.ts

@@ -0,0 +1,17 @@
+/**
+ * GET - Liste tous les enregistrements de user_token_ledger
+ */
+export declare function GET(request: Request): Promise<Response>;
+/**
+ * POST - Crée un nouvel enregistrement dans user_token_ledger
+ */
+export declare function POST(request: Request): Promise<Response>;
+/**
+ * PUT - Met à jour un enregistrement dans user_token_ledger
+ */
+export declare function PUT(request: Request): Promise<Response>;
+/**
+ * DELETE - Supprime un enregistrement de user_token_ledger
+ */
+export declare function DELETE(request: Request): Promise<Response>;
+//# sourceMappingURL=user_token_ledger.d.ts.map

package/dist/api/admin/user_token_ledger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"user_token_ledger.d.ts","sourceRoot":"","sources":["../../../src/api/admin/user_token_ledger.ts"],"names":[],"mappings":"AAWA;;GAEG;AACH,wBAAsB,GAAG,CAAC,OAAO,EAAE,OAAO,qBAkBzC;AAED;;GAEG;AACH,wBAAsB,IAAI,CAAC,OAAO,EAAE,OAAO,qBAsB1C;AAED;;GAEG;AACH,wBAAsB,GAAG,CAAC,OAAO,EAAE,OAAO,qBA4BzC;AAED;;GAEG;AACH,wBAAsB,MAAM,CAAC,OAAO,EAAE,OAAO,qBA0B5C"}

package/dist/api/admin/user_token_ledger.js

@@ -0,0 +1,94 @@
+import { getSupabaseServerClient } from "@lastbrain/core/server";
+const jsonResponse = (payload, status = 200) => {
+    return new Response(JSON.stringify(payload), {
+        headers: {
+            "content-type": "application/json"
+        },
+        status
+    });
+};
+/**
+ * GET - Liste tous les enregistrements de user_token_ledger
+ */
+export async function GET(request) {
+    const supabase = await getSupabaseServerClient();
+    const { data: { user }, error: authError } = await supabase.auth.getUser();
+    if (authError || !user) {
+        return jsonResponse({ error: "Non authentifié" }, 401);
+    }
+    const { data, error } = await supabase
+        .from("user_token_ledger")
+        .select("*");
+    if (error) {
+        return jsonResponse({ error: error.message }, 400);
+    }
+    return jsonResponse({ data });
+}
+/**
+ * POST - Crée un nouvel enregistrement dans user_token_ledger
+ */
+export async function POST(request) {
+    const supabase = await getSupabaseServerClient();
+    const { data: { user }, error: authError } = await supabase.auth.getUser();
+    if (authError || !user) {
+        return jsonResponse({ error: "Non authentifié" }, 401);
+    }
+    const body = await request.json();
+    const { data, error } = await supabase
+        .from("user_token_ledger")
+        .insert(body)
+        .select()
+        .single();
+    if (error) {
+        return jsonResponse({ error: error.message }, 400);
+    }
+    return jsonResponse({ data }, 201);
+}
+/**
+ * PUT - Met à jour un enregistrement dans user_token_ledger
+ */
+export async function PUT(request) {
+    const supabase = await getSupabaseServerClient();
+    const { data: { user }, error: authError } = await supabase.auth.getUser();
+    if (authError || !user) {
+        return jsonResponse({ error: "Non authentifié" }, 401);
+    }
+    const body = await request.json();
+    const { id, ...updateData } = body;
+    if (!id) {
+        return jsonResponse({ error: "ID requis pour la mise à jour" }, 400);
+    }
+    const { data, error } = await supabase
+        .from("user_token_ledger")
+        .update(updateData)
+        .eq("id", id)
+        .select()
+        .single();
+    if (error) {
+        return jsonResponse({ error: error.message }, 400);
+    }
+    return jsonResponse({ data });
+}
+/**
+ * DELETE - Supprime un enregistrement de user_token_ledger
+ */
+export async function DELETE(request) {
+    const supabase = await getSupabaseServerClient();
+    const { data: { user }, error: authError } = await supabase.auth.getUser();
+    if (authError || !user) {
+        return jsonResponse({ error: "Non authentifié" }, 401);
+    }
+    const { searchParams } = new URL(request.url);
+    const id = searchParams.get("id");
+    if (!id) {
+        return jsonResponse({ error: "ID requis pour la suppression" }, 400);
+    }
+    const { error } = await supabase
+        .from("user_token_ledger")
+        .delete()
+        .eq("id", id);
+    if (error) {
+        return jsonResponse({ error: error.message }, 400);
+    }
+    return jsonResponse({ success: true });
+}

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

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

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

@@ -0,0 +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;AAoCxD,wBAAsB,IAAI,CAAC,OAAO,EAAE,WAAW;;;;;;;;IA2H9C"}

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

@@ -0,0 +1,104 @@
+import { NextResponse } from "next/server";
+import { getSupabaseServerClient } from "@lastbrain/core/server";
+import { useTokens, getTokenBalance } from "../../server";
+import OpenAI from "openai";
+const openai = new OpenAI({
+    apiKey: process.env.OPENAI_API_KEY,
+});
+// 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,
+};
+// Équivalent en tokens (arbitraire pour notre système de comptage)
+const TOKENS_PER_IMAGE = {
+    "dall-e-2": 1000,
+    "dall-e-3-standard": 2000,
+    "dall-e-3-hd": 4000,
+};
+export async function POST(request) {
+    try {
+        const supabase = await getSupabaseServerClient();
+        // Vérifier l'authentification
+        const { data: { user }, error: authError, } = await supabase.auth.getUser();
+        if (authError || !user) {
+            return NextResponse.json({ error: "Non autorisé" }, { status: 401 });
+        }
+        const body = await request.json();
+        const { prompt, model = "dall-e-3", size = "1024x1024", quality = "standard", } = 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 tokenKey = model === "dall-e-3" ? `${model}-${quality}` : model;
+        const tokensRequired = TOKENS_PER_IMAGE[tokenKey] || 1000;
+        // Vérifier le solde de tokens
+        const currentBalance = await getTokenBalance(user.id);
+        if (currentBalance < tokensRequired) {
+            return NextResponse.json({
+                error: `Solde insuffisant. Disponible: ${currentBalance}, requis: ${tokensRequired}`,
+            }, { status: 402 });
+        }
+        // Paramètres pour DALL-E 3
+        const imageParams = {
+            model,
+            prompt,
+            n: 1,
+            response_format: "url",
+        };
+        // DALL-E 3 a des paramètres différents de DALL-E 2
+        if (model === "dall-e-3") {
+            imageParams.size = size;
+            imageParams.quality = quality;
+        }
+        else {
+            // DALL-E 2 ne supporte que certaines tailles
+            const validSizes = ["256x256", "512x512", "1024x1024"];
+            imageParams.size = validSizes.includes(size) ? size : "1024x1024";
+        }
+        // Appeler OpenAI
+        const response = await openai.images.generate(imageParams);
+        const imageUrl = response.data?.[0]?.url;
+        if (!imageUrl) {
+            throw new Error("Aucune image générée");
+        }
+        // Déduire les tokens utilisés
+        const tokenResult = await useTokens(user.id, tokensRequired, model, prompt, {
+            size,
+            quality,
+            cost,
+            imageUrl,
+        });
+        if (!tokenResult.success) {
+            return NextResponse.json({ error: tokenResult.error || "Erreur lors de la déduction des tokens" }, { status: 500 });
+        }
+        return NextResponse.json({
+            imageUrl,
+            tokensUsed: tokensRequired,
+            tokensRemaining: tokenResult.balance,
+            model,
+            cost,
+        });
+    }
+    catch (error) {
+        console.error("Erreur de génération d'image:", error);
+        if (error.code === 'insufficient_quota') {
+            return NextResponse.json({ error: "Quota OpenAI dépassé. Contactez l'administrateur." }, { status: 503 });
+        }
+        if (error.code === 'content_policy_violation') {
+            return NextResponse.json({ error: "Le prompt viole la politique de contenu d'OpenAI." }, { status: 400 });
+        }
+        return NextResponse.json({ error: error.message || "Erreur lors de la génération de l'image" }, { status: 500 });
+    }
+}

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

@@ -0,0 +1,11 @@
+import { NextRequest, NextResponse } from "next/server";
+export declare function POST(request: NextRequest): Promise<NextResponse<{
+    text: string;
+    tokensUsed: number;
+    tokensRemaining: number;
+    model: string;
+    cost: number;
+}> | NextResponse<{
+    error: any;
+}>>;
+//# sourceMappingURL=generate-text.d.ts.map

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

@@ -0,0 +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;AAiBxD,wBAAsB,IAAI,CAAC,OAAO,EAAE,WAAW;;;;;;;;IA+H9C"}