robin/Dramlog-Prod
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor: Consolidate all AI calls to use OpenRouter provider switch

Browse Source 
- bulk-scan.ts: Now uses OpenRouter for batch analysis
- scan-label.ts: Now uses OpenRouter with Gemini fallback
- analyze-bottle.ts: Now uses OpenRouter with Gemini fallback
- All AI calls now respect AI_PROVIDER env variable
- Uses Nebius/FP8 provider preferences consistently
- Unified logging: [FunctionName] Using provider: openrouter/gemini
This commit is contained in:
robin
2025-12-26 21:21:56 +01:00
parent e978499b54
commit 9c5f538efb
4 changed files with 362 additions and 191 deletions
Download Patch File Download Diff File Expand all files Collapse all files

210
src/app/actions/scan-label.ts
View File

@@ -6,6 +6,7 @@ import { createClient } from '@/lib/supabase/server';
import { createHash } from 'crypto';
import { trackApiUsage } from '@/services/track-api-usage';
import { checkCreditBalance, deductCredits } from '@/services/credit-service';
import { getAIProvider, getOpenRouterClient, OPENROUTER_PROVIDER_PREFERENCES } from '@/lib/openrouter';
import sharp from 'sharp';
// Native Schema Definition for Gemini API
@@ -30,10 +31,30 @@ const metadataSchema = {
required: ["name", "is_whisky", "confidence"],
};
const SCAN_PROMPT = `Extract whisky label metadata. Return JSON with:
- name: Full product name
- distillery: Distillery name
- bottler: Independent bottler if applicable
- category: e.g. "Single Malt", "Bourbon"
- abv: Alcohol percentage
- age: Age statement in years
- vintage: Vintage year
- distilled_at: Distillation date
- bottled_at: Bottling date
- batch_info: Batch or cask info
- is_whisky: boolean
- confidence: 0-1`;
export async function scanLabel(input: any): Promise<AnalysisResponse> {
if (!process.env.GEMINI_API_KEY) {
const provider = getAIProvider();
// Check API key based on provider
if (provider === 'gemini' && !process.env.GEMINI_API_KEY) {
return { success: false, error: 'GEMINI_API_KEY is not configured.' };
}
if (provider === 'openrouter' && !process.env.OPENROUTER_API_KEY) {
return { success: false, error: 'OPENROUTER_API_KEY is not configured.' };
}
let supabase;
try {
@@ -101,7 +122,7 @@ export async function scanLabel(input: any): Promise<AnalysisResponse> {
};
}
// Step 3: AI-Specific Image Optimization (Grayscale, Normalize, Resize)
// Step 3: AI-Specific Image Optimization
const startOptimization = performance.now();
const optimizedBuffer = await sharp(buffer)
.resize(1024, 1024, { fit: 'inside', withoutEnlargement: true })
@@ -117,94 +138,155 @@ export async function scanLabel(input: any): Promise<AnalysisResponse> {
const uploadSize = optimizedBuffer.length;
const endEncoding = performance.now();
// Step 5: Model Initialization & Step 6: API Call
// Step 5: AI Analysis
const startAiTotal = performance.now();
let jsonData;
let validatedData;
try {
const startModelInit = performance.now();
const genAI = new GoogleGenerativeAI(process.env.GEMINI_API_KEY);
const model = genAI.getGenerativeModel({
model: 'gemini-2.5-flash',
generationConfig: {
responseMimeType: "application/json",
responseSchema: metadataSchema as any,
console.log(`[ScanLabel] Using provider: ${provider}`);
if (provider === 'openrouter') {
// OpenRouter path
const client = getOpenRouterClient();
const startApi = performance.now();
const response = await client.chat.completions.create({
model: 'google/gemma-3-27b-it',
messages: [{
role: 'user',
content: [
{ type: 'image_url', image_url: { url: `data:${mimeType};base64,${base64Data}` } },
{ type: 'text', text: SCAN_PROMPT + '\n\nRespond ONLY with valid JSON.' },
],
}],
temperature: 0.1,
},
safetySettings: [
{ category: HarmCategory.HARM_CATEGORY_HARASSMENT, threshold: HarmBlockThreshold.BLOCK_NONE },
{ category: HarmCategory.HARM_CATEGORY_HATE_SPEECH, threshold: HarmBlockThreshold.BLOCK_NONE },
{ category: HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT, threshold: HarmBlockThreshold.BLOCK_NONE },
{ category: HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT, threshold: HarmBlockThreshold.BLOCK_NONE },
] as any,
});
const endModelInit = performance.now();
max_tokens: 1024,
// @ts-ignore
provider: OPENROUTER_PROVIDER_PREFERENCES,
});
const instruction = "Extract whisky label metadata.";
const startApi = performance.now();
const result = await model.generateContent([
{ inlineData: { data: base64Data, mimeType: mimeType } },
{ text: instruction },
]);
const endApi = performance.now();
const endApi = performance.now();
const content = response.choices[0]?.message?.content || '{}';
const startParse = performance.now();
jsonData = JSON.parse(result.response.text());
const endParse = performance.now();
const startParse = performance.now();
let jsonStr = content;
const jsonMatch = content.match(/```(?:json)?\s*([\s\S]*?)```/);
if (jsonMatch) jsonStr = jsonMatch[1].trim();
jsonData = JSON.parse(jsonStr);
const endParse = performance.now();
const startValidation = performance.now();
validatedData = BottleMetadataSchema.parse(jsonData);
const endValidation = performance.now();
const startValidation = performance.now();
validatedData = BottleMetadataSchema.parse(jsonData);
const endValidation = performance.now();
// Cache record
await supabase.from('vision_cache').insert({ hash: imageHash, result: validatedData });
await supabase.from('vision_cache').insert({ hash: imageHash, result: validatedData });
await trackApiUsage({
userId: userId,
apiType: 'gemini_ai',
endpoint: 'scanLabel',
success: true
});
await deductCredits(userId, 'gemini_ai', 'Bottle OCR scan');
await trackApiUsage({
userId: userId,
apiType: 'gemini_ai',
endpoint: 'scanLabel_openrouter',
success: true
});
await deductCredits(userId, 'gemini_ai', 'Bottle OCR scan (OpenRouter)');
const totalTime = performance.now() - perfTotal;
return {
success: true,
data: validatedData,
perf: {
imagePrep: endImagePrep - startImagePrep,
optimization: endOptimization - startOptimization,
cacheCheck: endCacheCheck - startCacheCheck,
encoding: endEncoding - startEncoding,
modelInit: endModelInit - startModelInit,
apiCall: endApi - startApi,
parsing: endParse - startParse,
validation: endValidation - startValidation,
total: totalTime,
cacheHit: false
},
raw: jsonData
} as any;
return {
success: true,
data: validatedData,
perf: {
imagePrep: endImagePrep - startImagePrep,
optimization: endOptimization - startOptimization,
cacheCheck: endCacheCheck - startCacheCheck,
encoding: endEncoding - startEncoding,
apiCall: endApi - startApi,
parsing: endParse - startParse,
validation: endValidation - startValidation,
total: performance.now() - perfTotal,
cacheHit: false
},
raw: jsonData
} as any;
} else {
// Gemini path
const startModelInit = performance.now();
const genAI = new GoogleGenerativeAI(process.env.GEMINI_API_KEY!);
const model = genAI.getGenerativeModel({
model: 'gemini-2.5-flash',
generationConfig: {
responseMimeType: "application/json",
responseSchema: metadataSchema as any,
temperature: 0.1,
},
safetySettings: [
{ category: HarmCategory.HARM_CATEGORY_HARASSMENT, threshold: HarmBlockThreshold.BLOCK_NONE },
{ category: HarmCategory.HARM_CATEGORY_HATE_SPEECH, threshold: HarmBlockThreshold.BLOCK_NONE },
{ category: HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT, threshold: HarmBlockThreshold.BLOCK_NONE },
{ category: HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT, threshold: HarmBlockThreshold.BLOCK_NONE },
] as any,
});
const endModelInit = performance.now();
const startApi = performance.now();
const result = await model.generateContent([
{ inlineData: { data: base64Data, mimeType: mimeType } },
{ text: 'Extract whisky label metadata.' },
]);
const endApi = performance.now();
const startParse = performance.now();
jsonData = JSON.parse(result.response.text());
const endParse = performance.now();
const startValidation = performance.now();
validatedData = BottleMetadataSchema.parse(jsonData);
const endValidation = performance.now();
await supabase.from('vision_cache').insert({ hash: imageHash, result: validatedData });
await trackApiUsage({
userId: userId,
apiType: 'gemini_ai',
endpoint: 'scanLabel_gemini',
success: true
});
await deductCredits(userId, 'gemini_ai', 'Bottle OCR scan (Gemini)');
return {
success: true,
data: validatedData,
perf: {
imagePrep: endImagePrep - startImagePrep,
optimization: endOptimization - startOptimization,
cacheCheck: endCacheCheck - startCacheCheck,
encoding: endEncoding - startEncoding,
modelInit: endModelInit - startModelInit,
apiCall: endApi - startApi,
parsing: endParse - startParse,
validation: endValidation - startValidation,
total: performance.now() - perfTotal,
cacheHit: false
},
raw: jsonData
} as any;
}
} catch (aiError: any) {
console.warn('[ScanLabel] AI Analysis failed, providing fallback path:', aiError.message);
console.warn(`[ScanLabel] ${provider} failed:`, aiError.message);
// Track failure
await trackApiUsage({
userId: userId,
apiType: 'gemini_ai',
endpoint: 'scanLabel',
endpoint: `scanLabel_${provider}`,
success: false,
errorMessage: aiError.message
});
// Return a specific structure that ScanAndTasteFlow can use to fallback to placeholder
return {
success: false,
isAiError: true,
error: aiError.message,
imageHash: imageHash // Useful for local tracking
imageHash: imageHash
} as any;
}

214
src/services/analyze-bottle.ts
View File

@@ -1,29 +1,33 @@
'use server';
import { geminiModel } from '@/lib/gemini';
import { GoogleGenerativeAI, HarmCategory, HarmBlockThreshold } from '@google/generative-ai';
import { getSystemPrompt } from '@/lib/ai-prompts';
import { BottleMetadataSchema, AnalysisResponse } 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';
import { getAIProvider, getOpenRouterClient, OPENROUTER_PROVIDER_PREFERENCES } from '@/lib/openrouter';
// WICHTIG: Wir akzeptieren jetzt FormData statt Strings
export async function analyzeBottle(input: any): Promise<AnalysisResponse> {
if (!process.env.GEMINI_API_KEY) {
const provider = getAIProvider();
// Check API key based on provider
if (provider === 'gemini' && !process.env.GEMINI_API_KEY) {
return { success: false, error: 'GEMINI_API_KEY is not configured.' };
}
if (provider === 'openrouter' && !process.env.OPENROUTER_API_KEY) {
return { success: false, error: 'OPENROUTER_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 (leichtgewichtig für den N100)
const file = getValue(input, 'file') as File;
const tagsString = getValue(input, 'tags') as string;
const locale = getValue(input, 'locale') || 'de';
@@ -32,10 +36,8 @@ export async function analyzeBottle(input: any): Promise<AnalysisResponse> {
return { success: false, error: 'Kein Bild empfangen.' };
}
// Tags müssen manuell geparst werden, da FormData alles flach macht
const tags = tagsString ? (typeof tagsString === 'string' ? JSON.parse(tagsString) : tagsString) : [];
// 2. Auth & Credits (bleibt gleich)
supabase = await createClient();
const { data: { user } } = await supabase.auth.getUser();
@@ -53,13 +55,10 @@ export async function analyzeBottle(input: any): Promise<AnalysisResponse> {
};
}
// 3. Datei in Buffer umwandeln (Schneller als String-Manipulation)
// Der N100 mag ArrayBuffer lieber als riesige Base64 Strings im JSON
const arrayBuffer = await file.arrayBuffer();
const buffer = Buffer.from(arrayBuffer);
// 4. Hash für Cache erstellen (direkt vom Buffer -> sehr schnell)
const imageHash = createHash('sha256').update(buffer).digest('hex');
// Cache Check
const { data: cachedResult } = await supabase
.from('vision_cache')
@@ -79,83 +78,152 @@ export async function analyzeBottle(input: any): Promise<AnalysisResponse> {
};
}
// 5. Für Gemini vorbereiten
const base64Data = buffer.toString('base64');
const mimeType = file.type || 'image/webp';
const uploadSize = buffer.length;
const instruction = getSystemPrompt(tags.length > 0 ? tags.join(', ') : 'No tags available', locale);
try {
// API Call
const startApi = performance.now();
const result = await geminiModel.generateContent([
{
inlineData: {
data: base64Data,
mimeType: mimeType,
console.log(`[AnalyzeBottle] Using provider: ${provider}`);
if (provider === 'openrouter') {
// OpenRouter path
const client = getOpenRouterClient();
const startApi = performance.now();
const response = await client.chat.completions.create({
model: 'google/gemma-3-27b-it',
messages: [{
role: 'user',
content: [
{ type: 'image_url', image_url: { url: `data:${mimeType};base64,${base64Data}` } },
{ type: 'text', text: instruction + '\n\nRespond ONLY with valid JSON.' },
],
}],
temperature: 0.1,
max_tokens: 1024,
// @ts-ignore
provider: OPENROUTER_PROVIDER_PREFERENCES,
});
const endApi = performance.now();
const content = response.choices[0]?.message?.content || '{}';
const startParse = performance.now();
let jsonStr = content;
const jsonMatch = content.match(/```(?:json)?\s*([\s\S]*?)```/);
if (jsonMatch) jsonStr = jsonMatch[1].trim();
let jsonData = JSON.parse(jsonStr);
if (Array.isArray(jsonData)) jsonData = jsonData[0];
const endParse = performance.now();
const searchString = jsonData.search_string;
delete jsonData.search_string;
if (!jsonData) throw new Error('Keine Daten in der KI-Antwort gefunden.');
const validatedData = BottleMetadataSchema.parse(jsonData);
await trackApiUsage({
userId: userId,
apiType: 'gemini_ai',
endpoint: 'analyzeBottle_openrouter',
success: true
});
await deductCredits(userId, 'gemini_ai', 'Bottle analysis (OpenRouter)');
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
},
},
{ text: instruction },
]);
const endApi = performance.now();
raw: jsonData
} as any;
const startParse = performance.now();
const responseText = result.response.text();
} else {
// Gemini path
const genAI = new GoogleGenerativeAI(process.env.GEMINI_API_KEY!);
const model = genAI.getGenerativeModel({
model: 'gemini-2.5-flash',
generationConfig: {
responseMimeType: "application/json",
temperature: 0.1,
},
safetySettings: [
{ category: HarmCategory.HARM_CATEGORY_HARASSMENT, threshold: HarmBlockThreshold.BLOCK_NONE },
{ category: HarmCategory.HARM_CATEGORY_HATE_SPEECH, threshold: HarmBlockThreshold.BLOCK_NONE },
{ category: HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT, threshold: HarmBlockThreshold.BLOCK_NONE },
{ category: HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT, threshold: HarmBlockThreshold.BLOCK_NONE },
] as any,
});
let jsonData;
try {
jsonData = JSON.parse(responseText);
} catch (e) {
const cleanedText = responseText.replace(/```json/g, '').replace(/```/g, '');
jsonData = JSON.parse(cleanedText);
const startApi = performance.now();
const result = await model.generateContent([
{ inlineData: { data: base64Data, mimeType: mimeType } },
{ text: instruction },
]);
const endApi = performance.now();
const startParse = performance.now();
const responseText = result.response.text();
let jsonData;
try {
jsonData = JSON.parse(responseText);
} catch (e) {
const cleanedText = responseText.replace(/```json/g, '').replace(/```/g, '');
jsonData = JSON.parse(cleanedText);
}
if (Array.isArray(jsonData)) jsonData = jsonData[0];
const endParse = performance.now();
const searchString = jsonData.search_string;
delete jsonData.search_string;
if (!jsonData) throw new Error('Keine Daten in der KI-Antwort gefunden.');
const validatedData = BottleMetadataSchema.parse(jsonData);
await trackApiUsage({
userId: userId,
apiType: 'gemini_ai',
endpoint: 'analyzeBottle_gemini',
success: true
});
await deductCredits(userId, 'gemini_ai', 'Bottle analysis (Gemini)');
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
} as any;
}
if (Array.isArray(jsonData)) jsonData = jsonData[0];
console.log('[Gemini AI] JSON Response:', jsonData);
const searchString = jsonData.search_string;
delete jsonData.search_string;
if (!jsonData) throw new Error('Keine Daten in der KI-Antwort gefunden.');
const validatedData = BottleMetadataSchema.parse(jsonData);
const endParse = performance.now();
// 6. Tracking & Credits
await trackApiUsage({
userId: userId,
apiType: 'gemini_ai',
endpoint: 'generateContent',
success: true
});
await deductCredits(userId, 'gemini_ai', 'Bottle analysis');
// Cache speichern
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
} as any;
} catch (aiError: any) {
console.warn('[AnalyzeBottle] AI Analysis failed, providing fallback path:', aiError.message);
console.warn(`[AnalyzeBottle] ${provider} failed:`, aiError.message);
await trackApiUsage({
userId: userId,
apiType: 'gemini_ai',
endpoint: 'generateContent',
endpoint: `analyzeBottle_${provider}`,
success: false,
errorMessage: aiError.message
});
@@ -169,7 +237,7 @@ export async function analyzeBottle(input: any): Promise<AnalysisResponse> {
}
} catch (error) {
console.error('Gemini Analysis Global Error:', error);
console.error('Analyze Bottle Global Error:', error);
return {
success: false,
error: error instanceof Error ? error.message : 'An unknown error occurred during analysis.',

127
src/services/bulk-scan.ts
View File

@@ -234,8 +234,8 @@ async function markBottleError(
}
/**
* Call Gemini to analyze bottle image
* Uses existing Gemini integration
* Analyze bottle image using configured AI provider
* Uses OpenRouter by default, falls back to Gemini
*/
async function analyzeBottleImage(imageUrl: string): Promise<{
success: boolean;
@@ -250,6 +250,9 @@ async function analyzeBottleImage(imageUrl: string): Promise<{
};
error?: string;
}> {
const { getAIProvider, getOpenRouterClient, OPENROUTER_PROVIDER_PREFERENCES } = await import('@/lib/openrouter');
const provider = getAIProvider();
try {
// Fetch image and convert to base64
const response = await fetch(imageUrl);
@@ -262,22 +265,7 @@ async function analyzeBottleImage(imageUrl: string): Promise<{
const base64 = Buffer.from(buffer).toString('base64');
const mimeType = blob.type || 'image/webp';
// Call Gemini
const apiKey = process.env.GOOGLE_GENERATIVE_AI_API_KEY;
if (!apiKey) {
return { success: false, error: 'API Key nicht konfiguriert' };
}
const geminiResponse = await fetch(
`https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key=${apiKey}`,
{
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({
contents: [{
parts: [
{
text: `Analyze this whisky bottle image. Extract:
const prompt = `Analyze this whisky bottle image. Extract:
- name: Full product name
- distillery: Distillery name
- category: e.g. "Single Malt", "Bourbon", "Blend"
@@ -286,46 +274,79 @@ async function analyzeBottleImage(imageUrl: string): Promise<{
- is_whisky: boolean, false if not a whisky
- confidence: 0-100 how confident you are
Respond ONLY with valid JSON, no markdown.`
},
{
inline_data: {
mime_type: mimeType,
data: base64
}
}
]
}],
generationConfig: {
temperature: 0.1,
maxOutputTokens: 500,
}
})
Respond ONLY with valid JSON, no markdown.`;
if (provider === 'openrouter') {
// OpenRouter path
const client = getOpenRouterClient();
const openRouterResponse = await client.chat.completions.create({
model: 'google/gemma-3-27b-it',
messages: [{
role: 'user',
content: [
{ type: 'image_url', image_url: { url: `data:${mimeType};base64,${base64}` } },
{ type: 'text', text: prompt },
],
}],
temperature: 0.1,
max_tokens: 500,
// @ts-ignore
provider: OPENROUTER_PROVIDER_PREFERENCES,
});
const content = openRouterResponse.choices[0]?.message?.content || '{}';
let jsonStr = content;
const jsonMatch = content.match(/```(?:json)?\s*([\s\S]*?)```/);
if (jsonMatch) jsonStr = jsonMatch[1].trim();
const parsed = JSON.parse(jsonStr);
return { success: true, data: parsed };
} else {
// Gemini path
const apiKey = process.env.GEMINI_API_KEY;
if (!apiKey) {
return { success: false, error: 'GEMINI_API_KEY nicht konfiguriert' };
}
);
if (!geminiResponse.ok) {
return { success: false, error: 'Gemini API Fehler' };
const geminiResponse = await fetch(
`https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash:generateContent?key=${apiKey}`,
{
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({
contents: [{
parts: [
{ text: prompt },
{ inline_data: { mime_type: mimeType, data: base64 } }
]
}],
generationConfig: { temperature: 0.1, maxOutputTokens: 500 }
})
}
);
if (!geminiResponse.ok) {
return { success: false, error: 'Gemini API Fehler' };
}
const geminiData = await geminiResponse.json();
const textContent = geminiData.candidates?.[0]?.content?.parts?.[0]?.text;
if (!textContent) {
return { success: false, error: 'Keine Antwort von Gemini' };
}
const jsonMatch = textContent.match(/\{[\s\S]*\}/);
if (!jsonMatch) {
return { success: false, error: 'Ungültige Gemini-Antwort' };
}
const parsed = JSON.parse(jsonMatch[0]);
return { success: true, data: parsed };
}
const geminiData = await geminiResponse.json();
const textContent = geminiData.candidates?.[0]?.content?.parts?.[0]?.text;
if (!textContent) {
return { success: false, error: 'Keine Antwort von Gemini' };
}
// Parse JSON response
const jsonMatch = textContent.match(/\{[\s\S]*\}/);
if (!jsonMatch) {
return { success: false, error: 'Ungültige Gemini-Antwort' };
}
const parsed = JSON.parse(jsonMatch[0]);
return { success: true, data: parsed };
} catch (error) {
console.error('Gemini analysis error:', error);
console.error(`[BulkScan] ${provider} analysis error:`, error);
return { success: false, error: 'Analysefehler' };
}
}