25144479621

Committed 30 Apr 2026 02:37AM UTC coverage: 90.135% (+0.1%) from 90.008%

Build # 25144479621

Build Type

push

github

Committed by

web-flow

Commit Message

feat(ai): add configurable moderation and summary model controls (#628)

Coverage Stats

9633 of 11308 branches covered (85.19%)

Branch coverage included in aggregate %.

305 of 312 new or added lines in 14 files covered. (97.76%)

7 existing lines in 4 files now uncovered.

15256 of 16305 relevant lines covered (93.57%)

178.43 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

97.35

/src/api/utils/configValidation.js

/**
 * Shared config validation utilities.
 *
 * Centralises CONFIG_SCHEMA, validateValue, and validateSingleValue so that
 * both route handlers and util modules can import from a single source of
 * truth without creating an inverted dependency (utils → routes).
 */

import {
  isSupportedAiModel,
  normalizeSupportedAiModel,
  SUPPORTED_AI_MODEL_TYPES,
} from '../../utils/supportedAiModels.js';
import { validateUrlForSsrfSync } from './ssrfProtection.js';

/** Module-level cache for compiled regex patterns used during validation. */
const _compiledPatterns = new Map();

/** Maximum number of distinct patterns to keep in the cache. */
const _MAX_PATTERN_CACHE = 100;

/**
 * Return a cached compiled RegExp for the given pattern string.
 * Avoids re-compiling the same pattern on every config validation call.
 * The cache is capped at _MAX_PATTERN_CACHE entries to prevent unbounded growth
 * in environments with dynamic schema patterns.
 *
 * @param {string} pattern
 * @returns {RegExp}
 */
function getCompiledPattern(pattern) {
  let re = _compiledPatterns.get(pattern);
  if (!re) {
    if (_compiledPatterns.size >= _MAX_PATTERN_CACHE) {
      // Evict the oldest entry (Map preserves insertion order).
      _compiledPatterns.delete(_compiledPatterns.keys().next().value);
    }
    re = new RegExp(pattern);
    _compiledPatterns.set(pattern, re);
  }
  return re;
}

const XP_ACTION_TYPES = [
  'grantRole',
  'removeRole',
  'sendDm',
  'announce',
  'xpBonus',
  'addReaction',
  'nickPrefix',
  'nickSuffix',
  'webhook',
];

const XP_EMBED_FIELD_SCHEMA = {
  type: 'object',
  properties: {
    id: { type: 'string', nullable: true },
    name: { type: 'string', nullable: true },
    value: { type: 'string', nullable: true },
    inline: { type: 'boolean', nullable: true },
  },
};

const XP_EMBED_FOOTER_SCHEMA = {
  nullable: true,
  anyOf: [
    { type: 'string' },
    {
      type: 'object',
      properties: {
        text: { type: 'string', nullable: true },
        iconURL: { type: 'string', nullable: true },
      },
    },
  ],
};

const XP_EMBED_SCHEMA = {
  type: 'object',
  nullable: true,
  properties: {
    title: { type: 'string', nullable: true },
    description: { type: 'string', nullable: true },
    color: { type: 'string', nullable: true },
    thumbnail: { type: 'string', nullable: true },
    thumbnailType: {
      type: 'string',
      enum: ['none', 'user_avatar', 'server_icon', 'custom'],
      nullable: true,
    },
    thumbnailUrl: { type: 'string', nullable: true },
    fields: { type: 'array', items: XP_EMBED_FIELD_SCHEMA, nullable: true },
    footer: XP_EMBED_FOOTER_SCHEMA,
    footerText: { type: 'string', nullable: true },
    footerIconUrl: { type: 'string', nullable: true },
    image: { type: 'string', nullable: true },
    imageUrl: { type: 'string', nullable: true },
    timestamp: { type: 'boolean', nullable: true },
    showTimestamp: { type: 'boolean', nullable: true },
  },
};

const XP_ACTION_ITEM_SCHEMA = {
  type: 'object',
  required: ['type'],
  properties: {
    id: { type: 'string', nullable: true },
    type: {
      type: 'string',
      enum: XP_ACTION_TYPES,
    },
    roleId: { type: 'string', nullable: true },
    message: { type: 'string', nullable: true },
    template: { type: 'string', nullable: true },
    format: { type: 'string', enum: ['text', 'embed', 'both'], nullable: true },
    channelMode: {
      type: 'string',
      enum: ['current', 'specific', 'none'],
      nullable: true,
    },
    channelId: { type: 'string', nullable: true },
    emoji: { type: 'string', nullable: true },
    amount: { type: 'number', integer: true, min: 1, max: 1000000, nullable: true },
    prefix: { type: 'string', nullable: true },
    suffix: { type: 'string', nullable: true },
    url: { type: 'string', nullable: true, ssrfUrl: true, allowHttp: true },
    payload: { type: 'string', nullable: true },
    embed: XP_EMBED_SCHEMA,
  },
  openProperties: true,
};

const XP_ACTION_REQUIRED_FIELDS = {
  grantRole: ['roleId'],
  removeRole: ['roleId'],
  xpBonus: ['amount'],
  addReaction: ['emoji'],
  nickPrefix: ['prefix'],
  nickSuffix: ['suffix'],
  webhook: ['url'],
};

function validateXpActionRequiredFields(action, path) {
  const requiredFields = XP_ACTION_REQUIRED_FIELDS[action.type] ?? [];
  const errors = [];

  for (const field of requiredFields) {
    const value = action[field];
    if (value == null || value === '') {
      errors.push(`${path}.${field}: required for action type "${action.type}"`);
    }
  }

  return errors;
}

const XP_LEVEL_ACTION_ENTRY_SCHEMA = {
  type: 'object',
  required: ['level', 'actions'],
  properties: {
    id: { type: 'string', nullable: true },
    level: { type: 'number', integer: true, min: 1, max: 1000 },
    actions: {
      type: 'array',
      items: XP_ACTION_ITEM_SCHEMA,
    },
  },
};

const AI_AUTOMOD_CATEGORY_KEYS = [
  'toxicity',
  'spam',
  'harassment',
  'hateSpeech',
  'sexualContent',
  'violence',
  'selfHarm',
];

const AI_AUTOMOD_ACTION_TYPES = ['none', 'flag', 'delete', 'warn', 'timeout', 'kick', 'ban'];

const CHANNEL_MODE_TYPES = ['off', 'mention', 'vibe'];

const PERMISSION_LEVEL_TYPES = ['everyone', 'moderator', 'admin'];

const AI_AUTOMOD_ACTION_VALUE_SCHEMA = {
  anyOf: [
    { type: 'string', enum: AI_AUTOMOD_ACTION_TYPES },
    { type: 'array', items: { type: 'string', enum: AI_AUTOMOD_ACTION_TYPES } },
  ],
};

const AI_MODEL_VALUE_SCHEMA = { type: 'string', aiModel: true };

const AI_AUTOMOD_THRESHOLD_SCHEMA = {
  type: 'object',
  properties: Object.fromEntries(
    AI_AUTOMOD_CATEGORY_KEYS.map((category) => [category, { type: 'number', min: 0, max: 1 }]),
  ),
};

const AI_AUTOMOD_ACTION_SCHEMA = {
  type: 'object',
  properties: Object.fromEntries(
    AI_AUTOMOD_CATEGORY_KEYS.map((category) => [category, AI_AUTOMOD_ACTION_VALUE_SCHEMA]),
  ),
};

/**
 * Schema definitions for writable config sections.
 * Used to validate types before persisting changes.
 */
export const CONFIG_SCHEMA = {
  ai: {
    type: 'object',
    properties: {
      enabled: { type: 'boolean' },
      systemPrompt: { type: 'string', maxLength: 4000 },
      channels: { type: 'array' },
      blockedChannelIds: { type: 'array' },
      historyLength: { type: 'number', min: 1, max: 100 },
      historyTTLDays: { type: 'number', min: 1, max: 365 },
      threadMode: {
        type: 'object',
        properties: {
          enabled: { type: 'boolean' },
          autoArchiveMinutes: { type: 'number', min: 60, max: 10080 },
          reuseWindowMinutes: { type: 'number', min: 1, max: 1440 },
        },
      },
      channelModes: {
        type: 'object',
        openProperties: { type: 'string', enum: CHANNEL_MODE_TYPES },
      },
      defaultChannelMode: { type: 'string', enum: ['off', 'mention', 'vibe'] },
    },
  },
  welcome: {
    type: 'object',
    properties: {
      enabled: { type: 'boolean' },
      channelId: { type: 'string', nullable: true },
      message: { type: 'string' },
      returningMessage: { type: 'string', nullable: true },
      returningMessageEnabled: { type: 'boolean' },
      variants: {
        type: 'array',
        items: { type: 'string' },
      },
      channels: {
        type: 'array',
        items: {
          type: 'object',
          properties: {
            channelId: { type: 'string' },
            message: { type: 'string' },
            variants: { type: 'array', items: { type: 'string' } },
          },
          required: ['channelId'],
        },
      },
      dynamic: {
        type: 'object',
        properties: {
          enabled: { type: 'boolean' },
          timezone: { type: 'string' },
          activityWindowMinutes: { type: 'number', min: 1, max: 10080 },
          milestoneInterval: { type: 'number', min: 0, max: 10000 },
          highlightChannels: { type: 'array' },
          excludeChannels: { type: 'array' },
        },
      },
      rulesChannel: { type: 'string', nullable: true },
      verifiedRole: { type: 'string', nullable: true },
      introChannel: { type: 'string', nullable: true },
      roleMenu: {
        type: 'object',
        properties: {
          enabled: { type: 'boolean' },
          options: { type: 'array', items: { type: 'object', required: ['label', 'roleId'] } },
        },
      },
      dmSequence: {
        type: 'object',
        properties: {
          enabled: { type: 'boolean' },
          steps: { type: 'array', items: { type: 'string' } },
        },
      },
    },
  },
  spam: {
    type: 'object',
    properties: {
      enabled: { type: 'boolean' },
    },
  },
  moderation: {
    type: 'object',
    properties: {
      enabled: { type: 'boolean' },
      alertChannelId: { type: 'string', nullable: true },
      autoDelete: { type: 'boolean' },
      dmNotifications: {
        type: 'object',
        properties: {
          warn: { type: 'boolean' },
          timeout: { type: 'boolean' },
          kick: { type: 'boolean' },
          ban: { type: 'boolean' },
        },
      },
      escalation: {
        type: 'object',
        properties: {
          enabled: { type: 'boolean' },
          thresholds: { type: 'array' },
        },
      },
      logging: {
        type: 'object',
        properties: {
          channels: {
            type: 'object',
            properties: {
              default: { type: 'string', nullable: true },
              warns: { type: 'string', nullable: true },
              bans: { type: 'string', nullable: true },
              kicks: { type: 'string', nullable: true },
              timeouts: { type: 'string', nullable: true },
              purges: { type: 'string', nullable: true },
              locks: { type: 'string', nullable: true },
            },
          },
        },
      },
      protectRoles: {
        type: 'object',
        properties: {
          enabled: { type: 'boolean' },
          roleIds: { type: 'array', items: { type: 'string' } },
          includeAdmins: { type: 'boolean' },
          includeModerators: { type: 'boolean' },
          includeServerOwner: { type: 'boolean' },
        },
      },
      rateLimit: {
        type: 'object',
        properties: {
          enabled: { type: 'boolean' },
          maxMessages: { type: 'number', min: 1 },
          windowSeconds: { type: 'number', min: 1 },
          muteAfterTriggers: { type: 'number', min: 1 },
          muteWindowSeconds: { type: 'number', min: 1 },
          muteDurationSeconds: { type: 'number', min: 1 },
        },
      },
      linkFilter: {
        type: 'object',
        properties: {
          enabled: { type: 'boolean' },
          blockedDomains: { type: 'array', items: { type: 'string' } },
        },
      },
    },
  },
  triage: {
    type: 'object',
    properties: {
      enabled: { type: 'boolean' },
      defaultInterval: { type: 'number', min: 1, max: 3600 },
      maxBufferSize: { type: 'number', min: 1, max: 1000 },
      includeBotsInContext: { type: 'boolean' },
      botAllowlist: { type: 'array', items: { type: 'string' } },
      triggerWords: { type: 'array' },
      moderationKeywords: { type: 'array' },
      classifyModel: AI_MODEL_VALUE_SCHEMA,
      classifyBudget: { type: 'number', min: 0, max: 100000 },
      respondModel: AI_MODEL_VALUE_SCHEMA,
      respondBudget: { type: 'number', min: 0, max: 100000 },
      thinkingTokens: { type: 'number', min: 0, max: 100000 },
      classifyBaseUrl: { type: 'string', nullable: true },
      classifyApiKey: { type: 'string', nullable: true },
      respondBaseUrl: { type: 'string', nullable: true },
      respondApiKey: { type: 'string', nullable: true },
      contextMessages: { type: 'number', min: 0, max: 100 },
      timeout: { type: 'number', min: 1000, max: 300000 },
      moderationResponse: { type: 'boolean' },
      channels: { type: 'array' },
      excludeChannels: { type: 'array' },
      allowedRoles: { type: 'array', items: { type: 'string' } },
      excludedRoles: { type: 'array', items: { type: 'string' } },
      debugFooter: { type: 'boolean' },
      debugFooterLevel: { type: 'string', nullable: true },
      moderationLogChannel: { type: 'string', nullable: true },
      statusReactions: { type: 'boolean', nullable: true },
      dailyBudgetUsd: { type: 'number', min: 0, nullable: true },
      confidenceThreshold: { type: 'number', min: 0, max: 1, nullable: true },
      responseCooldownMs: { type: 'number', min: 0, nullable: true },
    },
  },
  aiAutoMod: {
    type: 'object',
    properties: {
      enabled: { type: 'boolean' },
      model: AI_MODEL_VALUE_SCHEMA,
      thresholds: AI_AUTOMOD_THRESHOLD_SCHEMA,
      actions: AI_AUTOMOD_ACTION_SCHEMA,
      timeoutDurationMs: { type: 'number', min: 1000, max: 2419200000 },
      flagChannelId: { type: 'string', nullable: true },
      autoDelete: { type: 'boolean' },
      exemptRoleIds: { type: 'array', items: { type: 'string' } },
    },
  },
  auditLog: {
    type: 'object',
    properties: {
      enabled: { type: 'boolean' },
      retentionDays: { type: 'number', min: 1, max: 365 },
    },
  },
  botStatus: {
    type: 'object',
    properties: {
      enabled: { type: 'boolean' },
      status: { type: 'string', enum: ['online', 'idle', 'dnd', 'invisible'] },
      activityType: {
        type: 'string',
        enum: ['Playing', 'Watching', 'Listening', 'Competing', 'Streaming', 'Custom'],
      },
      activities: { type: 'array', items: { type: 'string' } },
      rotateIntervalMs: { type: 'number' },
      rotation: {
        type: 'object',
        properties: {
          enabled: { type: 'boolean' },
          intervalMinutes: { type: 'number' },
          messages: {
            type: 'array',
            items: {
              type: 'object',
              properties: {
                type: {
                  type: 'string',
                  enum: ['Playing', 'Watching', 'Listening', 'Competing', 'Streaming', 'Custom'],
                },
                text: { type: 'string', minLength: 1, pattern: '\\S' },
              },
              required: ['text'],
            },
          },
        },
      },
    },
  },
  reminders: {
    type: 'object',
    properties: {
      enabled: { type: 'boolean' },
      maxPerUser: { type: 'number', min: 1, max: 100 },
    },
  },
  quietMode: {
    type: 'object',
    properties: {
      enabled: { type: 'boolean' },
      maxDurationMinutes: { type: 'number', min: 1, max: 10080 },
      allowedRoles: { type: 'array' },
    },
  },
  voice: {
    type: 'object',
    properties: {
      enabled: { type: 'boolean' },
      xpPerMinute: { type: 'number', min: 0, max: 1000 },
      dailyXpCap: { type: 'number', min: 0, max: 1000000 },
      logChannel: { type: 'string', nullable: true },
    },
  },
  permissions: {
    type: 'object',
    properties: {
      enabled: { type: 'boolean' },
      usePermissions: { type: 'boolean' },
      adminRoleIds: { type: 'array', items: { type: 'string' } },
      moderatorRoleIds: { type: 'array', items: { type: 'string' } },
      // Legacy singular fields — kept for backward compat during migration
      adminRoleId: { type: 'string', nullable: true },
      moderatorRoleId: { type: 'string', nullable: true },
      modRoles: { type: 'array', items: { type: 'string' } },
      // allowedCommands is a freeform map of command → permission level — no fixed property list
      allowedCommands: {
        type: 'object',
        openProperties: { type: 'string', enum: PERMISSION_LEVEL_TYPES },
      },
    },
  },
  tldr: {
    type: 'object',
    properties: {
      enabled: { type: 'boolean' },
      model: AI_MODEL_VALUE_SCHEMA,
      systemPrompt: { type: 'string', maxLength: 4000 },
      defaultMessages: { type: 'number', min: 1, max: 200 },
      maxMessages: { type: 'number', min: 1, max: 200 },
      cooldownSeconds: { type: 'number', min: 0, max: 3600 },
    },
  },
  xp: {
    type: 'object',
    properties: {
      enabled: { type: 'boolean' },
      levelThresholds: {
        type: 'array',
        items: { type: 'number', min: 0 },
      },
      levelActions: {
        type: 'array',
        items: XP_LEVEL_ACTION_ENTRY_SCHEMA,
        uniqueBy: 'level',
      },
      defaultActions: {
        type: 'array',
        items: XP_ACTION_ITEM_SCHEMA,
      },
      levelUpDm: {
        type: 'object',
        properties: {
          enabled: { type: 'boolean' },
          sendOnEveryLevel: { type: 'boolean' },
          defaultMessage: { type: 'string', minLength: 1, maxLength: 2000, pattern: '\\S' },
          messages: {
            type: 'array',
            uniqueBy: 'level',
            items: {
              type: 'object',
              required: ['level', 'message'],
              properties: {
                level: { type: 'number', integer: true, min: 1, max: 1000 },
                message: { type: 'string', minLength: 1, maxLength: 2000, pattern: '\\S' },
              },
            },
          },
        },
      },
      roleRewards: {
        type: 'object',
        properties: {
          stackRoles: { type: 'boolean' },
          removeOnLevelDown: { type: 'boolean' },
        },
      },
    },
  },
};

/**
 * Validate a value against a schema fragment and collect any validation errors.
 *
 * @param {*} value - The value to validate.
 * @param {Object} schema - Schema fragment describing the expected shape; may include `type` (boolean|string|number|array|object), `nullable`, and `properties` for object children.
 * @param {string} path - Dot-notation path used to prefix validation error messages.
 * @returns {string[]} Array of validation error messages; empty if the value is valid for the provided schema.
 */
export function validateValue(value, schema, path) {
  const errors = [];

  if (value === undefined) {
    return errors;
  }

  if (value === null && schema.nullable) {
    return errors;
  }

  if (schema.anyOf) {
    const results = schema.anyOf.map((candidate) => validateValue(value, candidate, path));
    const success = results.find((candidateErrors) => candidateErrors.length === 0);
    if (success) {
      return success;
    }
    return results.flat();
  }

  if (value === null) {
    errors.push(`${path}: must not be null`);
    return errors;
  }

  switch (schema.type) {
    case 'boolean':
      if (typeof value !== 'boolean') {
        errors.push(`${path}: expected boolean, got ${typeof value}`);
      }
      break;
    case 'string':
      if (typeof value !== 'string') {
        errors.push(`${path}: expected string, got ${typeof value}`);
      } else {
        if (typeof schema.minLength === 'number' && value.length < schema.minLength) {
          errors.push(`${path}: must be at least ${schema.minLength} characters`);
        }
        if (schema.aiModel) {
          if (!isSupportedAiModel(value)) {
            errors.push(
              `${path}: must be one of [${SUPPORTED_AI_MODEL_TYPES.join(', ')}], got "${value}"`,
            );
          }
        } else if (schema.enum && !schema.enum.includes(value)) {
          errors.push(`${path}: must be one of [${schema.enum.join(', ')}], got "${value}"`);
        }
        if (schema.maxLength != null && value.length > schema.maxLength) {
          errors.push(`${path}: exceeds max length of ${schema.maxLength}`);
        }
        if (schema.pattern && !getCompiledPattern(schema.pattern).test(value)) {
          errors.push(`${path}: does not match required pattern`);
        }
        if (schema.ssrfUrl) {
          const ssrfResult = validateUrlForSsrfSync(value, {
            allowHttp: schema.allowHttp === true,
          });
          if (!ssrfResult.valid) {
            errors.push(`${path}: ${ssrfResult.error}`);
          }
        }
      }
      break;
    case 'number':
      if (typeof value !== 'number' || !Number.isFinite(value)) {
        errors.push(`${path}: expected finite number, got ${typeof value}`);
      } else {
        if (schema.min != null && value < schema.min) {
          errors.push(`${path}: must be >= ${schema.min}`);
        }
        if (schema.max != null && value > schema.max) {
          errors.push(`${path}: must be <= ${schema.max}`);
        }
        if (schema.integer === true && !Number.isInteger(value)) {
          errors.push(`${path}: must be an integer`);
        }
      }
      break;
    case 'array':
      if (!Array.isArray(value)) {
        errors.push(`${path}: expected array, got ${typeof value}`);
      } else if (schema.items) {
        for (let i = 0; i < value.length; i++) {
          errors.push(...validateValue(value[i], schema.items, `${path}[${i}]`));
        }

        if (schema.uniqueBy) {
          const seen = new Map();
          for (let i = 0; i < value.length; i++) {
            const item = value[i];
            const uniqueValue =
              item && typeof item === 'object' && !Array.isArray(item)
                ? item[schema.uniqueBy]
                : undefined;
            if (uniqueValue === undefined) continue;
            if (seen.has(uniqueValue)) {
              errors.push(
                `${path}[${i}].${schema.uniqueBy}: duplicate value "${uniqueValue}" also used at index ${seen.get(uniqueValue)}`,
              );
            } else {
              seen.set(uniqueValue, i);
            }
          }
        }
      }
      break;
    case 'object':
      if (typeof value !== 'object' || Array.isArray(value)) {
        errors.push(
          `${path}: expected object, got ${Array.isArray(value) ? 'array' : typeof value}`,
        );
      } else {
        if (schema.required) {
          for (const key of schema.required) {
            if (!Object.hasOwn(value, key)) {
              errors.push(`${path}: missing required key "${key}"`);
            }
          }
        }

        if (schema.properties || schema.openProperties) {
          const properties = schema.properties ?? {};
          for (const [key, val] of Object.entries(value)) {
            if (Object.hasOwn(properties, key)) {
              errors.push(...validateValue(val, properties[key], `${path}.${key}`));
            } else if (schema.openProperties && schema.openProperties !== true) {
              errors.push(...validateValue(val, schema.openProperties, `${path}.${key}`));
            } else if (!schema.openProperties) {
              errors.push(`${path}.${key}: unknown config key`);
            }
            // openProperties: true - freeform map, unknown keys are allowed
          }
        }

        if (schema === XP_ACTION_ITEM_SCHEMA) {
          errors.push(...validateXpActionRequiredFields(value, path));
        }
      }
      break;
  }

  return errors;
}

/**
 * Validate a single configuration path and its value against the writable config schema.
 *
 * @param {string} path - Dot-notation config path (e.g. "ai.enabled").
 * @param {*} value - The value to validate for the given path.
 * @returns {string[]} Array of validation error messages (empty if valid).
 */
function resolveSchemaForPath(path) {
  const segments = path.split('.');
  const section = segments[0];

  const schema = CONFIG_SCHEMA[section];
  if (!schema) {
    // Unknown section — let SAFE_CONFIG_KEYS guard handle it.
    return { status: 'unknown-section' };
  }

  // Walk the schema tree to find the leaf schema for this path.
  let currentSchema = schema;
  for (let i = 1; i < segments.length; i++) {
    if (currentSchema.properties && Object.hasOwn(currentSchema.properties, segments[i])) {
      currentSchema = currentSchema.properties[segments[i]];
    } else if (currentSchema.openProperties) {
      // Dynamic map keys (e.g. channelModes.<channelId>) consume this path
      // segment, then the remaining path (if any) resolves against the map's
      // value schema. `openProperties: true` means the dynamic value is fully
      // freeform and can only be validated as "allowed".
      currentSchema = currentSchema.openProperties === true ? {} : currentSchema.openProperties;
    } else {
      return { status: 'unknown-path' };
    }
  }

  return { status: 'found', schema: currentSchema };
}

/**
 * Validate a single configuration path and its value against the writable config schema.
 *
 * @param {string} path - Dot-notation config path (e.g. "ai.enabled").
 * @param {*} value - The value to validate for the given path.
 * @returns {string[]} Array of validation error messages (empty if valid).
 */
export function validateSingleValue(path, value) {
  const resolved = resolveSchemaForPath(path);
  if (resolved.status === 'unknown-path') return [`Unknown config path: ${path}`];
  if (resolved.status === 'unknown-section') return [];

  return validateValue(value, resolved.schema, path);
}

/**
 * Return the canonical runtime value for config leaves that support legacy aliases
 * or case-insensitive inputs. Unknown paths and ordinary values pass through.
 *
 * @param {string} path
 * @param {*} value
 * @returns {*}
 */
export function normalizeSingleValue(path, value) {
  const resolved = resolveSchemaForPath(path);
  if (resolved.schema?.aiModel && isSupportedAiModel(value)) {
    return normalizeSupportedAiModel(value);
  }
  return value;
}

VolvoxLLC / volvox-bot / 25144479621

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous