@lastbrain/module-ai 2.0.26 → 2.0.30

package/dist/server/global-settings.js

@@ -0,0 +1,42 @@
+import { getSupabaseServiceClient } from "@lastbrain/core/server";
+import { logger } from "@lastbrain/core";
+/**
+ * Get global AI configuration (default models for text and image)
+ * This is the single source of truth for all AI generation calls
+ */
+export async function getGlobalAISettings() {
+    const supabase = getSupabaseServiceClient();
+    const { data, error } = await supabase
+        .from("ai_global_settings")
+        .select("*")
+        .eq("id", 1)
+        .single();
+    if (error) {
+        logger.error("[getGlobalAISettings] Error fetching global settings:", error);
+        // Fallback to defaults if DB query fails
+        return {
+            default_text_provider: "openai",
+            default_text_model: "gpt-4.1-mini",
+            default_image_provider: "google",
+            default_image_model: "gemini-2.5-flash-image",
+            max_tokens_per_call: 16384,
+        };
+    }
+    return data;
+}
+/**
+ * Get default text model from global settings
+ * Returns "provider/model" format
+ */
+export async function getDefaultTextModel() {
+    const settings = await getGlobalAISettings();
+    return `${settings.default_text_provider}/${settings.default_text_model}`;
+}
+/**
+ * Get default image model from global settings
+ * Returns "provider/model" format
+ */
+export async function getDefaultImageModel() {
+    const settings = await getGlobalAISettings();
+    return `${settings.default_image_provider}/${settings.default_image_model}`;
+}

package/dist/server/model-filter.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Helper functions for model filtering and validation
+ */
+import type { GatewayModel } from "../types/gateway";
+export interface ModelFilterResult {
+    allowed: boolean;
+    model?: GatewayModel;
+    error?: string;
+}
+/**
+ * Check if a model is enabled for the given user
+ */
+export declare function isModelEnabled(ownerId: string, modelId: string): Promise<ModelFilterResult>;
+/**
+ * Get list of enabled models for a user
+ */
+export declare function getEnabledModels(ownerId: string): Promise<GatewayModel[]>;
+/**
+ * Validate model and return error response if not allowed
+ */
+export declare function createModelNotAllowedError(modelId: string, error: string): {
+    error: any;
+    status: number;
+};
+//# sourceMappingURL=model-filter.d.ts.map

package/dist/server/model-filter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model-filter.d.ts","sourceRoot":"","sources":["../../src/server/model-filter.ts"],"names":[],"mappings":"AAAA;;GAEG;AAKH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AA2BrD,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,YAAY,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;GAEG;AACH,wBAAsB,cAAc,CAClC,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,iBAAiB,CAAC,CAmL5B;AAED;;GAEG;AACH,wBAAsB,gBAAgB,CACpC,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,YAAY,EAAE,CAAC,CA2CzB;AAyBD;;GAEG;AACH,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,GACZ;IAAE,KAAK,EAAE,GAAG,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAShC"}

package/dist/server/model-filter.js

@@ -0,0 +1,240 @@
+/**
+ * Helper functions for model filtering and validation
+ */
+import { logger } from "@lastbrain/core";
+import { getSupabaseServiceClient } from "@lastbrain/core/server";
+import { fetchGatewayModels } from "./gateway-service";
+import { getDefaultTextModel, getDefaultImageModel } from "./global-settings";
+// Default models auto-enabled on first use
+const DEFAULT_MODELS = [
+    "openai/gpt-4o-mini",
+    "google/imagen-4.0-fast-generate-001",
+    "google/gemini-2.5-flash-image",
+];
+/**
+ * Get default models from ai_global_settings
+ * These models should always be allowed for all users
+ */
+async function getGlobalDefaultModels() {
+    try {
+        const [textModel, imageModel] = await Promise.all([
+            getDefaultTextModel(),
+            getDefaultImageModel(),
+        ]);
+        return [textModel, imageModel];
+    }
+    catch (err) {
+        logger.error("[ModelFilter] Failed to fetch global default models", err);
+        return [];
+    }
+}
+/**
+ * Check if a model is enabled for the given user
+ */
+export async function isModelEnabled(ownerId, modelId) {
+    try {
+        // 0. Get global default models - these are ALWAYS allowed
+        const globalDefaultModels = await getGlobalDefaultModels();
+        const isGlobalDefault = globalDefaultModels.includes(modelId);
+        if (isGlobalDefault) {
+            logger.debug(`[ModelFilter] Model ${modelId} is a global default, auto-allowing`);
+        }
+        // 1. Get user settings from user_ai_settings
+        const supabase = await getSupabaseServiceClient();
+        const { data: settings, error } = await supabase
+            .from("user_ai_settings")
+            .select("allowed_models")
+            .eq("owner_id", ownerId)
+            .single();
+        if (error && error.code !== "PGRST116") {
+            // PGRST116 = no rows returned (user has no settings yet)
+            logger.error("[ModelFilter] Error fetching settings:", error);
+            throw error;
+        }
+        // 2. If no settings exist, create default settings with basic models + global defaults
+        if (!settings) {
+            logger.info(`[ModelFilter] No settings for user ${ownerId}, creating default with gpt-4o-mini and imagen-4.0-fast`);
+            // Merge static defaults with global defaults
+            const allDefaultModels = Array.from(new Set([...DEFAULT_MODELS, ...globalDefaultModels]));
+            const { error: insertError } = await supabase
+                .from("user_ai_settings")
+                .insert({
+                owner_id: ownerId,
+                allowed_models: allDefaultModels,
+            });
+            if (insertError) {
+                logger.error("[ModelFilter] Failed to create default settings:", insertError);
+                // Continue anyway, model might still be in default list
+            }
+            // After creating settings, check if requested model is in default list OR global defaults
+            if (!DEFAULT_MODELS.includes(modelId) && !isGlobalDefault) {
+                return {
+                    allowed: false,
+                    error: `Model "${modelId}" is not enabled. Please enable it in your settings at /auth/ai/settings`,
+                };
+            }
+            // Model is in default list, fetch metadata
+            const gatewayModels = await fetchGatewayModels();
+            const model = findModelById(gatewayModels.providers, modelId);
+            if (!model) {
+                logger.warn(`[ModelFilter] Model ${modelId} not found in gateway`);
+                return {
+                    allowed: false,
+                    error: `Model "${modelId}" not found or unavailable`,
+                };
+            }
+            return {
+                allowed: true,
+                model,
+            };
+        }
+        // Parse allowed_models - can be array of strings or JSONB
+        let enabledModels = [];
+        if (settings?.allowed_models) {
+            if (Array.isArray(settings.allowed_models)) {
+                enabledModels = settings.allowed_models;
+            }
+            else if (typeof settings.allowed_models === "object") {
+                // Handle JSONB format: [{"provider":"openai","models":["gpt-4o-mini"]}]
+                enabledModels = settings.allowed_models.flatMap((item) => {
+                    if (item.models && Array.isArray(item.models)) {
+                        const provider = item.provider;
+                        return item.models.map((model) => `${provider}/${model}`);
+                    }
+                    return [];
+                });
+            }
+        }
+        // 3. If settings exist but empty, add default models + global defaults
+        if (enabledModels.length === 0) {
+            logger.info(`[ModelFilter] Empty allowed_models for user ${ownerId}, adding defaults`);
+            const allDefaultModels = Array.from(new Set([...DEFAULT_MODELS, ...globalDefaultModels]));
+            const { error: updateError } = await supabase
+                .from("user_ai_settings")
+                .update({
+                allowed_models: allDefaultModels,
+            })
+                .eq("owner_id", ownerId);
+            if (updateError) {
+                logger.error("[ModelFilter] Failed to update settings with defaults:", updateError);
+            }
+            enabledModels = allDefaultModels;
+        }
+        // 4. Check specific model filter - allow if in user settings OR global defaults
+        if (!enabledModels.includes(modelId) && !isGlobalDefault) {
+            logger.warn(`[ModelFilter] Model ${modelId} not enabled for user ${ownerId}`);
+            return {
+                allowed: false,
+                error: `Model "${modelId}" is not enabled for your account. Please enable it in your settings.`,
+            };
+        }
+        // If model is global default but not in user settings, add it
+        if (isGlobalDefault && !enabledModels.includes(modelId)) {
+            logger.info(`[ModelFilter] Adding global default model ${modelId} to user ${ownerId} settings`);
+            const updatedModels = Array.from(new Set([...enabledModels, modelId]));
+            const { error: updateError } = await supabase
+                .from("user_ai_settings")
+                .update({ allowed_models: updatedModels })
+                .eq("owner_id", ownerId);
+            if (updateError) {
+                logger.error("[ModelFilter] Failed to add global default to user settings:", updateError);
+            }
+        }
+        // 5. Model is allowed, fetch metadata
+        const gatewayModels = await fetchGatewayModels();
+        const model = findModelById(gatewayModels.providers, modelId);
+        if (!model) {
+            logger.warn(`[ModelFilter] Model ${modelId} not found in gateway`);
+            return {
+                allowed: false,
+                error: `Model "${modelId}" not found or unavailable`,
+            };
+        }
+        logger.debug(`[ModelFilter] Model ${modelId} allowed for user ${ownerId}`);
+        return {
+            allowed: true,
+            model,
+        };
+    }
+    catch (error) {
+        logger.error("[ModelFilter] Error checking model:", error);
+        return {
+            allowed: false,
+            error: `Failed to validate model: ${error.message}`,
+        };
+    }
+}
+/**
+ * Get list of enabled models for a user
+ */
+export async function getEnabledModels(ownerId) {
+    try {
+        const supabase = await getSupabaseServiceClient();
+        const { data: settings } = await supabase
+            .from("user_ai_settings")
+            .select("allowed_models")
+            .eq("owner_id", ownerId)
+            .single();
+        // Parse allowed_models
+        let enabledModelIds = [];
+        if (settings?.allowed_models) {
+            if (Array.isArray(settings.allowed_models)) {
+                enabledModelIds = settings.allowed_models;
+            }
+            else if (typeof settings.allowed_models === "object") {
+                // Handle JSONB format
+                enabledModelIds = settings.allowed_models.flatMap((item) => {
+                    if (item.models && Array.isArray(item.models)) {
+                        const provider = item.provider;
+                        return item.models.map((model) => `${provider}/${model}`);
+                    }
+                    return [];
+                });
+            }
+        }
+        // Fetch all models from gateway
+        const gatewayModels = await fetchGatewayModels();
+        // If no enabled models, return empty array (explicit enable required)
+        if (enabledModelIds.length === 0) {
+            return [];
+        }
+        // Filter by enabled models
+        const allModels = getAllModels(gatewayModels.providers);
+        return allModels.filter((model) => enabledModelIds.includes(model.id));
+    }
+    catch (error) {
+        logger.error("[ModelFilter] Error getting enabled models:", error);
+        return [];
+    }
+}
+/**
+ * Find a model by ID across all providers
+ */
+function findModelById(providers, modelId) {
+    for (const provider of providers) {
+        const model = provider.models.find((m) => m.id === modelId);
+        if (model) {
+            return model;
+        }
+    }
+    return undefined;
+}
+/**
+ * Get all models from all providers as flat array
+ */
+function getAllModels(providers) {
+    return providers.flatMap((p) => p.models);
+}
+/**
+ * Validate model and return error response if not allowed
+ */
+export function createModelNotAllowedError(modelId, error) {
+    return {
+        error: {
+            code: "MODEL_NOT_ALLOWED",
+            message: error,
+            model_id: modelId,
+        },
+        status: 403,
+    };
+}

package/dist/server/ocr.d.ts

@@ -0,0 +1,39 @@
+export interface ProcessOCRParams {
+    userId: string;
+    files: Array<{
+        name: string;
+        path: string;
+        extension: string;
+        bucket?: string;
+    }>;
+    mode: "verify" | "extract" | "verify_and_extract";
+    prompt: string;
+    extractionSchema?: Record<string, unknown>;
+    allowOverdraft?: boolean;
+}
+export interface OCRResult {
+    file_name: string;
+    file_path: string;
+    verified: boolean;
+    verification_message?: string;
+    extracted_data?: Record<string, unknown>;
+    confidence_score?: number;
+    processing_error?: string;
+}
+export interface ProcessOCRResponse {
+    success: boolean;
+    results: OCRResult[];
+    tokensUsed: number;
+    tokensRemaining?: number;
+    debitedFromQuota?: number;
+    debitedFromPurchased?: number;
+    remainingQuota?: number;
+    remainingPurchased?: number;
+    error?: string;
+}
+/**
+ * Process OCR using OpenAI Vision with proper token debit
+ * This function can be called directly by other modules
+ */
+export declare function processOCRWithTokens(params: ProcessOCRParams): Promise<ProcessOCRResponse>;
+//# sourceMappingURL=ocr.d.ts.map

package/dist/server/ocr.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ocr.d.ts","sourceRoot":"","sources":["../../src/server/ocr.ts"],"names":[],"mappings":"AAKA,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,KAAK,CAAC;QACX,IAAI,EAAE,MAAM,CAAC;QACb,IAAI,EAAE,MAAM,CAAC;QACb,SAAS,EAAE,MAAM,CAAC;QAClB,MAAM,CAAC,EAAE,MAAM,CAAC;KACjB,CAAC,CAAC;IACH,IAAI,EAAE,QAAQ,GAAG,SAAS,GAAG,oBAAoB,CAAC;IAClD,MAAM,EAAE,MAAM,CAAC;IACf,gBAAgB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC3C,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED,MAAM,WAAW,SAAS;IACxB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,OAAO,CAAC;IAClB,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACzC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,SAAS,EAAE,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;GAGG;AACH,wBAAsB,oBAAoB,CACxC,MAAM,EAAE,gBAAgB,GACvB,OAAO,CAAC,kBAAkB,CAAC,CAiU7B"}

package/dist/server/ocr.js

@@ -0,0 +1,280 @@
+import { getSupabaseServiceClient } from "@lastbrain/core/server";
+import { debitTokensWithPriority } from "./quota";
+import { generateText } from "ai";
+import { logger } from "@lastbrain/core";
+/**
+ * Process OCR using OpenAI Vision with proper token debit
+ * This function can be called directly by other modules
+ */
+export async function processOCRWithTokens(params) {
+    const { userId, files, mode, prompt, extractionSchema, allowOverdraft = false, } = params;
+    try {
+        const supabase = getSupabaseServiceClient();
+        if (!files || files.length === 0) {
+            return {
+                success: false,
+                results: [],
+                tokensUsed: 0,
+                error: "Aucun fichier à traiter",
+            };
+        }
+        if (!prompt) {
+            return {
+                success: false,
+                results: [],
+                tokensUsed: 0,
+                error: "Le prompt est requis",
+            };
+        }
+        // Estimate tokens needed (conservative: ~500 tokens per image)
+        const estimatedTokensPerFile = 500;
+        const estimatedTokensNeeded = files.length * estimatedTokensPerFile;
+        // Pre-check balance/quota
+        const { data: balanceData } = await supabase
+            .from("user_token_balance_v")
+            .select("balance")
+            .eq("owner_id", userId)
+            .single();
+        const purchasedBalance = balanceData?.balance || 0;
+        const { data: quotaData } = await supabase
+            .from("user_token_quota_monthly")
+            .select("effective_included_tokens, used_included_tokens, period_start, period_end")
+            .eq("owner_id", userId)
+            .single();
+        let remainingQuota = 0;
+        if (quotaData) {
+            const now = new Date();
+            const periodStart = quotaData.period_start
+                ? new Date(quotaData.period_start)
+                : null;
+            const periodEnd = quotaData.period_end
+                ? new Date(quotaData.period_end)
+                : null;
+            const isActive = periodStart && periodEnd && now >= periodStart && now <= periodEnd;
+            if (isActive) {
+                remainingQuota = Math.max(0, quotaData.effective_included_tokens -
+                    (quotaData.used_included_tokens || 0));
+            }
+        }
+        if (purchasedBalance < 0 && !allowOverdraft) {
+            return {
+                success: false,
+                results: [],
+                tokensUsed: 0,
+                error: "Solde insuffisant (compte en négatif). Veuillez recharger.",
+            };
+        }
+        if (purchasedBalance + remainingQuota < estimatedTokensNeeded &&
+            !allowOverdraft) {
+            return {
+                success: false,
+                results: [],
+                tokensUsed: 0,
+                error: "Solde insuffisant pour traiter les fichiers OCR.",
+            };
+        }
+        // Process each file
+        const results = [];
+        let totalTokensUsed = 0;
+        const model = "openai/gpt-4o"; // Use string model ID for Vercel AI Gateway
+        for (const file of files) {
+            try {
+                // Skip non-image files
+                const imageExtensions = ["jpg", "jpeg", "png", "webp", "gif"];
+                if (!imageExtensions.includes(file.extension.toLowerCase())) {
+                    results.push({
+                        file_name: file.name,
+                        file_path: file.path,
+                        verified: false,
+                        processing_error: `Type de fichier non supporté: ${file.extension}. Seules les images sont supportées pour l'OCR.`,
+                    });
+                    continue;
+                }
+                // Download file from Supabase Storage
+                const bucket = file.bucket || "app";
+                const { data: fileData, error: downloadError } = await supabase.storage
+                    .from(bucket)
+                    .download(file.path);
+                if (downloadError || !fileData) {
+                    logger.error(`Error downloading file ${file.path}:`, downloadError);
+                    results.push({
+                        file_name: file.name,
+                        file_path: file.path,
+                        verified: false,
+                        processing_error: "Impossible de télécharger le fichier",
+                    });
+                    continue;
+                }
+                // Convert file to base64
+                const buffer = await fileData.arrayBuffer();
+                const base64 = Buffer.from(buffer).toString("base64");
+                const imageUrl = `data:image/${file.extension};base64,${base64}`;
+                // Build prompt based on mode
+                let systemPrompt = "";
+                let userPrompt = prompt;
+                if (mode === "verify") {
+                    systemPrompt =
+                        "Tu es un expert en vérification de documents. Analyse l'image et vérifie si elle correspond aux critères demandés.";
+                    userPrompt +=
+                        "\n\nRéponds au format JSON avec les champs: verified (boolean), message (string), confidence (0-1)";
+                }
+                else if (mode === "extract") {
+                    systemPrompt =
+                        "Tu es un expert en extraction de données depuis des documents. Analyse l'image et extrait les informations demandées.";
+                    userPrompt += `\n\nRéponds au format JSON avec les champs extraits selon ce schéma: ${JSON.stringify(extractionSchema)}`;
+                }
+                else {
+                    // verify_and_extract
+                    systemPrompt =
+                        "Tu es un expert en vérification et extraction de données depuis des documents.";
+                    userPrompt += `\n\nRéponds au format JSON avec:
+- verified (boolean): si le document correspond aux critères
+- message (string): message de vérification
+- confidence (0-1): niveau de confiance
+- data (object): données extraites selon ce schéma: ${JSON.stringify(extractionSchema)}`;
+                }
+                // Call Vercel AI SDK Vision API with correct message format
+                const completion = await generateText({
+                    model: model,
+                    messages: [
+                        {
+                            role: "system",
+                            content: systemPrompt,
+                        },
+                        {
+                            role: "user",
+                            content: [
+                                { type: "text", text: userPrompt },
+                                {
+                                    type: "image",
+                                    image: imageUrl,
+                                },
+                            ],
+                        },
+                    ],
+                    temperature: 0.1,
+                });
+                const content = completion.text;
+                const tokensUsed = completion.usage?.totalTokens || 0;
+                totalTokensUsed += tokensUsed;
+                if (!content) {
+                    results.push({
+                        file_name: file.name,
+                        file_path: file.path,
+                        verified: false,
+                        processing_error: "Aucune réponse de l'API",
+                    });
+                    continue;
+                }
+                // Parse JSON response
+                try {
+                    const parsed = JSON.parse(content);
+                    if (mode === "verify") {
+                        results.push({
+                            file_name: file.name,
+                            file_path: file.path,
+                            verified: parsed.verified || false,
+                            verification_message: parsed.message,
+                            confidence_score: parsed.confidence,
+                        });
+                    }
+                    else if (mode === "extract") {
+                        results.push({
+                            file_name: file.name,
+                            file_path: file.path,
+                            verified: true,
+                            extracted_data: parsed,
+                        });
+                    }
+                    else {
+                        // verify_and_extract
+                        results.push({
+                            file_name: file.name,
+                            file_path: file.path,
+                            verified: parsed.verified || false,
+                            verification_message: parsed.message,
+                            confidence_score: parsed.confidence,
+                            extracted_data: parsed.data || {},
+                        });
+                    }
+                }
+                catch (parseError) {
+                    logger.error(`Error parsing OCR response for ${file.name}:`, parseError);
+                    results.push({
+                        file_name: file.name,
+                        file_path: file.path,
+                        verified: false,
+                        processing_error: "Erreur lors du parsing de la réponse",
+                    });
+                }
+            }
+            catch (error) {
+                logger.error(`Error processing OCR for ${file.name}:`, error);
+                results.push({
+                    file_name: file.name,
+                    file_path: file.path,
+                    verified: false,
+                    processing_error: error instanceof Error ? error.message : "Erreur inconnue",
+                });
+            }
+        }
+        // Debit tokens using the same system as generate-text
+        if (totalTokensUsed > 0) {
+            // Calculate cost for gpt-4o vision
+            // gpt-4o: $2.50/1M input, $10/1M output
+            const inputTokens = Math.floor(totalTokensUsed * 0.4); // Approximate (images are input)
+            const outputTokens = Math.floor(totalTokensUsed * 0.6);
+            const cost = (inputTokens / 1_000_000) * 2.5 + (outputTokens / 1_000_000) * 10;
+            const tokenResult = await debitTokensWithPriority(userId, totalTokensUsed, "gpt-4o", `OCR processing: ${files.length} files`, {
+                inputTokens,
+                outputTokens,
+                cost,
+                generatedText: `OCR results for ${files.length} files`,
+                allowOverdraft,
+            });
+            if (!tokenResult.success) {
+                return {
+                    success: false,
+                    results,
+                    tokensUsed: totalTokensUsed,
+                    error: tokenResult.error ||
+                        "Erreur lors de la déduction des tokens (quota/achat)",
+                };
+            }
+            const tokensRemainingTotal = tokenResult.remainingQuota + tokenResult.remainingPurchased;
+            return {
+                success: true,
+                results,
+                tokensUsed: totalTokensUsed,
+                tokensRemaining: tokensRemainingTotal,
+                debitedFromQuota: tokenResult.debitedFromQuota,
+                debitedFromPurchased: tokenResult.debitedFromPurchased,
+                remainingQuota: tokenResult.remainingQuota,
+                remainingPurchased: tokenResult.remainingPurchased,
+            };
+        }
+        return {
+            success: true,
+            results,
+            tokensUsed: 0,
+        };
+    }
+    catch (error) {
+        logger.error("Erreur de traitement OCR:", error);
+        const err = error;
+        if (err.code === "insufficient_quota") {
+            return {
+                success: false,
+                results: [],
+                tokensUsed: 0,
+                error: "Quota IA dépassé. Contactez l'administrateur.",
+            };
+        }
+        return {
+            success: false,
+            results: [],
+            tokensUsed: 0,
+            error: err.message || "Erreur lors du traitement OCR",
+        };
+    }
+}

package/dist/server/openai-client.d.ts

@@ -0,0 +1,19 @@
+import OpenAI from "openai";
+/**
+ * Obtenir le client OpenAI (singleton)
+ */
+export declare function getOpenAIClient(): OpenAI;
+export interface ChatCompletionParams {
+    model?: string;
+    messages: OpenAI.Chat.ChatCompletionMessageParam[];
+    temperature?: number;
+    max_tokens?: number;
+    response_format?: {
+        type: "json_object" | "text";
+    };
+}
+/**
+ * Appeler OpenAI Chat Completion avec les paramètres fournis
+ */
+export declare function createChatCompletion(params: ChatCompletionParams): Promise<OpenAI.Chat.ChatCompletion>;
+//# sourceMappingURL=openai-client.d.ts.map

package/dist/server/openai-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openai-client.d.ts","sourceRoot":"","sources":["../../src/server/openai-client.ts"],"names":[],"mappings":"AAAA,OAAO,MAAM,MAAM,QAAQ,CAAC;AAI5B;;GAEG;AACH,wBAAgB,eAAe,IAAI,MAAM,CAOxC;AAED,MAAM,WAAW,oBAAoB;IACnC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC,IAAI,CAAC,0BAA0B,EAAE,CAAC;IACnD,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,eAAe,CAAC,EAAE;QAAE,IAAI,EAAE,aAAa,GAAG,MAAM,CAAA;KAAE,CAAC;CACpD;AAED;;GAEG;AACH,wBAAsB,oBAAoB,CACxC,MAAM,EAAE,oBAAoB,GAC3B,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,CAUrC"}