@smallironman/mcp-memory-keeper 0.12.2-fork1

package/dist/utils/token-limits.js

@@ -0,0 +1,350 @@
+"use strict";
+/**
+ * Token limit management utilities for MCP Memory Keeper
+ *
+ * Provides dynamic calculation of safe limits based on actual content
+ * instead of relying on hardcoded values scattered throughout the codebase.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_TOKEN_CONFIG = exports.TOKEN_WARNING_THRESHOLD = void 0;
+exports.estimateTokens = estimateTokens;
+exports.calculateSize = calculateSize;
+exports.estimateResponseOverhead = estimateResponseOverhead;
+exports.calculateSafeItemLimit = calculateSafeItemLimit;
+exports.calculateDynamicDefaultLimit = calculateDynamicDefaultLimit;
+exports.checkTokenLimit = checkTokenLimit;
+exports.getTokenConfig = getTokenConfig;
+// Validation bounds for environment variables
+const VALIDATION_BOUNDS = {
+    MAX_TOKENS: { MIN: 1000, MAX: 100000 },
+    SAFETY_BUFFER: { MIN: 0.1, MAX: 1.0 },
+    MIN_ITEMS: { MIN: 1, MAX: 100 },
+    MAX_ITEMS: { MIN: 10, MAX: 1000 },
+    CHARS_PER_TOKEN: { MIN: 2.5, MAX: 5.0 }, // Advanced: token estimation ratio
+};
+// SQL query limits
+const QUERY_LIMITS = {
+    SAMPLE_SIZE: 10, // Items to sample for average size calculation
+};
+// JSON formatting
+const JSON_INDENT_SPACES = 2;
+// Warning threshold for token usage (70% of limit)
+exports.TOKEN_WARNING_THRESHOLD = 0.7;
+/** Default configuration values */
+exports.DEFAULT_TOKEN_CONFIG = {
+    mcpMaxTokens: 25000,
+    safetyBuffer: 0.8, // Use only 80% of the limit for safety
+    minItems: 1,
+    maxItems: 100,
+    charsPerToken: 3.5, // Conservative estimate for JSON content
+};
+/**
+ * Estimates token count for a given text
+ * @param text The text to estimate tokens for
+ * @param charsPerToken Optional character-to-token ratio (default: 3.5)
+ * @returns Estimated number of tokens
+ *
+ * Token estimation is based on empirical analysis of OpenAI's tokenization:
+ * - OpenAI's guideline: ~4 characters per token for English text
+ * - Default uses 3.5 chars/token for more conservative estimation
+ * - This accounts for JSON formatting, special characters, and metadata overhead
+ * - Conservative estimation prevents unexpected token limit errors
+ * - Can be configured via MCP_CHARS_PER_TOKEN environment variable
+ */
+function estimateTokens(text, charsPerToken = exports.DEFAULT_TOKEN_CONFIG.charsPerToken) {
+    return Math.ceil(text.length / charsPerToken);
+}
+/**
+ * Calculate the size of a value in bytes
+ */
+function calculateSize(value) {
+    return Buffer.byteLength(value, 'utf8');
+}
+/**
+ * Estimates the overhead of the response structure
+ * @param itemCount Number of items in the response
+ * @param includeMetadata Whether metadata fields are included
+ * @param config Optional token configuration
+ * @returns Estimated tokens for the response wrapper
+ */
+function estimateResponseOverhead(itemCount, includeMetadata = false, config = exports.DEFAULT_TOKEN_CONFIG) {
+    // Base pagination structure
+    const basePagination = {
+        total: 0,
+        returned: 0,
+        offset: 0,
+        hasMore: false,
+        nextOffset: null,
+        totalCount: 0,
+        page: 1,
+        pageSize: 0,
+        totalPages: 1,
+        hasNextPage: false,
+        hasPreviousPage: false,
+        previousOffset: null,
+        totalSize: 0,
+        averageSize: 0,
+        defaultsApplied: { limit: true, sort: true },
+        truncated: false,
+        truncatedCount: 0,
+    };
+    // Extended fields when metadata is included
+    if (includeMetadata) {
+        // Additional overhead for metadata fields:
+        // - Timestamps (created_at, updated_at): ~40 chars each
+        // - Size field: ~10 chars
+        // - Warning messages: up to 200 chars
+        // - JSON formatting: ~100 chars
+        // Total additional overhead: ~200 tokens
+        const METADATA_OVERHEAD_TOKENS = 200;
+        return (estimateTokens(JSON.stringify(basePagination), config.charsPerToken) +
+            METADATA_OVERHEAD_TOKENS);
+    }
+    return estimateTokens(JSON.stringify(basePagination), config.charsPerToken);
+}
+/**
+ * Calculate the safe number of items that can be returned
+ * @param items Sample items to calculate with
+ * @param includeMetadata Whether metadata will be included
+ * @param config Token limit configuration
+ * @returns Safe number of items to return
+ */
+function calculateSafeItemLimit(items, includeMetadata = false, config = exports.DEFAULT_TOKEN_CONFIG) {
+    if (items.length === 0)
+        return 0;
+    // Calculate safe token limit (with buffer)
+    const safeTokenLimit = Math.floor(config.mcpMaxTokens * config.safetyBuffer);
+    // Calculate overhead
+    const responseOverhead = estimateResponseOverhead(items.length, includeMetadata, config);
+    // Calculate average item size from a sample
+    // Sample size of 10 items provides good statistical representation
+    // while keeping calculation overhead minimal
+    const SAMPLE_SIZE = 10;
+    const sampleSize = Math.min(SAMPLE_SIZE, items.length);
+    const sampleItems = items.slice(0, sampleSize);
+    // Helper to safely parse JSON metadata
+    const parseMetadata = (metadata) => {
+        if (!metadata)
+            return null;
+        if (typeof metadata === 'object')
+            return metadata;
+        try {
+            return JSON.parse(metadata);
+        }
+        catch (error) {
+            console.warn('Invalid JSON in metadata, using null:', error);
+            return null;
+        }
+    };
+    // Transform items if metadata is included
+    const itemsForCalculation = includeMetadata
+        ? sampleItems.map(item => ({
+            key: item.key,
+            value: item.value,
+            category: item.category,
+            priority: item.priority,
+            channel: item.channel,
+            metadata: parseMetadata(item.metadata),
+            size: item.size || calculateSize(item.value || ''),
+            created_at: item.created_at,
+            updated_at: item.updated_at,
+        }))
+        : sampleItems;
+    // Calculate average tokens per item
+    const totalSampleTokens = itemsForCalculation.reduce((sum, item) => {
+        return (sum + estimateTokens(JSON.stringify(item, null, JSON_INDENT_SPACES), config.charsPerToken));
+    }, 0);
+    const avgTokensPerItem = Math.ceil(totalSampleTokens / sampleSize);
+    // Calculate how many items can fit
+    const availableTokens = safeTokenLimit - responseOverhead;
+    const safeItemCount = Math.floor(availableTokens / avgTokensPerItem);
+    // Apply min/max constraints
+    const finalCount = Math.max(config.minItems, Math.min(safeItemCount, config.maxItems, items.length));
+    // Log calculation details for debugging
+    if (process.env.MCP_DEBUG_LOGGING) {
+        console.log('[Token Calculation]', {
+            safeTokenLimit,
+            responseOverhead,
+            avgTokensPerItem,
+            availableTokens,
+            calculatedCount: safeItemCount,
+            finalCount,
+            includeMetadata,
+        });
+    }
+    return finalCount;
+}
+/**
+ * Dynamically calculate the default limit based on typical item sizes
+ * @param sessionId Session to analyze
+ * @param includeMetadata Whether metadata will be included
+ * @param db Database connection
+ * @returns Calculated safe default limit
+ */
+function calculateDynamicDefaultLimit(sessionId, includeMetadata, db) {
+    try {
+        // Get a sample of recent items to calculate average size
+        const sampleQuery = `
+      SELECT * FROM context_items
+      WHERE session_id = ?
+      ORDER BY created_at DESC
+      LIMIT ${QUERY_LIMITS.SAMPLE_SIZE}
+    `;
+        const sampleItems = db.prepare(sampleQuery).all(sessionId);
+        if (sampleItems.length === 0) {
+            // No items yet, use conservative defaults
+            // With metadata: 30 items (typically ~800 chars each = ~6,800 tokens)
+            // Without metadata: 100 items (typically ~200 chars each = ~5,700 tokens)
+            // These defaults ensure first queries don't exceed limits
+            const DEFAULT_LIMIT_WITH_METADATA = 30;
+            const DEFAULT_LIMIT_WITHOUT_METADATA = 100;
+            return includeMetadata ? DEFAULT_LIMIT_WITH_METADATA : DEFAULT_LIMIT_WITHOUT_METADATA;
+        }
+        // Calculate safe limit based on actual data
+        const safeLimit = calculateSafeItemLimit(sampleItems, includeMetadata);
+        // Round to nearest 10 for cleaner limits and better user experience
+        // Minimum of 10 items to ensure useful results even with large items
+        const ROUNDING_FACTOR = 10;
+        const MIN_DYNAMIC_LIMIT = 10;
+        return Math.max(MIN_DYNAMIC_LIMIT, Math.floor(safeLimit / ROUNDING_FACTOR) * ROUNDING_FACTOR);
+    }
+    catch (error) {
+        // Fallback to conservative defaults on error
+        console.error('Error calculating dynamic limit:', error);
+        const FALLBACK_LIMIT_WITH_METADATA = 30;
+        const FALLBACK_LIMIT_WITHOUT_METADATA = 100;
+        return includeMetadata ? FALLBACK_LIMIT_WITH_METADATA : FALLBACK_LIMIT_WITHOUT_METADATA;
+    }
+}
+/**
+ * Check if a response would exceed token limits
+ * @param items Items to be returned
+ * @param includeMetadata Whether metadata is included
+ * @param config Token limit configuration
+ * @returns Object with exceedsLimit flag and estimated tokens
+ */
+function checkTokenLimit(items, includeMetadata = false, config = exports.DEFAULT_TOKEN_CONFIG) {
+    // Helper to safely parse JSON metadata (reused from calculateSafeItemLimit)
+    const parseMetadata = (metadata) => {
+        if (!metadata)
+            return null;
+        if (typeof metadata === 'object')
+            return metadata;
+        try {
+            return JSON.parse(metadata);
+        }
+        catch (error) {
+            console.warn('Invalid JSON in metadata, using null:', error);
+            return null;
+        }
+    };
+    // Transform items if needed
+    const itemsForCalculation = includeMetadata
+        ? items.map(item => ({
+            key: item.key,
+            value: item.value,
+            category: item.category,
+            priority: item.priority,
+            channel: item.channel,
+            metadata: parseMetadata(item.metadata),
+            size: item.size || calculateSize(item.value || ''),
+            created_at: item.created_at,
+            updated_at: item.updated_at,
+        }))
+        : items;
+    // Build full response structure matching actual handler response
+    const response = {
+        items: itemsForCalculation,
+        pagination: {
+            total: items.length,
+            returned: items.length,
+            offset: 0,
+            hasMore: false,
+            nextOffset: null,
+            truncated: false,
+            truncatedCount: 0,
+            warning: undefined,
+        },
+    };
+    const responseJson = JSON.stringify(response, null, JSON_INDENT_SPACES);
+    const estimatedTokens = estimateTokens(responseJson, config.charsPerToken);
+    const safeLimit = Math.floor(config.mcpMaxTokens * config.safetyBuffer);
+    const exceedsLimit = estimatedTokens > safeLimit;
+    const safeItemCount = exceedsLimit
+        ? calculateSafeItemLimit(items, includeMetadata, config)
+        : items.length;
+    return { exceedsLimit, estimatedTokens, safeItemCount };
+}
+/**
+ * Get configuration from environment or use defaults
+ * Validates all environment variables to ensure they're within reasonable bounds
+ */
+function getTokenConfig() {
+    const config = { ...exports.DEFAULT_TOKEN_CONFIG };
+    // Validate and apply MCP_MAX_TOKENS
+    if (process.env.MCP_MAX_TOKENS) {
+        const maxTokens = parseInt(process.env.MCP_MAX_TOKENS, 10);
+        if (!isNaN(maxTokens) &&
+            maxTokens >= VALIDATION_BOUNDS.MAX_TOKENS.MIN &&
+            maxTokens <= VALIDATION_BOUNDS.MAX_TOKENS.MAX) {
+            config.mcpMaxTokens = maxTokens;
+        }
+        else {
+            console.warn(`Invalid MCP_MAX_TOKENS (${process.env.MCP_MAX_TOKENS}), using default ${exports.DEFAULT_TOKEN_CONFIG.mcpMaxTokens}`);
+        }
+    }
+    // Validate and apply MCP_TOKEN_SAFETY_BUFFER
+    if (process.env.MCP_TOKEN_SAFETY_BUFFER) {
+        const buffer = parseFloat(process.env.MCP_TOKEN_SAFETY_BUFFER);
+        if (!isNaN(buffer) &&
+            buffer >= VALIDATION_BOUNDS.SAFETY_BUFFER.MIN &&
+            buffer <= VALIDATION_BOUNDS.SAFETY_BUFFER.MAX) {
+            config.safetyBuffer = buffer;
+        }
+        else {
+            console.warn(`Invalid MCP_TOKEN_SAFETY_BUFFER (${process.env.MCP_TOKEN_SAFETY_BUFFER}), using default ${exports.DEFAULT_TOKEN_CONFIG.safetyBuffer}`);
+        }
+    }
+    // Validate and apply MCP_MIN_ITEMS
+    if (process.env.MCP_MIN_ITEMS) {
+        const minItems = parseInt(process.env.MCP_MIN_ITEMS, 10);
+        if (!isNaN(minItems) &&
+            minItems >= VALIDATION_BOUNDS.MIN_ITEMS.MIN &&
+            minItems <= VALIDATION_BOUNDS.MIN_ITEMS.MAX) {
+            config.minItems = minItems;
+        }
+        else {
+            console.warn(`Invalid MCP_MIN_ITEMS (${process.env.MCP_MIN_ITEMS}), using default ${exports.DEFAULT_TOKEN_CONFIG.minItems}`);
+        }
+    }
+    // Validate and apply MCP_MAX_ITEMS
+    if (process.env.MCP_MAX_ITEMS) {
+        const maxItems = parseInt(process.env.MCP_MAX_ITEMS, 10);
+        if (!isNaN(maxItems) &&
+            maxItems >= VALIDATION_BOUNDS.MAX_ITEMS.MIN &&
+            maxItems <= VALIDATION_BOUNDS.MAX_ITEMS.MAX) {
+            config.maxItems = maxItems;
+        }
+        else {
+            console.warn(`Invalid MCP_MAX_ITEMS (${process.env.MCP_MAX_ITEMS}), using default ${exports.DEFAULT_TOKEN_CONFIG.maxItems}`);
+        }
+    }
+    // Validate and apply MCP_CHARS_PER_TOKEN (advanced setting)
+    if (process.env.MCP_CHARS_PER_TOKEN) {
+        const charsPerToken = parseFloat(process.env.MCP_CHARS_PER_TOKEN);
+        if (!isNaN(charsPerToken) &&
+            charsPerToken >= VALIDATION_BOUNDS.CHARS_PER_TOKEN.MIN &&
+            charsPerToken <= VALIDATION_BOUNDS.CHARS_PER_TOKEN.MAX) {
+            config.charsPerToken = charsPerToken;
+        }
+        else {
+            console.warn(`Invalid MCP_CHARS_PER_TOKEN (${process.env.MCP_CHARS_PER_TOKEN}), using default ${exports.DEFAULT_TOKEN_CONFIG.charsPerToken}. Valid range: ${VALIDATION_BOUNDS.CHARS_PER_TOKEN.MIN}-${VALIDATION_BOUNDS.CHARS_PER_TOKEN.MAX}`);
+        }
+    }
+    // Ensure min <= max
+    if (config.minItems > config.maxItems) {
+        console.warn(`MCP_MIN_ITEMS (${config.minItems}) > MCP_MAX_ITEMS (${config.maxItems}), swapping values`);
+        [config.minItems, config.maxItems] = [config.maxItems, config.minItems];
+    }
+    return config;
+}

package/dist/utils/tool-profiles.js

@@ -0,0 +1,242 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_PROFILES = exports.ALL_TOOL_NAMES_SET = exports.ALL_TOOL_NAMES = void 0;
+exports.loadConfigFile = loadConfigFile;
+exports.validateToolNames = validateToolNames;
+exports.resolveActiveProfile = resolveActiveProfile;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+/**
+ * All known tool names - source of truth for validation.
+ * Update this list whenever a tool is added or removed from the
+ * ListToolsRequestSchema handler in src/index.ts.
+ */
+exports.ALL_TOOL_NAMES = [
+    // Session Management
+    'context_session_start',
+    'context_session_list',
+    'context_set_project_dir',
+    // Core Context
+    'context_save',
+    'context_get',
+    'context_status',
+    // File Caching
+    'context_cache_file',
+    'context_file_changed',
+    // Checkpoints
+    'context_checkpoint',
+    'context_restore_checkpoint',
+    // Summarization & Compaction
+    'context_summarize',
+    'context_prepare_compaction',
+    // Git Integration
+    'context_git_commit',
+    // Search
+    'context_search',
+    'context_search_all',
+    'context_semantic_search',
+    // Export/Import
+    'context_export',
+    'context_import',
+    // Knowledge Graph
+    'context_analyze',
+    'context_find_related',
+    'context_visualize',
+    // Multi-Agent
+    'context_delegate',
+    // Session Branching/Merging
+    'context_branch_session',
+    'context_merge_sessions',
+    // Journal & Timeline
+    'context_journal_entry',
+    'context_timeline',
+    // Advanced Features
+    'context_compress',
+    'context_integrate_tool',
+    'context_diff',
+    // Channel Management
+    'context_list_channels',
+    'context_channel_stats',
+    'context_reassign_channel',
+    // Watch
+    'context_watch',
+    // Batch Operations
+    'context_batch_save',
+    'context_batch_delete',
+    'context_batch_update',
+    // Relationships
+    'context_link',
+    'context_get_related',
+];
+/** Pre-computed Set for O(1) lookups — used internally and exported for index.ts */
+exports.ALL_TOOL_NAMES_SET = new Set(exports.ALL_TOOL_NAMES);
+/** Built-in default profiles */
+exports.DEFAULT_PROFILES = {
+    minimal: [
+        'context_session_start',
+        'context_session_list',
+        'context_save',
+        'context_get',
+        'context_search',
+        'context_status',
+        'context_checkpoint',
+        'context_restore_checkpoint',
+    ],
+    standard: [
+        'context_session_start',
+        'context_session_list',
+        'context_set_project_dir',
+        'context_save',
+        'context_get',
+        'context_status',
+        'context_checkpoint',
+        'context_restore_checkpoint',
+        'context_search',
+        'context_search_all',
+        'context_summarize',
+        'context_prepare_compaction',
+        'context_git_commit',
+        'context_export',
+        'context_import',
+        'context_journal_entry',
+        'context_timeline',
+        'context_list_channels',
+        'context_channel_stats',
+        'context_batch_save',
+        'context_batch_delete',
+        'context_batch_update',
+    ],
+    full: [...exports.ALL_TOOL_NAMES],
+};
+const CONFIG_DIR = path.join(os.homedir(), '.mcp-memory-keeper');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+/** Load config file, returning null if absent or invalid */
+function loadConfigFile(configPath = CONFIG_FILE) {
+    try {
+        if (!fs.existsSync(configPath)) {
+            return null;
+        }
+        const raw = fs.readFileSync(configPath, 'utf-8');
+        const parsed = JSON.parse(raw);
+        if (!parsed ||
+            typeof parsed !== 'object' ||
+            Array.isArray(parsed) ||
+            !parsed.profiles ||
+            typeof parsed.profiles !== 'object' ||
+            Array.isArray(parsed.profiles)) {
+            console.warn(`[MCP-Memory-Keeper] Config file at ${configPath} is missing a valid "profiles" key. Ignoring file.`);
+            return null;
+        }
+        // Validated: parsed.profiles is a non-null, non-array object
+        return { profiles: parsed.profiles };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.warn(`[MCP-Memory-Keeper] Failed to load config file at ${configPath}: ${message}. Ignoring file.`);
+        return null;
+    }
+}
+/** Validate tool names against ALL_TOOL_NAMES, returning unknown names */
+function validateToolNames(tools) {
+    return tools.filter(name => !exports.ALL_TOOL_NAMES_SET.has(name));
+}
+/** Resolve the active profile based on env var and config file */
+function resolveActiveProfile(configPath) {
+    const warnings = [];
+    let profileName = (process.env.TOOL_PROFILE || '').trim();
+    const hasEnvVar = profileName.length > 0;
+    if (!hasEnvVar) {
+        profileName = 'full';
+    }
+    const config = loadConfigFile(configPath);
+    let toolList;
+    let source = 'default';
+    // Resolution precedence: config file > built-in defaults
+    if (config && config.profiles[profileName] !== undefined) {
+        const candidate = config.profiles[profileName];
+        // Validate that the profile value is actually an array of strings
+        if (!Array.isArray(candidate) || !candidate.every(item => typeof item === 'string')) {
+            warnings.push(`Profile "${profileName}" in config file is not a valid array of strings. Falling back to built-in default.`);
+        }
+        else {
+            toolList = candidate;
+            source = hasEnvVar ? 'env+config' : 'config';
+        }
+    }
+    if (toolList === undefined && exports.DEFAULT_PROFILES[profileName] !== undefined) {
+        toolList = [...exports.DEFAULT_PROFILES[profileName]];
+        source = hasEnvVar ? 'env+builtin' : 'default';
+    }
+    if (toolList === undefined) {
+        // Profile not found anywhere
+        const allProfiles = {
+            ...exports.DEFAULT_PROFILES,
+            ...(config ? config.profiles : {}),
+        };
+        const profileList = Object.entries(allProfiles)
+            .map(([name, tools]) => `${name}(${Array.isArray(tools) ? tools.length : '?'})`)
+            .join(', ');
+        warnings.push(`Unknown TOOL_PROFILE "${profileName}". Available profiles: ${profileList}. Using "full".`);
+        profileName = 'full';
+        toolList = [...exports.DEFAULT_PROFILES.full];
+        source = 'default';
+    }
+    // Validate tool names
+    const unknownNames = validateToolNames(toolList);
+    if (unknownNames.length > 0) {
+        warnings.push(`Unknown tool names in profile "${profileName}": ${unknownNames.join(', ')}. These will be ignored.`);
+    }
+    // Filter to only valid tools
+    const validTools = toolList.filter(name => exports.ALL_TOOL_NAMES_SET.has(name));
+    // Guard against empty profile
+    if (validTools.length === 0) {
+        warnings.push(`Profile "${profileName}" has no valid tools after filtering. Using "full".`);
+        profileName = 'full';
+        return {
+            profileName,
+            tools: new Set(exports.ALL_TOOL_NAMES),
+            source: 'default',
+            warnings,
+        };
+    }
+    return {
+        profileName,
+        tools: new Set(validTools),
+        source,
+        warnings,
+    };
+}