@bratcliffe909/mcp-server-segmind/dist/utils/cost-tracker.js

Model Context Protocol server for Segmind API - Generate images and videos using AI models

import * as fs from 'fs';
import * as path from 'path';
import { logger } from './logger.js';
class CostTracker {
    static instance;
    costData;
    dataPath;
    isDirty = false;
    constructor() {
        this.dataPath = path.join(process.cwd(), '.segmind-cost-data.json');
        this.costData = this.loadCostData();
        setInterval(() => {
            if (this.isDirty) {
                this.saveCostData();
            }
        }, 30000);
    }
    static getInstance() {
        if (!CostTracker.instance) {
            CostTracker.instance = new CostTracker();
        }
        return CostTracker.instance;
    }
    loadCostData() {
        try {
            if (fs.existsSync(this.dataPath)) {
                const data = fs.readFileSync(this.dataPath, 'utf-8');
                return JSON.parse(data);
            }
        }
        catch (error) {
            logger.warn('Failed to load cost data', { error });
        }
        return {
            version: '1.0',
            models: {},
            lastUpdated: new Date().toISOString(),
        };
    }
    saveCostData() {
        try {
            fs.writeFileSync(this.dataPath, JSON.stringify(this.costData, null, 2));
            this.isDirty = false;
            logger.debug('Cost data saved');
        }
        catch (error) {
            logger.error('Failed to save cost data', { error });
        }
    }
    recordCost(modelId, creditsUsed, parameters) {
        const existing = this.costData.models[modelId];
        if (existing) {
            const totalSamples = existing.sampleCount + 1;
            const newAverage = (existing.averageCost * existing.sampleCount + creditsUsed) / totalSamples;
            const updatedModel = {
                ...existing,
                averageCost: newAverage,
                minCost: Math.min(existing.minCost, creditsUsed),
                maxCost: Math.max(existing.maxCost, creditsUsed),
                sampleCount: totalSamples,
                lastUpdated: new Date().toISOString(),
                parameters: parameters || existing.parameters,
            };
            this.costData.models[modelId] = updatedModel;
        }
        else {
            const newModel = {
                modelId,
                averageCost: creditsUsed,
                minCost: creditsUsed,
                maxCost: creditsUsed,
                sampleCount: 1,
                lastUpdated: new Date().toISOString(),
                parameters,
            };
            this.costData.models[modelId] = newModel;
        }
        this.costData.lastUpdated = new Date().toISOString();
        this.isDirty = true;
        const currentModel = this.costData.models[modelId];
        logger.debug('Cost recorded', {
            modelId,
            creditsUsed,
            newAverage: currentModel?.averageCost,
        });
    }
    getEstimatedCost(modelId) {
        const data = this.costData.models[modelId];
        if (data && data.sampleCount > 0) {
            return data.averageCost;
        }
        return null;
    }
    getCostInfo(modelId) {
        return this.costData.models[modelId] || null;
    }
    getAllCosts() {
        return this.costData.models;
    }
    clearModelData(modelId) {
        const models = { ...this.costData.models };
        delete models[modelId];
        this.costData.models = models;
        this.isDirty = true;
    }
    exportData() {
        return JSON.parse(JSON.stringify(this.costData));
    }
    importData(data) {
        const models = { ...this.costData.models };
        Object.entries(data.models).forEach(([modelId, modelData]) => {
            const existing = models[modelId];
            if (!existing || modelData.sampleCount > existing.sampleCount) {
                models[modelId] = modelData;
            }
        });
        this.costData.models = models;
        this.isDirty = true;
    }
}
export const costTracker = CostTracker.getInstance();
//# sourceMappingURL=cost-tracker.js.map