@iam-brain/opencode-codex-auth 1.5.1 → 1.7.0

package/dist/lib/config/file.js

@@ -3,7 +3,7 @@ import fsPromises from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { isRecord } from "../util.js";
-import { CONFIG_FILE, DEFAULT_CODEX_CONFIG_TEMPLATE } from "./types.js";
+import { CONFIG_FILE, DEFAULT_CODEX_CONFIG_TEMPLATE, LEGACY_CONFIG_FILE } from "./types.js";
 function describeValueType(value) {
     if (Array.isArray(value))
         return "array";
@@ -11,8 +11,23 @@ function describeValueType(value) {
         return "null";
     return typeof value;
 }
+function describeValuePreview(value) {
+    if (typeof value === "string")
+        return JSON.stringify(value);
+    if (typeof value === "number" || typeof value === "boolean" || value === null || value === undefined) {
+        return String(value);
+    }
+    if (Array.isArray(value)) {
+        return `array(${value.length})`;
+    }
+    if (typeof value === "object") {
+        const keys = Object.keys(value);
+        return keys.length > 0 ? `object(${keys.slice(0, 3).join(", ")})` : "object";
+    }
+    return String(value);
+}
 function pushValidationIssue(issues, input) {
-    issues.push(`${input.path}: expected ${input.expected}, got ${describeValueType(input.actual)}`);
+    issues.push(`${input.path}: expected ${input.expected}, found ${describeValueType(input.actual)} (${describeValuePreview(input.actual)})`);
 }
 export function parseEnvBoolean(value) {
     if (value === undefined)
@@ -91,6 +106,85 @@ function stripJsonComments(raw) {
     }
     return out;
 }
+const SUPPORTED_INCLUDE_OPTIONS = [
+    "reasoning.encrypted_content",
+    "file_search_call.results",
+    "message.output_text.logprobs"
+];
+function normalizeNonEmptyString(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+function deriveReasoningSummaryAlias(value) {
+    if (value === undefined)
+        return undefined;
+    return value !== "none";
+}
+function deriveVerbosityEnabledAlias(value) {
+    if (value === undefined)
+        return undefined;
+    return value !== "none";
+}
+function deriveVerbosityAlias(value) {
+    if (value === undefined || value === "none")
+        return undefined;
+    return value;
+}
+function normalizeReasoningSummaryOption(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const normalized = value.trim().toLowerCase();
+    if (normalized === "auto" || normalized === "concise" || normalized === "detailed" || normalized === "none") {
+        return normalized;
+    }
+    return undefined;
+}
+export function normalizeTextVerbosityOption(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const normalized = value.trim().toLowerCase();
+    if (normalized === "default" ||
+        normalized === "low" ||
+        normalized === "medium" ||
+        normalized === "high" ||
+        normalized === "none") {
+        return normalized;
+    }
+    return undefined;
+}
+function normalizeIncludeOptions(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    const out = [];
+    const seen = new Set();
+    for (const entry of value) {
+        if (typeof entry !== "string")
+            continue;
+        const normalized = entry.trim().toLowerCase();
+        if (!SUPPORTED_INCLUDE_OPTIONS.includes(normalized))
+            continue;
+        if (seen.has(normalized))
+            continue;
+        seen.add(normalized);
+        out.push(normalized);
+    }
+    return out.length > 0 ? out : undefined;
+}
+function normalizeServiceTierInput(value) {
+    if (typeof value !== "string") {
+        return { value: undefined, usedDeprecatedDefaultAlias: false };
+    }
+    const normalized = value.trim().toLowerCase();
+    if (normalized === "default") {
+        return { value: "auto", usedDeprecatedDefaultAlias: true };
+    }
+    if (normalized === "auto" || normalized === "priority" || normalized === "flex") {
+        return { value: normalized, usedDeprecatedDefaultAlias: false };
+    }
+    return { value: undefined, usedDeprecatedDefaultAlias: false };
+}
 function normalizeModelBehaviorSettings(raw) {
     if (!isRecord(raw))
         return undefined;
@@ -98,21 +192,58 @@ function normalizeModelBehaviorSettings(raw) {
     const personality = normalizePersonalityOption(raw.personality);
     if (personality)
         out.personality = personality;
-    if (typeof raw.thinkingSummaries === "boolean")
-        out.thinkingSummaries = raw.thinkingSummaries;
-    if (typeof raw.verbosityEnabled === "boolean")
-        out.verbosityEnabled = raw.verbosityEnabled;
-    const verbosity = normalizeVerbosityOption(raw.verbosity);
-    if (verbosity)
-        out.verbosity = verbosity;
-    const serviceTier = normalizeServiceTierOption(raw.serviceTier);
-    if (serviceTier)
-        out.serviceTier = serviceTier;
+    const reasoningEffort = normalizeNonEmptyString(raw.reasoningEffort);
+    if (reasoningEffort)
+        out.reasoningEffort = reasoningEffort;
+    const reasoningSummary = normalizeReasoningSummaryOption(raw.reasoningSummary);
+    if (reasoningSummary) {
+        out.reasoningSummary = reasoningSummary;
+    }
+    else if (typeof raw.reasoningSummaries === "boolean") {
+        out.reasoningSummary = raw.reasoningSummaries ? "auto" : "none";
+    }
+    else if (typeof raw.thinkingSummaries === "boolean") {
+        out.reasoningSummary = raw.thinkingSummaries ? "auto" : "none";
+    }
+    out.reasoningSummaries = deriveReasoningSummaryAlias(out.reasoningSummary);
+    const textVerbosity = normalizeTextVerbosityOption(raw.textVerbosity);
+    if (textVerbosity) {
+        out.textVerbosity = textVerbosity;
+    }
+    else {
+        const verbosityEnabled = typeof raw.verbosityEnabled === "boolean" ? raw.verbosityEnabled : undefined;
+        const verbosity = normalizeVerbosityOption(raw.verbosity);
+        if (verbosityEnabled === false) {
+            out.textVerbosity = "none";
+        }
+        else if (verbosity) {
+            out.textVerbosity = verbosity;
+        }
+        else if (verbosityEnabled === true) {
+            out.textVerbosity = "default";
+        }
+    }
+    out.verbosityEnabled = deriveVerbosityEnabledAlias(out.textVerbosity);
+    out.verbosity = deriveVerbosityAlias(out.textVerbosity);
+    const serviceTier = normalizeServiceTierInput(raw.serviceTier);
+    if (serviceTier.value)
+        out.serviceTier = serviceTier.value;
+    const include = normalizeIncludeOptions(raw.include);
+    if (include)
+        out.include = include;
+    if (typeof raw.parallelToolCalls === "boolean") {
+        out.parallelToolCalls = raw.parallelToolCalls;
+    }
     if (!out.personality &&
-        out.thinkingSummaries === undefined &&
+        !out.reasoningEffort &&
+        out.reasoningSummary === undefined &&
+        out.reasoningSummaries === undefined &&
+        out.textVerbosity === undefined &&
         out.verbosityEnabled === undefined &&
         out.verbosity === undefined &&
-        out.serviceTier === undefined) {
+        out.serviceTier === undefined &&
+        out.include === undefined &&
+        out.parallelToolCalls === undefined) {
         return undefined;
     }
     return out;
@@ -131,10 +262,15 @@ function normalizeModelConfigOverride(raw) {
                 continue;
             variantMap[variantName] = {
                 ...(normalized.personality ? { personality: normalized.personality } : {}),
-                ...(normalized.thinkingSummaries !== undefined ? { thinkingSummaries: normalized.thinkingSummaries } : {}),
+                ...(normalized.reasoningEffort ? { reasoningEffort: normalized.reasoningEffort } : {}),
+                ...(normalized.reasoningSummary ? { reasoningSummary: normalized.reasoningSummary } : {}),
+                ...(normalized.reasoningSummaries !== undefined ? { reasoningSummaries: normalized.reasoningSummaries } : {}),
+                ...(normalized.textVerbosity ? { textVerbosity: normalized.textVerbosity } : {}),
                 ...(normalized.verbosityEnabled !== undefined ? { verbosityEnabled: normalized.verbosityEnabled } : {}),
                 ...(normalized.verbosity ? { verbosity: normalized.verbosity } : {}),
-                ...(normalized.serviceTier ? { serviceTier: normalized.serviceTier } : {})
+                ...(normalized.serviceTier ? { serviceTier: normalized.serviceTier } : {}),
+                ...(normalized.include ? { include: normalized.include } : {}),
+                ...(normalized.parallelToolCalls !== undefined ? { parallelToolCalls: normalized.parallelToolCalls } : {})
             };
         }
         if (Object.keys(variantMap).length > 0) {
@@ -146,13 +282,36 @@ function normalizeModelConfigOverride(raw) {
     }
     return {
         ...(modelBehavior?.personality ? { personality: modelBehavior.personality } : {}),
-        ...(modelBehavior?.thinkingSummaries !== undefined ? { thinkingSummaries: modelBehavior.thinkingSummaries } : {}),
+        ...(modelBehavior?.reasoningEffort ? { reasoningEffort: modelBehavior.reasoningEffort } : {}),
+        ...(modelBehavior?.reasoningSummary ? { reasoningSummary: modelBehavior.reasoningSummary } : {}),
+        ...(modelBehavior?.reasoningSummaries !== undefined
+            ? { reasoningSummaries: modelBehavior.reasoningSummaries }
+            : {}),
+        ...(modelBehavior?.textVerbosity ? { textVerbosity: modelBehavior.textVerbosity } : {}),
         ...(modelBehavior?.verbosityEnabled !== undefined ? { verbosityEnabled: modelBehavior.verbosityEnabled } : {}),
         ...(modelBehavior?.verbosity ? { verbosity: modelBehavior.verbosity } : {}),
         ...(modelBehavior?.serviceTier ? { serviceTier: modelBehavior.serviceTier } : {}),
+        ...(modelBehavior?.include ? { include: modelBehavior.include } : {}),
+        ...(modelBehavior?.parallelToolCalls !== undefined ? { parallelToolCalls: modelBehavior.parallelToolCalls } : {}),
         ...(variants ? { variants } : {})
     };
 }
+function normalizeCustomModelConfig(raw) {
+    if (!isRecord(raw))
+        return undefined;
+    const behavior = normalizeModelConfigOverride(raw);
+    const targetModel = normalizeNonEmptyString(raw.targetModel);
+    const name = normalizeNonEmptyString(raw.name);
+    if (!targetModel && !behavior && !name)
+        return undefined;
+    if (!targetModel)
+        return undefined;
+    return {
+        targetModel,
+        ...(name ? { name } : {}),
+        ...(behavior ?? {})
+    };
+}
 function normalizeNewBehaviorSections(raw) {
     const global = normalizeModelBehaviorSettings(raw.global);
     const perModelRaw = isRecord(raw.perModel) ? raw.perModel : undefined;
@@ -176,6 +335,22 @@ function normalizeNewBehaviorSections(raw) {
         ...(perModel ? { perModel } : {})
     };
 }
+function normalizeCustomModels(raw) {
+    const customModelsRaw = isRecord(raw.customModels) ? raw.customModels : undefined;
+    if (!customModelsRaw)
+        return undefined;
+    const out = {};
+    for (const [slug, value] of Object.entries(customModelsRaw)) {
+        const normalizedSlug = normalizeNonEmptyString(slug)?.toLowerCase();
+        if (!normalizedSlug)
+            continue;
+        const normalized = normalizeCustomModelConfig(value);
+        if (!normalized)
+            continue;
+        out[normalizedSlug] = normalized;
+    }
+    return Object.keys(out).length > 0 ? out : undefined;
+}
 function validateModelBehaviorShape(value, pathPrefix, issues) {
     if (!isRecord(value)) {
         pushValidationIssue(issues, { path: pathPrefix, expected: "object", actual: value });
@@ -184,6 +359,31 @@ function validateModelBehaviorShape(value, pathPrefix, issues) {
     if ("personality" in value && typeof value.personality !== "string") {
         pushValidationIssue(issues, { path: `${pathPrefix}.personality`, expected: "string", actual: value.personality });
     }
+    if ("reasoningEffort" in value && typeof value.reasoningEffort !== "string") {
+        pushValidationIssue(issues, {
+            path: `${pathPrefix}.reasoningEffort`,
+            expected: "string",
+            actual: value.reasoningEffort
+        });
+    }
+    if ("reasoningSummary" in value) {
+        const reasoningSummary = value.reasoningSummary;
+        const normalized = typeof reasoningSummary === "string" ? reasoningSummary.trim().toLowerCase() : "";
+        if (!(normalized === "auto" || normalized === "concise" || normalized === "detailed" || normalized === "none")) {
+            pushValidationIssue(issues, {
+                path: `${pathPrefix}.reasoningSummary`,
+                expected: '"auto" | "concise" | "detailed" | "none"',
+                actual: reasoningSummary
+            });
+        }
+    }
+    if ("reasoningSummaries" in value && typeof value.reasoningSummaries !== "boolean") {
+        pushValidationIssue(issues, {
+            path: `${pathPrefix}.reasoningSummaries`,
+            expected: "boolean",
+            actual: value.reasoningSummaries
+        });
+    }
     if ("thinkingSummaries" in value && typeof value.thinkingSummaries !== "boolean") {
         pushValidationIssue(issues, {
             path: `${pathPrefix}.thinkingSummaries`,
@@ -209,17 +409,82 @@ function validateModelBehaviorShape(value, pathPrefix, issues) {
             });
         }
     }
+    if ("textVerbosity" in value) {
+        const textVerbosity = value.textVerbosity;
+        const normalized = typeof textVerbosity === "string" ? textVerbosity.trim().toLowerCase() : "";
+        if (!(normalized === "default" ||
+            normalized === "low" ||
+            normalized === "medium" ||
+            normalized === "high" ||
+            normalized === "none")) {
+            pushValidationIssue(issues, {
+                path: `${pathPrefix}.textVerbosity`,
+                expected: '"default" | "low" | "medium" | "high" | "none"',
+                actual: textVerbosity
+            });
+        }
+    }
     if ("serviceTier" in value) {
         const serviceTier = value.serviceTier;
         const normalized = typeof serviceTier === "string" ? serviceTier.trim().toLowerCase() : "";
-        if (!(normalized === "default" || normalized === "priority" || normalized === "flex")) {
+        if (!(normalized === "default" || normalized === "auto" || normalized === "priority" || normalized === "flex")) {
             pushValidationIssue(issues, {
                 path: `${pathPrefix}.serviceTier`,
-                expected: '"default" | "priority" | "flex"',
+                expected: '"auto" | "priority" | "flex" (deprecated alias: "default")',
                 actual: serviceTier
             });
         }
     }
+    if ("include" in value) {
+        if (!Array.isArray(value.include)) {
+            pushValidationIssue(issues, {
+                path: `${pathPrefix}.include`,
+                expected: "array",
+                actual: value.include
+            });
+        }
+        else {
+            for (const entry of value.include) {
+                const normalized = typeof entry === "string" ? entry.trim().toLowerCase() : "";
+                if (!SUPPORTED_INCLUDE_OPTIONS.includes(normalized)) {
+                    pushValidationIssue(issues, {
+                        path: `${pathPrefix}.include`,
+                        expected: SUPPORTED_INCLUDE_OPTIONS.map((item) => `"${item}"`).join(" | "),
+                        actual: entry
+                    });
+                }
+            }
+        }
+    }
+    if ("parallelToolCalls" in value && typeof value.parallelToolCalls !== "boolean") {
+        pushValidationIssue(issues, {
+            path: `${pathPrefix}.parallelToolCalls`,
+            expected: "boolean",
+            actual: value.parallelToolCalls
+        });
+    }
+}
+function validateCustomModelShape(value, pathPrefix, issues) {
+    validateModelBehaviorShape(value, pathPrefix, issues);
+    if (!isRecord(value))
+        return;
+    if ("targetModel" in value && typeof value.targetModel !== "string") {
+        pushValidationIssue(issues, {
+            path: `${pathPrefix}.targetModel`,
+            expected: "string",
+            actual: value.targetModel
+        });
+    }
+    if (!("targetModel" in value)) {
+        issues.push(`${pathPrefix}.targetModel: expected string, found missing (custom models require targetModel)`);
+    }
+    if ("name" in value && typeof value.name !== "string") {
+        pushValidationIssue(issues, {
+            path: `${pathPrefix}.name`,
+            expected: "string",
+            actual: value.name
+        });
+    }
 }
 export function parseConfigJsonWithComments(raw) {
     return JSON.parse(stripJsonComments(raw));
@@ -282,13 +547,7 @@ export function normalizeVerbosityOption(value) {
     return undefined;
 }
 export function normalizeServiceTierOption(value) {
-    if (typeof value !== "string")
-        return undefined;
-    const normalized = value.trim().toLowerCase();
-    if (normalized === "default" || normalized === "priority" || normalized === "flex") {
-        return normalized;
-    }
-    return undefined;
+    return normalizeServiceTierInput(value).value;
 }
 export function validateConfigFileObject(raw) {
     const issues = [];
@@ -400,12 +659,96 @@ export function validateConfigFileObject(raw) {
             }
         }
     }
+    if ("customModels" in raw) {
+        if (!isRecord(raw.customModels)) {
+            pushValidationIssue(issues, { path: "customModels", expected: "object", actual: raw.customModels });
+        }
+        else {
+            for (const [slug, value] of Object.entries(raw.customModels)) {
+                validateCustomModelShape(value, `customModels.${slug}`, issues);
+                if (!isRecord(value) || !("variants" in value))
+                    continue;
+                const variants = value.variants;
+                if (!isRecord(variants)) {
+                    pushValidationIssue(issues, {
+                        path: `customModels.${slug}.variants`,
+                        expected: "object",
+                        actual: variants
+                    });
+                    continue;
+                }
+                for (const [variantName, variantValue] of Object.entries(variants)) {
+                    validateModelBehaviorShape(variantValue, `customModels.${slug}.variants.${variantName}`, issues);
+                }
+            }
+        }
+    }
     return { valid: issues.length === 0, issues };
 }
 export function parseConfigFileObject(raw) {
+    return parseConfigFileObjectWithMetadata(raw).config;
+}
+function collectDeprecatedModelBehaviorKeys(raw) {
     if (!isRecord(raw))
-        return {};
+        return [];
+    const keys = [];
+    const collectBehaviorAlias = (value, pathPrefix) => {
+        if (!isRecord(value))
+            return;
+        if (typeof value.reasoningSummaries === "boolean") {
+            keys.push(`${pathPrefix}.reasoningSummaries`);
+        }
+        if (typeof value.thinkingSummaries === "boolean") {
+            keys.push(`${pathPrefix}.thinkingSummaries`);
+        }
+        if ("verbosityEnabled" in value) {
+            keys.push(`${pathPrefix}.verbosityEnabled`);
+        }
+        if ("verbosity" in value) {
+            keys.push(`${pathPrefix}.verbosity`);
+        }
+        if (typeof value.serviceTier === "string" && value.serviceTier.trim().toLowerCase() === "default") {
+            keys.push(`${pathPrefix}.serviceTier="default"`);
+        }
+    };
+    collectBehaviorAlias(raw.global, "global");
+    if (isRecord(raw.perModel)) {
+        for (const [modelName, modelValue] of Object.entries(raw.perModel)) {
+            collectBehaviorAlias(modelValue, `perModel.${modelName}`);
+            if (!isRecord(modelValue))
+                continue;
+            const variants = isRecord(modelValue.variants) ? modelValue.variants : undefined;
+            if (!variants)
+                continue;
+            for (const [variantName, variantValue] of Object.entries(variants)) {
+                collectBehaviorAlias(variantValue, `perModel.${modelName}.variants.${variantName}`);
+            }
+        }
+    }
+    if (isRecord(raw.customModels)) {
+        for (const [slug, modelValue] of Object.entries(raw.customModels)) {
+            collectBehaviorAlias(modelValue, `customModels.${slug}`);
+            if (!isRecord(modelValue))
+                continue;
+            const variants = isRecord(modelValue.variants) ? modelValue.variants : undefined;
+            if (!variants)
+                continue;
+            for (const [variantName, variantValue] of Object.entries(variants)) {
+                collectBehaviorAlias(variantValue, `customModels.${slug}.variants.${variantName}`);
+            }
+        }
+    }
+    return keys;
+}
+function parseConfigFileObjectWithMetadata(raw) {
+    if (!isRecord(raw)) {
+        return {
+            config: {},
+            deprecatedKeys: []
+        };
+    }
     const behaviorSettings = normalizeNewBehaviorSections(raw);
+    const customModels = normalizeCustomModels(raw);
     const personalityFromBehavior = behaviorSettings?.global?.personality;
     const runtime = isRecord(raw.runtime) ? raw.runtime : undefined;
     const debug = typeof raw.debug === "boolean" ? raw.debug : undefined;
@@ -426,28 +769,32 @@ export function parseConfigFileObject(raw) {
     const collaborationProfileEnabled = typeof runtime?.collaborationProfile === "boolean" ? runtime.collaborationProfile : undefined;
     const orchestratorSubagentsEnabled = typeof runtime?.orchestratorSubagents === "boolean" ? runtime.orchestratorSubagents : undefined;
     return {
-        debug,
-        proactiveRefresh,
-        proactiveRefreshBufferMs,
-        quiet: quietMode,
-        quietMode,
-        pidOffsetEnabled,
-        personality: personalityFromBehavior,
-        mode,
-        rotationStrategy,
-        promptCacheKeyStrategy,
-        spoofMode,
-        compatInputSanitizer,
-        remapDeveloperMessagesToUser,
-        codexCompactionOverride,
-        headerSnapshots,
-        headerSnapshotBodies,
-        headerTransformDebug,
-        collaborationProfile: collaborationProfileEnabled,
-        collaborationProfileEnabled,
-        orchestratorSubagents: orchestratorSubagentsEnabled,
-        orchestratorSubagentsEnabled,
-        behaviorSettings
+        config: {
+            debug,
+            proactiveRefresh,
+            proactiveRefreshBufferMs,
+            quiet: quietMode,
+            quietMode,
+            pidOffsetEnabled,
+            personality: personalityFromBehavior,
+            mode,
+            rotationStrategy,
+            promptCacheKeyStrategy,
+            spoofMode,
+            compatInputSanitizer,
+            remapDeveloperMessagesToUser,
+            codexCompactionOverride,
+            headerSnapshots,
+            headerSnapshotBodies,
+            headerTransformDebug,
+            collaborationProfile: collaborationProfileEnabled,
+            collaborationProfileEnabled,
+            orchestratorSubagents: orchestratorSubagentsEnabled,
+            orchestratorSubagentsEnabled,
+            behaviorSettings,
+            customModels
+        },
+        deprecatedKeys: collectDeprecatedModelBehaviorKeys(raw)
     };
 }
 export function resolveDefaultConfigPath(env) {
@@ -457,9 +804,51 @@ export function resolveDefaultConfigPath(env) {
     }
     return path.join(os.homedir(), ".config", "opencode", CONFIG_FILE);
 }
+export function resolveLegacyDefaultConfigPath(env) {
+    const xdgRoot = env.XDG_CONFIG_HOME?.trim();
+    if (xdgRoot) {
+        return path.join(xdgRoot, "opencode", LEGACY_CONFIG_FILE);
+    }
+    return path.join(os.homedir(), ".config", "opencode", LEGACY_CONFIG_FILE);
+}
+function quarantineLegacyConfigSync(filePath) {
+    try {
+        const quarantineDir = path.join(path.dirname(filePath), "quarantine");
+        fs.mkdirSync(quarantineDir, { recursive: true });
+        const dest = path.join(quarantineDir, `${path.basename(filePath)}.${Date.now()}.quarantine.json`);
+        fs.renameSync(filePath, dest);
+        return dest;
+    }
+    catch {
+        return undefined;
+    }
+}
+function resolveDefaultConfigCandidates(env) {
+    const filePath = resolveDefaultConfigPath(env);
+    const legacyPath = resolveLegacyDefaultConfigPath(env);
+    const hasFile = fs.existsSync(filePath);
+    const hasLegacy = fs.existsSync(legacyPath);
+    if (hasFile && hasLegacy) {
+        return [filePath, legacyPath];
+    }
+    if (hasFile)
+        return [filePath];
+    if (hasLegacy)
+        return [legacyPath];
+    return [filePath];
+}
 export async function ensureDefaultConfigFile(input = {}) {
     const env = input.env ?? process.env;
-    const filePath = input.filePath ?? resolveDefaultConfigPath(env);
+    const filePath = input.filePath ??
+        (() => {
+            const canonicalPath = resolveDefaultConfigPath(env);
+            const legacyPath = resolveLegacyDefaultConfigPath(env);
+            if (fs.existsSync(canonicalPath))
+                return canonicalPath;
+            if (fs.existsSync(legacyPath))
+                return legacyPath;
+            return canonicalPath;
+        })();
     const overwrite = input.overwrite === true;
     if (!overwrite && fs.existsSync(filePath)) {
         return { filePath, created: false };
@@ -479,7 +868,15 @@ export async function ensureDefaultConfigFile(input = {}) {
 export function loadConfigFile(input = {}) {
     const env = input.env ?? process.env;
     const explicitPath = input.filePath ?? env.OPENCODE_OPENAI_MULTI_CONFIG_PATH?.trim();
-    const candidates = explicitPath ? [explicitPath] : [resolveDefaultConfigPath(env)];
+    const candidates = explicitPath ? [explicitPath] : resolveDefaultConfigCandidates(env);
+    const canonicalPath = explicitPath ? undefined : resolveDefaultConfigPath(env);
+    const legacyPath = explicitPath ? undefined : resolveLegacyDefaultConfigPath(env);
+    const shouldQuarantineLegacyAfterCanonicalLoad = !explicitPath &&
+        canonicalPath !== undefined &&
+        legacyPath !== undefined &&
+        candidates.length > 1 &&
+        fs.existsSync(canonicalPath) &&
+        fs.existsSync(legacyPath);
     for (const filePath of candidates) {
         if (!filePath || !fs.existsSync(filePath))
             continue;
@@ -491,7 +888,19 @@ export function loadConfigFile(input = {}) {
                 console.warn(`[opencode-codex-auth] Invalid codex-config at ${filePath}. ${validation.issues.join("; ")}`);
                 continue;
             }
-            return parseConfigFileObject(parsed);
+            const result = parseConfigFileObjectWithMetadata(parsed);
+            if (result.deprecatedKeys.length > 0) {
+                console.warn(`[opencode-codex-auth] Deprecated config key(s) in ${filePath}: ${result.deprecatedKeys.join(", ")}. Use reasoningSummary, textVerbosity, and serviceTier: "auto" instead.`);
+            }
+            if (shouldQuarantineLegacyAfterCanonicalLoad &&
+                filePath === canonicalPath &&
+                legacyPath &&
+                fs.existsSync(legacyPath)) {
+                const quarantinedPath = quarantineLegacyConfigSync(legacyPath);
+                const suffix = quarantinedPath ? ` Quarantined legacy file to ${quarantinedPath}.` : "";
+                console.warn(`[opencode-codex-auth] Found both ${CONFIG_FILE} and ${LEGACY_CONFIG_FILE}. Using ${CONFIG_FILE}.${suffix}`);
+            }
+            return result.config;
         }
         catch (error) {
             const detail = error instanceof Error ? error.message : String(error);