chore: Prepare for Tailwind v4 migration

src/services/analyze-bottle-mistral.ts

@@ -0,0 +1,191 @@
+'use server';
+
+import { Mistral } from '@mistralai/mistralai';
+import { getSystemPrompt } from '@/lib/ai-prompts';
+import { BottleMetadataSchema, AnalysisResponse, BottleMetadata } from '@/types/whisky';
+import { createClient } from '@/lib/supabase/server';
+import { createHash } from 'crypto';
+import { trackApiUsage } from './track-api-usage';
+import { checkCreditBalance, deductCredits } from './credit-service';
+
+// WICHTIG: Wir akzeptieren jetzt FormData statt Strings
+export async function analyzeBottleMistral(input: any): Promise<AnalysisResponse & { search_string?: string }> {
+    if (!process.env.MISTRAL_API_KEY) {
+        return { success: false, error: 'MISTRAL_API_KEY is not configured.' };
+    }
+
+    let supabase;
+    try {
+        // Helper to get value from either FormData or POJO
+        const getValue = (obj: any, key: string): any => {
+            if (obj && typeof obj.get === 'function') return obj.get(key);
+            if (obj && typeof obj[key] !== 'undefined') return obj[key];
+            return null;
+        };
+
+        // 1. Daten extrahieren
+        const file = getValue(input, 'file') as File;
+        const tagsString = getValue(input, 'tags') as string;
+        const locale = getValue(input, 'locale') || 'de';
+
+        if (!file) {
+            return { success: false, error: 'Kein Bild empfangen.' };
+        }
+
+        const tags = tagsString ? (typeof tagsString === 'string' ? JSON.parse(tagsString) : tagsString) : [];
+
+        // 2. Auth & Credits
+        supabase = await createClient();
+        const { data: { user } } = await supabase.auth.getUser();
+        if (!user) {
+            return { success: false, error: 'Nicht autorisiert oder Session abgelaufen.' };
+        }
+
+        const userId = user.id;
+        const creditCheck = await checkCreditBalance(userId, 'gemini_ai');
+        if (!creditCheck.allowed) {
+            return {
+                success: false,
+                error: `Nicht genügend Credits. Benötigt: ${creditCheck.cost}, Verfügbar: ${creditCheck.balance}.`
+            };
+        }
+
+        // 3. Datei in Buffer umwandeln
+        const arrayBuffer = await file.arrayBuffer();
+        const buffer = Buffer.from(arrayBuffer);
+
+        // 4. Hash für Cache erstellen
+        const imageHash = createHash('sha256').update(buffer).digest('hex');
+
+        // Cache Check
+        const { data: cachedResult } = await supabase
+            .from('vision_cache')
+            .select('result')
+            .eq('hash', imageHash)
+            .maybeSingle();
+
+        if (cachedResult) {
+            return {
+                success: true,
+                data: cachedResult.result as any,
+                perf: {
+                    apiDuration: 0,
+                    parseDuration: 0,
+                    uploadSize: buffer.length
+                }
+            };
+        }
+
+        // 5. Für Mistral vorbereiten
+        const client = new Mistral({ apiKey: process.env.MISTRAL_API_KEY });
+        const base64Data = buffer.toString('base64');
+        const mimeType = file.type || 'image/webp';
+        const dataUrl = `data:${mimeType};base64,${base64Data}`;
+        const uploadSize = buffer.length;
+
+        const prompt = getSystemPrompt(tags.length > 0 ? tags.join(', ') : 'Keine Tags verfügbar', locale);
+
+        try {
+            const startApi = performance.now();
+            const chatResponse = await client.chat.complete({
+                model: 'mistral-large-latest',
+                messages: [
+                    {
+                        role: 'user',
+                        content: [
+                            { type: 'text', text: prompt },
+                            { type: 'image_url', imageUrl: dataUrl }H
+                        ]
+                    }
+                ],
+                responseFormat: { type: 'json_object' },
+                temperature: 0.1
+            });
+            const endApi = performance.now();
+
+            const startParse = performance.now();
+            const rawContent = chatResponse.choices?.[0].message.content;
+            if (!rawContent) throw new Error("Keine Antwort von Mistral");
+
+            let jsonData;
+            try {
+                jsonData = JSON.parse(rawContent as string);
+            } catch (e) {
+                const cleanedText = (rawContent as string).replace(/```json/g, '').replace(/```/g, '');
+                jsonData = JSON.parse(cleanedText);
+            }
+
+            if (Array.isArray(jsonData)) jsonData = jsonData[0];
+            console.log('[Mistral AI] JSON Response:', jsonData);
+
+            const searchString = jsonData.search_string;
+            delete jsonData.search_string;
+
+            if (typeof jsonData.abv === 'string') {
+                // Fix: Global replace to remove all % signs
+                jsonData.abv = parseFloat(jsonData.abv.replace(/%/g, '').trim());
+            }
+
+            if (jsonData.age) jsonData.age = parseInt(jsonData.age);
+            if (jsonData.vintage) jsonData.vintage = parseInt(jsonData.vintage);
+
+            const validatedData = BottleMetadataSchema.parse(jsonData);
+            const endParse = performance.now();
+
+            await trackApiUsage({
+                userId: userId,
+                apiType: 'gemini_ai',
+                endpoint: 'mistral/mistral-large',
+                success: true,
+                provider: 'mistral',
+                model: 'mistral-large-latest',
+                responseText: rawContent as string
+            });
+
+            await deductCredits(userId, 'gemini_ai', 'Mistral AI analysis');
+
+            await supabase
+                .from('vision_cache')
+                .insert({ hash: imageHash, result: validatedData });
+
+            return {
+                success: true,
+                data: validatedData,
+                search_string: searchString,
+                perf: {
+                    apiDuration: endApi - startApi,
+                    parseDuration: endParse - startParse,
+                    uploadSize: uploadSize
+                },
+                raw: jsonData
+            };
+
+        } catch (aiError: any) {
+            console.warn('[MistralAnalysis] AI Analysis failed, providing fallback path:', aiError.message);
+
+            await trackApiUsage({
+                userId: userId,
+                apiType: 'gemini_ai',
+                endpoint: 'mistral/mistral-large',
+                success: false,
+                errorMessage: aiError.message,
+                provider: 'mistral',
+                model: 'mistral-large-latest'
+            });
+
+            return {
+                success: false,
+                isAiError: true,
+                error: aiError.message,
+                imageHash: imageHash
+            } as any;
+        }
+
+    } catch (error) {
+        console.error('Mistral Analysis Global Error:', error);
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Mistral AI analysis failed.',
+        };
+    }
+}