@lastbrain/module-ai 2.0.26 → 2.0.30

package/dist/server/openai-client.js

@@ -0,0 +1,26 @@
+import OpenAI from "openai";
+let openaiInstance = null;
+/**
+ * Obtenir le client OpenAI (singleton)
+ */
+export function getOpenAIClient() {
+    if (!openaiInstance) {
+        openaiInstance = new OpenAI({
+            apiKey: process.env.OPENAI_API_KEY,
+        });
+    }
+    return openaiInstance;
+}
+/**
+ * Appeler OpenAI Chat Completion avec les paramètres fournis
+ */
+export async function createChatCompletion(params) {
+    const client = getOpenAIClient();
+    return await client.chat.completions.create({
+        model: params.model || "gpt-4o",
+        messages: params.messages,
+        temperature: params.temperature ?? 0.7,
+        max_tokens: params.max_tokens,
+        response_format: params.response_format,
+    });
+}

package/dist/server/pricing-config.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Database access layer for pricing configuration
+ */
+import type { PricingConfig } from "./pricing";
+/**
+ * Get current pricing configuration from database
+ * Uses best pack price (lowest $/token) as reference
+ */
+export declare function getPricingConfig(): Promise<PricingConfig>;
+/**
+ * Get pricing config for a specific pack
+ */
+export declare function getPricingConfigForPack(packId: string): Promise<PricingConfig>;
+/**
+ * Get pricing config with custom markup
+ */
+export declare function getPricingConfigWithMarkup(markupCoef: number): Promise<PricingConfig>;
+//# sourceMappingURL=pricing-config.d.ts.map

package/dist/server/pricing-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pricing-config.d.ts","sourceRoot":"","sources":["../../src/server/pricing-config.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAI/C;;;GAGG;AACH,wBAAsB,gBAAgB,IAAI,OAAO,CAAC,aAAa,CAAC,CA4C/D;AAaD;;GAEG;AACH,wBAAsB,uBAAuB,CAC3C,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,aAAa,CAAC,CA8BxB;AAED;;GAEG;AACH,wBAAsB,0BAA0B,CAC9C,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,aAAa,CAAC,CAMxB"}

package/dist/server/pricing-config.js

@@ -0,0 +1,94 @@
+/**
+ * Database access layer for pricing configuration
+ */
+import { getSupabaseServiceClient } from "@lastbrain/core/server";
+import { logger } from "@lastbrain/core";
+const DEFAULT_MARKUP_COEF = 1.35; // 35% margin on cost
+/**
+ * Get current pricing configuration from database
+ * Uses best pack price (lowest $/token) as reference
+ */
+export async function getPricingConfig() {
+    try {
+        const supabase = await getSupabaseServiceClient();
+        const { data: packs, error } = await supabase
+            .from("token_packs")
+            .select("tokens, price_cents, currency")
+            .eq("is_active", true);
+        if (error || !packs || packs.length === 0) {
+            logger.warn("[PricingConfig] No active packs found, using fallback");
+            return getFallbackConfig();
+        }
+        // Find best pack (lowest price per token)
+        let bestPack = null;
+        for (const pack of packs) {
+            const priceUsd = pack.price_cents / 100;
+            if (!bestPack ||
+                priceUsd / pack.tokens < bestPack.priceUsd / bestPack.tokens) {
+                bestPack = { tokens: pack.tokens, priceUsd };
+            }
+        }
+        if (!bestPack) {
+            return getFallbackConfig();
+        }
+        logger.debug(`[PricingConfig] Using pack: ${bestPack.tokens} tokens = $${bestPack.priceUsd.toFixed(2)} (${((bestPack.priceUsd / bestPack.tokens) * 1_000_000).toFixed(4)} $/M tokens)`);
+        return {
+            packTokens: bestPack.tokens,
+            packPriceUsd: bestPack.priceUsd,
+            markupCoef: DEFAULT_MARKUP_COEF,
+        };
+    }
+    catch (error) {
+        logger.error("[PricingConfig] Error fetching config:", error);
+        return getFallbackConfig();
+    }
+}
+/**
+ * Fallback configuration (Creator pack equivalent)
+ */
+function getFallbackConfig() {
+    return {
+        packTokens: 2_000_000, // 2M tokens
+        packPriceUsd: 5.0, // $5 USD
+        markupCoef: DEFAULT_MARKUP_COEF,
+    };
+}
+/**
+ * Get pricing config for a specific pack
+ */
+export async function getPricingConfigForPack(packId) {
+    try {
+        const supabase = await getSupabaseServiceClient();
+        const { data: pack, error } = await supabase
+            .from("token_packs")
+            .select("tokens, price_cents, currency")
+            .eq("id", packId)
+            .eq("is_active", true)
+            .single();
+        if (error || !pack) {
+            logger.warn(`[PricingConfig] Pack ${packId} not found, using default`);
+            return getPricingConfig();
+        }
+        const priceUsd = pack.price_cents / 100;
+        logger.debug(`[PricingConfig] Using specific pack: ${pack.tokens} tokens = $${priceUsd.toFixed(2)} (${((priceUsd / pack.tokens) * 1_000_000).toFixed(4)} $/M tokens)`);
+        return {
+            packTokens: pack.tokens,
+            packPriceUsd: priceUsd,
+            markupCoef: DEFAULT_MARKUP_COEF,
+        };
+    }
+    catch (error) {
+        logger.error("[PricingConfig] Error fetching pack config:", error);
+        return getPricingConfig();
+    }
+}
+/**
+ * Get pricing config with custom markup
+ */
+export async function getPricingConfigWithMarkup(markupCoef) {
+    const config = await getPricingConfig();
+    return {
+        ...config,
+        markupCoef,
+    };
+}

package/dist/server/pricing-validator.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Centralized pricing validation to prevent free API calls
+ *
+ * CRITICAL SECURITY:
+ * - ALL endpoints MUST validate pricing before calling expensive APIs
+ * - Pricing must be > 0 to prevent free consumption
+ * - Gateway pricing is ALREADY in $/token (not $/1M tokens)
+ */
+import type { ProviderPricing } from "./billing";
+import type { GatewayPricing } from "../types/gateway";
+export interface PricingValidationResult {
+    valid: boolean;
+    pricing?: ProviderPricing;
+    error?: string;
+    errorCode?: "NO_PRICING" | "INVALID_PRICING";
+}
+/**
+ * Validate and convert Gateway pricing to ProviderPricing for text models
+ *
+ * @param gatewayPricing Pricing from Gateway API ($/1M tokens)
+ * @param modelId Model identifier for logging
+ * @returns Validation result with converted pricing
+ */
+export declare function validateTextPricing(gatewayPricing: GatewayPricing | undefined, modelId: string): PricingValidationResult;
+/**
+ * Validate and convert Gateway pricing to ProviderPricing for image models
+ *
+ * @param gatewayPricing Pricing from Gateway API
+ * @param modelId Model identifier for logging
+ * @returns Validation result with converted pricing
+ */
+export declare function validateImagePricing(gatewayPricing: GatewayPricing | undefined, modelId: string): PricingValidationResult;
+/**
+ * Verify estimated cost is valid (> 0)
+ *
+ * @param estimatedCost Estimated cost in USD
+ * @param modelId Model identifier for logging
+ * @returns True if valid, false otherwise
+ */
+export declare function validateEstimatedCost(estimatedCost: number, modelId: string): boolean;
+//# sourceMappingURL=pricing-validator.d.ts.map

package/dist/server/pricing-validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pricing-validator.d.ts","sourceRoot":"","sources":["../../src/server/pricing-validator.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AACjD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAEvD,MAAM,WAAW,uBAAuB;IACtC,KAAK,EAAE,OAAO,CAAC;IACf,OAAO,CAAC,EAAE,eAAe,CAAC;IAC1B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,YAAY,GAAG,iBAAiB,CAAC;CAC9C;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CACjC,cAAc,EAAE,cAAc,GAAG,SAAS,EAC1C,OAAO,EAAE,MAAM,GACd,uBAAuB,CAuDzB;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAClC,cAAc,EAAE,cAAc,GAAG,SAAS,EAC1C,OAAO,EAAE,MAAM,GACd,uBAAuB,CAwCzB;AAED;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CACnC,aAAa,EAAE,MAAM,EACrB,OAAO,EAAE,MAAM,GACd,OAAO,CAYT"}

package/dist/server/pricing-validator.js

@@ -0,0 +1,113 @@
+/**
+ * Centralized pricing validation to prevent free API calls
+ *
+ * CRITICAL SECURITY:
+ * - ALL endpoints MUST validate pricing before calling expensive APIs
+ * - Pricing must be > 0 to prevent free consumption
+ * - Gateway pricing is ALREADY in $/token (not $/1M tokens)
+ */
+import { logger } from "@lastbrain/core";
+/**
+ * Validate and convert Gateway pricing to ProviderPricing for text models
+ *
+ * @param gatewayPricing Pricing from Gateway API ($/1M tokens)
+ * @param modelId Model identifier for logging
+ * @returns Validation result with converted pricing
+ */
+export function validateTextPricing(gatewayPricing, modelId) {
+    // Check pricing exists
+    if (!gatewayPricing) {
+        logger.error(`[PricingValidator] No pricing available for model ${modelId}`);
+        return {
+            valid: false,
+            error: "Pricing non disponible pour ce modèle. Réessayez plus tard.",
+            errorCode: "NO_PRICING",
+        };
+    }
+    // Check input pricing
+    if (!gatewayPricing.input || gatewayPricing.input <= 0) {
+        logger.error(`[PricingValidator] Missing or invalid input pricing for model ${modelId}`, { gatewayPricing });
+        return {
+            valid: false,
+            error: "Pricing incomplet pour ce modèle. Contactez le support.",
+            errorCode: "INVALID_PRICING",
+        };
+    }
+    // Check output pricing
+    if (!gatewayPricing.output || gatewayPricing.output <= 0) {
+        logger.error(`[PricingValidator] Missing or invalid output pricing for model ${modelId}`, { gatewayPricing });
+        return {
+            valid: false,
+            error: "Pricing incomplet pour ce modèle. Contactez le support.",
+            errorCode: "INVALID_PRICING",
+        };
+    }
+    // Gateway pricing is ALREADY in $/token (e.g., "0.00000015" = $0.15/1M tokens)
+    // No conversion needed - use as-is
+    const pricing = {
+        inputUsdPerToken: parseFloat(gatewayPricing.input.toString()),
+        outputUsdPerToken: parseFloat(gatewayPricing.output.toString()),
+    };
+    logger.debug(`[PricingValidator] Validated pricing for ${modelId}:`, {
+        gateway: gatewayPricing,
+        converted: pricing,
+    });
+    return {
+        valid: true,
+        pricing,
+    };
+}
+/**
+ * Validate and convert Gateway pricing to ProviderPricing for image models
+ *
+ * @param gatewayPricing Pricing from Gateway API
+ * @param modelId Model identifier for logging
+ * @returns Validation result with converted pricing
+ */
+export function validateImagePricing(gatewayPricing, modelId) {
+    // Check pricing exists
+    if (!gatewayPricing) {
+        logger.error(`[PricingValidator] No pricing available for model ${modelId}`);
+        return {
+            valid: false,
+            error: "Pricing non disponible pour ce modèle. Réessayez plus tard.",
+            errorCode: "NO_PRICING",
+        };
+    }
+    // Check image pricing
+    if (!gatewayPricing.image || gatewayPricing.image <= 0) {
+        logger.error(`[PricingValidator] Missing or invalid image pricing for model ${modelId}`, { gatewayPricing });
+        return {
+            valid: false,
+            error: "Pricing incomplet pour ce modèle. Contactez le support.",
+            errorCode: "INVALID_PRICING",
+        };
+    }
+    // Image pricing is already in $/image (no conversion needed)
+    const pricing = {
+        imageUsdPerImage: parseFloat(gatewayPricing.image.toString()),
+    };
+    logger.debug(`[PricingValidator] Validated pricing for ${modelId}:`, {
+        gateway: gatewayPricing,
+        converted: pricing,
+    });
+    return {
+        valid: true,
+        pricing,
+    };
+}
+/**
+ * Verify estimated cost is valid (> 0)
+ *
+ * @param estimatedCost Estimated cost in USD
+ * @param modelId Model identifier for logging
+ * @returns True if valid, false otherwise
+ */
+export function validateEstimatedCost(estimatedCost, modelId) {
+    if (estimatedCost <= 0) {
+        logger.error(`[PricingValidator] Invalid cost estimation for model ${modelId}: $${estimatedCost}`);
+        return false;
+    }
+    logger.debug(`[PricingValidator] Estimated cost for ${modelId}: $${estimatedCost.toFixed(6)}`);
+    return true;
+}

package/dist/server/pricing.d.ts

@@ -0,0 +1,121 @@
+/**
+ * CENTRALIZED PRICING ENGINE - Server Only
+ * Single source of truth for all cost ↔ tokens ↔ margin calculations
+ *
+ * Business logic:
+ * - We sell token packs (e.g., 100K tokens = $5 USD)
+ * - Internal price: sale_usd_per_token = pack_price_usd / pack_tokens
+ * - We apply markup to provider costs: sell_usd = provider_cost * markup_coef
+ * - We debit in tokens: debit_tokens = ceil(sell_usd / sale_usd_per_token)
+ */
+export interface PricingConfig {
+    /** Tokens in the reference pack (e.g., 100000) */
+    packTokens: number;
+    /** Pack price in USD (e.g., 5.00) */
+    packPriceUsd: number;
+    /** Markup coefficient applied to provider cost (e.g., 1.35 = 35% margin on cost) */
+    markupCoef: number;
+}
+export interface ProviderPricing {
+    /** Input tokens cost ($/1M tokens) */
+    inputUsdPerMToken?: number;
+    /** Output tokens cost ($/1M tokens) */
+    outputUsdPerMToken?: number;
+    /** Cache read cost ($/1M tokens) */
+    cacheReadUsdPerMToken?: number;
+    /** Web search cost ($/unit) */
+    webSearchUsdPerUnit?: number;
+    /** Image generation cost ($/image) */
+    imageUsdPerImage?: number;
+    /** Tiered pricing for input (advanced) */
+    inputTiers?: Array<{
+        upTo: number;
+        pricePerMToken: number;
+    }>;
+    /** Tiered pricing for output (advanced) */
+    outputTiers?: Array<{
+        upTo: number;
+        pricePerMToken: number;
+    }>;
+}
+export interface Usage {
+    /** Input tokens consumed */
+    inputTokens?: number;
+    /** Output tokens generated */
+    outputTokens?: number;
+    /** Cache read tokens */
+    cacheReadTokens?: number;
+    /** Web search units used */
+    webSearchUnits?: number;
+    /** Images generated */
+    images?: number;
+}
+export interface BillingResult {
+    /** Provider cost in USD */
+    providerCostUsd: number;
+    /** Selling price in USD (with markup) */
+    sellUsd: number;
+    /** Tokens to debit from user account */
+    debitTokens: number;
+    /** Internal token price ($/token) */
+    saleUsdPerToken: number;
+    /** Markup coefficient used */
+    markupCoef: number;
+    /** Margin in USD (sellUsd - providerCostUsd) */
+    marginUsd: number;
+    /** Margin as % of sell price */
+    marginPctVsSell: number;
+    /** Margin as % of provider cost */
+    marginPctVsCost: number;
+}
+export interface ModelDisplayPricing {
+    /** Model ID */
+    modelId: string;
+    /** Estimated tokens for display */
+    estimatedTokens: number | null;
+    /** Display string (e.g., "8,500 tokens/img" or "N/A") */
+    displayPrice: string;
+    /** True if pricing is available */
+    available: boolean;
+}
+/**
+ * Compute billing for AI usage
+ * @param config Pricing configuration (pack size, markup)
+ * @param pricing Provider pricing data
+ * @param usage Actual usage (tokens, images, etc.)
+ * @returns Complete billing breakdown
+ */
+export declare function computeBilling(config: PricingConfig, pricing: ProviderPricing, usage: Usage): BillingResult;
+/**
+ * Convert tokens to sell price in USD
+ */
+export declare function tokensToSellUsd(tokens: number, config: PricingConfig): number;
+/**
+ * Convert USD to tokens (rounded up)
+ */
+export declare function sellUsdToTokens(usd: number, config: PricingConfig): number;
+/**
+ * Convert provider cost to debit tokens (with markup)
+ */
+export declare function providerUsdToDebitTokens(providerCostUsd: number, config: PricingConfig): number;
+/**
+ * Convert image price to debit tokens
+ */
+export declare function imagePriceUsdToDebitTokens(pricePerImageUsd: number, images: number, config: PricingConfig): number;
+/**
+ * Calculate display pricing for a model (for UI)
+ */
+export declare function calculateDisplayPricing(modelId: string, modelType: "text" | "image", pricing: ProviderPricing | null | undefined, config: PricingConfig): ModelDisplayPricing;
+/**
+ * Calculate markup coefficient from desired margin percentage
+ * @param marginPct Desired margin as % of cost (e.g., 35 for 35%)
+ * @returns Markup coefficient (e.g., 1.35)
+ */
+export declare function marginPctToMarkupCoef(marginPct: number): number;
+/**
+ * Calculate margin percentage from markup coefficient
+ * @param markupCoef Markup coefficient (e.g., 1.35)
+ * @returns Margin as % of cost (e.g., 35)
+ */
+export declare function markupCoefToMarginPct(markupCoef: number): number;
+//# sourceMappingURL=pricing.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pricing.d.ts","sourceRoot":"","sources":["../../src/server/pricing.ts"],"names":[],"mappings":"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"}

package/dist/server/pricing.js

@@ -0,0 +1,225 @@
+/**
+ * CENTRALIZED PRICING ENGINE - Server Only
+ * Single source of truth for all cost ↔ tokens ↔ margin calculations
+ *
+ * Business logic:
+ * - We sell token packs (e.g., 100K tokens = $5 USD)
+ * - Internal price: sale_usd_per_token = pack_price_usd / pack_tokens
+ * - We apply markup to provider costs: sell_usd = provider_cost * markup_coef
+ * - We debit in tokens: debit_tokens = ceil(sell_usd / sale_usd_per_token)
+ */
+// ============================================================================
+// CORE CALCULATION FUNCTION
+// ============================================================================
+/**
+ * Compute billing for AI usage
+ * @param config Pricing configuration (pack size, markup)
+ * @param pricing Provider pricing data
+ * @param usage Actual usage (tokens, images, etc.)
+ * @returns Complete billing breakdown
+ */
+export function computeBilling(config, pricing, usage) {
+    // 1. Calculate internal token sale price
+    const saleUsdPerToken = config.packPriceUsd / config.packTokens;
+    // 2. Calculate provider cost in USD
+    let providerCostUsd = 0;
+    // Input tokens cost
+    if (usage.inputTokens && pricing.inputUsdPerMToken) {
+        if (pricing.inputTiers && pricing.inputTiers.length > 0) {
+            providerCostUsd += calculateTieredCost(usage.inputTokens, pricing.inputTiers);
+        }
+        else {
+            providerCostUsd +=
+                (usage.inputTokens / 1_000_000) * pricing.inputUsdPerMToken;
+        }
+    }
+    // Output tokens cost
+    if (usage.outputTokens && pricing.outputUsdPerMToken) {
+        if (pricing.outputTiers && pricing.outputTiers.length > 0) {
+            providerCostUsd += calculateTieredCost(usage.outputTokens, pricing.outputTiers);
+        }
+        else {
+            providerCostUsd +=
+                (usage.outputTokens / 1_000_000) * pricing.outputUsdPerMToken;
+        }
+    }
+    // Cache read tokens cost
+    if (usage.cacheReadTokens && pricing.cacheReadUsdPerMToken) {
+        providerCostUsd +=
+            (usage.cacheReadTokens / 1_000_000) * pricing.cacheReadUsdPerMToken;
+    }
+    // Web search cost
+    if (usage.webSearchUnits && pricing.webSearchUsdPerUnit) {
+        providerCostUsd += usage.webSearchUnits * pricing.webSearchUsdPerUnit;
+    }
+    // Image generation cost
+    if (usage.images && pricing.imageUsdPerImage) {
+        providerCostUsd += usage.images * pricing.imageUsdPerImage;
+    }
+    // 3. Apply markup to get sell price
+    const sellUsd = providerCostUsd * config.markupCoef;
+    // 4. Convert to tokens (always round up to protect margin)
+    const debitTokens = Math.ceil(sellUsd / saleUsdPerToken);
+    // 5. Calculate margins
+    const marginUsd = sellUsd - providerCostUsd;
+    const marginPctVsSell = sellUsd > 0 ? (marginUsd / sellUsd) * 100 : 0;
+    const marginPctVsCost = providerCostUsd > 0 ? (marginUsd / providerCostUsd) * 100 : 0;
+    return {
+        providerCostUsd: roundUsd(providerCostUsd),
+        sellUsd: roundUsd(sellUsd),
+        debitTokens,
+        saleUsdPerToken: roundUsd(saleUsdPerToken),
+        markupCoef: config.markupCoef,
+        marginUsd: roundUsd(marginUsd),
+        marginPctVsSell: roundPct(marginPctVsSell),
+        marginPctVsCost: roundPct(marginPctVsCost),
+    };
+}
+/**
+ * Calculate cost with tiered pricing
+ */
+function calculateTieredCost(tokens, tiers) {
+    let remainingTokens = tokens;
+    let cost = 0;
+    let previousLimit = 0;
+    for (const tier of tiers) {
+        const tierLimit = tier.upTo;
+        const tierTokens = Math.min(remainingTokens, tierLimit - previousLimit);
+        if (tierTokens <= 0)
+            break;
+        cost += (tierTokens / 1_000_000) * tier.pricePerMToken;
+        remainingTokens -= tierTokens;
+        previousLimit = tierLimit;
+        if (remainingTokens <= 0)
+            break;
+    }
+    // Remaining tokens use last tier price
+    if (remainingTokens > 0 && tiers.length > 0) {
+        const lastTier = tiers[tiers.length - 1];
+        cost += (remainingTokens / 1_000_000) * lastTier.pricePerMToken;
+    }
+    return cost;
+}
+// ============================================================================
+// HELPER FUNCTIONS
+// ============================================================================
+/**
+ * Convert tokens to sell price in USD
+ */
+export function tokensToSellUsd(tokens, config) {
+    const saleUsdPerToken = config.packPriceUsd / config.packTokens;
+    return roundUsd(tokens * saleUsdPerToken);
+}
+/**
+ * Convert USD to tokens (rounded up)
+ */
+export function sellUsdToTokens(usd, config) {
+    const saleUsdPerToken = config.packPriceUsd / config.packTokens;
+    return Math.ceil(usd / saleUsdPerToken);
+}
+/**
+ * Convert provider cost to debit tokens (with markup)
+ */
+export function providerUsdToDebitTokens(providerCostUsd, config) {
+    const saleUsdPerToken = config.packPriceUsd / config.packTokens;
+    const sellUsd = providerCostUsd * config.markupCoef;
+    return Math.ceil(sellUsd / saleUsdPerToken);
+}
+/**
+ * Convert image price to debit tokens
+ */
+export function imagePriceUsdToDebitTokens(pricePerImageUsd, images, config) {
+    const saleUsdPerToken = config.packPriceUsd / config.packTokens;
+    const providerCost = pricePerImageUsd * images;
+    const sellUsd = providerCost * config.markupCoef;
+    return Math.ceil(sellUsd / saleUsdPerToken);
+}
+/**
+ * Calculate display pricing for a model (for UI)
+ */
+export function calculateDisplayPricing(modelId, modelType, pricing, config) {
+    if (!pricing) {
+        return {
+            modelId,
+            estimatedTokens: null,
+            displayPrice: "N/A",
+            available: false,
+        };
+    }
+    if (modelType === "image") {
+        if (!pricing.imageUsdPerImage) {
+            return {
+                modelId,
+                estimatedTokens: null,
+                displayPrice: "N/A",
+                available: false,
+            };
+        }
+        const tokens = imagePriceUsdToDebitTokens(pricing.imageUsdPerImage, 1, config);
+        return {
+            modelId,
+            estimatedTokens: tokens,
+            displayPrice: `${tokens.toLocaleString()} tokens/img`,
+            available: true,
+        };
+    }
+    if (modelType === "text") {
+        // Display cost per 1M tokens (500K input + 500K output)
+        if (!pricing.inputUsdPerMToken && !pricing.outputUsdPerMToken) {
+            return {
+                modelId,
+                estimatedTokens: null,
+                displayPrice: "Variable",
+                available: true, // Text models can still work without exact pricing
+            };
+        }
+        const result = computeBilling(config, pricing, {
+            inputTokens: 500_000,
+            outputTokens: 500_000,
+        });
+        const tokensPerM = Math.round(result.debitTokens);
+        return {
+            modelId,
+            estimatedTokens: tokensPerM,
+            displayPrice: `~${tokensPerM.toLocaleString()} tokens/1M`,
+            available: true,
+        };
+    }
+    return {
+        modelId,
+        estimatedTokens: null,
+        displayPrice: "N/A",
+        available: false,
+    };
+}
+// ============================================================================
+// UTILITIES
+// ============================================================================
+/**
+ * Round USD to 8 decimals
+ */
+function roundUsd(value) {
+    return Math.round(value * 100_000_000) / 100_000_000;
+}
+/**
+ * Round percentage to 2 decimals
+ */
+function roundPct(value) {
+    return Math.round(value * 100) / 100;
+}
+/**
+ * Calculate markup coefficient from desired margin percentage
+ * @param marginPct Desired margin as % of cost (e.g., 35 for 35%)
+ * @returns Markup coefficient (e.g., 1.35)
+ */
+export function marginPctToMarkupCoef(marginPct) {
+    return 1 + marginPct / 100;
+}
+/**
+ * Calculate margin percentage from markup coefficient
+ * @param markupCoef Markup coefficient (e.g., 1.35)
+ * @returns Margin as % of cost (e.g., 35)
+ */
+export function markupCoefToMarginPct(markupCoef) {
+    return (markupCoef - 1) * 100;
+}