mcp4openapi 0.3.1 → 0.3.3

package/dist/src/mcp-server.js

@@ -1,1369 +0,0 @@
-/**
- * Main MCP server implementation
- *
- * Why: Coordinates OpenAPI parser, profile loader, tool generator, and request execution.
- * Single entry point for tool registration and invocation.
- */
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
-import { OpenAPIParser } from './openapi-parser.js';
-import { ProfileLoader } from './profile-loader.js';
-import { ToolGenerator } from './tool-generator.js';
-import { normalizeArguments } from './argument-normalizer.js';
-import { CompositeExecutor } from './composite-executor.js';
-import { ProxyDownloadExecutor } from './proxy-executor.js';
-import { enforceFiltering, parseFilteringHeader } from './filtering.js';
-import { ConfigurationError, OperationNotFoundError, ResourceNotFoundError, ValidationError, AuthenticationError, AuthorizationError, RateLimitError, NetworkError, generateCorrelationId } from './errors.js';
-import { OAUTH_RATE_LIMIT } from './constants.js';
-import { HttpClientFactory } from './http-client-factory.js';
-import { SchemaValidator } from './schema-validator.js';
-import { ConsoleLogger, JsonLogger } from './logger.js';
-import { isInitializeRequest, isToolCallRequest } from './jsonrpc-validator.js';
-import { generateNameWarnings } from './naming-warnings.js';
-import { NamingStrategy } from './naming.js';
-import { isSafePropertyName } from './validation-utils.js';
-import { ToolFilterService, EnvConfigParser, HeaderConfigParser, RegexCompiler, RegexValidator, OperationClassifier, OpenAPIOperationResolver, OperationDetector, applySessionToolFilter, } from './tool-filter/index.js';
-import { buildHttpTransportBaseConfig } from './http-transport-config.js';
-export class MCPServer {
-    /**
-     * Execute a tools/call request via the JSON-RPC handler.
-     * Intended for internal use and tests to avoid accessing private methods.
-     */
-    async callToolRpc(name, args, sessionId, requestId = 1) {
-        const message = {
-            jsonrpc: '2.0',
-            id: requestId,
-            method: 'tools/call',
-            params: {
-                name,
-                arguments: args,
-            },
-        };
-        return this.handleToolCall(message, sessionId);
-    }
-    /**
-     * Filter response payload to include only specified fields.
-     *
-     * Supports YouTrack-style field selectors like:
-     * - "author(id,login)"
-     * - "comments(id,text,author(id,login))"
-     *
-     * Recurses into nested objects and arrays when subfields are specified.
-     */
-    filterFields(data, fields) {
-        const selection = this.parseFieldSelection(fields);
-        return this.applyFieldSelection(data, selection);
-    }
-    parseFieldSelection(fields) {
-        const root = Object.create(null);
-        for (const field of fields) {
-            const trimmed = field.trim();
-            if (!trimmed)
-                continue;
-            this.mergeFieldSelector(root, trimmed);
-        }
-        return root;
-    }
-    mergeFieldSelector(target, selector) {
-        const baseName = selector.split('(')[0].trim();
-        if (!baseName)
-            return;
-        if (!isSafePropertyName(baseName))
-            return;
-        const openParen = selector.indexOf('(');
-        if (openParen === -1) {
-            target[baseName] = true;
-            return;
-        }
-        const closeParen = selector.lastIndexOf(')');
-        if (closeParen === -1 || closeParen <= openParen) {
-            target[baseName] = true;
-            return;
-        }
-        const inner = selector.slice(openParen + 1, closeParen).trim();
-        const subSelectors = this.splitTopLevel(inner);
-        const subTree = Object.create(null);
-        for (const sub of subSelectors) {
-            this.mergeFieldSelector(subTree, sub);
-        }
-        const existing = target[baseName];
-        if (existing === true)
-            return;
-        if (!existing) {
-            target[baseName] = subTree;
-            return;
-        }
-        this.mergeSelectionTrees(existing, subTree);
-    }
-    mergeSelectionTrees(target, incoming) {
-        for (const [key, val] of Object.entries(incoming)) {
-            if (!isSafePropertyName(key))
-                continue;
-            const existing = target[key];
-            if (!existing) {
-                target[key] = val;
-                continue;
-            }
-            if (existing === true || val === true) {
-                target[key] = true;
-                continue;
-            }
-            this.mergeSelectionTrees(existing, val);
-        }
-    }
-    splitTopLevel(input) {
-        const result = [];
-        let depth = 0;
-        let current = '';
-        for (const ch of input) {
-            if (ch === '(')
-                depth += 1;
-            if (ch === ')')
-                depth = Math.max(0, depth - 1);
-            if (ch === ',' && depth === 0) {
-                const trimmed = current.trim();
-                if (trimmed)
-                    result.push(trimmed);
-                current = '';
-                continue;
-            }
-            current += ch;
-        }
-        const last = current.trim();
-        if (last)
-            result.push(last);
-        return result;
-    }
-    applyFieldSelection(data, selection) {
-        if (!data || typeof data !== 'object') {
-            return data;
-        }
-        if (Array.isArray(data)) {
-            return data.map(item => this.applyFieldSelection(item, selection));
-        }
-        const obj = data;
-        const filtered = Object.create(null);
-        for (const [key, sel] of Object.entries(selection)) {
-            if (!isSafePropertyName(key))
-                continue;
-            if (!Object.prototype.hasOwnProperty.call(obj, key))
-                continue;
-            const value = obj[key];
-            if (sel === true) {
-                filtered[key] = value;
-            }
-            else {
-                filtered[key] = this.applyFieldSelection(value, sel);
-            }
-        }
-        return filtered;
-    }
-    /**
-     * Format error message for client with correlation ID
-     *
-     * Why: Categorize errors as "safe" (4xx client errors) vs "unsafe" (5xx server errors)
-     * Safe errors show API message to help user fix the issue
-     * Unsafe errors show generic message to avoid leaking sensitive info
-     */
-    formatErrorForClient(error, correlationId) {
-        // Authentication errors - safe to show (token expired, invalid credentials)
-        if (error instanceof AuthenticationError) {
-            return `Authentication failed: ${error.message} (correlation ID: ${correlationId})`;
-        }
-        // Authorization errors - safe to show (insufficient permissions)
-        if (error instanceof AuthorizationError) {
-            return `Authorization failed: ${error.message} (correlation ID: ${correlationId})`;
-        }
-        // Rate limit errors - safe to show (helps user understand backoff)
-        if (error instanceof RateLimitError) {
-            const retryInfo = error.details?.retryAfter
-                ? ` Retry after ${error.details.retryAfter} seconds.`
-                : '';
-            return `Rate limit exceeded: ${error.message}${retryInfo} (correlation ID: ${correlationId})`;
-        }
-        // Network errors with 4xx status - safe to show (client errors)
-        if (error instanceof NetworkError && error.details?.statusCode) {
-            const statusCode = error.details.statusCode;
-            if (statusCode >= 400 && statusCode < 500) {
-                return `Request failed: ${error.message} (correlation ID: ${correlationId})`;
-            }
-        }
-        // Validation errors - safe to show (helps user fix input)
-        if (error instanceof ValidationError) {
-            return `Validation error: ${error.message} (correlation ID: ${correlationId})`;
-        }
-        // Operation not found - safe to show (configuration issue)
-        if (error instanceof OperationNotFoundError) {
-            return `Operation not found: ${error.message} (correlation ID: ${correlationId})`;
-        }
-        if (error instanceof ResourceNotFoundError) {
-            return `${error.message} (correlation ID: ${correlationId})`;
-        }
-        // Configuration errors - safe to show (helps admin fix setup)
-        if (error instanceof ConfigurationError) {
-            return `Configuration error: ${error.message} (correlation ID: ${correlationId})`;
-        }
-        // Generic/unknown errors - hide details, show only correlation ID
-        return `Internal error (correlation ID: ${correlationId})`;
-    }
-    constructor(logger) {
-        this.httpClientFactory = new HttpClientFactory();
-        this.httpTransport = null;
-        this.logger = logger || new ConsoleLogger();
-        this.schemaValidator = new SchemaValidator();
-        this.server = new Server({
-            name: 'mcp4openapi',
-            version: '0.1.0',
-        }, {
-            capabilities: {
-                tools: {},
-            },
-        });
-        this.parser = new OpenAPIParser();
-        this.toolGenerator = new ToolGenerator(this.parser);
-        this.setupHandlers();
-    }
-    async initialize(specPath, profilePath) {
-        // Load OpenAPI spec
-        await this.parser.load(specPath);
-        this.logger.info('Loaded OpenAPI spec', { specPath });
-        // Load or create MCP profile
-        if (profilePath) {
-            const loader = new ProfileLoader();
-            this.profile = await loader.load(profilePath);
-            this.logger.info('Loaded profile', {
-                profile: this.profile.profile_name,
-                toolCount: this.profile.tools.length,
-            });
-        }
-        else {
-            this.profile = ProfileLoader.createDefaultProfile('default', this.parser);
-            this.logger.info('Using auto-generated default profile', {
-                profile: this.profile.profile_name,
-                toolCount: this.profile.tools.length,
-            });
-            // Check if we should warn about long names
-            this.checkToolNameLengths();
-        }
-        this.applyGlobalToolFiltering();
-        // Re-create logger with auth config for token redaction
-        const authConfigs = this.getAuthConfigs();
-        if (authConfigs.length > 0) {
-            // Use first auth config for logger (primary)
-            this.logger = this.createLoggerWithAuth(authConfigs[0]);
-            this.logger.info('Logger re-configured with auth token redaction', {
-                authMethods: authConfigs.length,
-            });
-        }
-        // Setup HTTP client with interceptors
-        // For stdio transport, create client with env token
-        // For HTTP transport, clients are created per-session with user's token
-        const baseUrl = this.getBaseUrl();
-        const envAuthConfig = this.getEnvBackedAuthConfig();
-        const envVarName = envAuthConfig?.value_from_env;
-        const envToken = envVarName ? process.env[envVarName] : undefined;
-        if (envAuthConfig && envToken) {
-            // Token available in env - create global client (stdio transport)
-            const httpClient = this.httpClientFactory.createGlobalClient({
-                profile: this.profile,
-                baseUrl,
-            });
-            this.compositeExecutor = new CompositeExecutor(this.parser, httpClient, this.profile.parameter_aliases);
-        }
-        else {
-            // No env token or no auth - will use per-session clients (HTTP transport)
-            this.compositeExecutor = new CompositeExecutor(this.parser, undefined, this.profile.parameter_aliases);
-        }
-        this.logger.info('MCP server initialized', {
-            baseUrl,
-            toolCount: this.profile.tools.length,
-        });
-    }
-    /**
-     * Create logger with auth configuration for token redaction
-     *
-     * Why: Prevents sensitive tokens from appearing in logs
-     */
-    createLoggerWithAuth(authConfig) {
-        const logFormat = process.env.MCP4_LOG_FORMAT || 'console';
-        const logLevel = this.logger instanceof ConsoleLogger || this.logger instanceof JsonLogger
-            ? this.logger.level
-            : undefined;
-        return logFormat === 'json'
-            ? new JsonLogger(logLevel, authConfig)
-            : new ConsoleLogger(logLevel, authConfig);
-    }
-    /**
-     * Check tool name lengths and warn if needed
-     */
-    checkToolNameLengths() {
-        const maxLength = parseInt(process.env.MCP4_TOOLNAME_MAX || '45', 10);
-        const strategy = (process.env.MCP4_TOOLNAME_STRATEGY || 'none').toLowerCase();
-        const warnOnly = (process.env.MCP4_TOOLNAME_WARN_ONLY || 'true').toLowerCase() === 'true';
-        // Only warn if strategy is 'none' or warn-only mode is enabled
-        if (strategy !== NamingStrategy.None && !warnOnly) {
-            return; // Names already shortened, no need to warn
-        }
-        // Get all operations as OperationForNaming
-        const operations = this.parser.getAllOperations();
-        const opsForNaming = operations.map(op => ({
-            operationId: op.operationId,
-            method: op.method,
-            path: op.path,
-            tags: op.tags,
-        }));
-        const warningOptions = {
-            maxLength,
-            similarTopN: parseInt(process.env.MCP4_TOOLNAME_SIMILAR_TOP || '3', 10),
-            similarityThreshold: parseFloat(process.env.MCP4_TOOLNAME_SIMILARITY_THRESHOLD || '0.75'),
-            minParts: parseInt(process.env.MCP4_TOOLNAME_MIN_PARTS || '3', 10),
-            minLength: parseInt(process.env.MCP4_TOOLNAME_MIN_LENGTH || '20', 10),
-        };
-        generateNameWarnings(opsForNaming, warningOptions, this.logger);
-    }
-    /**
-     * Get base URL from profile config or OpenAPI spec
-     */
-    getBaseUrl() {
-        const baseUrlConfig = this.profile?.interceptors?.base_url;
-        if (baseUrlConfig) {
-            const envValue = process.env[baseUrlConfig.value_from_env];
-            if (envValue)
-                return envValue;
-            if (baseUrlConfig.default)
-                return baseUrlConfig.default;
-        }
-        return this.parser.getBaseUrl();
-    }
-    /**
-     * Get auth configurations as array (supports single or multiple auth methods)
-     * Returns array sorted by priority (lower = higher priority)
-     */
-    getAuthConfigs() {
-        const auth = this.profile?.interceptors?.auth;
-        if (!auth)
-            return [];
-        const configs = Array.isArray(auth) ? auth : [auth];
-        // Sort by priority (lower = higher priority)
-        return configs.sort((a, b) => (a.priority || 0) - (b.priority || 0));
-    }
-    /**
-     * Get primary (highest priority) auth configuration
-     */
-    getPrimaryAuthConfig() {
-        const configs = this.getAuthConfigs();
-        return configs[0];
-    }
-    /**
-     * Get highest priority auth configuration that reads token from environment
-     */
-    getEnvBackedAuthConfig() {
-        const configs = this.getAuthConfigs();
-        return configs.find(config => config.type !== 'oauth' && !!config.value_from_env);
-    }
-    /**
-     * Get OAuth configuration from auth configs (if any)
-     */
-    getOAuthConfig() {
-        const configs = this.getAuthConfigs();
-        const oauthConfig = configs.find(c => c.type === 'oauth');
-        return oauthConfig?.oauth_config;
-    }
-    buildOAuthConfigWithAllowedRedirectHosts(oauthConfig) {
-        if (!oauthConfig) {
-            return undefined;
-        }
-        return {
-            ...oauthConfig,
-            allowed_redirect_hosts: oauthConfig.allowed_redirect_hosts
-                || (process.env.MCP4_ALLOWED_ORIGINS
-                    ? this.extractHostsFromOrigins(process.env.MCP4_ALLOWED_ORIGINS)
-                    : undefined),
-        };
-    }
-    getProfileIdValue() {
-        if (!this.profile) {
-            throw new ConfigurationError('Profile not initialized. Call initialize() first.');
-        }
-        const profileId = this.profile.profile_id?.trim() || this.profile.profile_name;
-        if (!profileId) {
-            throw new ConfigurationError('Profile is missing profile_id and profile_name.');
-        }
-        return profileId;
-    }
-    getOAuthRateLimitConfig() {
-        const authConfigs = this.getAuthConfigs();
-        const oauthAuthConfig = authConfigs.find(c => c.type === 'oauth');
-        const oauthRateLimit = oauthAuthConfig?.oauth_rate_limit;
-        const max = oauthRateLimit?.max_requests
-            || parseInt(process.env.MCP4_OAUTH_RATE_LIMIT_MAX || String(OAUTH_RATE_LIMIT.MAX_REQUESTS), 10);
-        const windowMs = oauthRateLimit?.window_ms
-            || parseInt(process.env.MCP4_OAUTH_RATE_LIMIT_WINDOW_MS || String(OAUTH_RATE_LIMIT.WINDOW_MS), 10);
-        return { max, windowMs };
-    }
-    getHttpProfileContext() {
-        if (!this.profile) {
-            throw new ConfigurationError('Profile not initialized. Call initialize() first.');
-        }
-        const authConfigs = this.getAuthConfigs();
-        const baseUrl = this.getBaseUrl();
-        const oauthConfig = this.buildOAuthConfigWithAllowedRedirectHosts(this.getOAuthConfig());
-        const resourceMetadata = this.parser.getResourceMetadata();
-        const oauthRateLimit = this.getOAuthRateLimitConfig();
-        return {
-            profileId: this.getProfileIdValue(),
-            oauthConfig,
-            authConfigs,
-            baseUrl,
-            rateLimitOAuthMax: oauthRateLimit.max,
-            rateLimitOAuthWindowMs: oauthRateLimit.windowMs,
-            resourceName: this.profile.resource_name || resourceMetadata.name || 'MCP Server',
-            resourceDocumentation: this.profile.resource_documentation || resourceMetadata.documentation,
-            parser: this.parser,
-        };
-    }
-    /**
-     * Extract hostnames from origin patterns for OAuth redirect validation
-     * e.g., "http://localhost:*,https://app.example.com" -> ["localhost", "app.example.com"]
-     *
-     * Filters out CIDR blocks (e.g., "127.0.0.1/8") which are valid for origin validation
-     * but not for OAuth redirect URI validation
-     */
-    extractHostsFromOrigins(origins) {
-        const hosts = [];
-        for (const origin of origins.split(',')) {
-            const trimmed = origin.trim();
-            try {
-                // Handle wildcard ports: http://localhost:* -> localhost
-                const normalized = trimmed.replace(/:\*$/, ':80');
-                const url = new URL(normalized);
-                // Preserve wildcards in hostname
-                if (trimmed.includes('*.')) {
-                    const match = trimmed.match(/\*\.[^:/]+/);
-                    if (match) {
-                        hosts.push(match[0]);
-                    }
-                }
-                else {
-                    hosts.push(url.hostname);
-                }
-            }
-            catch {
-                // If not a URL, treat as hostname/pattern directly
-                // Skip CIDR blocks (e.g., 127.0.0.1/8, 10.0.0.0/8, 2a06:2140::/29)
-                if (trimmed && !trimmed.includes(' ') && !trimmed.includes('/')) {
-                    hosts.push(trimmed);
-                }
-            }
-        }
-        return [...new Set(hosts)]; // Dedupe
-    }
-    /**
-     * Get or create HTTP client for session
-     */
-    async getHttpClientForSession(sessionId, profileId) {
-        if (!sessionId) {
-            // Fallback to global client for stdio transport
-            if (!this.httpClientFactory.hasGlobalClient()) {
-                const hasHttpTransport = !!this.httpTransport;
-                const transport = hasHttpTransport ? 'http' : 'stdio';
-                const envAuthConfig = this.getEnvBackedAuthConfig();
-                const envVarName = envAuthConfig?.value_from_env || 'MCP4_API_TOKEN';
-                const hasEnvToken = !!process.env[envVarName];
-                throw new ConfigurationError(`HTTP client not initialized. ` +
-                    `Transport: ${transport}, ` +
-                    `HasEnvToken(${envVarName}): ${hasEnvToken}, ` +
-                    `Suggestion: ${hasHttpTransport
-                        ? 'Send token in Authorization header during initialization'
-                        : `Set ${envVarName} environment variable`}`, { transport, hasEnvToken, envVarName, hasHttpTransport });
-            }
-            return this.httpClientFactory.getGlobalClient();
-        }
-        // Validate profile exists
-        if (!this.profile) {
-            throw new ConfigurationError('Profile not initialized. Call initialize() first.');
-        }
-        // Get auth token from session (ensures token is valid/refreshed)
-        const authToken = await this.getAuthTokenFromSession(sessionId, profileId);
-        // Create or get session client using factory
-        return this.httpClientFactory.getOrCreateSessionClient(sessionId, {
-            profile: this.profile,
-            baseUrl: this.getBaseUrl(),
-            sessionToken: authToken,
-        });
-    }
-    /**
-     * Get auth token from HTTP transport session
-     * Ensures token is valid (refreshes if expired) before returning
-     */
-    async getAuthTokenFromSession(sessionId, profileId) {
-        // Early return if sessionId is missing/empty
-        // Prevents misleading warn logs with empty sessionId
-        if (!sessionId) {
-            return undefined;
-        }
-        if (!this.httpTransport) {
-            return undefined;
-        }
-        // Ensure token is valid (refresh if expired)
-        const effectiveProfileId = profileId || this.getProfileIdValue();
-        const isValid = await this.httpTransport.ensureValidSessionToken(effectiveProfileId, sessionId);
-        if (!isValid) {
-            this.logger.warn('Session token validation/refresh failed', { profileId: effectiveProfileId, sessionId });
-            // Still return token if available - let the API call fail with proper error
-        }
-        // Use public API instead of type casting
-        return this.httpTransport.getSessionToken(effectiveProfileId, sessionId);
-    }
-    /**
-     * Cleanup HTTP client for destroyed session
-     *
-     * Why: Prevent memory leak - sessions expire but cached clients stay forever
-     */
-    cleanupSessionClient(profileId, sessionId) {
-        const removed = this.httpClientFactory.cleanupSessionClient(sessionId);
-        if (removed) {
-            this.logger.info('Cleaned up session HTTP client', { profileId, sessionId });
-        }
-    }
-    /**
-     * Setup MCP request handlers
-     */
-    setupHandlers() {
-        // List available tools
-        this.server.setRequestHandler(ListToolsRequestSchema, async () => {
-            try {
-                if (!this.profile) {
-                    throw new ConfigurationError('Server not initialized. Call initialize() first.');
-                }
-                const tools = this.profile.tools.map(toolDef => this.toolGenerator.generateTool(toolDef));
-                return { tools };
-            }
-            catch (err) {
-                // Generate correlation ID only on error (lazy)
-                const correlationId = generateCorrelationId();
-                this.logger.error('ListTools handler error', err, { correlationId });
-                // Always return generic error to clients
-                throw new Error(`Internal error (correlation ID: ${correlationId})`);
-            }
-        });
-        // Execute tool
-        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-            try {
-                if (!this.profile || !this.compositeExecutor) {
-                    throw new ConfigurationError('Server not initialized. Call initialize() first.');
-                }
-                const toolDef = this.profile.tools.find(t => t.name === request.params.name);
-                if (!toolDef) {
-                    throw new OperationNotFoundError(request.params.name);
-                }
-                const args = request.params.arguments || {};
-                // Validate arguments
-                this.toolGenerator.validateArguments(toolDef, args);
-                // Execute composite or simple tool
-                let result;
-                if (toolDef.composite && toolDef.steps) {
-                    const compositeResult = await this.compositeExecutor.execute(toolDef.steps, args, toolDef.partial_results || false);
-                    // Include metadata about completion
-                    result = {
-                        ...compositeResult.data,
-                        _metadata: {
-                            completed_steps: compositeResult.completed_steps,
-                            total_steps: compositeResult.total_steps,
-                            success: compositeResult.completed_steps === compositeResult.total_steps,
-                            errors: compositeResult.errors,
-                        },
-                    };
-                }
-                else {
-                    result = await this.executeSimpleTool(toolDef, args);
-                }
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify(result, null, 2),
-                        },
-                    ],
-                };
-            }
-            catch (err) {
-                // Generate correlation ID only on error (lazy)
-                const correlationId = generateCorrelationId();
-                this.logger.error('CallTool handler error', err, {
-                    correlationId,
-                    toolName: request.params.name,
-                    action: request.params.arguments?.action
-                });
-                // Return user-friendly error message with correlation ID
-                const errorMessage = this.formatErrorForClient(err, correlationId);
-                throw new Error(errorMessage);
-            }
-        });
-    }
-    /**
-     * Execute simple (non-composite) tool
-     *
-     * Why separate: Simple tools map directly to single OpenAPI operation.
-     * No result aggregation needed.
-     */
-    async executeSimpleTool(toolDef, args, sessionId, profileId) {
-        const normalizedArgs = normalizeArguments(toolDef, args);
-        this.logger.debug('Executing simple tool', {
-            toolName: toolDef.name,
-            action: normalizedArgs['action'],
-            resourceType: normalizedArgs['resource_type'],
-            sessionId
-        });
-        // Get operation definition (can be string or ProxyDownloadOperation)
-        const operationDef = this.toolGenerator.getOperationDefinition(toolDef, normalizedArgs);
-        if (!operationDef) {
-            throw new ValidationError(`Could not map tool action to operation`, {
-                toolName: toolDef.name,
-                action: args['action'],
-                resourceType: args['resource_type'],
-                availableOperations: Object.keys(toolDef.operations || {})
-            });
-        }
-        // Check if this is a proxy download operation
-        if (typeof operationDef === 'object' && operationDef.type === 'proxy_download') {
-            return this.executeProxyDownload(operationDef, normalizedArgs, sessionId, profileId);
-        }
-        // Regular string operation
-        const operationId = operationDef;
-        const operation = this.parser.getOperation(operationId);
-        if (!operation) {
-            throw new OperationNotFoundError(operationId);
-        }
-        // Build request
-        const path = this.resolvePath(operation.path, normalizedArgs);
-        const queryParams = this.extractQueryParams(operation, normalizedArgs);
-        const body = this.extractBody(operation, normalizedArgs, toolDef);
-        this.logger.debug('Executing HTTP request', {
-            operationId,
-            method: operation.method,
-            path,
-            hasQueryParams: Object.keys(queryParams).length > 0,
-            hasBody: !!body
-        });
-        // Validate request body against schema
-        if (body && operation.requestBody) {
-            const validationResult = this.schemaValidator.validateRequestBody(operation, body);
-            if (!validationResult.valid && validationResult.errors) {
-                const errorDetails = validationResult.errors
-                    .map(e => `  - ${e.path}: ${e.message}`)
-                    .join('\n');
-                throw new ValidationError(`Request body validation failed:\n${errorDetails}`, { operationId, validationErrors: validationResult.errors });
-            }
-        }
-        // Execute with session-specific client
-        const httpClient = await this.getHttpClientForSession(sessionId, profileId);
-        // Set fields parameter if response_fields are configured for this action AND enabled
-        const action = normalizedArgs.action;
-        if (toolDef.send_response_fields_as_param && toolDef.response_fields && action && toolDef.response_fields[action]) {
-            const fields = toolDef.response_fields[action];
-            queryParams.fields = fields.join(',');
-        }
-        const response = await httpClient.request(operation.method, path, {
-            params: queryParams,
-            body,
-            operationId: operationId,
-        });
-        // Apply response field filtering if configured
-        let result = response.body;
-        if (toolDef.response_fields) {
-            const action = normalizedArgs.action;
-            if (action && toolDef.response_fields[action]) {
-                const fields = toolDef.response_fields[action];
-                result = this.filterFields(result, fields);
-            }
-        }
-        return result;
-    }
-    /**
-     * Execute proxy download operation
-     *
-     * Why: Some APIs return authenticated URLs that LLMs cannot fetch directly.
-     * This proxies the download through the MCP server.
-     */
-    async executeProxyDownload(operation, args, sessionId, profileId) {
-        this.logger.debug('Executing proxy download', {
-            metadataEndpoint: operation.metadata_endpoint,
-            urlField: operation.url_field,
-            sessionId
-        });
-        // Get the metadata operation to build the path
-        const metadataOp = this.parser.getOperation(operation.metadata_endpoint);
-        if (!metadataOp) {
-            throw new OperationNotFoundError(operation.metadata_endpoint);
-        }
-        // Build path for metadata endpoint
-        const metadataPath = this.resolvePath(metadataOp.path, args);
-        const metadataMethod = metadataOp.method;
-        let directDownloadRequest;
-        if (operation.download_endpoint) {
-            const downloadOp = this.parser.getOperation(operation.download_endpoint);
-            if (!downloadOp) {
-                throw new OperationNotFoundError(operation.download_endpoint);
-            }
-            directDownloadRequest = {
-                path: this.resolvePath(downloadOp.path, args),
-                method: downloadOp.method,
-            };
-        }
-        // Get auth credentials for download
-        const httpClient = await this.getHttpClientForSession(sessionId, profileId);
-        const authCredentials = httpClient.getAuthCredentials();
-        // Execute proxy download
-        const proxyExecutor = new ProxyDownloadExecutor(httpClient, this.logger);
-        const result = await proxyExecutor.execute(operation, { path: metadataPath, method: metadataMethod }, authCredentials, directDownloadRequest);
-        this.logger.debug('Proxy download completed', {
-            fileName: result.fileName,
-            mimeType: result.mimeType,
-            size: result.size
-        });
-        return result;
-    }
-    /**
-     * Encode path segment if it contains special characters (like slashes)
-     *
-     * Why: GitLab and other APIs require path parameters (like project paths)
-     * to be URL-encoded when used in URL path.
-     */
-    encodePathSegment(value) {
-        const val = String(value);
-        return val.includes('/') ? encodeURIComponent(val) : val;
-    }
-    /**
-     * Resolve path parameters using profile aliases
-     *
-     * Why aliases: Different tools may use different parameter names for same path param.
-     * Example: GitLab uses "resource_id", "project_id", "group_id" all mapping to "{id}"
-     */
-    resolvePath(template, args) {
-        const aliases = this.profile?.parameter_aliases || {};
-        return template.replace(/\{(\w+)\}/g, (_, key) => {
-            // Try direct match first
-            if (args[key] !== undefined) {
-                return this.encodePathSegment(args[key]);
-            }
-            // Try aliases from profile
-            const possibleAliases = aliases[key] || [];
-            for (const alias of possibleAliases) {
-                if (args[alias] !== undefined) {
-                    return this.encodePathSegment(args[alias]);
-                }
-            }
-            throw new ValidationError(`Missing path parameter: ${key}` +
-                (possibleAliases.length > 0 ? `. Tried aliases: ${possibleAliases.join(', ')}` : ''), { paramName: key, possibleAliases });
-        });
-    }
-    /**
-     * Extract query parameters from args
-     *
-     * Why: Separate query params from body params. Array handling is done by HttpClient
-     * based on profile's array_format setting.
-     */
-    extractQueryParams(operation, args) {
-        const params = {};
-        const aliases = this.profile?.parameter_aliases || {};
-        for (const param of operation.parameters) {
-            if (param.in === 'query') {
-                let value = args[param.name];
-                // If not found by direct name, check aliases
-                if (value === undefined) {
-                    const possibleAliases = aliases[param.name] || [];
-                    for (const alias of possibleAliases) {
-                        if (args[alias] !== undefined) {
-                            value = args[alias];
-                            break;
-                        }
-                    }
-                }
-                if (value !== undefined) {
-                    // Pass arrays as-is, HttpClient will serialize based on array_format
-                    if (Array.isArray(value)) {
-                        params[param.name] = value.map(String);
-                    }
-                    else {
-                        params[param.name] = String(value);
-                    }
-                }
-            }
-        }
-        return params;
-    }
-    /**
-     * Extract request body from args
-     *
-     * Why: For create/update operations, collect non-metadata fields into body.
-     * Metadata (action, resource_type, etc.) are not sent to API.
-     * Path/query parameters are excluded from body UNLESS they're also in request body schema.
-     *
-     * Uses metadata_params from tool definition, defaults to ['action', 'resource_type']
-     */
-    extractBody(operation, args, toolDef) {
-        // Metadata fields from tool definition (or defaults)
-        const metadataList = toolDef.metadata_params || ['action', 'resource_type'];
-        const metadata = new Set(metadataList);
-        // Collect parameter names that go in path or query
-        const pathOrQuery = new Set();
-        for (const param of operation.parameters) {
-            if (param.in === 'path' || param.in === 'query') {
-                pathOrQuery.add(param.name);
-            }
-        }
-        // Get body schema properties to check if path/query params should also be in body
-        const bodySchemaProps = new Set();
-        if (operation.requestBody?.content) {
-            // Check all content types (typically application/json)
-            for (const mediaType of Object.values(operation.requestBody.content)) {
-                if (mediaType.schema?.properties) {
-                    for (const propName of Object.keys(mediaType.schema.properties)) {
-                        bodySchemaProps.add(propName);
-                    }
-                }
-            }
-        }
-        const body = {};
-        let hasBody = false;
-        for (const [key, value] of Object.entries(args)) {
-            // Include field if:
-            // - Not metadata
-            // - Not in path/query OR is in path/query but also required in body schema
-            // - Value is defined
-            const isPathOrQuery = pathOrQuery.has(key);
-            const isInBodySchema = bodySchemaProps.has(key);
-            if (!metadata.has(key) && (!isPathOrQuery || isInBodySchema) && value !== undefined) {
-                body[key] = value;
-                hasBody = true;
-            }
-        }
-        return hasBody ? body : undefined;
-    }
-    /**
-     * Start server with stdio transport
-     */
-    async runStdio() {
-        const transport = new StdioServerTransport();
-        await this.server.connect(transport);
-        this.logger.info('MCP server running on stdio');
-    }
-    /**
-     * Start server with HTTP transport
-     *
-     * Implements MCP Specification 2025-03-26 Streamable HTTP transport
-     *
-     * Why: Enables remote MCP server access with SSE streaming, session management,
-     * and resumability for reliable communication over HTTP.
-     */
-    async runHttp(host, port) {
-        const { HttpTransport } = await import('./http-transport.js');
-        const profileContext = this.getHttpProfileContext();
-        if (profileContext.oauthConfig) {
-            this.logger.info('OAuth authentication enabled for HTTP transport');
-        }
-        const baseConfig = buildHttpTransportBaseConfig(host, port);
-        const config = {
-            ...baseConfig,
-            profileRoutingEnabled: false,
-            defaultProfileId: profileContext.profileId,
-            // OAuth rate limiting (priority: profile > env vars > defaults)
-            rateLimitOAuthMax: profileContext.rateLimitOAuthMax,
-            rateLimitOAuthWindowMs: profileContext.rateLimitOAuthWindowMs,
-            // OAuth config already merged with allowed_redirect_hosts
-            oauthConfig: profileContext.oauthConfig,
-            baseUrl: profileContext.baseUrl,
-            authConfigs: profileContext.authConfigs,
-            resourceName: profileContext.resourceName,
-            resourceDocumentation: profileContext.resourceDocumentation,
-            parser: profileContext.parser,
-        };
-        // Warn if binding to non-localhost without explicit MCP4_ALLOWED_ORIGINS
-        const isLocalhost = host === 'localhost' || host === '127.0.0.1' || host === '::1';
-        const hasAllowedOrigins = Array.isArray(config.allowedOrigins) && config.allowedOrigins.length > 0;
-        if (!isLocalhost && !hasAllowedOrigins) {
-            this.logger.warn('Binding to non-localhost with empty MCP4_ALLOWED_ORIGINS. Set MCP4_ALLOWED_ORIGINS or bind to localhost.');
-        }
-        this.httpTransport = new HttpTransport(config, this.logger);
-        this.recordGlobalToolFilterMetrics();
-        // Set message handler to process JSON-RPC messages
-        this.httpTransport.setMessageHandler(async (message, sessionId, profileId) => {
-            return await this.handleJsonRpcMessage(message, sessionId, profileId);
-        });
-        // Register cleanup listener for session destruction (memory leak prevention)
-        this.httpTransport.onSessionDestroyed((profileId, sessionId) => {
-            this.cleanupSessionClient(profileId, sessionId);
-        });
-        await this.httpTransport.start();
-        this.logger.info('MCP server running on HTTP', { host, port });
-    }
-    attachHttpTransport(transport) {
-        this.httpTransport = transport;
-    }
-    handleSessionDestroyed(profileId, sessionId) {
-        this.cleanupSessionClient(profileId, sessionId);
-    }
-    /**
-     * Handle JSON-RPC message from HTTP transport
-     *
-     * Why: Unified message handling for both stdio and HTTP transports
-     */
-    async handleJsonRpcMessage(message, sessionId, profileId) {
-        // Handle initialize
-        if (isInitializeRequest(message)) {
-            return this.handleInitialize(message, sessionId, profileId);
-        }
-        // Handle tool calls
-        if (isToolCallRequest(message)) {
-            return await this.handleToolCall(message, sessionId, profileId);
-        }
-        // Handle other JSON-RPC requests
-        // (tools/list, prompts/list, etc.)
-        return await this.handleOtherRequest(message, sessionId, profileId);
-    }
-    async handleHttpMessage(message, sessionId, profileId) {
-        return this.handleJsonRpcMessage(message, sessionId, profileId);
-    }
-    handleInitialize(message, sessionId, profileId) {
-        const req = message;
-        const params = req.params;
-        if (!this.httpTransport && params?.filtering !== undefined) {
-            if (typeof params.filtering !== 'string') {
-                throw new ValidationError('Invalid X-Mcp4-Params header. Expected comma-separated key=value pairs.');
-            }
-            const parsed = parseFilteringHeader(params.filtering);
-            this.stdioFiltering = parsed.filtering;
-        }
-        if (this.httpTransport && sessionId) {
-            this.applySessionToolFiltering(sessionId, profileId);
-        }
-        const result = {
-            protocolVersion: '2025-03-26',
-            serverInfo: {
-                name: 'mcp4openapi',
-                version: '0.1.0',
-            },
-            capabilities: {
-                tools: {},
-            },
-        };
-        // OAuth capability is communicated via 401 responses with WWW-Authenticate header
-        // as per MCP Authorization specification
-        // Include sessionId if available (for HTTP transport)
-        if (sessionId) {
-            result.sessionId = sessionId;
-        }
-        return {
-            jsonrpc: '2.0',
-            id: req.id,
-            result,
-        };
-    }
-    async handleToolCall(message, sessionId, profileId) {
-        const req = message;
-        const params = req.params;
-        const toolName = params.name;
-        const args = params.arguments;
-        // Check OAuth authentication for tool operations
-        if (this.httpTransport && this.httpTransport.hasOAuthProvider(profileId)) {
-            const authToken = await this.getAuthTokenFromSession(sessionId || '', profileId);
-            if (!authToken) {
-                // Return OAuth required error with WWW-Authenticate header
-                // This should trigger the OAuth flow in the client
-                const errorResponse = {
-                    jsonrpc: '2.0',
-                    id: req.id,
-                    error: {
-                        code: -32001, // Application error
-                        message: 'Authentication required. Please authorize via OAuth.',
-                        data: {
-                            oauth_required: true,
-                            resource_metadata: this.httpTransport.getOAuthProtectedResourceUrl(profileId),
-                            scope: 'api'
-                        }
-                    }
-                };
-                return errorResponse;
-            }
-        }
-        try {
-            // Find tool definition
-            const toolDef = this.profile?.tools.find(t => t.name === toolName);
-            if (!toolDef) {
-                throw new ResourceNotFoundError(toolName, 'Tool');
-            }
-            const toolFilter = this.getToolFilterForSession(sessionId, profileId);
-            if (toolFilter && !toolFilter.allowedToolNames.has(toolName)) {
-                this.recordToolFilterRejection(toolName, 'session');
-                const reason = toolFilter.reasons.get(toolName)?.[0];
-                const reasonSuffix = reason ? ` Blocked by: ${reason}.` : '';
-                throw new AuthorizationError(`Tool '${toolName}' not allowed by X-Mcp4-Tools filter.${reasonSuffix}`);
-            }
-            const filtering = this.getFilteringForSession(sessionId, profileId);
-            if (filtering) {
-                const operation = this.getFilteringOperationInfo(toolDef, args);
-                enforceFiltering({
-                    filtering,
-                    toolDef,
-                    args,
-                    parameterAliases: this.profile?.parameter_aliases,
-                    operation,
-                });
-            }
-            // Execute tool (reuse existing execution logic)
-            let result;
-            if (toolDef.composite && toolDef.steps) {
-                const httpClient = await this.getHttpClientForSession(sessionId, profileId);
-                const compositeResult = await this.compositeExecutor.execute(toolDef.steps, args, toolDef.partial_results || false, httpClient);
-                result = {
-                    data: compositeResult.data,
-                    completed_steps: compositeResult.completed_steps,
-                    total_steps: compositeResult.total_steps,
-                    success: compositeResult.completed_steps === compositeResult.total_steps,
-                    errors: compositeResult.errors,
-                };
-            }
-            else {
-                result = await this.executeSimpleTool(toolDef, args, sessionId, profileId);
-            }
-            return {
-                jsonrpc: '2.0',
-                id: req.id,
-                result: {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify(result, null, 2),
-                        },
-                    ],
-                },
-            };
-        }
-        catch (error) {
-            // Generate correlation ID only on error (lazy)
-            const correlationId = generateCorrelationId();
-            // Log internal error details with correlation ID
-            this.logger.error('Tool call error', error, {
-                correlationId,
-                toolName,
-                action: args?.action,
-                resourceType: args?.resource_type,
-                sessionId
-            });
-            // Return user-friendly error message with correlation ID
-            const errorMessage = this.formatErrorForClient(error, correlationId);
-            // Map error type to JSON-RPC error code
-            let errorCode = -32603; // Internal error (default)
-            if (error instanceof AuthenticationError) {
-                errorCode = -32001; // Authentication error
-            }
-            else if (error instanceof AuthorizationError) {
-                errorCode = -32002; // Authorization error
-            }
-            else if (error instanceof ValidationError) {
-                errorCode = -32602; // Invalid params
-            }
-            else if (error instanceof RateLimitError) {
-                errorCode = -32003; // Rate limit error
-            }
-            else if (error instanceof OperationNotFoundError) {
-                errorCode = -32601; // Method not found
-            }
-            else if (error instanceof ResourceNotFoundError) {
-                errorCode = -32601; // Method not found
-            }
-            return {
-                jsonrpc: '2.0',
-                id: req.id,
-                error: {
-                    code: errorCode,
-                    message: errorMessage,
-                },
-            };
-        }
-    }
-    getFilteringForSession(sessionId, profileId) {
-        if (this.httpTransport && sessionId) {
-            const effectiveProfileId = profileId || this.getProfileIdValue();
-            return this.httpTransport.getSessionFiltering(effectiveProfileId, sessionId);
-        }
-        return this.stdioFiltering;
-    }
-    getToolFilterForSession(sessionId, profileId) {
-        if (this.httpTransport && sessionId && typeof this.httpTransport.getSessionToolFilter === 'function') {
-            const effectiveProfileId = profileId || this.getProfileIdValue();
-            return this.httpTransport.getSessionToolFilter(effectiveProfileId, sessionId);
-        }
-        return undefined;
-    }
-    getFilteringOperationInfo(toolDef, args) {
-        if (toolDef.composite) {
-            return undefined;
-        }
-        const operationId = this.toolGenerator.mapActionToOperation(toolDef, args);
-        if (!operationId) {
-            return undefined;
-        }
-        return this.parser.getOperation(operationId);
-    }
-    async handleOtherRequest(message, sessionId, profileId) {
-        const req = message;
-        // Check OAuth authentication for other operations (like tools/list)
-        if (this.httpTransport && this.httpTransport.hasOAuthProvider(profileId)) {
-            const authToken = await this.getAuthTokenFromSession(sessionId || '', profileId);
-            if (!authToken) {
-                // Return OAuth required error with WWW-Authenticate header
-                // This should trigger the OAuth flow in the client
-                const errorResponse = {
-                    jsonrpc: '2.0',
-                    id: req.id,
-                    error: {
-                        code: -32001, // Application error
-                        message: 'Authentication required. Please authorize via OAuth.',
-                        data: {
-                            oauth_required: true,
-                            resource_metadata: this.httpTransport.getOAuthProtectedResourceUrl(profileId),
-                            scope: 'api'
-                        }
-                    }
-                };
-                return errorResponse;
-            }
-        }
-        // Handle tools/list
-        if (req.method === 'tools/list') {
-            const sessionFilter = this.getToolFilterForSession(sessionId, profileId);
-            const allowedSet = sessionFilter?.allowedToolNames;
-            const tools = this.profile?.tools
-                .filter(toolDef => !allowedSet || allowedSet.has(toolDef.name))
-                .map(toolDef => this.toolGenerator.generateTool(toolDef)) || [];
-            return {
-                jsonrpc: '2.0',
-                id: req.id,
-                result: {
-                    tools,
-                },
-            };
-        }
-        // Unknown method
-        return {
-            jsonrpc: '2.0',
-            id: req.id,
-            error: {
-                code: -32601,
-                message: `Method not found: ${req.method}`,
-            },
-        };
-    }
-    applyGlobalToolFiltering() {
-        if (!this.profile) {
-            return;
-        }
-        // Initialize ToolFilterService if not already done
-        if (!this.toolFilterService) {
-            const validator = new RegexValidator();
-            const compiler = new RegexCompiler(validator);
-            const envParser = new EnvConfigParser(compiler);
-            const headerParser = new HeaderConfigParser(compiler);
-            // Create OperationDetector for category filtering
-            const classifier = new OperationClassifier();
-            const resolver = new OpenAPIOperationResolver(this.parser);
-            const detector = new OperationDetector(classifier, resolver);
-            this.toolFilterService = new ToolFilterService(envParser, headerParser, this.logger, detector);
-        }
-        const originalTools = this.profile.tools;
-        const originalCount = originalTools.length;
-        // Apply filtering using new service
-        const filteredTools = this.toolFilterService.applyGlobalFilter(originalTools, process.env);
-        const allowedCount = filteredTools.length;
-        const removedCount = originalCount - allowedCount;
-        // Early return if no filtering config present (service returned same tools)
-        if (filteredTools === originalTools) {
-            return;
-        }
-        // Validation: check if filter has no effect
-        if (originalCount > 0 && allowedCount === originalCount && removedCount === 0) {
-            throw new ConfigurationError(`Tool filter configuration has no effect. Original tool count: ${originalCount}, filtered: ${allowedCount}. Check MCP4_TOOL_FILTER_* patterns.`);
-        }
-        // Validation: check if all tools filtered
-        if (originalCount > 0 && allowedCount === 0) {
-            throw new ConfigurationError(`All tools filtered out (original: ${originalCount}). Check MCP4_TOOL_FILTER_* settings.`);
-        }
-        // Validate composite tools against filtered operations
-        const resolver = this.buildToolFilterResolver();
-        this.validateCompositeToolsAgainstFilteredOperations(originalTools, filteredTools, resolver);
-        // Update profile
-        this.profile.tools = filteredTools;
-        // Record summary for metrics
-        this.globalToolFilterSummary = {
-            originalCount,
-            allowedCount,
-            removedCount,
-            patternCounts: {
-                // Note: counts not available from new service, using simplified version
-                filtered: removedCount
-            }
-        };
-        // Warn if high percentage filtered
-        const warnThreshold = this.getToolFilterWarnThresholdPct();
-        if (originalCount > 0) {
-            const percentFiltered = (removedCount / originalCount) * 100;
-            if (percentFiltered >= warnThreshold) {
-                this.logger.warn('Tool filter removed high percentage of tools', {
-                    original: originalCount,
-                    surviving: allowedCount,
-                    threshold_pct: warnThreshold,
-                    removed_count: removedCount
-                });
-            }
-        }
-        if (this.httpTransport) {
-            this.recordGlobalToolFilterMetrics();
-        }
-    }
-    applySessionToolFiltering(sessionId, profileId) {
-        if (!this.httpTransport || !this.profile) {
-            return;
-        }
-        if (typeof this.httpTransport.getSessionToolFilterRequest !== 'function') {
-            return;
-        }
-        const effectiveProfileId = profileId || this.getProfileIdValue();
-        const request = this.httpTransport.getSessionToolFilterRequest(effectiveProfileId, sessionId);
-        if (!request) {
-            return;
-        }
-        const originalCount = this.profile.tools.length;
-        const resolver = this.buildToolFilterResolver();
-        const sessionFilter = applySessionToolFilter(this.profile.tools, request, resolver);
-        const allowedCount = sessionFilter.allowedToolNames.size;
-        if (allowedCount === originalCount) {
-            throw new ValidationError(`X-Mcp4-Tools filter has no effect for this session. Available tools: ${originalCount}, after filter: ${allowedCount}. Check patterns.`);
-        }
-        if (originalCount > 0 && allowedCount === 0) {
-            const sources = request.rawEntries.length > 0 ? request.rawEntries.join(', ') : 'none';
-            throw new ValidationError(`X-Mcp4-Tools filtered out all tools (original: ${originalCount}). Removed by: ${sources}. Check session filter configuration.`);
-        }
-        this.httpTransport.setSessionToolFilter(effectiveProfileId, sessionId, sessionFilter);
-        this.logger.info('Session tool filter applied', {
-            sessionId,
-            originalCount,
-            allowedCount,
-            patterns: request.rawEntries,
-        });
-        this.recordSessionToolFilterMetrics(sessionId, allowedCount, request);
-    }
-    buildToolFilterResolver() {
-        return {
-            getOperationById: (operationId) => this.parser.getOperation(operationId),
-            getOperationForCall: (call) => {
-                const [method, path] = call.split(' ');
-                if (!method || !path) {
-                    return undefined;
-                }
-                const pathInfo = this.parser.getPath(path);
-                return pathInfo?.operations[method.toLowerCase()];
-            },
-        };
-    }
-    validateCompositeToolsAgainstFilteredOperations(originalTools, allowedTools, resolver) {
-        const operationToTools = new Map();
-        for (const tool of originalTools) {
-            if (!tool.operations) {
-                continue;
-            }
-            for (const operationId of Object.values(tool.operations)) {
-                if (typeof operationId !== 'string') {
-                    continue;
-                }
-                const names = operationToTools.get(operationId) ?? [];
-                names.push(tool.name);
-                operationToTools.set(operationId, names);
-            }
-        }
-        const allowedOperationIds = new Set();
-        for (const tool of allowedTools) {
-            if (!tool.operations) {
-                continue;
-            }
-            for (const operationId of Object.values(tool.operations)) {
-                if (typeof operationId !== 'string') {
-                    continue;
-                }
-                allowedOperationIds.add(operationId);
-            }
-        }
-        for (const tool of allowedTools) {
-            if (!tool.composite || !tool.steps) {
-                continue;
-            }
-            for (const step of tool.steps) {
-                const operation = resolver.getOperationForCall(step.call);
-                if (!operation) {
-                    continue;
-                }
-                if (allowedOperationIds.has(operation.operationId)) {
-                    continue;
-                }
-                const removedTools = operationToTools.get(operation.operationId);
-                if (!removedTools || removedTools.length === 0) {
-                    continue;
-                }
-                const removedList = removedTools.join(', ');
-                throw new ConfigurationError(`Composite tool '${tool.name}' step '${step.call}' calls filtered tool '${removedList}'. ` +
-                    `Add '${removedList}' to filter or include _allow_list or _allow_read if it is a list or read operation.`);
-            }
-        }
-    }
-    getToolFilterWarnThresholdPct() {
-        const raw = process.env.MCP4_TOOL_FILTER_WARN_THRESHOLD_PCT;
-        if (raw === undefined) {
-            return 90;
-        }
-        const parsed = Number(raw);
-        if (Number.isNaN(parsed) || parsed <= 0) {
-            throw new ConfigurationError(`Invalid MCP4_TOOL_FILTER_WARN_THRESHOLD_PCT: expected positive number, got '${raw}'.`);
-        }
-        return parsed;
-    }
-    recordGlobalToolFilterMetrics() {
-        if (!this.httpTransport || !this.globalToolFilterSummary) {
-            return;
-        }
-        if (typeof this.httpTransport.recordGlobalToolFilterMetrics !== 'function') {
-            return;
-        }
-        this.httpTransport.recordGlobalToolFilterMetrics(this.globalToolFilterSummary);
-    }
-    recordSessionToolFilterMetrics(sessionId, allowedCount, request) {
-        if (!this.httpTransport) {
-            return;
-        }
-        if (typeof this.httpTransport.recordSessionToolFilterMetrics !== 'function') {
-            return;
-        }
-        this.httpTransport.recordSessionToolFilterMetrics(sessionId, allowedCount, request);
-    }
-    recordToolFilterRejection(toolName, source) {
-        if (!this.httpTransport) {
-            return;
-        }
-        if (typeof this.httpTransport.recordToolFilterRejection !== 'function') {
-            return;
-        }
-        this.httpTransport.recordToolFilterRejection(toolName, source);
-    }
-    /**
-     * Stop the MCP server gracefully
-     *
-     * Why: Cleanup resources, close connections, allow graceful shutdown
-     */
-    async stop() {
-        if (this.httpTransport) {
-            await this.httpTransport.stop();
-        }
-    }
-}
-//# sourceMappingURL=mcp-server.js.map