@chinchillaenterprises/mcp-ai-assistant/dist/utils/error-handler.js

MCP server for AI assistant with ElevenLabs text-to-speech integration

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.ElevenLabsError = void 0;
exports.handleElevenLabsError = handleElevenLabsError;
exports.validateFilePath = validateFilePath;
exports.validateFileSize = validateFileSize;
exports.retryOperation = retryOperation;
exports.validateFile = validateFile;
exports.estimateCost = estimateCost;
exports.formatErrorForLogging = formatErrorForLogging;
class ElevenLabsError extends Error {
    code;
    statusCode;
    constructor(message, code, statusCode) {
        super(message);
        this.code = code;
        this.statusCode = statusCode;
        this.name = 'ElevenLabsError';
    }
}
exports.ElevenLabsError = ElevenLabsError;
function handleElevenLabsError(error) {
    if (error.response) {
        // API error with response
        const status = error.response.status;
        const message = error.response.data?.message || error.message;
        switch (status) {
            case 401:
                return new ElevenLabsError("Invalid API key", "UNAUTHORIZED", status);
            case 403:
                return new ElevenLabsError("Access forbidden", "FORBIDDEN", status);
            case 404:
                return new ElevenLabsError("Resource not found", "NOT_FOUND", status);
            case 429:
                return new ElevenLabsError("Rate limit exceeded", "RATE_LIMIT", status);
            case 500:
                return new ElevenLabsError("ElevenLabs server error", "SERVER_ERROR", status);
            default:
                return new ElevenLabsError(message, "API_ERROR", status);
        }
    }
    else if (error.request) {
        // Network error
        return new ElevenLabsError("Network error - unable to reach ElevenLabs API", "NETWORK_ERROR");
    }
    else {
        // Other error
        return new ElevenLabsError(error.message || "Unknown error", "UNKNOWN");
    }
}
function validateFilePath(filePath) {
    if (!filePath || typeof filePath !== 'string') {
        throw new Error("File path is required and must be a string");
    }
    if (filePath.trim().length === 0) {
        throw new Error("File path cannot be empty");
    }
}
function validateFileSize(size) {
    const MAX_SIZE = 1024 * 1024 * 1024; // 1GB
    if (size > MAX_SIZE) {
        throw new Error(`File size ${size} exceeds maximum limit of ${MAX_SIZE} bytes (1GB)`);
    }
}
async function retryOperation(operation, maxRetries = 3, delayMs = 1000) {
    let lastError;
    for (let i = 0; i <= maxRetries; i++) {
        try {
            return await operation();
        }
        catch (error) {
            lastError = error instanceof Error ? error : new Error(String(error));
            if (i < maxRetries) {
                await new Promise(resolve => setTimeout(resolve, delayMs * Math.pow(2, i)));
            }
        }
    }
    throw lastError;
}
function validateFile(filePath, size) {
    validateFilePath(filePath);
    if (size !== undefined) {
        validateFileSize(size);
    }
}
function estimateCost(durationSeconds, pricePerHour = 0.30) {
    const hours = durationSeconds / 3600;
    return hours * pricePerHour;
}
function formatErrorForLogging(error) {
    if (error instanceof ElevenLabsError) {
        return `ElevenLabsError(${error.code}): ${error.message}`;
    }
    if (error instanceof Error) {
        return `Error: ${error.message}`;
    }
    return `Unknown error: ${JSON.stringify(error)}`;
}
//# sourceMappingURL=error-handler.js.map