@bloopai/debugger-mcp/dist/errorUtils.js

An MCP server that provides interactive debugging capabilities to AI coding agents

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.McpErrorBuilder = void 0;
const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
class McpErrorBuilder {
    _error;
    _toolName;
    _mcpErrorCode;
    _mcpDebugErrorType;
    _sessionProvider;
    _sessionId;
    _additionalDebugData;
    constructor() { }
    static normalizeErrorObject(error) {
        if (error instanceof Error) {
            return {
                message: error.message,
                name: error.name,
                stack: error.stack,
                originalError: error,
            };
        }
        return {
            message: String(error),
            originalError: error,
        };
    }
    static createMcpErrorFromError(error, toolName, mcpErrorCode, mcpDebugErrorType, sessionProvider, sessionId, additionalDebugData) {
        const normalized = McpErrorBuilder.normalizeErrorObject(error);
        const asyncEvents = sessionProvider.drainAsyncEventQueue();
        const debugData = {
            errorType: mcpDebugErrorType,
            sessionId: sessionId,
            originalMessage: normalized.message,
            originalName: normalized.name,
            originalStack: normalized.stack,
            asyncEvents: asyncEvents,
            ...additionalDebugData,
        };
        let errorMessage = `Error in tool ${toolName}: ${normalized.message}`;
        if (mcpDebugErrorType === 'invalid_tool_arguments' &&
            additionalDebugData?.problemDetail) {
            errorMessage = `${additionalDebugData.problemDetail}`;
        }
        else if (mcpDebugErrorType === 'session_not_found' && sessionId) {
            errorMessage = `Debug session not found: ${sessionId}`;
        }
        return new types_js_1.McpError(mcpErrorCode, errorMessage, debugData);
    }
    error(error) {
        this._error = error;
        return this;
    }
    toolName(toolName) {
        this._toolName = toolName;
        return this;
    }
    mcpErrorCode(mcpErrorCode) {
        this._mcpErrorCode = mcpErrorCode;
        return this;
    }
    mcpDebugErrorType(mcpDebugErrorType) {
        this._mcpDebugErrorType = mcpDebugErrorType;
        return this;
    }
    sessionProvider(sessionProvider) {
        this._sessionProvider = sessionProvider;
        return this;
    }
    sessionId(sessionId) {
        this._sessionId = sessionId;
        return this;
    }
    additionalDebugData(additionalDebugData) {
        this._additionalDebugData = additionalDebugData;
        return this;
    }
    build() {
        if (this._error === undefined)
            throw new Error("McpErrorBuilder: 'error' is required.");
        if (!this._toolName)
            throw new Error("McpErrorBuilder: 'toolName' is required.");
        if (!this._mcpErrorCode)
            throw new Error("McpErrorBuilder: 'mcpErrorCode' is required.");
        if (!this._mcpDebugErrorType)
            throw new Error("McpErrorBuilder: 'mcpDebugErrorType' is required.");
        if (!this._sessionProvider)
            throw new Error("McpErrorBuilder: 'sessionProvider' is required.");
        return McpErrorBuilder.createMcpErrorFromError(this._error, this._toolName, this._mcpErrorCode, this._mcpDebugErrorType, this._sessionProvider, this._sessionId, this._additionalDebugData);
    }
}
exports.McpErrorBuilder = McpErrorBuilder;