codex-configurator 0.2.4 → 0.2.6

package/src/components/Header.js

@@ -1,53 +1,29 @@
 import React from 'react';
 import { Text, Box } from 'ink';
 
-const WORDMARK = [
-  ' ██████╗ ██████╗ ██████╗ ███████╗██╗  ██╗     ██████╗ ██████╗ ███╗   ██╗███████╗██╗ ██████╗ ██╗   ██╗██████╗  █████╗ ████████╗ ██████╗ ██████╗ ',
-  '██╔════╝██╔═══██╗██╔══██╗██╔════╝╚██╗██╔╝    ██╔════╝██╔═══██╗████╗  ██║██╔════╝██║██╔════╝ ██║   ██║██╔══██╗██╔══██╗╚══██╔══╝██╔═══██╗██╔══██╗',
-  '██║     ██║   ██║██║  ██║█████╗   ╚███╔╝     ██║     ██║   ██║██╔██╗ ██║█████╗  ██║██║  ███╗██║   ██║██████╔╝███████║   ██║   ██║   ██║██████╔╝',
-  '██║     ██║   ██║██║  ██║██╔══╝   ██╔██╗     ██║     ██║   ██║██║╚██╗██║██╔══╝  ██║██║   ██║██║   ██║██╔══██╗██╔══██║   ██║   ██║   ██║██╔══██╗',
-  '╚██████╗╚██████╔╝██████╔╝███████╗██╔╝ ██╗    ╚██████╗╚██████╔╝██║ ╚████║██║     ██║╚██████╔╝╚██████╔╝██║  ██║██║  ██║   ██║   ╚██████╔╝██║  ██║',
-  ' ╚═════╝ ╚═════╝ ╚═════╝ ╚══════╝╚═╝  ╚═╝     ╚═════╝ ╚═════╝ ╚═╝  ╚═══╝╚═╝     ╚═╝ ╚═════╝  ╚═════╝ ╚═╝  ╚═╝╚═╝  ╚═╝   ╚═╝    ╚═════╝ ╚═╝  ╚═╝',
-];
-
-export const Header = ({ codexVersion, codexVersionStatus, packageVersion }) =>
-  React.createElement(
-    Box,
-    {
-      flexDirection: 'column',
-      paddingX: 1,
-      marginBottom: 1,
-    },
-      React.createElement(
-        Box,
-        { flexDirection: 'row', marginBottom: 1, gap: 0, alignItems: 'flex-end' },
-        React.createElement(
-          Box,
-          { flexDirection: 'column' },
-          ...WORDMARK.map((line, index) =>
-            React.createElement(Text, { color: 'magentaBright', bold: true, key: `word-${index}` }, line)
-          )
-        ),
-      React.createElement(
-        Box,
-        { marginLeft: 1 },
-        React.createElement(Text, { color: 'gray', bold: true }, `v${packageVersion || 'unknown'}`)
-      )
-    ),
-    React.createElement(
-      Box,
-      { flexDirection: 'row' },
-      React.createElement(Text, { color: 'gray' }, `Codex ${codexVersion}`),
-      codexVersionStatus
-        ? codexVersionStatus === 'up to date'
-          ? React.createElement(
-              React.Fragment,
-              null,
-              React.createElement(Text, { color: 'gray' }, ' ('),
-              React.createElement(Text, { color: 'green' }, '✓'),
-              React.createElement(Text, { color: 'gray' }, ` ${codexVersionStatus})`)
-            )
-          : React.createElement(Text, { color: 'gray' }, ` (${codexVersionStatus})`)
-        : null
-    )
-  );
+export const Header = ({ packageVersion }) =>
+	React.createElement(
+		Box,
+		{
+			flexDirection: 'row',
+			paddingX: 1,
+			paddingY: 0,
+			justifyContent: 'space-between',
+			backgroundColor: 'magenta',
+			marginBottom: 0,
+		},
+		React.createElement(
+			Box,
+			{ gap: 1 },
+			React.createElement(
+				Text,
+				{ color: 'white', bold: true },
+				' CODEX CONFIGURATOR',
+			),
+			React.createElement(
+				Text,
+				{ color: 'white', dimColor: false },
+				`v${packageVersion || 'unknown'}`,
+			),
+		),
+	);

package/src/configFeatures.js

@@ -1,4 +1,7 @@
-import { getReferenceFeatureKeys } from './configReference.js';
+import {
+  getReferenceFeatureKeys,
+  getReferenceOptionForPath,
+} from './configReference.js';
 
 const prettifyFeatureName = (key) =>
   key
@@ -6,189 +9,50 @@ const prettifyFeatureName = (key) =>
     .map((segment) => `${segment[0]?.toUpperCase() || ''}${segment.slice(1)}`)
     .join(' ');
 
-const makeFeatureDefinition = (
-  key,
-  short,
-  usage = 'Uses the feature flag value in your config.',
-  options = {}
-) => {
-  const deprecation = options?.deprecation;
-  const defaultValue = typeof options?.defaultValue === 'boolean' ? options.defaultValue : false;
-  const isDocumented = options?.isDocumented === true;
+const buildFeatureDefinitionFromReference = (key) => {
+  const normalizedKey = String(key || '').trim();
+  if (!normalizedKey) {
+    return null;
+  }
+
+  const referenceEntry = getReferenceOptionForPath(['features', normalizedKey]);
+  if (!referenceEntry) {
+    return null;
+  }
+
+  const description = String(referenceEntry.description || '').trim();
+  const defaultValue = typeof referenceEntry.defaultValue === 'boolean'
+    ? referenceEntry.defaultValue
+    : null;
 
   return {
-    key,
-    short,
-    usage: deprecation ? `[!] ${deprecation}` : usage,
-    deprecation,
+    key: normalizedKey,
+    short: description || 'Official configuration option.',
+    usage: null,
+    deprecation: referenceEntry.deprecated === true ? 'Deprecated configuration option.' : null,
     defaultValue,
-    isDocumented,
+    isDocumented: true,
   };
 };
 
-export const CONFIG_FEATURE_DEFINITIONS = [
-  makeFeatureDefinition(
-    'apply_patch_freeform',
-    'Enable freeform apply_patch style for code edits.',
-    'When enabled, patch edits can use larger freeform blocks.',
-    { isDocumented: true }
-  ),
-  makeFeatureDefinition(
-    'apps',
-    'Enable built-in app/connector features.',
-    'Toggle access to app integrations used by Codex.',
-    { isDocumented: true }
-  ),
-  makeFeatureDefinition(
-    'apps_mcp_gateway',
-    'Use the MCP app gateway.',
-    'Route app calls through the MCP gateway when available.',
-    { isDocumented: true }
-  ),
-  makeFeatureDefinition(
-    'child_agents_md',
-    'Allow child-agent markdown workflows.',
-    'Enable loading child-agent instructions from markdown files.',
-    { isDocumented: true }
-  ),
-  makeFeatureDefinition('codex_git_commit', 'Enable Codex-assisted git commit workflows.', 'Allows additional git-oriented agent workflows.'),
-  makeFeatureDefinition(
-    'collab',
-    'Enable collaboration mode helpers.',
-    'Turn on multi-party collaboration flow features.',
-    { deprecation: 'collab is deprecated; use [features].multi_agent instead.' }
-  ),
-  makeFeatureDefinition(
-    'collaboration_modes',
-    'Enable multiple collaboration modes.',
-    'Allow the assistant to switch between interaction modes.',
-    { defaultValue: true, isDocumented: true }
-  ),
-  makeFeatureDefinition('connectors', 'Enable external connector support.', 'Controls optional third-party connector behavior.'),
-  makeFeatureDefinition('enable_experimental_windows_sandbox', 'Enable experimental Windows sandbox.', 'Turns on experimental Windows sandbox behavior.'),
-  makeFeatureDefinition('enable_request_compression', 'Enable request compression.', 'Compress request payloads for matching model endpoints.'),
-  makeFeatureDefinition('experimental_use_freeform_apply_patch', 'Enable experimental freeform apply_patch usage.', 'Allows experimental patching behavior in edit flows.'),
-  makeFeatureDefinition('experimental_use_unified_exec_tool', 'Enable experimental unified exec tool.', 'Use unified execution routing when invoking shell tools.'),
-  makeFeatureDefinition('include_apply_patch_tool', 'Expose the apply_patch tool.', 'Makes apply patch tool calls available to the model.'),
-  makeFeatureDefinition('js_repl', 'Enable JavaScript REPL.', 'Allow JavaScript-based REPL style tooling.'),
-  makeFeatureDefinition('js_repl_tools_only', 'Restrict js_repl to tool-only mode.', 'Limits js_repl usage to explicit tool calls.'),
-  makeFeatureDefinition('memory_tool', 'Enable memory tool support.', 'Allows Codex to use memory-related workflow tools.'),
-  makeFeatureDefinition(
-    'multi_agent',
-    'Enable multi-agent support.',
-    'Allows multiple coordinated agent contexts.',
-    { isDocumented: true }
-  ),
-  makeFeatureDefinition(
-    'personality',
-    'Enable personality controls.',
-    'Turns on personality-related routing flags.',
-    { defaultValue: true, isDocumented: true }
-  ),
-  makeFeatureDefinition(
-    'powershell_utf8',
-    'Use UTF-8 in PowerShell sessions.',
-    'Keep PowerShell command output in UTF-8 encoding.',
-    { defaultValue: true, isDocumented: true }
-  ),
-  makeFeatureDefinition('prevent_idle_sleep', 'Prevent idle sleep while running.', 'Keeps the system awake during active sessions.'),
-  makeFeatureDefinition(
-    'remote_models',
-    'Enable remote model discovery.',
-    'Allows loading model lists from remote model providers.',
-    { isDocumented: true }
-  ),
-  makeFeatureDefinition(
-    'request_rule',
-    'Enable request rule controls.',
-    'Turn on request routing/validation policy behavior.',
-    { defaultValue: true, isDocumented: true }
-  ),
-  makeFeatureDefinition('responses_websockets', 'Enable Responses WebSocket transport.', 'Use websocket transport for Responses API calls.'),
-  makeFeatureDefinition('responses_websockets_v2', 'Enable Responses WebSocket v2 transport.', 'Use the next-generation websocket transport stack.'),
-  makeFeatureDefinition(
-    'runtime_metrics',
-    'Enable runtime metrics collection.',
-    'Record runtime metrics for analysis and telemetry.',
-    { isDocumented: true }
-  ),
-  makeFeatureDefinition(
-    'search_tool',
-    'Enable internal search tool.',
-    'Turns on the built-in search execution tool.',
-    { isDocumented: true }
-  ),
-  makeFeatureDefinition(
-    'shell_snapshot',
-    'Enable shell snapshots.',
-    'Capture shell environment state before runs.',
-    { isDocumented: true }
-  ),
-  makeFeatureDefinition(
-    'shell_tool',
-    'Enable shell tool access.',
-    'Allows Codex to run shell commands through the tool interface.',
-    { defaultValue: true, isDocumented: true }
-  ),
-  makeFeatureDefinition('shell_zsh_fork', 'Enable zsh forked shell tool.', 'Runs shell commands through a forked zsh process.'),
-  makeFeatureDefinition('skill_env_var_dependency_prompt', 'Enable environment variable prompts for skills.', 'Prompts when skills require missing environment variables.'),
-  makeFeatureDefinition('skill_mcp_dependency_install', 'Enable auto install MCP skill dependencies.', 'Installs missing MCP dependencies for skill execution.'),
-  makeFeatureDefinition('sqlite', 'Enable SQLite support features.', 'Turns SQLite-specific feature behavior on or off.'),
-  makeFeatureDefinition('steer', 'Enable steering control mode.', 'Allows steering the tool call strategy for some actions.'),
-  makeFeatureDefinition('undo', 'Enable undo behavior.', 'Expose undo controls for reversible operations.'),
-  makeFeatureDefinition(
-    'unified_exec',
-    'Use unified execution layer.',
-    'Route execution commands through the unified tool layer.',
-    { isDocumented: true }
-  ),
-  makeFeatureDefinition(
-    'use_linux_sandbox_bwrap',
-    'Enable Linux bubblewrap sandbox.',
-    'Use bwrap for Linux sandbox isolation.',
-    { isDocumented: true }
-  ),
-  makeFeatureDefinition(
-    'web_search',
-    'Enable web search tool.',
-    'Allows the model to call a web search tool.',
-    { isDocumented: true }
-  ),
-  makeFeatureDefinition(
-    'web_search_cached',
-    'Enable cached web search only.',
-    'Restricts web search calls to cached results.',
-    { isDocumented: true }
-  ),
-  makeFeatureDefinition(
-    'web_search_request',
-    'Enable web search request flow.',
-    'Turns on request-mode web search behavior.',
-    { isDocumented: true }
-  ),
-];
-
-const FEATURE_DEFINITION_MAP = CONFIG_FEATURE_DEFINITIONS.reduce((acc, definition) => {
-  acc[definition.key] = definition;
-
-  return acc;
-}, {});
-
-const DOCUMENTED_REFERENCE_FEATURE_KEYS = getReferenceFeatureKeys();
+const buildFeatureDefinitionMap = () =>
+  getReferenceFeatureKeys()
+    .map((key) => buildFeatureDefinitionFromReference(key))
+    .filter(Boolean)
+    .reduce((acc, definition) => {
+      acc[definition.key] = definition;
+      return acc;
+    }, {});
 
 export const getConfigFeatureKeys = () => {
-  if (DOCUMENTED_REFERENCE_FEATURE_KEYS.length > 0) {
-    return DOCUMENTED_REFERENCE_FEATURE_KEYS;
-  }
-
-  return CONFIG_FEATURE_DEFINITIONS
-    .filter((definition) => definition.isDocumented === true)
-    .map((definition) => definition.key);
+  return getReferenceFeatureKeys();
 };
 
-export const getConfigFeatureDefinition = (key) => FEATURE_DEFINITION_MAP[key];
+export const getConfigFeatureDefinition = (key) =>
+  buildFeatureDefinitionMap()[String(key || '').trim()];
 
 export const getConfigFeatureDefinitionOrFallback = (key) => {
+  const normalizedKey = String(key || '').trim();
   if (!key) {
     return {
       short: `${prettifyFeatureName(String(key))}`,
@@ -199,9 +63,9 @@ export const getConfigFeatureDefinitionOrFallback = (key) => {
   }
 
   return (
-    FEATURE_DEFINITION_MAP[key] || {
-      key,
-      short: prettifyFeatureName(String(key)),
+    getConfigFeatureDefinition(normalizedKey) || {
+      key: normalizedKey,
+      short: prettifyFeatureName(normalizedKey),
       usage: 'This configured key is not in the official feature list.',
       defaultValue: false,
       isDocumented: false,

package/src/configHelp.js

@@ -1,77 +1,8 @@
-import {
-  getConfigFeatureDefinition,
-  getConfigFeatureDefinitionOrFallback,
-} from './configFeatures.js';
 import {
   getReferenceOptionForPath,
-  getReferenceCustomIdPlaceholder,
-  getReferenceDescendantOptions,
-  getReferenceTableDefinitions,
+  getReferenceVariantForPath,
 } from './configReference.js';
 
-const CONFIG_VALUE_OPTIONS = {
-  model: [
-    'gpt-5.3-codex',
-    'gpt-5.3-codex-spark',
-    'gpt-5.2-codex',
-    'gpt-5.1-codex-max',
-    'gpt-5.2',
-    'gpt-5.1-codex-mini',
-  ],
-};
-
-const CONFIG_PATH_EXPLANATIONS = [
-  {
-    path: ['projects', '*', 'trust_level'],
-    short: 'Controls how much trust this project gets for command execution.',
-    usage: 'Use trusted for known folders, untrusted for extra prompts.',
-  },
-];
-
-const CONFIG_PATH_OPTIONS = [
-  {
-    path: ['projects', '*', 'trust_level'],
-    values: ['trusted', 'untrusted'],
-    explanations: {
-      trusted: 'Runs with normal trust for this path.',
-      untrusted: 'Limits risky actions and prompts more often.',
-    },
-  },
-];
-
-const CONFIG_OPTION_EXPLANATIONS = {
-  model: {
-    'gpt-5.3-codex': 'Latest frontier agentic coding model.',
-    'gpt-5.3-codex-spark': 'Ultra-fast coding model.',
-    'gpt-5.2-codex': 'Frontier agentic coding model.',
-    'gpt-5.1-codex-max': 'Codex-optimized flagship for deep and fast reasoning.',
-    'gpt-5.2': 'Latest frontier model with improvements across knowledge, reasoning and coding.',
-    'gpt-5.1-codex-mini': 'Optimized for codex. Cheaper, faster, but less capable.',
-  },
-  trust_level: {
-    trusted: 'Runs with normal trust for this path.',
-    untrusted: 'Limits risky actions and prompts more often.',
-  },
-};
-const SECTION_PURPOSE_OVERRIDES = {
-  agents: 'Named agent definitions and per-agent configuration file references.',
-  apps: 'Per-app enablement rules and tool-level approval controls.',
-  features: 'Feature flags for optional and experimental Codex behavior.',
-  feedback: 'Feedback submission settings for Codex surfaces.',
-  history: 'Session history retention policy and on-disk size limits.',
-  mcp_servers: 'MCP server definitions, transport settings, and authentication configuration.',
-  model_providers: 'Model provider definitions, API endpoints, and credential settings.',
-  notice: 'Visibility toggles for startup and migration notices.',
-  otel: 'OpenTelemetry exporter configuration for telemetry and traces.',
-  profiles: 'Named profile overrides you can select per session.',
-  projects: 'Project/worktree trust settings scoped by filesystem path.',
-  sandbox_workspace_write: 'Workspace-write sandbox behavior, writable roots, and network access rules.',
-  shell_environment_policy: 'Shell environment inheritance and variable override policy.',
-  skills: 'Skill discovery and loading controls.',
-  tools: 'Tool-related configuration, including legacy compatibility flags.',
-  tui: 'Terminal UI behavior, notifications, and presentation settings.',
-};
-
 const makePathSegments = (segments, key) => {
   const normalizedSegments = Array.isArray(segments)
     ? segments.map((segment) => String(segment))
@@ -84,89 +15,9 @@ const makePathSegments = (segments, key) => {
   return [...normalizedSegments, String(key)];
 };
 
-const pathMatches = (actualPath, patternPath) =>
-  actualPath.length === patternPath.length &&
-  actualPath.every((segment, index) => patternPath[index] === '*' || patternPath[index] === segment);
-
-const getContextEntry = (segments, key, candidates) => {
-  const fullPath = makePathSegments(segments, key);
-  return candidates.find((entry) => pathMatches(fullPath, entry.path)) || null;
-};
-
 const getReferenceEntry = (segments, key) => getReferenceOptionForPath(makePathSegments(segments, key));
 
-const formatPlaceholderLabel = (placeholder) => {
-  const cleaned = String(placeholder || '')
-    .replace(/^</, '')
-    .replace(/>$/, '');
-
-  return cleaned || 'id';
-};
-
-const toFirstSentence = (text) => {
-  const normalized = String(text || '').replace(/\s+/g, ' ').trim();
-  if (!normalized) {
-    return '';
-  }
-
-  const periodIndex = normalized.indexOf('. ');
-  if (periodIndex < 0) {
-    return normalized;
-  }
-
-  return normalized.slice(0, periodIndex + 1);
-};
-
-const getSectionPurposeDescription = (descendantOptions) => {
-  for (const option of descendantOptions) {
-    const firstSentence = toFirstSentence(option?.description);
-    if (firstSentence) {
-      return firstSentence;
-    }
-  }
-
-  return '';
-};
-
-const buildInferredSectionHelp = (segments, key) => {
-  const sectionPath = makePathSegments(segments, key);
-  const childDefinitions = getReferenceTableDefinitions(sectionPath);
-  const descendantOptions = getReferenceDescendantOptions(sectionPath);
-  const customPlaceholder = getReferenceCustomIdPlaceholder(sectionPath);
-  const parentCustomPlaceholder = getReferenceCustomIdPlaceholder(sectionPath.slice(0, -1));
-
-  if (childDefinitions.length === 0 && descendantOptions.length === 0 && !customPlaceholder) {
-    return null;
-  }
-
-  const rootOverride = sectionPath.length === 1
-    ? SECTION_PURPOSE_OVERRIDES[sectionPath[0]]
-    : null;
-  const customLabel = customPlaceholder ? formatPlaceholderLabel(customPlaceholder) : '';
-  const bestPurposeDescription = getSectionPurposeDescription(descendantOptions);
-  const dynamicEntryLabel = parentCustomPlaceholder
-    ? formatPlaceholderLabel(parentCustomPlaceholder)
-    : '';
-  const short = rootOverride
-    || (dynamicEntryLabel
-      ? `Configuration for this ${dynamicEntryLabel} entry.`
-      : '')
-    || bestPurposeDescription
-    || (customLabel
-      ? `Section for custom ${customLabel} entries.`
-      : 'Section with related settings.');
-
-  return {
-    short,
-    usage: null,
-  };
-};
-
 const getReferenceUsage = (entry) => {
-  if (entry.deprecated) {
-    return 'This option is deprecated in the official configuration reference.';
-  }
-
   if (entry.enumValues.length > 0) {
     return null;
   }
@@ -196,46 +47,25 @@ const buildReferenceHelp = (entry) => {
   }
 
   return {
-    short: entry.description || 'Official configuration option.',
+    short: String(entry.description || '').trim() || null,
     usage: getReferenceUsage(entry),
-    deprecation: entry.deprecated ? entry.description : undefined,
   };
 };
 
 export const getConfigHelp = (segments, key) => {
-  const contextHelp = getContextEntry(segments, key, CONFIG_PATH_EXPLANATIONS);
-  if (contextHelp) {
-    return contextHelp;
-  }
-
   const referenceEntry = getReferenceEntry(segments, key);
   const referenceHelp = buildReferenceHelp(referenceEntry);
 
-  if (segments?.[segments.length - 1] === 'features') {
-    const featureDefinition = getConfigFeatureDefinition(String(key));
-    if (referenceHelp) {
-      return {
-        ...referenceHelp,
-        usage: featureDefinition?.deprecation || referenceHelp.usage || featureDefinition?.usage || null,
-        deprecation: featureDefinition?.deprecation || referenceHelp.deprecation,
-      };
-    }
-
-    return getConfigFeatureDefinitionOrFallback(key);
-  }
-
   if (referenceHelp) {
     return referenceHelp;
   }
 
-  const inferredSectionHelp = buildInferredSectionHelp(segments, key);
-  if (inferredSectionHelp) {
-    return inferredSectionHelp;
-  }
-
   return null;
 };
 
+export const getConfigVariantMeta = (segments, key) =>
+  getReferenceVariantForPath(makePathSegments(segments, key));
+
 export const getConfigOptions = (segments, key, value, kind) => {
   if (kind !== 'value') {
     return null;
@@ -251,29 +81,21 @@ export const getConfigOptions = (segments, key, value, kind) => {
     return [false, true];
   }
 
-  const context = getContextEntry(segments, key, CONFIG_PATH_OPTIONS);
-  if (context) {
-    return context.values;
-  }
-
   if (referenceEntry?.enumValues?.length > 0) {
     return referenceEntry.enumValues;
   }
 
-  if (Object.prototype.hasOwnProperty.call(CONFIG_VALUE_OPTIONS, key)) {
-    return CONFIG_VALUE_OPTIONS[key];
-  }
-
   return null;
 };
 
 export const getConfigOptionExplanation = (segments, key, option) => {
-  const context = getContextEntry(segments, key, CONFIG_PATH_OPTIONS);
-  if (context?.explanations) {
-    return context.explanations[String(option)] || null;
+  const referenceEntry = getReferenceOptionForPath(makePathSegments(segments, key));
+  const enumDescription = referenceEntry?.enumOptionDescriptions?.[String(option)];
+  if (enumDescription) {
+    return enumDescription;
   }
 
-  return CONFIG_OPTION_EXPLANATIONS[key]?.[String(option)] || null;
+  return null;
 };
 
 export const getConfigDefaultOption = (segments, key, kind, options) => {
@@ -282,58 +104,20 @@ export const getConfigDefaultOption = (segments, key, kind, options) => {
   }
 
   const fullPath = makePathSegments(segments, key);
-  const pathKey = fullPath.join('.');
-  const parentPath = fullPath.slice(0, -1);
-  const explicitDefaults = {
-    approval_policy: 'on-request',
-    cli_auth_credentials_store: 'file',
-    file_opener: 'vscode',
-    'history.persistence': 'save-all',
-    mcp_oauth_credentials_store: 'auto',
-    model_reasoning_summary: 'auto',
-    model_verbosity: 'medium',
-    personality: 'pragmatic',
-    sandbox_mode: 'read-only',
-    'shell_environment_policy.inherit': 'all',
-    'tui.alternate_screen': 'auto',
-    'tui.notification_method': 'auto',
-  };
-
-  if (parentPath[parentPath.length - 1] === 'features') {
-    const definition = getConfigFeatureDefinition(String(key));
-    const featureDefault = definition?.defaultValue;
-
-    if (typeof featureDefault === 'boolean') {
-      return options.some((option) => Object.is(option, featureDefault))
-        ? featureDefault
-        : null;
-    }
-  }
-
-  if (
-    fullPath.length >= 3 &&
-    fullPath[0] === 'projects' &&
-    fullPath[fullPath.length - 1] === 'trust_level'
-  ) {
-    return options.some((option) => option === 'untrusted') ? 'untrusted' : null;
-  }
-
-  if (pathKey === 'web_search') {
-    return options.some((option) => option === 'cached') ? 'cached' : null;
+  const referenceEntry = getReferenceOptionForPath(fullPath);
+  const schemaDefault = referenceEntry?.defaultValue;
+  if (schemaDefault === null || schemaDefault === undefined) {
+    return null;
   }
 
-  if (
-    fullPath.length >= 3 &&
-    fullPath[0] === 'profiles' &&
-    fullPath[fullPath.length - 1] === 'web_search'
-  ) {
-    return options.some((option) => option === 'cached') ? 'cached' : null;
+  if (options.some((option) => Object.is(option, schemaDefault))) {
+    return schemaDefault;
   }
 
-  if (Object.prototype.hasOwnProperty.call(explicitDefaults, pathKey)) {
-    const explicitDefault = explicitDefaults[pathKey];
-    return options.some((option) => Object.is(option, explicitDefault))
-      ? explicitDefault
+  if (typeof schemaDefault !== 'string') {
+    const schemaDefaultAsString = String(schemaDefault);
+    return options.some((option) => Object.is(option, schemaDefaultAsString))
+      ? schemaDefaultAsString
       : null;
   }