@iam-brain/opencode-codex-auth 0.3.1 → 1.0.0

package/dist/lib/config.js

@@ -2,6 +2,7 @@ import fs from "node:fs";
 import fsPromises from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
+import { isRecord } from "./util";
 const CONFIG_FILE = "codex-config.json";
 export const DEFAULT_CODEX_CONFIG = {
     $schema: "https://schemas.iam-brain.dev/opencode-codex-auth/codex-config.schema.json",
@@ -16,12 +17,16 @@ export const DEFAULT_CODEX_CONFIG = {
         rotationStrategy: "sticky",
         sanitizeInputs: false,
         developerMessagesToUser: true,
+        promptCacheKeyStrategy: "default",
         headerSnapshots: false,
+        headerSnapshotBodies: false,
         headerTransformDebug: false,
         pidOffset: false
     },
     global: {
-        personality: "pragmatic"
+        personality: "pragmatic",
+        verbosityEnabled: true,
+        verbosity: "default"
     },
     perModel: {}
 };
@@ -71,11 +76,23 @@ const DEFAULT_CODEX_CONFIG_TEMPLATE = `{
     // default: true
     "developerMessagesToUser": true,
 
+    // Prompt cache key policy.
+    // "default" keeps upstream session-based keys.
+    // "project" overrides with a hashed project path + runtime mode key.
+    // options: "default" | "project"
+    // default: "default"
+    "promptCacheKeyStrategy": "default",
+
     // Write request header snapshots to plugin logs.
     // options: true | false
     // default: false
     "headerSnapshots": false,
 
+    // Capture request bodies in snapshot files.
+    // options: true | false
+    // default: false
+    "headerSnapshotBodies": false,
+
     // Capture inbound/outbound header transforms for message requests.
     // options: true | false
     // default: false
@@ -85,6 +102,11 @@ const DEFAULT_CODEX_CONFIG_TEMPLATE = `{
     // options: true | false
     // default: false
     "pidOffset": false
+
+    // Experimental collaboration controls (optional):
+    // "collaborationProfile": true,
+    // "orchestratorSubagents": true,
+    // "collaborationToolProfile": "opencode" // "opencode" | "codex"
   },
 
   "global": {
@@ -92,33 +114,204 @@ const DEFAULT_CODEX_CONFIG_TEMPLATE = `{
     // built-ins: "pragmatic", "friendly"
     // custom: any lowercase key from personalities/<key>.md
     // default: "pragmatic"
-    "personality": "pragmatic"
+    "personality": "pragmatic",
 
     // Thinking summaries behavior:
     // true  => force on
     // false => force off
     // omit  => use model default from catalog cache (recommended)
     // "thinkingSummaries": true
+
+    // Text verbosity behavior:
+    // verbosityEnabled: true  => apply verbosity setting/default
+    // verbosityEnabled: false => do not send textVerbosity
+    // default: true
+    "verbosityEnabled": true,
+
+    // options: "default" | "low" | "medium" | "high"
+    // "default" uses each model's catalog default verbosity.
+    // default: "default"
+    "verbosity": "default"
   },
 
   // Optional model-specific overrides.
   // Supports same fields as global plus nested variants.
   "perModel": {
-    // "gpt-5.3-codex": {
-    //   "personality": "friendly",
-    //   "thinkingSummaries": true,
-    //   "variants": {
-    //     "high": {
-    //       "personality": "pragmatic",
-    //       "thinkingSummaries": false
-    //     }
-    //   }
-    // }
+     // "gpt-5.3-codex": {
+     //   "personality": "friendly",
+     //   "thinkingSummaries": true,
+     //   "verbosityEnabled": true,
+     //   "verbosity": "default",
+     //   "variants": {
+     //     "high": {
+     //       "personality": "pragmatic",
+     //       "thinkingSummaries": false,
+     //       "verbosityEnabled": true,
+     //       "verbosity": "high"
+     //     }
+     //   }
+     // }
   }
 }
 `;
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
+function describeValueType(value) {
+    if (Array.isArray(value))
+        return "array";
+    if (value === null)
+        return "null";
+    return typeof value;
+}
+function pushValidationIssue(issues, input) {
+    issues.push(`${input.path}: expected ${input.expected}, got ${describeValueType(input.actual)}`);
+}
+function validateModelBehaviorShape(value, pathPrefix, issues) {
+    if (!isRecord(value)) {
+        pushValidationIssue(issues, { path: pathPrefix, expected: "object", actual: value });
+        return;
+    }
+    if ("personality" in value && typeof value.personality !== "string") {
+        pushValidationIssue(issues, { path: `${pathPrefix}.personality`, expected: "string", actual: value.personality });
+    }
+    if ("thinkingSummaries" in value && typeof value.thinkingSummaries !== "boolean") {
+        pushValidationIssue(issues, {
+            path: `${pathPrefix}.thinkingSummaries`,
+            expected: "boolean",
+            actual: value.thinkingSummaries
+        });
+    }
+    if ("verbosityEnabled" in value && typeof value.verbosityEnabled !== "boolean") {
+        pushValidationIssue(issues, {
+            path: `${pathPrefix}.verbosityEnabled`,
+            expected: "boolean",
+            actual: value.verbosityEnabled
+        });
+    }
+    if ("verbosity" in value) {
+        const verbosity = value.verbosity;
+        const normalized = typeof verbosity === "string" ? verbosity.trim().toLowerCase() : "";
+        if (!(normalized === "default" || normalized === "low" || normalized === "medium" || normalized === "high")) {
+            pushValidationIssue(issues, {
+                path: `${pathPrefix}.verbosity`,
+                expected: '"default" | "low" | "medium" | "high"',
+                actual: verbosity
+            });
+        }
+    }
+}
+export function validateConfigFileObject(raw) {
+    const issues = [];
+    if (!isRecord(raw)) {
+        pushValidationIssue(issues, { path: "$", expected: "object", actual: raw });
+        return { valid: false, issues };
+    }
+    if ("$schema" in raw && typeof raw.$schema !== "string") {
+        pushValidationIssue(issues, { path: "$schema", expected: "string", actual: raw.$schema });
+    }
+    if ("debug" in raw && typeof raw.debug !== "boolean") {
+        pushValidationIssue(issues, { path: "debug", expected: "boolean", actual: raw.debug });
+    }
+    if ("quiet" in raw && typeof raw.quiet !== "boolean") {
+        pushValidationIssue(issues, { path: "quiet", expected: "boolean", actual: raw.quiet });
+    }
+    if ("refreshAhead" in raw) {
+        if (!isRecord(raw.refreshAhead)) {
+            pushValidationIssue(issues, { path: "refreshAhead", expected: "object", actual: raw.refreshAhead });
+        }
+        else {
+            if ("enabled" in raw.refreshAhead && typeof raw.refreshAhead.enabled !== "boolean") {
+                pushValidationIssue(issues, {
+                    path: "refreshAhead.enabled",
+                    expected: "boolean",
+                    actual: raw.refreshAhead.enabled
+                });
+            }
+            if ("bufferMs" in raw.refreshAhead &&
+                (typeof raw.refreshAhead.bufferMs !== "number" || !Number.isFinite(raw.refreshAhead.bufferMs))) {
+                pushValidationIssue(issues, {
+                    path: "refreshAhead.bufferMs",
+                    expected: "number",
+                    actual: raw.refreshAhead.bufferMs
+                });
+            }
+        }
+    }
+    if ("runtime" in raw) {
+        if (!isRecord(raw.runtime)) {
+            pushValidationIssue(issues, { path: "runtime", expected: "object", actual: raw.runtime });
+        }
+        else {
+            const runtime = raw.runtime;
+            const enumChecks = [
+                { field: "mode", allowed: ["native", "codex"] },
+                { field: "rotationStrategy", allowed: ["sticky", "hybrid", "round_robin"] },
+                { field: "promptCacheKeyStrategy", allowed: ["default", "project"] },
+                { field: "collaborationToolProfile", allowed: ["opencode", "codex"] }
+            ];
+            for (const check of enumChecks) {
+                const value = runtime[check.field];
+                if (value === undefined)
+                    continue;
+                const normalized = typeof value === "string" ? value.trim().toLowerCase() : "";
+                if (!check.allowed.includes(normalized)) {
+                    pushValidationIssue(issues, {
+                        path: `runtime.${check.field}`,
+                        expected: check.allowed.map((item) => `"${item}"`).join(" | "),
+                        actual: value
+                    });
+                }
+            }
+            const boolFields = [
+                "sanitizeInputs",
+                "developerMessagesToUser",
+                "codexCompactionOverride",
+                "headerSnapshots",
+                "headerSnapshotBodies",
+                "headerTransformDebug",
+                "pidOffset",
+                "collaborationProfile",
+                "orchestratorSubagents"
+            ];
+            for (const field of boolFields) {
+                if (field in runtime && typeof runtime[field] !== "boolean") {
+                    pushValidationIssue(issues, {
+                        path: `runtime.${field}`,
+                        expected: "boolean",
+                        actual: runtime[field]
+                    });
+                }
+            }
+        }
+    }
+    if ("global" in raw) {
+        validateModelBehaviorShape(raw.global, "global", issues);
+    }
+    if ("perModel" in raw) {
+        if (!isRecord(raw.perModel)) {
+            pushValidationIssue(issues, { path: "perModel", expected: "object", actual: raw.perModel });
+        }
+        else {
+            for (const [modelName, modelValue] of Object.entries(raw.perModel)) {
+                validateModelBehaviorShape(modelValue, `perModel.${modelName}`, issues);
+                if (!isRecord(modelValue))
+                    continue;
+                if (!("variants" in modelValue))
+                    continue;
+                const variants = modelValue.variants;
+                if (!isRecord(variants)) {
+                    pushValidationIssue(issues, {
+                        path: `perModel.${modelName}.variants`,
+                        expected: "object",
+                        actual: variants
+                    });
+                    continue;
+                }
+                for (const [variantName, variantValue] of Object.entries(variants)) {
+                    validateModelBehaviorShape(variantValue, `perModel.${modelName}.variants.${variantName}`, issues);
+                }
+            }
+        }
+    }
+    return { valid: issues.length === 0, issues };
 }
 function parseEnvBoolean(value) {
     if (value === undefined)
@@ -237,48 +430,53 @@ function parseRotationStrategy(value) {
     }
     return undefined;
 }
-function normalizeCustomSettings(raw) {
-    if (!isRecord(raw))
+function parsePromptCacheKeyStrategy(value) {
+    if (typeof value !== "string")
         return undefined;
-    const out = {};
-    if (typeof raw.thinkingSummaries === "boolean") {
-        out.thinkingSummaries = raw.thinkingSummaries;
-    }
-    const rawOptions = isRecord(raw.options) ? raw.options : undefined;
-    const globalPersonality = normalizePersonalityOption(rawOptions?.personality);
-    if (globalPersonality) {
-        out.options = { personality: globalPersonality };
-    }
-    const rawModels = isRecord(raw.models) ? raw.models : undefined;
-    if (rawModels) {
-        const models = {};
-        for (const [modelName, value] of Object.entries(rawModels)) {
-            const normalized = normalizeModelConfigOverride(value);
-            if (!normalized)
-                continue;
-            models[modelName] = normalized;
-        }
-        if (Object.keys(models).length > 0) {
-            out.models = models;
-        }
+    const normalized = value.trim().toLowerCase();
+    if (normalized === "default" || normalized === "project")
+        return normalized;
+    return undefined;
+}
+function parseCollaborationToolProfile(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const normalized = value.trim().toLowerCase();
+    if (normalized === "opencode" || normalized === "codex") {
+        return normalized;
     }
-    if (out.thinkingSummaries === undefined && !out.options && !out.models) {
+    return undefined;
+}
+function normalizeVerbosityOption(value) {
+    if (typeof value !== "string")
         return undefined;
+    const normalized = value.trim().toLowerCase();
+    if (normalized === "default" || normalized === "low" || normalized === "medium" || normalized === "high") {
+        return normalized;
     }
-    return out;
+    return undefined;
 }
 function normalizeModelBehaviorSettings(raw) {
     if (!isRecord(raw))
         return undefined;
     const out = {};
-    const options = isRecord(raw.options) ? raw.options : undefined;
-    const personality = normalizePersonalityOption(raw.personality) ?? normalizePersonalityOption(options?.personality);
+    const personality = normalizePersonalityOption(raw.personality);
     if (personality)
         out.personality = personality;
     if (typeof raw.thinkingSummaries === "boolean") {
         out.thinkingSummaries = raw.thinkingSummaries;
     }
-    if (!out.personality && out.thinkingSummaries === undefined) {
+    if (typeof raw.verbosityEnabled === "boolean") {
+        out.verbosityEnabled = raw.verbosityEnabled;
+    }
+    const verbosity = normalizeVerbosityOption(raw.verbosity);
+    if (verbosity) {
+        out.verbosity = verbosity;
+    }
+    if (!out.personality &&
+        out.thinkingSummaries === undefined &&
+        out.verbosityEnabled === undefined &&
+        out.verbosity === undefined) {
         return undefined;
     }
     return out;
@@ -296,8 +494,10 @@ function normalizeModelConfigOverride(raw) {
             if (!normalized)
                 continue;
             variantMap[variantName] = {
-                ...(normalized.personality ? { options: { personality: normalized.personality } } : {}),
-                ...(normalized.thinkingSummaries !== undefined ? { thinkingSummaries: normalized.thinkingSummaries } : {})
+                ...(normalized.personality ? { personality: normalized.personality } : {}),
+                ...(normalized.thinkingSummaries !== undefined ? { thinkingSummaries: normalized.thinkingSummaries } : {}),
+                ...(normalized.verbosityEnabled !== undefined ? { verbosityEnabled: normalized.verbosityEnabled } : {}),
+                ...(normalized.verbosity ? { verbosity: normalized.verbosity } : {})
             };
         }
         if (Object.keys(variantMap).length > 0) {
@@ -308,15 +508,17 @@ function normalizeModelConfigOverride(raw) {
         return undefined;
     }
     return {
-        ...(modelBehavior?.personality ? { options: { personality: modelBehavior.personality } } : {}),
+        ...(modelBehavior?.personality ? { personality: modelBehavior.personality } : {}),
         ...(modelBehavior?.thinkingSummaries !== undefined ? { thinkingSummaries: modelBehavior.thinkingSummaries } : {}),
+        ...(modelBehavior?.verbosityEnabled !== undefined ? { verbosityEnabled: modelBehavior.verbosityEnabled } : {}),
+        ...(modelBehavior?.verbosity ? { verbosity: modelBehavior.verbosity } : {}),
         ...(variants ? { variants } : {})
     };
 }
 function normalizeNewBehaviorSections(raw) {
     const global = normalizeModelBehaviorSettings(raw.global);
     const perModelRaw = isRecord(raw.perModel) ? raw.perModel : undefined;
-    let models;
+    let perModel;
     if (perModelRaw) {
         const modelMap = {};
         for (const [modelName, value] of Object.entries(perModelRaw)) {
@@ -326,94 +528,49 @@ function normalizeNewBehaviorSections(raw) {
             modelMap[modelName] = normalized;
         }
         if (Object.keys(modelMap).length > 0) {
-            models = modelMap;
+            perModel = modelMap;
         }
     }
-    if (!global && !models) {
+    if (!global && !perModel) {
         return undefined;
     }
     return {
-        ...(global?.personality ? { options: { personality: global.personality } } : {}),
-        ...(global?.thinkingSummaries !== undefined ? { thinkingSummaries: global.thinkingSummaries } : {}),
-        ...(models ? { models } : {})
+        ...(global ? { global } : {}),
+        ...(perModel ? { perModel } : {})
     };
 }
-function mergeCustomSettings(primary, secondary) {
-    if (!primary && !secondary)
-        return undefined;
-    if (!primary)
-        return secondary;
-    if (!secondary)
-        return primary;
-    const modelKeys = new Set([...Object.keys(primary.models ?? {}), ...Object.keys(secondary.models ?? {})]);
-    let models;
-    if (modelKeys.size > 0) {
-        const merged = {};
-        for (const key of modelKeys) {
-            const a = primary.models?.[key];
-            const b = secondary.models?.[key];
-            const personality = b?.options?.personality !== undefined ? b.options.personality : a?.options?.personality;
-            const thinkingSummaries = b?.thinkingSummaries !== undefined ? b.thinkingSummaries : a?.thinkingSummaries;
-            const variantKeys = new Set([...Object.keys(a?.variants ?? {}), ...Object.keys(b?.variants ?? {})]);
-            let variants;
-            if (variantKeys.size > 0) {
-                const variantMap = {};
-                for (const variantKey of variantKeys) {
-                    const base = a?.variants?.[variantKey];
-                    const override = b?.variants?.[variantKey];
-                    const variantPersonality = override?.options?.personality !== undefined ? override.options.personality : base?.options?.personality;
-                    const variantThinkingSummaries = override?.thinkingSummaries !== undefined ? override.thinkingSummaries : base?.thinkingSummaries;
-                    if (variantPersonality === undefined && variantThinkingSummaries === undefined)
-                        continue;
-                    variantMap[variantKey] = {
-                        ...(variantPersonality ? { options: { personality: variantPersonality } } : {}),
-                        ...(variantThinkingSummaries !== undefined ? { thinkingSummaries: variantThinkingSummaries } : {})
-                    };
-                }
-                if (Object.keys(variantMap).length > 0) {
-                    variants = variantMap;
-                }
-            }
-            if (personality === undefined && thinkingSummaries === undefined && !variants)
-                continue;
-            merged[key] = {
-                ...(personality ? { options: { personality } } : {}),
-                ...(thinkingSummaries !== undefined ? { thinkingSummaries } : {}),
-                ...(variants ? { variants } : {})
-            };
-        }
-        if (Object.keys(merged).length > 0) {
-            models = merged;
-        }
-    }
-    const mergedPersonality = secondary.options?.personality !== undefined ? secondary.options.personality : primary.options?.personality;
-    return {
-        thinkingSummaries: secondary.thinkingSummaries !== undefined ? secondary.thinkingSummaries : primary.thinkingSummaries,
-        ...(mergedPersonality ? { options: { personality: mergedPersonality } } : {}),
-        ...(models ? { models } : {})
-    };
-}
-function cloneCustomSettings(input) {
+function cloneBehaviorSettings(input) {
     if (!input)
         return undefined;
     return {
-        thinkingSummaries: input.thinkingSummaries,
-        options: input.options ? { ...input.options } : undefined,
-        models: input.models
-            ? Object.fromEntries(Object.entries(input.models).map(([key, value]) => [
+        ...(input.global
+            ? {
+                global: {
+                    ...input.global
+                }
+            }
+            : {}),
+        perModel: input.perModel
+            ? Object.fromEntries(Object.entries(input.perModel).map(([key, value]) => [
                 key,
                 {
-                    ...(value.options ? { options: { ...value.options } } : {}),
+                    ...(value.personality !== undefined ? { personality: value.personality } : {}),
                     ...(value.thinkingSummaries !== undefined ? { thinkingSummaries: value.thinkingSummaries } : {}),
+                    ...(value.verbosityEnabled !== undefined ? { verbosityEnabled: value.verbosityEnabled } : {}),
+                    ...(value.verbosity !== undefined ? { verbosity: value.verbosity } : {}),
                     ...(value.variants
                         ? {
                             variants: Object.fromEntries(Object.entries(value.variants).map(([variantKey, variantValue]) => [
                                 variantKey,
                                 {
-                                    ...(variantValue.options ? { options: { ...variantValue.options } } : {}),
+                                    ...(variantValue.personality !== undefined ? { personality: variantValue.personality } : {}),
                                     ...(variantValue.thinkingSummaries !== undefined
                                         ? { thinkingSummaries: variantValue.thinkingSummaries }
-                                        : {})
+                                        : {}),
+                                    ...(variantValue.verbosityEnabled !== undefined
+                                        ? { verbosityEnabled: variantValue.verbosityEnabled }
+                                        : {}),
+                                    ...(variantValue.verbosity !== undefined ? { verbosity: variantValue.verbosity } : {})
                                 }
                             ]))
                         }
@@ -426,17 +583,15 @@ function cloneCustomSettings(input) {
 function parseConfigFileObject(raw) {
     if (!isRecord(raw))
         return {};
-    const explicitCustomSettings = normalizeCustomSettings(raw.customSettings);
-    const newCustomSettings = normalizeNewBehaviorSections(raw);
-    const customSettings = mergeCustomSettings(explicitCustomSettings, newCustomSettings);
-    const personalityFromTopLevel = normalizePersonalityOption(raw.personality);
-    const personalityFromCustom = customSettings?.options?.personality;
+    const behaviorSettings = normalizeNewBehaviorSections(raw);
+    const personalityFromBehavior = behaviorSettings?.global?.personality;
     const debug = typeof raw.debug === "boolean" ? raw.debug : undefined;
     const proactiveRefresh = isRecord(raw.refreshAhead) && typeof raw.refreshAhead.enabled === "boolean" ? raw.refreshAhead.enabled : undefined;
     const proactiveRefreshBufferMs = isRecord(raw.refreshAhead) && typeof raw.refreshAhead.bufferMs === "number" ? raw.refreshAhead.bufferMs : undefined;
     const quietMode = typeof raw.quiet === "boolean" ? raw.quiet : undefined;
     const mode = parseRuntimeMode(isRecord(raw.runtime) ? raw.runtime.mode : undefined);
     const rotationStrategy = parseRotationStrategy(isRecord(raw.runtime) ? raw.runtime.rotationStrategy : undefined);
+    const promptCacheKeyStrategy = parsePromptCacheKeyStrategy(isRecord(raw.runtime) ? raw.runtime.promptCacheKeyStrategy : undefined);
     const spoofMode = mode === "native" ? "native" : mode === "codex" ? "codex" : undefined;
     const compatInputSanitizer = isRecord(raw.runtime) && typeof raw.runtime.sanitizeInputs === "boolean" ? raw.runtime.sanitizeInputs : undefined;
     const remapDeveloperMessagesToUser = isRecord(raw.runtime) && typeof raw.runtime.developerMessagesToUser === "boolean"
@@ -446,26 +601,41 @@ function parseConfigFileObject(raw) {
         ? raw.runtime.codexCompactionOverride
         : undefined;
     const headerSnapshots = isRecord(raw.runtime) && typeof raw.runtime.headerSnapshots === "boolean" ? raw.runtime.headerSnapshots : undefined;
+    const headerSnapshotBodies = isRecord(raw.runtime) && typeof raw.runtime.headerSnapshotBodies === "boolean"
+        ? raw.runtime.headerSnapshotBodies
+        : undefined;
     const headerTransformDebug = isRecord(raw.runtime) && typeof raw.runtime.headerTransformDebug === "boolean"
         ? raw.runtime.headerTransformDebug
         : undefined;
     const pidOffsetEnabled = isRecord(raw.runtime) && typeof raw.runtime.pidOffset === "boolean" ? raw.runtime.pidOffset : undefined;
+    const collaborationProfileEnabled = isRecord(raw.runtime) && typeof raw.runtime.collaborationProfile === "boolean"
+        ? raw.runtime.collaborationProfile
+        : undefined;
+    const orchestratorSubagentsEnabled = isRecord(raw.runtime) && typeof raw.runtime.orchestratorSubagents === "boolean"
+        ? raw.runtime.orchestratorSubagents
+        : undefined;
+    const collaborationToolProfile = parseCollaborationToolProfile(isRecord(raw.runtime) ? raw.runtime.collaborationToolProfile : undefined);
     return {
         debug,
         proactiveRefresh,
         proactiveRefreshBufferMs,
         quietMode,
         pidOffsetEnabled,
-        personality: personalityFromTopLevel ?? personalityFromCustom,
+        personality: personalityFromBehavior,
         mode,
         rotationStrategy,
+        promptCacheKeyStrategy,
         spoofMode,
         compatInputSanitizer,
         remapDeveloperMessagesToUser,
         codexCompactionOverride,
         headerSnapshots,
+        headerSnapshotBodies,
         headerTransformDebug,
-        customSettings
+        collaborationProfileEnabled,
+        orchestratorSubagentsEnabled,
+        collaborationToolProfile,
+        behaviorSettings
     };
 }
 export function resolveDefaultConfigPath(env) {
@@ -499,9 +669,16 @@ export function loadConfigFile(input = {}) {
         try {
             const raw = fs.readFileSync(filePath, "utf8");
             const parsed = parseConfigJsonWithComments(raw);
+            const validation = validateConfigFileObject(parsed);
+            if (!validation.valid) {
+                console.warn(`[opencode-codex-auth] Invalid codex-config at ${filePath}; ignoring file. ${validation.issues.join("; ")}`);
+                return {};
+            }
             return parseConfigFileObject(parsed);
         }
-        catch {
+        catch (error) {
+            const detail = error instanceof Error ? error.message : String(error);
+            console.warn(`[opencode-codex-auth] Failed to read codex-config at ${filePath}; ignoring file. ${detail}`);
             return {};
         }
     }
@@ -510,15 +687,18 @@ export function loadConfigFile(input = {}) {
 export function resolveConfig(input) {
     const env = input.env;
     const file = input.file ?? {};
-    const fileCustom = normalizeCustomSettings(file.customSettings);
+    const fileBehavior = cloneBehaviorSettings(file.behaviorSettings);
     const envDebug = env.OPENCODE_OPENAI_MULTI_DEBUG === "1" || env.DEBUG_CODEX_PLUGIN === "1";
     const proactiveRefresh = parseEnvBoolean(env.OPENCODE_OPENAI_MULTI_PROACTIVE_REFRESH) ?? file.proactiveRefresh;
     const proactiveRefreshBufferMs = parseEnvNumber(env.OPENCODE_OPENAI_MULTI_PROACTIVE_REFRESH_BUFFER_MS) ?? file.proactiveRefreshBufferMs;
     const quietMode = parseEnvBoolean(env.OPENCODE_OPENAI_MULTI_QUIET) ?? file.quietMode;
     const pidOffsetEnabled = parseEnvBoolean(env.OPENCODE_OPENAI_MULTI_PID_OFFSET) ?? file.pidOffsetEnabled;
     const rotationStrategy = parseRotationStrategy(env.OPENCODE_OPENAI_MULTI_ROTATION_STRATEGY) ?? file.rotationStrategy;
+    const promptCacheKeyStrategy = parsePromptCacheKeyStrategy(env.OPENCODE_OPENAI_MULTI_PROMPT_CACHE_KEY_STRATEGY) ?? file.promptCacheKeyStrategy;
     const envPersonality = normalizePersonalityOption(env.OPENCODE_OPENAI_MULTI_PERSONALITY);
     const envThinkingSummaries = parseEnvBoolean(env.OPENCODE_OPENAI_MULTI_THINKING_SUMMARIES);
+    const envVerbosityEnabled = parseEnvBoolean(env.OPENCODE_OPENAI_MULTI_VERBOSITY_ENABLED);
+    const envVerbosity = normalizeVerbosityOption(env.OPENCODE_OPENAI_MULTI_VERBOSITY);
     const spoofModeFromEnv = parseSpoofMode(env.OPENCODE_OPENAI_MULTI_SPOOF_MODE);
     const modeFromEnv = parseRuntimeMode(env.OPENCODE_OPENAI_MULTI_MODE);
     const modeFromSpoofEnv = modeFromEnv === undefined && spoofModeFromEnv !== undefined
@@ -530,36 +710,30 @@ export function resolveConfig(input) {
         modeFromSpoofEnv ??
         file.mode ??
         (spoofModeFromEnv === "codex" || file.spoofMode === "codex" ? "codex" : "native");
-    const customSettings = cloneCustomSettings(fileCustom);
+    const behaviorSettings = cloneBehaviorSettings(fileBehavior) ?? {};
+    const globalBehavior = {
+        ...(behaviorSettings.global ?? {})
+    };
     if (envPersonality) {
-        if (!customSettings) {
-            // Keep behavior deterministic by ensuring one source of truth for runtime resolution.
-            input.file = { ...file, customSettings: { options: { personality: envPersonality } } };
-        }
-        else {
-            customSettings.options = { ...(customSettings.options ?? {}), personality: envPersonality };
-        }
+        globalBehavior.personality = envPersonality;
     }
     if (envThinkingSummaries !== undefined) {
-        if (!customSettings) {
-            input.file = {
-                ...file,
-                customSettings: { ...(input.file?.customSettings ?? {}), thinkingSummaries: envThinkingSummaries }
-            };
-        }
-        else {
-            customSettings.thinkingSummaries = envThinkingSummaries;
-        }
+        globalBehavior.thinkingSummaries = envThinkingSummaries;
     }
-    const resolvedCustomSettings = customSettings ??
-        cloneCustomSettings(normalizeCustomSettings(input.file?.customSettings)) ??
-        (envPersonality || envThinkingSummaries !== undefined
-            ? {
-                ...(envPersonality ? { options: { personality: envPersonality } } : {}),
-                ...(envThinkingSummaries !== undefined ? { thinkingSummaries: envThinkingSummaries } : {})
-            }
-            : undefined);
-    const personality = envPersonality ?? file.personality ?? resolvedCustomSettings?.options?.personality;
+    if (envVerbosityEnabled !== undefined) {
+        globalBehavior.verbosityEnabled = envVerbosityEnabled;
+    }
+    if (envVerbosity) {
+        globalBehavior.verbosity = envVerbosity;
+    }
+    if (globalBehavior.personality !== undefined ||
+        globalBehavior.thinkingSummaries !== undefined ||
+        globalBehavior.verbosityEnabled !== undefined ||
+        globalBehavior.verbosity !== undefined) {
+        behaviorSettings.global = globalBehavior;
+    }
+    const resolvedBehaviorSettings = behaviorSettings.global !== undefined || behaviorSettings.perModel !== undefined ? behaviorSettings : undefined;
+    const personality = envPersonality ?? resolvedBehaviorSettings?.global?.personality;
     // Runtime mode is canonical; spoofMode remains a compatibility input only.
     // If runtime mode is explicitly set via env, ignore spoof env for consistency.
     const spoofMode = modeFromEnv !== undefined
@@ -571,7 +745,11 @@ export function resolveConfig(input) {
     const remapDeveloperMessagesToUser = parseEnvBoolean(env.OPENCODE_OPENAI_MULTI_REMAP_DEVELOPER_MESSAGES_TO_USER) ?? file.remapDeveloperMessagesToUser;
     const codexCompactionOverride = parseEnvBoolean(env.OPENCODE_OPENAI_MULTI_CODEX_COMPACTION_OVERRIDE) ?? file.codexCompactionOverride;
     const headerSnapshots = parseEnvBoolean(env.OPENCODE_OPENAI_MULTI_HEADER_SNAPSHOTS) ?? file.headerSnapshots;
+    const headerSnapshotBodies = parseEnvBoolean(env.OPENCODE_OPENAI_MULTI_HEADER_SNAPSHOT_BODIES) ?? file.headerSnapshotBodies;
     const headerTransformDebug = parseEnvBoolean(env.OPENCODE_OPENAI_MULTI_HEADER_TRANSFORM_DEBUG) ?? file.headerTransformDebug;
+    const collaborationProfileEnabled = parseEnvBoolean(env.OPENCODE_OPENAI_MULTI_COLLABORATION_PROFILE) ?? file.collaborationProfileEnabled;
+    const orchestratorSubagentsEnabled = parseEnvBoolean(env.OPENCODE_OPENAI_MULTI_ORCHESTRATOR_SUBAGENTS) ?? file.orchestratorSubagentsEnabled;
+    const collaborationToolProfile = parseCollaborationToolProfile(env.OPENCODE_OPENAI_MULTI_COLLABORATION_TOOL_PROFILE) ?? file.collaborationToolProfile;
     return {
         ...file,
         debug: envDebug || file.debug === true,
@@ -582,13 +760,18 @@ export function resolveConfig(input) {
         personality,
         mode,
         rotationStrategy,
+        promptCacheKeyStrategy,
         spoofMode,
         compatInputSanitizer,
         remapDeveloperMessagesToUser,
         codexCompactionOverride,
         headerSnapshots,
+        headerSnapshotBodies,
         headerTransformDebug,
-        customSettings: resolvedCustomSettings
+        collaborationProfileEnabled,
+        orchestratorSubagentsEnabled,
+        collaborationToolProfile,
+        behaviorSettings: resolvedBehaviorSettings
     };
 }
 export function getDebugEnabled(cfg) {
@@ -622,6 +805,9 @@ export function getMode(cfg) {
 export function getRotationStrategy(cfg) {
     return cfg.rotationStrategy === "hybrid" || cfg.rotationStrategy === "round_robin" ? cfg.rotationStrategy : "sticky";
 }
+export function getPromptCacheKeyStrategy(cfg) {
+    return cfg.promptCacheKeyStrategy === "project" ? "project" : "default";
+}
 export function getCompatInputSanitizerEnabled(cfg) {
     return cfg.compatInputSanitizer === true;
 }
@@ -643,10 +829,30 @@ export function getHeaderSnapshotsEnabled(cfg) {
 export function getHeaderTransformDebugEnabled(cfg) {
     return cfg.headerTransformDebug === true;
 }
-export function getCustomSettings(cfg) {
-    return cfg.customSettings;
+export function getHeaderSnapshotBodiesEnabled(cfg) {
+    return cfg.headerSnapshotBodies === true;
+}
+export function getCollaborationProfileEnabled(cfg) {
+    if (cfg.collaborationProfileEnabled === true)
+        return true;
+    if (cfg.collaborationProfileEnabled === false)
+        return false;
+    return getMode(cfg) === "codex";
+}
+export function getOrchestratorSubagentsEnabled(cfg) {
+    if (cfg.orchestratorSubagentsEnabled === true)
+        return true;
+    if (cfg.orchestratorSubagentsEnabled === false)
+        return false;
+    return getCollaborationProfileEnabled(cfg);
+}
+export function getCollaborationToolProfile(cfg) {
+    return cfg.collaborationToolProfile === "codex" ? "codex" : "opencode";
+}
+export function getBehaviorSettings(cfg) {
+    return cfg.behaviorSettings;
 }
 export function getThinkingSummariesOverride(cfg) {
-    return cfg.customSettings?.thinkingSummaries;
+    return cfg.behaviorSettings?.global?.thinkingSummaries;
 }
 //# sourceMappingURL=config.js.map