@lastbrain/module-ai 2.0.26 → 2.0.30

package/dist/server/billing.js

@@ -0,0 +1,488 @@
+/**
+ * Core billing functions for wallet-based AI token system
+ *
+ * RÈGLE ÉCONOMIQUE FONDAMENTALE :
+ * ================================
+ * Un pack vendu X$ donne un budget fournisseur limité (ex: 5$ vendu => 2$ budget provider)
+ * Le reste (3$) = marge + infrastructure.
+ *
+ * L'utilisateur NE PEUT PAS générer des milliers de recettes pour 5$.
+ * Le système ne doit JAMAIS permettre d'être à perte.
+ *
+ * Pour garantir cela, CHAQUE action a un coût minimum de vente (minSellUsd):
+ * - generate-recipe-text: min 0.20$ (action à forte valeur)
+ * - generate-image: min calculé selon le modèle
+ * - autocomplete UI (input/textarea): min 0$ (micro-calls)
+ *
+ * Le calcul de marge cible est 60% sur le prix de vente:
+ * sellCostUsd = providerCostUsd / (1 - 0.60) = providerCostUsd / 0.40
+ *
+ * MAIS on respecte TOUJOURS la contrainte pack:
+ * - on ne peut pas dépasser le budget provider restant
+ * - on applique le minimum par action si configuré
+ */
+// ============================================================================
+// CORE FUNCTIONS
+// ============================================================================
+/**
+ * Compute provider cost in USD from usage and pricing
+ * @param usage Actual tokens/images used
+ * @param pricing Provider pricing ($/token, $/image)
+ * @returns Total provider cost in USD
+ */
+export function computeProviderCostUsd(usage, pricing) {
+    let cost = 0;
+    console.log("[BILLING] computeProviderCostUsd START", {
+        usage,
+        pricing,
+    });
+    // Input tokens
+    if (usage.inputTokens && pricing.inputUsdPerToken) {
+        const inputCost = usage.inputTokens * pricing.inputUsdPerToken;
+        console.log("[BILLING] Input tokens cost:", {
+            inputTokens: usage.inputTokens,
+            inputUsdPerToken: pricing.inputUsdPerToken,
+            inputCost,
+        });
+        cost += inputCost;
+    }
+    // Output tokens
+    if (usage.outputTokens && pricing.outputUsdPerToken) {
+        const outputCost = usage.outputTokens * pricing.outputUsdPerToken;
+        console.log("[BILLING] Output tokens cost:", {
+            outputTokens: usage.outputTokens,
+            outputUsdPerToken: pricing.outputUsdPerToken,
+            outputCost,
+        });
+        cost += outputCost;
+    }
+    // Cache read tokens
+    if (usage.cacheReadTokens && pricing.cacheReadUsdPerToken) {
+        const cacheCost = usage.cacheReadTokens * pricing.cacheReadUsdPerToken;
+        console.log("[BILLING] Cache read tokens cost:", {
+            cacheReadTokens: usage.cacheReadTokens,
+            cacheReadUsdPerToken: pricing.cacheReadUsdPerToken,
+            cacheCost,
+        });
+        cost += cacheCost;
+    }
+    // Web search
+    if (usage.webSearchUnits && pricing.webSearchUsdPerUnit) {
+        const searchCost = usage.webSearchUnits * pricing.webSearchUsdPerUnit;
+        console.log("[BILLING] Web search cost:", {
+            webSearchUnits: usage.webSearchUnits,
+            webSearchUsdPerUnit: pricing.webSearchUsdPerUnit,
+            searchCost,
+        });
+        cost += searchCost;
+    }
+    // Images
+    if (usage.images && pricing.imageUsdPerImage) {
+        const imageCost = usage.images * pricing.imageUsdPerImage;
+        console.log("[BILLING] Images cost:", {
+            images: usage.images,
+            imageUsdPerImage: pricing.imageUsdPerImage,
+            imageCost,
+        });
+        cost += imageCost;
+    }
+    const roundedCost = roundUsd(cost);
+    console.log("[BILLING] computeProviderCostUsd RESULT:", {
+        rawCost: cost,
+        roundedCost,
+    });
+    return roundedCost;
+}
+/**
+ * Compute token debit from wallet (with automatic margin smoothing)
+ * @param wallet Current wallet state
+ * @param providerCostUsd Provider cost for this transaction
+ * @returns Debit details (tokens, sell value, margin)
+ */
+export function computeDebitFromWallet(wallet, providerCostUsd) {
+    console.log("[BILLING] computeDebitFromWallet START", {
+        wallet,
+        providerCostUsd,
+    });
+    // Validate wallet state
+    if (wallet.tokenBalance <= 0) {
+        throw new Error("Insufficient token balance");
+    }
+    // FALLBACK: If wallet is at 0 USD but tokens exist (legacy credits, manual edits, etc.)
+    // Use default pack_coef = 1.35 (35% margin) to compute rates
+    const DEFAULT_PACK_COEF = 1.35;
+    const hasWalletBudget = wallet.walletProviderBudgetUsd > 0 && wallet.walletSellValueUsd > 0;
+    let usdProviderPerToken;
+    let usdSellPerToken;
+    console.log("[BILLING] Wallet budget status:", {
+        hasWalletBudget,
+        walletProviderBudgetUsd: wallet.walletProviderBudgetUsd,
+        walletSellValueUsd: wallet.walletSellValueUsd,
+        tokenBalance: wallet.tokenBalance,
+    });
+    if (hasWalletBudget) {
+        // Normal case: use smoothed rates from wallet
+        usdProviderPerToken = wallet.walletProviderBudgetUsd / wallet.tokenBalance;
+        usdSellPerToken = wallet.walletSellValueUsd / wallet.tokenBalance;
+        console.log("[BILLING] Using wallet smoothed rates:", {
+            usdProviderPerToken,
+            usdSellPerToken,
+            margin: ((usdSellPerToken - usdProviderPerToken) / usdSellPerToken) * 100 + "%",
+        });
+    }
+    else {
+        // Fallback case: reconstruct rates using default coef
+        // Assume token price = provider cost × coef
+        // We estimate: 1 token ≈ $0.00005 sell (typical for 100K @ $5)
+        const FALLBACK_USD_SELL_PER_TOKEN = 0.00005;
+        usdSellPerToken = FALLBACK_USD_SELL_PER_TOKEN;
+        usdProviderPerToken = usdSellPerToken / DEFAULT_PACK_COEF;
+        console.log("[BILLING] Using fallback rates:", {
+            DEFAULT_PACK_COEF,
+            FALLBACK_USD_SELL_PER_TOKEN,
+            usdProviderPerToken,
+            usdSellPerToken,
+            margin: ((usdSellPerToken - usdProviderPerToken) / usdSellPerToken) * 100 + "%",
+        });
+    }
+    // Compute tokens to debit (round up)
+    const debitTokens = Math.ceil(providerCostUsd / usdProviderPerToken);
+    // Compute sell value and margin
+    const sellUsd = roundUsd(debitTokens * usdSellPerToken);
+    const marginUsd = roundUsd(sellUsd - providerCostUsd);
+    console.log("[BILLING] Debit calculation:", {
+        providerCostUsd,
+        usdProviderPerToken,
+        debitTokens,
+        usdSellPerToken,
+        sellUsd,
+        marginUsd,
+        marginPercent: ((marginUsd / sellUsd) * 100).toFixed(2) + "%",
+    });
+    // Safety check
+    if (debitTokens > wallet.tokenBalance) {
+        throw new Error(`Insufficient balance: need ${debitTokens}, have ${wallet.tokenBalance}`);
+    }
+    console.log("[BILLING] computeDebitFromWallet RESULT:", {
+        debitTokens,
+        sellUsd,
+        marginUsd,
+        usdProviderPerToken: roundUsd(usdProviderPerToken),
+        usdSellPerToken: roundUsd(usdSellPerToken),
+    });
+    return {
+        debitTokens,
+        sellUsd,
+        marginUsd,
+        usdProviderPerToken: roundUsd(usdProviderPerToken),
+        usdSellPerToken: roundUsd(usdSellPerToken),
+    };
+}
+/**
+ * Compute wallet update for pack purchase
+ * @param pack Pack details (tokens, price, coef)
+ * @returns Wallet deltas to add
+ */
+export function computeWalletUpdateForPurchase(pack) {
+    // Provider budget = what we can spend on provider APIs
+    const providerBudgetAddedUsd = roundUsd(pack.packPriceUsd / pack.packCoef);
+    // Sell value = what user paid (our revenue)
+    const sellValueAddedUsd = roundUsd(pack.packPriceUsd);
+    return {
+        providerBudgetAddedUsd,
+        sellValueAddedUsd,
+    };
+}
+/**
+ * Estimate debit tokens for display (using pack coef)
+ * Useful for public pricing page before user has wallet
+ * @param providerCostUsd Provider cost
+ * @param packCoef Pack margin coefficient
+ * @param packTokens Pack size
+ * @param packPriceUsd Pack price
+ * @returns Estimated tokens
+ */
+export function estimateDebitTokens(providerCostUsd, packCoef, packTokens, packPriceUsd) {
+    // Simulate wallet rates for this pack
+    const providerBudgetUsd = packPriceUsd / packCoef;
+    const usdProviderPerToken = providerBudgetUsd / packTokens;
+    return Math.ceil(providerCostUsd / usdProviderPerToken);
+}
+// ============================================================================
+// UTILITIES
+// ============================================================================
+/**
+ * Round USD to 10 decimals (handles nano-dollar precision)
+ */
+function roundUsd(value) {
+    return Math.round(value * 10_000_000_000) / 10_000_000_000;
+}
+/**
+ * Validate that pricing has required fields for usage type
+ */
+export function validatePricing(pricing, usageType) {
+    if (usageType === "image") {
+        return pricing.imageUsdPerImage !== undefined;
+    }
+    return (pricing.inputUsdPerToken !== undefined ||
+        pricing.outputUsdPerToken !== undefined);
+}
+/**
+ * Minimum sell cost per action type (USD)
+ * Ces minimums garantissent qu'on ne sera jamais à perte
+ * et que les actions à forte valeur ajoutée sont facturées correctement
+ */
+const ACTION_MIN_SELL_USD = {
+    "generate-recipe-text": 0.1, // Génération complète de recette : min 0.10$
+    "generate-image": 0.1, // Génération image : min 0.10$
+    "generate-text": 0.001, // Génération texte générique : min 0.001$ (évite coûts quasi-nuls)
+    autocomplete: 0.0, // Autocomplétion UI : micro-calls, pas de minimum
+    "suggestion-input": 0.0, // Suggestions : micro-calls
+    "suggestion-textarea": 0.0, // Suggestions : micro-calls
+};
+/**
+ * Get minimum sell cost for action type
+ */
+function getActionMinSellUsd(actionType) {
+    return ACTION_MIN_SELL_USD[actionType] || 0;
+}
+/**
+ * Get current wallet state for a user
+ * CENTRALIZED - This is the single source of truth for wallet state
+ */
+export async function getWalletState(userId) {
+    const { getSupabaseServiceClient } = await import("@lastbrain/core/server");
+    const { logger } = await import("@lastbrain/core");
+    const supabase = await getSupabaseServiceClient();
+    logger.info(`[getWalletState] Fetching wallet for user: ${userId}`);
+    // Get token balance (ledger uses owner_id not user_id)
+    const { data: ledgerData, error: ledgerError } = await supabase
+        .from("user_token_ledger")
+        .select("amount")
+        .eq("owner_id", userId);
+    if (ledgerError) {
+        logger.error("[getWalletState] Error fetching ledger:", ledgerError);
+        throw new Error("Failed to fetch token balance");
+    }
+    const tokenBalance = (ledgerData || []).reduce((sum, row) => sum + (row.amount || 0), 0);
+    logger.info(`[getWalletState] Token balance for user ${userId}: ${tokenBalance}`);
+    // Get wallet USD values (wallet uses user_id)
+    const { data: walletData, error: walletError } = await supabase
+        .from("user_token_wallet")
+        .select("wallet_provider_budget_usd, wallet_sell_value_usd")
+        .eq("user_id", userId)
+        .single();
+    logger.info(`[getWalletState] Wallet query result - data: ${JSON.stringify(walletData)}, error: ${JSON.stringify(walletError)}`);
+    if (walletError || !walletData) {
+        logger.warn(`[getWalletState] No wallet found for user ${userId}, creating new wallet`);
+        // Initialize wallet
+        const { data: insertData, error: insertError } = await supabase
+            .from("user_token_wallet")
+            .insert({
+            user_id: userId,
+            wallet_provider_budget_usd: 0,
+            wallet_sell_value_usd: 0,
+        })
+            .select()
+            .single();
+        logger.info(`[getWalletState] Insert result - data: ${JSON.stringify(insertData)}, error: ${JSON.stringify(insertError)}`);
+        return {
+            tokenBalance,
+            walletProviderBudgetUsd: 0,
+            walletSellValueUsd: 0,
+        };
+    }
+    const result = {
+        tokenBalance,
+        walletProviderBudgetUsd: parseFloat(walletData.wallet_provider_budget_usd.toString()),
+        walletSellValueUsd: parseFloat(walletData.wallet_sell_value_usd.toString()),
+    };
+    logger.info(`[getWalletState] Returning wallet state for user ${userId}: ${JSON.stringify(result)}`);
+    return result;
+}
+/**
+ * FONCTION CENTRALE DE BILLING
+ * ============================
+ * Calcule et débite l'utilisation IA selon les règles économiques.
+ *
+ * Cette fonction est la SEULE source de vérité pour tous les calculs de billing.
+ * Elle est appelée par TOUS les endpoints (generate-text, generate-image, recipes, etc.)
+ *
+ * RÈGLES DE CALCUL :
+ * 1. Marge cible = 60% du prix de vente
+ *    => sellCostUsd = providerCostUsd / (1 - 0.60) = providerCostUsd / 0.40 = providerCostUsd * 2.5
+ *
+ * 2. Minimum par action (si configuré)
+ *    => sellCostUsd = max(sellCostUsd calculé, minSellUsd)
+ *
+ * 3. Contrainte budget provider
+ *    => on ne peut jamais débiter plus que le budget provider restant
+ *
+ * 4. Arrondi safe (ceil) pour éviter sous-facturation
+ *
+ * LOGGING : log ANONYME de chaque débit pour contrôle
+ */
+export function computeAndDebitAIUsage(params) {
+    const { userId, actionType, providerCostUsd, wallet, metadata, minSellUsdOverride, } = params;
+    // Hash user ID for anonymous logging (first 8 chars)
+    const userHash = userId.substring(0, 8);
+    // 1. Calculate initial costs
+    // Formula: sellCost = providerCost / (1 - margin%) = providerCost / 0.40
+    const MARGIN_TARGET = 0.6; // 60% margin on sell price
+    let sellCostUsd = providerCostUsd / (1 - MARGIN_TARGET);
+    let adjustedProviderCostUsd = providerCostUsd;
+    // 2. Apply minimum sell cost for action type
+    const minSellUsd = minSellUsdOverride !== undefined
+        ? minSellUsdOverride
+        : getActionMinSellUsd(actionType);
+    if (sellCostUsd < minSellUsd) {
+        sellCostUsd = minSellUsd;
+        // IMPORTANT: When minimum is applied, recalculate provider cost proportionally
+        // to maintain the 60% margin: providerCost = sellCost * (1 - 0.60) = sellCost * 0.40
+        adjustedProviderCostUsd = sellCostUsd * (1 - MARGIN_TARGET);
+    }
+    // 3. Round up (safe rounding to avoid under-charging)
+    sellCostUsd = Math.ceil(sellCostUsd * 1_000_000) / 1_000_000;
+    adjustedProviderCostUsd =
+        Math.ceil(adjustedProviderCostUsd * 1_000_000) / 1_000_000;
+    // 4. Check provider budget sufficiency (use adjusted cost)
+    if (wallet.walletProviderBudgetUsd < adjustedProviderCostUsd) {
+        const errorMsg = `Insufficient provider budget: have $${wallet.walletProviderBudgetUsd.toFixed(6)}, need $${adjustedProviderCostUsd.toFixed(6)}`;
+        console.error(`[BILLING] user=${userHash} action=${actionType} ERROR: ${errorMsg}`);
+        return {
+            success: false,
+            error: "insufficient_credits",
+        };
+    }
+    // 5. Check sell budget sufficiency
+    if (wallet.walletSellValueUsd < sellCostUsd) {
+        const errorMsg = `Insufficient sell value: have $${wallet.walletSellValueUsd.toFixed(6)}, need $${sellCostUsd.toFixed(6)}`;
+        console.error(`[BILLING] user=${userHash} action=${actionType} ERROR: ${errorMsg}`);
+        return {
+            success: false,
+            error: "insufficient_credits",
+        };
+    }
+    // 6. Calculate margin (use adjusted provider cost)
+    const marginUsd = roundUsd(sellCostUsd - adjustedProviderCostUsd);
+    const marginPercent = sellCostUsd > 0 ? (marginUsd / sellCostUsd) * 100 : 0;
+    // 7. Calculate new wallet state (debit adjusted provider cost)
+    const newProviderBudget = wallet.walletProviderBudgetUsd - adjustedProviderCostUsd;
+    const newSellValue = wallet.walletSellValueUsd - sellCostUsd;
+    const percentRemaining = wallet.walletSellValueUsd > 0
+        ? (newSellValue / wallet.walletSellValueUsd) * 100
+        : 0;
+    // 8. Calculate tokens debited (for backward compatibility with ledger)
+    // Use current wallet rates
+    const tokensDebited = wallet.tokenBalance > 0 && wallet.walletSellValueUsd > 0
+        ? Math.ceil((sellCostUsd / wallet.walletSellValueUsd) * wallet.tokenBalance)
+        : 0;
+    // 9. ANONYMOUS LOGGING (no prompt, no content)
+    console.log(`[BILLING] user=${userHash} action=${actionType} ` +
+        `model=${metadata.model || "unknown"} ` +
+        `provider=${metadata.provider || "unknown"} ` +
+        `adjustedCost=$${adjustedProviderCostUsd.toFixed(6)} ` +
+        `sell=$${sellCostUsd.toFixed(6)} ` +
+        `margin=$${marginUsd.toFixed(6)} (${marginPercent.toFixed(2)}%) ` +
+        `providerLeft=$${newProviderBudget.toFixed(6)} ` +
+        `sellLeft=$${newSellValue.toFixed(6)} ` +
+        `remaining=${percentRemaining.toFixed(1)}%`);
+    return {
+        success: true,
+        sellCostUsd,
+        providerCostUsd: adjustedProviderCostUsd, // Return adjusted cost for ledger
+        marginUsd,
+        marginPercent,
+        tokensDebited,
+        newWallet: {
+            walletProviderBudgetUsd: newProviderBudget,
+            walletSellValueUsd: newSellValue,
+            percentRemaining,
+        },
+    };
+}
+// ============================================================================
+// ADMIN WALLET CREDITS MANAGEMENT
+// ============================================================================
+/**
+ * Add wallet credits to a user (admin function)
+ * Adds both provider budget and sell value proportionally
+ * @param userId User ID
+ * @param sellValueUsd Amount in USD to add to sell value
+ * @param reason Admin reason for adding credits
+ * @returns Success status and new wallet state
+ */
+export async function addWalletCredits(userId, sellValueUsd, reason) {
+    const { getSupabaseServiceClient } = await import("@lastbrain/core/server");
+    const { logger } = await import("@lastbrain/core");
+    const supabase = await getSupabaseServiceClient();
+    try {
+        // Calculate provider budget proportionally (40% of sell value for 60% margin)
+        const MARGIN_TARGET = 0.6;
+        const providerBudgetUsd = sellValueUsd * (1 - MARGIN_TARGET); // 40% goes to provider
+        // Insert into ledger
+        const { error: ledgerError } = await supabase
+            .from("user_token_ledger")
+            .insert({
+            owner_id: userId,
+            type: "gift", // Manual credit addition by admin (gift from admin)
+            amount: 0, // Tokens not used anymore, but keep for backward compat
+            sell_value_added_usd: sellValueUsd,
+            provider_budget_added_usd: providerBudgetUsd,
+            meta: {
+                reason,
+                admin_action: true,
+            },
+        });
+        if (ledgerError) {
+            logger.error("[addWalletCredits] Ledger insert error:", ledgerError);
+            return { success: false, error: ledgerError.message };
+        }
+        // Update wallet table - First, get current wallet values
+        const { data: currentWallet } = await supabase
+            .from("user_token_wallet")
+            .select("wallet_provider_budget_usd, wallet_sell_value_usd")
+            .eq("user_id", userId)
+            .single();
+        // Calculate new values
+        const newProviderBudget = (currentWallet?.wallet_provider_budget_usd || 0) + providerBudgetUsd;
+        const newSellValue = (currentWallet?.wallet_sell_value_usd || 0) + sellValueUsd;
+        // Upsert wallet
+        const { error: upsertError } = await supabase
+            .from("user_token_wallet")
+            .upsert({
+            user_id: userId,
+            wallet_provider_budget_usd: newProviderBudget,
+            wallet_sell_value_usd: newSellValue,
+            updated_at: new Date().toISOString(),
+        }, {
+            onConflict: "user_id",
+        });
+        if (upsertError) {
+            logger.error("[addWalletCredits] Wallet update error:", upsertError);
+            return { success: false, error: upsertError.message };
+        }
+        // Get new balance from wallet view
+        const { data: walletData, error: walletError } = await supabase
+            .from("user_token_wallet")
+            .select("wallet_sell_value_usd")
+            .eq("user_id", userId)
+            .single();
+        if (walletError || !walletData) {
+            logger.error("[addWalletCredits] Wallet query error:", walletError);
+            return {
+                success: false,
+                error: walletError?.message || "Wallet not found",
+            };
+        }
+        logger.info(`[addWalletCredits] Added $${sellValueUsd} to user ${userId}, new balance: $${walletData.wallet_sell_value_usd}`);
+        return {
+            success: true,
+            newBalance: walletData.wallet_sell_value_usd,
+        };
+    }
+    catch (error) {
+        logger.error("[addWalletCredits] Error:", error);
+        return { success: false, error: error.message };
+    }
+}

package/dist/server/gateway-service.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Service for fetching and caching AI models from Vercel AI Gateway
+ */
+import type { GatewayModelsResponse } from "../types/gateway";
+/**
+ * Fetch models from Vercel AI Gateway with fallback cache
+ */
+export declare function fetchGatewayModels(): Promise<GatewayModelsResponse>;
+/**
+ * Clear cache (useful for testing or manual refresh)
+ */
+export declare function clearGatewayCache(): void;
+//# sourceMappingURL=gateway-service.d.ts.map

package/dist/server/gateway-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gateway-service.d.ts","sourceRoot":"","sources":["../../src/server/gateway-service.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,KAAK,EACV,qBAAqB,EAGtB,MAAM,kBAAkB,CAAC;AAU1B;;GAEG;AACH,wBAAsB,kBAAkB,IAAI,OAAO,CAAC,qBAAqB,CAAC,CA0DzE;AAiHD;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,IAAI,CAGxC"}

package/dist/server/gateway-service.js

@@ -0,0 +1,161 @@
+/**
+ * Service for fetching and caching AI models from Vercel AI Gateway
+ */
+import { logger } from "@lastbrain/core";
+const GATEWAY_BASE_URL = process.env.AI_GATEWAY_BASE_URL || "https://ai-gateway.vercel.sh";
+const CACHE_TTL_MS = 60 * 60 * 1000; // 1 hour
+// In-memory cache fallback
+let cachedModels = null;
+let cacheTimestamp = null;
+/**
+ * Fetch models from Vercel AI Gateway with fallback cache
+ */
+export async function fetchGatewayModels() {
+    const now = Date.now();
+    // Check if cache is still valid
+    if (cachedModels && cacheTimestamp && now - cacheTimestamp < CACHE_TTL_MS) {
+        logger.debug("[Gateway] Returning cached models (still valid)");
+        return cachedModels;
+    }
+    try {
+        const response = await fetch(`${GATEWAY_BASE_URL}/v1/models`, {
+            method: "GET",
+            headers: {
+                "Content-Type": "application/json",
+            },
+            // Timeout after 10 seconds
+            signal: AbortSignal.timeout(10000),
+        });
+        if (!response.ok) {
+            throw new Error(`Gateway returned ${response.status}: ${response.statusText}`);
+        }
+        const data = await response.json();
+        // Transform gateway response to our format
+        const transformed = transformGatewayResponse(data);
+        // Update cache
+        cachedModels = transformed;
+        cacheTimestamp = now;
+        return transformed;
+    }
+    catch (error) {
+        logger.error("[Gateway] Failed to fetch models:", error);
+        // Return stale cache if available
+        if (cachedModels) {
+            return {
+                ...cachedModels,
+                stale: true,
+                cached_at: cacheTimestamp
+                    ? new Date(cacheTimestamp).toISOString()
+                    : undefined,
+            };
+        }
+        // No cache available, return empty response
+        logger.error("[Gateway] No cache available, returning empty providers list");
+        return {
+            providers: [],
+            stale: true,
+        };
+    }
+}
+/**
+ * Transform gateway API response to our internal format
+ */
+function transformGatewayResponse(data) {
+    // Gateway response format: { object: "list", data: [...models] }
+    const providers = [];
+    // Try data.data first (Vercel Gateway format), fallback to data.models
+    const modelsArray = data.data || data.models || [];
+    if (Array.isArray(modelsArray) && modelsArray.length > 0) {
+        // Group models by provider
+        const providerMap = new Map();
+        for (const model of modelsArray) {
+            const modelData = {
+                id: model.id || model.model_id,
+                name: model.name || model.display_name || model.id,
+                description: model.description,
+                type: model.type || inferModelType(model.id),
+                provider: extractProvider(model.id),
+                context_window: model.context_window || model.context_length,
+                max_tokens: model.max_output_tokens || model.max_tokens,
+                pricing: model.pricing
+                    ? {
+                        input: model.pricing.input || model.pricing.prompt || 0,
+                        output: model.pricing.output || model.pricing.completion || 0,
+                        image: model.pricing.image,
+                        request: model.pricing.request,
+                        web_search: model.pricing.web_search,
+                    }
+                    : undefined,
+                tags: model.tags || [],
+                supports_tools: model.supports_tools || model.supports_function_calling,
+                supports_vision: model.supports_vision || model.modalities?.includes("vision"),
+            };
+            const providerName = modelData.provider;
+            if (!providerMap.has(providerName)) {
+                providerMap.set(providerName, []);
+            }
+            providerMap.get(providerName).push(modelData);
+        }
+        // Convert map to providers array
+        for (const [providerName, models] of providerMap) {
+            providers.push({
+                name: providerName,
+                display_name: formatProviderName(providerName),
+                models,
+            });
+        }
+    }
+    return { providers };
+}
+/**
+ * Extract provider name from model ID (e.g., "openai/gpt-4" -> "openai")
+ */
+function extractProvider(modelId) {
+    if (modelId.includes("/")) {
+        return modelId.split("/")[0] || "unknown";
+    }
+    return "unknown";
+}
+/**
+ * Infer model type from ID
+ */
+function inferModelType(modelId) {
+    const id = modelId.toLowerCase();
+    if (id.includes("dall-e") || id.includes("image") || id.includes("imagen")) {
+        return "image";
+    }
+    if (id.includes("embedding") || id.includes("ada")) {
+        return "embedding";
+    }
+    if (id.includes("whisper") || id.includes("audio")) {
+        return "audio";
+    }
+    return "text";
+}
+/**
+ * Format provider name for display
+ */
+function formatProviderName(provider) {
+    const names = {
+        openai: "OpenAI",
+        anthropic: "Anthropic",
+        google: "Google",
+        mistral: "Mistral AI",
+        meta: "Meta",
+        cohere: "Cohere",
+    };
+    return (names[provider] || provider.charAt(0).toUpperCase() + provider.slice(1));
+}
+/**
+ * Count total models across all providers
+ */
+function countModels(response) {
+    return response.providers.reduce((sum, p) => sum + p.models.length, 0);
+}
+/**
+ * Clear cache (useful for testing or manual refresh)
+ */
+export function clearGatewayCache() {
+    cachedModels = null;
+    cacheTimestamp = null;
+}

package/dist/server/global-settings.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Get global AI configuration (default models for text and image)
+ * This is the single source of truth for all AI generation calls
+ */
+export declare function getGlobalAISettings(): Promise<any>;
+/**
+ * Get default text model from global settings
+ * Returns "provider/model" format
+ */
+export declare function getDefaultTextModel(): Promise<string>;
+/**
+ * Get default image model from global settings
+ * Returns "provider/model" format
+ */
+export declare function getDefaultImageModel(): Promise<string>;
+//# sourceMappingURL=global-settings.d.ts.map

package/dist/server/global-settings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"global-settings.d.ts","sourceRoot":"","sources":["../../src/server/global-settings.ts"],"names":[],"mappings":"AAGA;;;GAGG;AACH,wBAAsB,mBAAmB,iBAyBxC;AAED;;;GAGG;AACH,wBAAsB,mBAAmB,IAAI,OAAO,CAAC,MAAM,CAAC,CAG3D;AAED;;;GAGG;AACH,wBAAsB,oBAAoB,IAAI,OAAO,CAAC,MAAM,CAAC,CAG5D"}