salmon-loop 0.3.2 → 0.4.1

package/dist/core/config/validate.js

@@ -1,925 +1,14 @@
-import { LLM_OUTPUT_KINDS } from '../types/index.js';
-import { ConfigError } from './errors.js';
-import { normalizePermissionMode, normalizeUiLogMode, normalizeUiLogView } from './normalize.js';
-import { MARKDOWN_RENDER_MODES, MARKDOWN_THEMES, } from './types.js';
-function isRecord(value) {
-    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
-}
-function isString(value) {
-    return typeof value === 'string';
-}
-function isNumber(value) {
-    return typeof value === 'number' && Number.isFinite(value);
-}
-function isBoolean(value) {
-    return typeof value === 'boolean';
-}
-function isNull(value) {
-    return value === null;
-}
-function isValidLlmOutputKind(value) {
-    return typeof value === 'string' && LLM_OUTPUT_KINDS.includes(value);
-}
-function isValidMarkdownTheme(value) {
-    return typeof value === 'string' && MARKDOWN_THEMES.includes(value);
-}
-function isValidMarkdownRenderMode(value) {
-    return typeof value === 'string' && MARKDOWN_RENDER_MODES.includes(value);
-}
-function validateLlmCapabilities(input, context) {
-    if (input === undefined)
-        return undefined;
-    if (!isRecord(input)) {
-        throw new ConfigError('CONFIG_INVALID_LLM_CAPABILITIES', {
-            ...context,
-            expected: 'object',
-        });
-    }
-    const allowedKeys = new Set(['toolCalling', 'responseFormatJsonObject', 'streaming']);
-    for (const key of Object.keys(input)) {
-        if (!allowedKeys.has(key)) {
-            throw new ConfigError('CONFIG_INVALID_LLM_CAPABILITY', {
-                ...context,
-                capability: key,
-                expected: 'toolCalling|responseFormatJsonObject|streaming',
-            });
-        }
-    }
-    const cfg = {};
-    for (const key of ['toolCalling', 'responseFormatJsonObject', 'streaming']) {
-        if (input[key] !== undefined && !isBoolean(input[key])) {
-            throw new ConfigError('CONFIG_INVALID_LLM_CAPABILITY', {
-                ...context,
-                capability: key,
-                expected: 'boolean',
-            });
-        }
-        if (input[key] !== undefined) {
-            cfg[key] = input[key];
-        }
-    }
-    return cfg;
-}
-function normalizeLlmModelParams(input, context) {
-    if (!isRecord(input))
-        return undefined;
-    for (const key of [
-        'capabilities',
-        'toolCalling',
-        'responseFormatJsonObject',
-        'streaming',
-    ]) {
-        if (input[key] !== undefined) {
-            throw new ConfigError('CONFIG_INVALID_LLM_CAPABILITY_LOCATION', {
-                ...context,
-                capability: key,
-                expected: 'model.capabilities',
-            });
-        }
-    }
-    return input;
-}
+import { configFileV1Schema, zodIssueToConfigError } from './schema.js';
+/**
+ * Validate and normalize a raw config file object against the ConfigFileV1 schema.
+ *
+ * Uses Zod for declarative validation with full error code mapping.
+ * First-error-wins semantics: only the first validation issue is reported.
+ */
 export function validateConfigFileV1(input) {
-    if (!isRecord(input)) {
-        throw new ConfigError('CONFIG_INVALID_ROOT', { expected: 'object' });
-    }
-    const version = input.version;
-    if (version !== undefined && version !== 1) {
-        throw new ConfigError('CONFIG_UNSUPPORTED', { version: String(version) });
-    }
-    const cfg = { version: 1 };
-    if (input.mode !== undefined) {
-        if (!isString(input.mode)) {
-            throw new ConfigError('CONFIG_INVALID_MODE', { expected: 'interactive|yolo' });
-        }
-        const normalized = normalizePermissionMode(input.mode);
-        if (!normalized) {
-            throw new ConfigError('CONFIG_INVALID_MODE', { mode: String(input.mode) });
-        }
-        cfg.mode = normalized;
-    }
-    if (input.observability !== undefined) {
-        if (!isRecord(input.observability)) {
-            throw new ConfigError('CONFIG_INVALID_OBSERVABILITY', { expected: 'object' });
-        }
-        const obs = input.observability;
-        cfg.observability = {};
-        if (obs.langfuse !== undefined) {
-            if (!isRecord(obs.langfuse)) {
-                throw new ConfigError('CONFIG_INVALID_OBSERVABILITY_LANGFUSE', { expected: 'object' });
-            }
-            const lf = obs.langfuse;
-            const out = {};
-            if (lf.enabled !== undefined && !isBoolean(lf.enabled)) {
-                throw new ConfigError('CONFIG_INVALID_LANGFUSE_ENABLED', { expected: 'boolean' });
-            }
-            if (lf.outcome !== undefined && !isBoolean(lf.outcome)) {
-                throw new ConfigError('CONFIG_INVALID_LANGFUSE_OUTCOME', { expected: 'boolean' });
-            }
-            if (lf.endpoint !== undefined && !isString(lf.endpoint)) {
-                throw new ConfigError('CONFIG_INVALID_LANGFUSE_ENDPOINT', { expected: 'string' });
-            }
-            if (lf.apiKey !== undefined && !(isString(lf.apiKey) || isNull(lf.apiKey))) {
-                throw new ConfigError('CONFIG_INVALID_LANGFUSE_API_KEY', {
-                    expected: 'string|null',
-                });
-            }
-            if (lf.sessionId !== undefined && !isString(lf.sessionId)) {
-                throw new ConfigError('CONFIG_INVALID_LANGFUSE_SESSION_ID', { expected: 'string' });
-            }
-            if (lf.userId !== undefined && !isString(lf.userId)) {
-                throw new ConfigError('CONFIG_INVALID_LANGFUSE_USER_ID', { expected: 'string' });
-            }
-            out.enabled = lf.enabled;
-            out.outcome = lf.outcome;
-            out.endpoint = lf.endpoint;
-            out.apiKey = lf.apiKey;
-            out.sessionId = lf.sessionId;
-            out.userId = lf.userId;
-            cfg.observability.langfuse = out;
-        }
-        if (obs.audit !== undefined) {
-            const auditRaw = obs.audit;
-            if (!isRecord(auditRaw)) {
-                throw new ConfigError('CONFIG_INVALID_OBSERVABILITY_AUDIT', { expected: 'object' });
-            }
-            const scopeRaw = auditRaw.scope;
-            const bufferRaw = auditRaw.buffer;
-            const auditOut = {};
-            if (scopeRaw !== undefined) {
-                if (!isString(scopeRaw) || (scopeRaw !== 'repo' && scopeRaw !== 'user')) {
-                    throw new ConfigError('CONFIG_INVALID_OBSERVABILITY_AUDIT_SCOPE', {
-                        expected: 'repo|user',
-                    });
-                }
-                auditOut.scope = scopeRaw;
-            }
-            if (bufferRaw !== undefined) {
-                if (!isRecord(bufferRaw)) {
-                    throw new ConfigError('CONFIG_INVALID_OBSERVABILITY_AUDIT_BUFFER', {
-                        expected: 'object',
-                    });
-                }
-                if (bufferRaw.maxEvents !== undefined && !isNumber(bufferRaw.maxEvents)) {
-                    throw new ConfigError('CONFIG_INVALID_OBSERVABILITY_AUDIT_MAX_EVENTS', {
-                        expected: 'number',
-                    });
-                }
-                if (bufferRaw.maxBytes !== undefined && !isNumber(bufferRaw.maxBytes)) {
-                    throw new ConfigError('CONFIG_INVALID_OBSERVABILITY_AUDIT_MAX_BYTES', {
-                        expected: 'number',
-                    });
-                }
-                if (bufferRaw.droppedWarn !== undefined && !isNumber(bufferRaw.droppedWarn)) {
-                    throw new ConfigError('CONFIG_INVALID_OBSERVABILITY_AUDIT_DROPPED_WARN', {
-                        expected: 'number',
-                    });
-                }
-                auditOut.buffer = {
-                    maxEvents: bufferRaw.maxEvents,
-                    maxBytes: bufferRaw.maxBytes,
-                    droppedWarn: bufferRaw.droppedWarn,
-                };
-            }
-            if (auditOut.scope || auditOut.buffer) {
-                cfg.observability.audit = auditOut;
-            }
-        }
-    }
-    if (input.cli !== undefined) {
-        if (!isRecord(input.cli)) {
-            throw new ConfigError('CONFIG_INVALID_CLI', { expected: 'object' });
-        }
-        if (input.cli.defaults !== undefined) {
-            if (!isRecord(input.cli.defaults)) {
-                throw new ConfigError('CONFIG_INVALID_CLI_DEFAULTS', { expected: 'object' });
-            }
-            cfg.cli = { defaults: {} };
-            const d = input.cli.defaults;
-            if (d.verbosity !== undefined && !isString(d.verbosity)) {
-                throw new ConfigError('CONFIG_INVALID_VERBOSITY', { expected: 'string' });
-            }
-            if (d.strategy !== undefined && !isString(d.strategy)) {
-                throw new ConfigError('CONFIG_INVALID_STRATEGY', { expected: 'string' });
-            }
-            if (d.dryRun !== undefined && !isBoolean(d.dryRun)) {
-                throw new ConfigError('CONFIG_INVALID_DRY_RUN', { expected: 'boolean' });
-            }
-            cfg.cli.defaults = {
-                verbosity: d.verbosity,
-                strategy: d.strategy,
-                dryRun: d.dryRun,
-            };
-        }
-    }
-    if (input.server !== undefined) {
-        const serverRaw = input.server;
-        if (!isRecord(serverRaw)) {
-            throw new ConfigError('CONFIG_INVALID_SERVER', { expected: 'object' });
-        }
-        for (const key of Object.keys(serverRaw)) {
-            if (key !== 'a2a' && key !== 'acp') {
-                throw new ConfigError('CONFIG_INVALID_SERVER_UNKNOWN_KEY', { key });
-            }
-        }
-        const server = {};
-        if (serverRaw.a2a !== undefined) {
-            if (!isRecord(serverRaw.a2a)) {
-                throw new ConfigError('CONFIG_INVALID_SERVER_A2A', { expected: 'object' });
-            }
-            const a2aRaw = serverRaw.a2a;
-            if (a2aRaw.host !== undefined && !isString(a2aRaw.host)) {
-                throw new ConfigError('CONFIG_INVALID_SERVER_A2A_HOST', { expected: 'string' });
-            }
-            if (a2aRaw.port !== undefined && !isNumber(a2aRaw.port)) {
-                throw new ConfigError('CONFIG_INVALID_SERVER_A2A_PORT', { expected: 'number' });
-            }
-            if (a2aRaw.tokens !== undefined) {
-                if (!Array.isArray(a2aRaw.tokens) || !a2aRaw.tokens.every(isString)) {
-                    throw new ConfigError('CONFIG_INVALID_SERVER_A2A_TOKENS', { expected: 'string[]' });
-                }
-            }
-            server.a2a = {
-                host: a2aRaw.host,
-                port: a2aRaw.port,
-                tokens: a2aRaw.tokens,
-            };
-        }
-        if (serverRaw.acp !== undefined) {
-            if (!isRecord(serverRaw.acp)) {
-                throw new ConfigError('CONFIG_INVALID_SERVER_ACP', { expected: 'object' });
-            }
-            const acpRaw = serverRaw.acp;
-            const acp = {};
-            if (acpRaw.sessionStore !== undefined) {
-                if (!isRecord(acpRaw.sessionStore)) {
-                    throw new ConfigError('CONFIG_INVALID_SERVER_ACP_SESSION_STORE', { expected: 'object' });
-                }
-                const sessionStoreRaw = acpRaw.sessionStore;
-                const validateOptionalNumber = (value, code) => {
-                    if (value !== undefined && !isNumber(value)) {
-                        throw new ConfigError(code, { expected: 'number' });
-                    }
-                };
-                validateOptionalNumber(sessionStoreRaw.maxEntries, 'CONFIG_INVALID_SERVER_ACP_SESSION_STORE_MAX_ENTRIES');
-                validateOptionalNumber(sessionStoreRaw.maxAgeMs, 'CONFIG_INVALID_SERVER_ACP_SESSION_STORE_MAX_AGE_MS');
-                validateOptionalNumber(sessionStoreRaw.historyMaxEntries, 'CONFIG_INVALID_SERVER_ACP_SESSION_STORE_HISTORY_MAX_ENTRIES');
-                validateOptionalNumber(sessionStoreRaw.lockStaleMs, 'CONFIG_INVALID_SERVER_ACP_SESSION_STORE_LOCK_STALE_MS');
-                validateOptionalNumber(sessionStoreRaw.lockHeartbeatMs, 'CONFIG_INVALID_SERVER_ACP_SESSION_STORE_LOCK_HEARTBEAT_MS');
-                acp.sessionStore = {
-                    maxEntries: sessionStoreRaw.maxEntries,
-                    maxAgeMs: sessionStoreRaw.maxAgeMs,
-                    historyMaxEntries: sessionStoreRaw.historyMaxEntries,
-                    lockStaleMs: sessionStoreRaw.lockStaleMs,
-                    lockHeartbeatMs: sessionStoreRaw.lockHeartbeatMs,
-                };
-            }
-            if (acpRaw.checkpointManifest !== undefined) {
-                if (!isRecord(acpRaw.checkpointManifest)) {
-                    throw new ConfigError('CONFIG_INVALID_SERVER_ACP_CHECKPOINT_MANIFEST', {
-                        expected: 'object',
-                    });
-                }
-                const manifestRaw = acpRaw.checkpointManifest;
-                const validateOptionalNumber = (value, code) => {
-                    if (value !== undefined && !isNumber(value)) {
-                        throw new ConfigError(code, { expected: 'number' });
-                    }
-                };
-                validateOptionalNumber(manifestRaw.lockStaleMs, 'CONFIG_INVALID_SERVER_ACP_CHECKPOINT_MANIFEST_LOCK_STALE_MS');
-                validateOptionalNumber(manifestRaw.lockHeartbeatMs, 'CONFIG_INVALID_SERVER_ACP_CHECKPOINT_MANIFEST_LOCK_HEARTBEAT_MS');
-                acp.checkpointManifest = {
-                    lockStaleMs: manifestRaw.lockStaleMs,
-                    lockHeartbeatMs: manifestRaw.lockHeartbeatMs,
-                };
-            }
-            server.acp = acp;
-        }
-        cfg.server = server;
-    }
-    if (input.ui !== undefined) {
-        const uiRaw = input.ui;
-        if (!isRecord(uiRaw)) {
-            throw new ConfigError('CONFIG_INVALID_UI', { expected: 'object' });
-        }
-        const ui = {};
-        const logRaw = uiRaw.log;
-        if (logRaw !== undefined) {
-            if (!isRecord(logRaw)) {
-                throw new ConfigError('CONFIG_INVALID_UI_LOG', { expected: 'object' });
-            }
-            const viewRaw = logRaw.view;
-            const modeRaw = logRaw.mode;
-            if (viewRaw !== undefined) {
-                if (!isString(viewRaw)) {
-                    throw new ConfigError('CONFIG_INVALID_UI_LOG_VIEW', { expected: 'string' });
-                }
-                const normalized = normalizeUiLogView(viewRaw);
-                if (!normalized) {
-                    throw new ConfigError('CONFIG_INVALID_UI_LOG_VIEW', { view: String(viewRaw) });
-                }
-                ui.log = { ...(ui.log ?? {}), view: normalized };
-            }
-            else {
-                ui.log = {};
-            }
-            if (modeRaw !== undefined) {
-                if (!isString(modeRaw)) {
-                    throw new ConfigError('CONFIG_INVALID_UI_LOG_MODE', { expected: 'string' });
-                }
-                const normalized = normalizeUiLogMode(modeRaw);
-                if (!normalized) {
-                    throw new ConfigError('CONFIG_INVALID_UI_LOG_MODE', { mode: String(modeRaw) });
-                }
-                ui.log = { ...(ui.log ?? {}), mode: normalized };
-            }
-        }
-        cfg.ui = ui;
-    }
-    if (input.context !== undefined) {
-        const contextRaw = input.context;
-        if (!isRecord(contextRaw)) {
-            throw new ConfigError('CONFIG_INVALID_CONTEXT', { expected: 'object' });
-        }
-        cfg.context = {};
-        if (contextRaw.useTokenBudget !== undefined && !isBoolean(contextRaw.useTokenBudget)) {
-            throw new ConfigError('CONFIG_INVALID_USE_TOKEN_BUDGET', { expected: 'boolean' });
-        }
-        if (contextRaw.useTokenBudget !== undefined) {
-            cfg.context.useTokenBudget = contextRaw.useTokenBudget;
-        }
-        if (contextRaw.cache !== undefined) {
-            if (!isRecord(contextRaw.cache)) {
-                throw new ConfigError('CONFIG_INVALID_CONTEXT_CACHE', { expected: 'object' });
-            }
-            const cacheRaw = contextRaw.cache;
-            const cache = {};
-            if (cacheRaw.mode !== undefined &&
-                cacheRaw.mode !== 'memory' &&
-                cacheRaw.mode !== 'persistent') {
-                throw new ConfigError('CONFIG_INVALID_CONTEXT_CACHE_MODE', { mode: String(cacheRaw.mode) });
-            }
-            if (cacheRaw.path !== undefined && !isString(cacheRaw.path)) {
-                throw new ConfigError('CONFIG_INVALID_CONTEXT_CACHE_PATH', { expected: 'string' });
-            }
-            if (cacheRaw.allowedRoots !== undefined &&
-                (!Array.isArray(cacheRaw.allowedRoots) || cacheRaw.allowedRoots.some((v) => !isString(v)))) {
-                throw new ConfigError('CONFIG_INVALID_CONTEXT_CACHE_ALLOWED_ROOTS', {
-                    expected: 'string[]',
-                });
-            }
-            if (cacheRaw.maxEntries !== undefined && !isNumber(cacheRaw.maxEntries)) {
-                throw new ConfigError('CONFIG_INVALID_CONTEXT_CACHE_MAX_ENTRIES', { expected: 'number' });
-            }
-            if (cacheRaw.ttlMs !== undefined && !isNumber(cacheRaw.ttlMs)) {
-                throw new ConfigError('CONFIG_INVALID_CONTEXT_CACHE_TTL', { expected: 'number' });
-            }
-            if (cacheRaw.maxPayloadBytes !== undefined && !isNumber(cacheRaw.maxPayloadBytes)) {
-                throw new ConfigError('CONFIG_INVALID_CONTEXT_CACHE_MAX_PAYLOAD', { expected: 'number' });
-            }
-            if (cacheRaw.mode === 'persistent') {
-                if (!isString(cacheRaw.path) || cacheRaw.path.length === 0) {
-                    throw new ConfigError('CONFIG_INVALID_CONTEXT_CACHE_PATH', {
-                        expected: 'non-empty string',
-                    });
-                }
-                if (!Array.isArray(cacheRaw.allowedRoots) ||
-                    cacheRaw.allowedRoots.length === 0 ||
-                    cacheRaw.allowedRoots.some((v) => !isString(v) || v.length === 0)) {
-                    throw new ConfigError('CONFIG_INVALID_CONTEXT_CACHE_ALLOWED_ROOTS', {
-                        expected: 'non-empty string[]',
-                    });
-                }
-            }
-            cache.mode = cacheRaw.mode;
-            cache.path = cacheRaw.path;
-            cache.allowedRoots = cacheRaw.allowedRoots;
-            cache.maxEntries = cacheRaw.maxEntries;
-            cache.ttlMs = cacheRaw.ttlMs;
-            cache.maxPayloadBytes = cacheRaw.maxPayloadBytes;
-            cfg.context.cache = cache;
-        }
-        if (contextRaw.churn !== undefined) {
-            if (!isRecord(contextRaw.churn)) {
-                throw new ConfigError('CONFIG_INVALID_CHURN', { expected: 'object' });
-            }
-            const churnRaw = contextRaw.churn;
-            const churn = {};
-            if (churnRaw.weight !== undefined) {
-                if (!isRecord(churnRaw.weight)) {
-                    throw new ConfigError('CONFIG_INVALID_CHURN_WEIGHT', { expected: 'object' });
-                }
-                const weightRaw = churnRaw.weight;
-                if (weightRaw.primary !== undefined && !isNumber(weightRaw.primary)) {
-                    throw new ConfigError('CONFIG_INVALID_CHURN_WEIGHT_PRIMARY', { expected: 'number' });
-                }
-                if (weightRaw.rerank !== undefined && !isNumber(weightRaw.rerank)) {
-                    throw new ConfigError('CONFIG_INVALID_CHURN_WEIGHT_RERANK', { expected: 'number' });
-                }
-                if (weightRaw.tiebreak !== undefined && !isNumber(weightRaw.tiebreak)) {
-                    throw new ConfigError('CONFIG_INVALID_CHURN_WEIGHT_TIEBREAK', { expected: 'number' });
-                }
-                churn.weight = {
-                    primary: weightRaw.primary,
-                    rerank: weightRaw.rerank,
-                    tiebreak: weightRaw.tiebreak,
-                };
-            }
-            cfg.context.churn = churn;
-        }
-        if (contextRaw.dynamicBudget !== undefined) {
-            if (!isRecord(contextRaw.dynamicBudget)) {
-                throw new ConfigError('CONFIG_INVALID_DYNAMIC_BUDGET', { expected: 'object' });
-            }
-            const dynamicBudgetRaw = contextRaw.dynamicBudget;
-            const dynamicBudget = {};
-            if (dynamicBudgetRaw.enabled !== undefined && !isBoolean(dynamicBudgetRaw.enabled)) {
-                throw new ConfigError('CONFIG_INVALID_DYNAMIC_BUDGET_ENABLED', { expected: 'boolean' });
-            }
-            if (dynamicBudgetRaw.minBudget !== undefined && !isNumber(dynamicBudgetRaw.minBudget)) {
-                throw new ConfigError('CONFIG_INVALID_DYNAMIC_BUDGET_MIN', { expected: 'number' });
-            }
-            if (dynamicBudgetRaw.maxBudget !== undefined && !isNumber(dynamicBudgetRaw.maxBudget)) {
-                throw new ConfigError('CONFIG_INVALID_DYNAMIC_BUDGET_MAX', { expected: 'number' });
-            }
-            if (dynamicBudgetRaw.adjustmentStep !== undefined &&
-                !isNumber(dynamicBudgetRaw.adjustmentStep)) {
-                throw new ConfigError('CONFIG_INVALID_DYNAMIC_BUDGET_STEP', { expected: 'number' });
-            }
-            dynamicBudget.enabled = dynamicBudgetRaw.enabled;
-            dynamicBudget.minBudget = dynamicBudgetRaw.minBudget;
-            dynamicBudget.maxBudget = dynamicBudgetRaw.maxBudget;
-            dynamicBudget.adjustmentStep = dynamicBudgetRaw.adjustmentStep;
-            if (dynamicBudgetRaw.alerts !== undefined) {
-                if (!isRecord(dynamicBudgetRaw.alerts)) {
-                    throw new ConfigError('CONFIG_INVALID_DYNAMIC_BUDGET_ALERTS', { expected: 'object' });
-                }
-                const alertsRaw = dynamicBudgetRaw.alerts;
-                if (alertsRaw.truncationRateWarn !== undefined && !isNumber(alertsRaw.truncationRateWarn)) {
-                    throw new ConfigError('CONFIG_INVALID_DYNAMIC_BUDGET_ALERT_TRUNCATION', {
-                        expected: 'number',
-                    });
-                }
-                if (alertsRaw.criticalDropRateWarn !== undefined &&
-                    !isNumber(alertsRaw.criticalDropRateWarn)) {
-                    throw new ConfigError('CONFIG_INVALID_DYNAMIC_BUDGET_ALERT_CRITICAL_DROP', {
-                        expected: 'number',
-                    });
-                }
-                dynamicBudget.alerts = {
-                    truncationRateWarn: alertsRaw.truncationRateWarn,
-                    criticalDropRateWarn: alertsRaw.criticalDropRateWarn,
-                };
-            }
-            cfg.context.dynamicBudget = dynamicBudget;
-        }
-    }
-    if (input.verify !== undefined) {
-        if (!isRecord(input.verify)) {
-            throw new ConfigError('CONFIG_INVALID_VERIFY', { expected: 'object' });
-        }
-        if (input.verify.command !== undefined && !isString(input.verify.command)) {
-            throw new ConfigError('CONFIG_INVALID_VERIFY_COMMAND', { expected: 'string' });
-        }
-        if (input.verify.timeoutMs !== undefined && !isNumber(input.verify.timeoutMs)) {
-            throw new ConfigError('CONFIG_INVALID_VERIFY_TIMEOUT', { expected: 'number' });
-        }
-        cfg.verify = { command: input.verify.command, timeoutMs: input.verify.timeoutMs };
-    }
-    if (input.astValidation !== undefined) {
-        const astValidationRaw = input.astValidation;
-        if (!isRecord(astValidationRaw)) {
-            throw new ConfigError('CONFIG_INVALID_AST_VALIDATION', { expected: 'object' });
-        }
-        const strictnessRaw = astValidationRaw.strictness;
-        if (strictnessRaw !== undefined && strictnessRaw !== 'lenient' && strictnessRaw !== 'strict') {
-            throw new ConfigError('CONFIG_INVALID_AST_VALIDATION_STRICTNESS', {
-                strictness: String(strictnessRaw),
-            });
-        }
-        cfg.astValidation = {
-            strictness: strictnessRaw,
-        };
-    }
-    if (input.llm !== undefined) {
-        if (!isRecord(input.llm)) {
-            throw new ConfigError('CONFIG_INVALID_LLM', { expected: 'object' });
-        }
-        cfg.llm = {};
-        if (input.llm.activeModel !== undefined && !isString(input.llm.activeModel)) {
-            throw new ConfigError('CONFIG_INVALID_LLM_ACTIVE_MODEL', { expected: 'string' });
-        }
-        if (input.llm.activeModel !== undefined)
-            cfg.llm.activeModel = input.llm.activeModel;
-        const llmAny = input.llm;
-        if (llmAny.simpleModel !== undefined && !isString(llmAny.simpleModel)) {
-            throw new ConfigError('CONFIG_INVALID_LLM_SIMPLE_MODEL', { expected: 'string' });
-        }
-        if (llmAny.simpleModel !== undefined)
-            cfg.llm.simpleModel = llmAny.simpleModel;
-        if (llmAny.mediumModel !== undefined && !isString(llmAny.mediumModel)) {
-            throw new ConfigError('CONFIG_INVALID_LLM_MEDIUM_MODEL', { expected: 'string' });
-        }
-        if (llmAny.mediumModel !== undefined)
-            cfg.llm.mediumModel = llmAny.mediumModel;
-        if (llmAny.complexModel !== undefined && !isString(llmAny.complexModel)) {
-            throw new ConfigError('CONFIG_INVALID_LLM_COMPLEX_MODEL', { expected: 'string' });
-        }
-        if (llmAny.complexModel !== undefined)
-            cfg.llm.complexModel = llmAny.complexModel;
-        if (llmAny.reasoningModel !== undefined && !isString(llmAny.reasoningModel)) {
-            throw new ConfigError('CONFIG_INVALID_LLM_REASONING_MODEL', { expected: 'string' });
-        }
-        if (llmAny.reasoningModel !== undefined)
-            cfg.llm.reasoningModel = llmAny.reasoningModel;
-        if (input.llm.providers !== undefined) {
-            if (!isRecord(input.llm.providers)) {
-                throw new ConfigError('CONFIG_INVALID_LLM_PROVIDERS', { expected: 'object' });
-            }
-            cfg.llm.providers = {};
-            for (const [id, rawProvider] of Object.entries(input.llm.providers)) {
-                if (!isRecord(rawProvider)) {
-                    throw new ConfigError('CONFIG_INVALID_PROVIDER', { provider: id, expected: 'object' });
-                }
-                const p = { type: String(rawProvider.type) };
-                if (!isString(rawProvider.type)) {
-                    throw new ConfigError('CONFIG_INVALID_TYPE', { provider: id, expected: 'string' });
-                }
-                if (rawProvider.client !== undefined) {
-                    if (!isRecord(rawProvider.client)) {
-                        throw new ConfigError('CONFIG_INVALID_CLIENT', { provider: id, expected: 'object' });
-                    }
-                    if (rawProvider.client.package !== undefined && !isString(rawProvider.client.package)) {
-                        throw new ConfigError('CONFIG_INVALID_CLIENT_PACKAGE', {
-                            provider: id,
-                            expected: 'string',
-                        });
-                    }
-                    p.client = { package: rawProvider.client.package };
-                }
-                if (rawProvider.api !== undefined) {
-                    if (!isRecord(rawProvider.api)) {
-                        throw new ConfigError('CONFIG_INVALID_API', { provider: id, expected: 'object' });
-                    }
-                    const api = rawProvider.api;
-                    if (api.baseUrl !== undefined && !isString(api.baseUrl)) {
-                        throw new ConfigError('CONFIG_INVALID_BASE_URL', { provider: id, expected: 'string' });
-                    }
-                    if (api.apiKey !== undefined && api.apiKey !== null && !isString(api.apiKey)) {
-                        throw new ConfigError('CONFIG_INVALID_API_KEY', {
-                            provider: id,
-                            expected: 'string_or_null',
-                        });
-                    }
-                    if (api.timeoutMs !== undefined && !isNumber(api.timeoutMs)) {
-                        throw new ConfigError('CONFIG_INVALID_TIMEOUT', { provider: id, expected: 'number' });
-                    }
-                    if (api.headers !== undefined) {
-                        if (!isRecord(api.headers)) {
-                            throw new ConfigError('CONFIG_INVALID_HEADERS', { provider: id, expected: 'object' });
-                        }
-                        for (const [k, v] of Object.entries(api.headers)) {
-                            if (!isString(v)) {
-                                throw new ConfigError('CONFIG_INVALID_HEADER_VALUE', {
-                                    provider: id,
-                                    header: k,
-                                    expected: 'string',
-                                });
-                            }
-                        }
-                    }
-                    p.api = {
-                        baseUrl: api.baseUrl,
-                        apiKey: api.apiKey,
-                        timeoutMs: api.timeoutMs,
-                        headers: api.headers,
-                    };
-                }
-                if (rawProvider.models !== undefined) {
-                    throw new ConfigError('CONFIG_LLM_PROVIDER_MODELS_NOT_SUPPORTED', {
-                        provider: id,
-                        hint: 'use llm.models with provider references',
-                    });
-                }
-                const providerCapabilities = validateLlmCapabilities(rawProvider.capabilities, {
-                    provider: id,
-                });
-                if (providerCapabilities) {
-                    p.capabilities = providerCapabilities;
-                }
-                cfg.llm.providers[id] = p;
-            }
-        }
-        if (input.llm.models !== undefined) {
-            if (!isRecord(input.llm.models)) {
-                throw new ConfigError('CONFIG_INVALID_LLM_MODELS', { expected: 'object' });
-            }
-            cfg.llm.models = {};
-            for (const [slot, rawModel] of Object.entries(input.llm.models)) {
-                if (!isRecord(rawModel)) {
-                    throw new ConfigError('CONFIG_INVALID_LLM_MODEL_PROFILE', {
-                        model: slot,
-                        expected: 'object',
-                    });
-                }
-                const provider = rawModel.provider;
-                if (!isString(provider) &&
-                    !(Array.isArray(provider) && provider.length > 0 && provider.every(isString))) {
-                    throw new ConfigError('CONFIG_INVALID_LLM_MODEL_PROVIDER', {
-                        model: slot,
-                        expected: 'string_or_non_empty_string_array',
-                    });
-                }
-                if (!isString(rawModel.id) || !rawModel.id.trim()) {
-                    throw new ConfigError('CONFIG_INVALID_LLM_MODEL_ID', {
-                        model: slot,
-                        expected: 'non_empty_string',
-                    });
-                }
-                const params = normalizeLlmModelParams(rawModel.params, {
-                    model: slot,
-                    location: 'params',
-                });
-                const capabilities = validateLlmCapabilities(rawModel.capabilities, {
-                    model: slot,
-                });
-                cfg.llm.models[slot] = {
-                    provider: provider,
-                    id: rawModel.id,
-                    params,
-                    capabilities,
-                };
-            }
-        }
-        if (input.llm.routing !== undefined) {
-            if (!isRecord(input.llm.routing)) {
-                throw new ConfigError('CONFIG_INVALID_ROUTING', { expected: 'object' });
-            }
-            const r = input.llm.routing;
-            cfg.llm.routing = {};
-            if (r.fallbackProviders !== undefined) {
-                if (!Array.isArray(r.fallbackProviders) || !r.fallbackProviders.every(isString)) {
-                    throw new ConfigError('CONFIG_INVALID_FALLBACK_PROVIDERS', { expected: 'string_array' });
-                }
-                cfg.llm.routing.fallbackProviders = r.fallbackProviders;
-            }
-            if (r.taskToModel !== undefined) {
-                if (!isRecord(r.taskToModel)) {
-                    throw new ConfigError('CONFIG_INVALID_TASK_TO_MODEL', { expected: 'object' });
-                }
-                for (const [k, v] of Object.entries(r.taskToModel)) {
-                    if (!isString(v)) {
-                        throw new ConfigError('CONFIG_INVALID_TASK_TO_MODEL_VALUE', {
-                            task: k,
-                            expected: 'string',
-                        });
-                    }
-                }
-                cfg.llm.routing.taskToModel = r.taskToModel;
-            }
-            if (r.phaseToModel !== undefined) {
-                if (!isRecord(r.phaseToModel)) {
-                    throw new ConfigError('CONFIG_INVALID_PHASE_TO_MODEL', { expected: 'object' });
-                }
-                for (const [k, v] of Object.entries(r.phaseToModel)) {
-                    if (!isString(v)) {
-                        throw new ConfigError('CONFIG_INVALID_PHASE_TO_MODEL_VALUE', {
-                            phase: k,
-                            expected: 'string',
-                        });
-                    }
-                }
-                cfg.llm.routing.phaseToModel = r.phaseToModel;
-            }
-        }
-    }
-    if (input.security !== undefined) {
-        const securityRaw = input.security;
-        if (!isRecord(securityRaw)) {
-            throw new ConfigError('CONFIG_INVALID_SECURITY', { expected: 'object' });
-        }
-        if (securityRaw.redaction !== undefined) {
-            if (!isRecord(securityRaw.redaction)) {
-                throw new ConfigError('CONFIG_INVALID_SECURITY_REDACTION', { expected: 'object' });
-            }
-            const redactionRaw = securityRaw.redaction;
-            if (redactionRaw.enabled !== undefined && !isBoolean(redactionRaw.enabled)) {
-                throw new ConfigError('CONFIG_INVALID_SECURITY_REDACTION_ENABLED', {
-                    expected: 'boolean',
-                });
-            }
-            if (redactionRaw.mark !== undefined && !isString(redactionRaw.mark)) {
-                throw new ConfigError('CONFIG_INVALID_SECURITY_REDACTION_MARK', { expected: 'string' });
-            }
-            if (redactionRaw.maxDepth !== undefined && !isNumber(redactionRaw.maxDepth)) {
-                throw new ConfigError('CONFIG_INVALID_SECURITY_REDACTION_MAX_DEPTH', {
-                    expected: 'number',
-                });
-            }
-            if (redactionRaw.keyAllowlist !== undefined &&
-                (!Array.isArray(redactionRaw.keyAllowlist) ||
-                    redactionRaw.keyAllowlist.some((v) => !isString(v)))) {
-                throw new ConfigError('CONFIG_INVALID_SECURITY_REDACTION_KEY_ALLOWLIST', {
-                    expected: 'string[]',
-                });
-            }
-            if (redactionRaw.keyDenylist !== undefined &&
-                (!Array.isArray(redactionRaw.keyDenylist) ||
-                    redactionRaw.keyDenylist.some((v) => !isString(v)))) {
-                throw new ConfigError('CONFIG_INVALID_SECURITY_REDACTION_KEY_DENYLIST', {
-                    expected: 'string[]',
-                });
-            }
-            if (redactionRaw.patterns !== undefined &&
-                (!Array.isArray(redactionRaw.patterns) || redactionRaw.patterns.some((v) => !isString(v)))) {
-                throw new ConfigError('CONFIG_INVALID_SECURITY_REDACTION_PATTERNS', {
-                    expected: 'string[]',
-                });
-            }
-            if (redactionRaw.disableDefaults !== undefined && !isBoolean(redactionRaw.disableDefaults)) {
-                throw new ConfigError('CONFIG_INVALID_SECURITY_REDACTION_DISABLE_DEFAULTS', {
-                    expected: 'boolean',
-                });
-            }
-            cfg.security = {
-                redaction: {
-                    enabled: redactionRaw.enabled,
-                    mark: redactionRaw.mark,
-                    maxDepth: redactionRaw.maxDepth,
-                    keyAllowlist: redactionRaw.keyAllowlist,
-                    keyDenylist: redactionRaw.keyDenylist,
-                    patterns: redactionRaw.patterns,
-                    disableDefaults: redactionRaw.disableDefaults,
-                },
-            };
-        }
-    }
-    if (input.output !== undefined) {
-        if (!isRecord(input.output)) {
-            throw new ConfigError('CONFIG_INVALID_OUTPUT', { expected: 'object' });
-        }
-        const output = input.output;
-        cfg.output = {};
-        if (output.llm !== undefined) {
-            if (!isRecord(output.llm)) {
-                throw new ConfigError('CONFIG_INVALID_LLM_OUTPUT', { expected: 'object' });
-            }
-            const llmOutput = output.llm;
-            if (llmOutput.kinds !== undefined) {
-                if (!Array.isArray(llmOutput.kinds) || !llmOutput.kinds.every(isString)) {
-                    throw new ConfigError('CONFIG_INVALID_LLM_OUTPUT_KINDS', { expected: 'string_array' });
-                }
-                const invalidKind = llmOutput.kinds.find((kind) => !isValidLlmOutputKind(kind));
-                if (invalidKind) {
-                    throw new ConfigError('CONFIG_INVALID_LLM_OUTPUT_KIND', { kind: String(invalidKind) });
-                }
-            }
-            cfg.output.llm = {
-                kinds: llmOutput.kinds,
-            };
-        }
-        if (output.markdown !== undefined) {
-            if (!isRecord(output.markdown)) {
-                throw new ConfigError('CONFIG_INVALID_OUTPUT_MARKDOWN', { expected: 'object' });
-            }
-            const markdown = output.markdown;
-            if (markdown.theme !== undefined) {
-                if (!isString(markdown.theme)) {
-                    throw new ConfigError('CONFIG_INVALID_MARKDOWN_THEME', { expected: 'string' });
-                }
-                if (!isValidMarkdownTheme(markdown.theme)) {
-                    throw new ConfigError('CONFIG_INVALID_MARKDOWN_THEME', { theme: String(markdown.theme) });
-                }
-            }
-            if (markdown.mode !== undefined) {
-                if (!isString(markdown.mode)) {
-                    throw new ConfigError('CONFIG_INVALID_MARKDOWN_RENDER_MODE', { expected: 'string' });
-                }
-                if (!isValidMarkdownRenderMode(markdown.mode)) {
-                    throw new ConfigError('CONFIG_INVALID_MARKDOWN_RENDER_MODE', {
-                        mode: String(markdown.mode),
-                    });
-                }
-            }
-            cfg.output.markdown = {
-                theme: markdown.theme,
-                mode: markdown.mode,
-            };
-        }
-    }
-    if (input.toolAuthorization !== undefined) {
-        if (!isRecord(input.toolAuthorization)) {
-            throw new ConfigError('CONFIG_INVALID_TOOL_AUTH', { expected: 'object' });
-        }
-        cfg.toolAuthorization = {};
-        const t = input.toolAuthorization;
-        if (t.sessionTtlMs !== undefined && !isNumber(t.sessionTtlMs)) {
-            throw new ConfigError('CONFIG_INVALID_TOOL_AUTH_TTL', { expected: 'number' });
-        }
-        if (t.nonInteractive !== undefined) {
-            if (!isRecord(t.nonInteractive)) {
-                throw new ConfigError('CONFIG_INVALID_TOOL_AUTH_NON_INTERACTIVE', { expected: 'object' });
-            }
-            const ni = t.nonInteractive;
-            if (ni.strategy !== undefined && !isString(ni.strategy)) {
-                throw new ConfigError('CONFIG_INVALID_TOOL_AUTH_NON_INTERACTIVE_STRATEGY', {
-                    expected: 'string',
-                });
-            }
-            const strategy = ni.strategy ?? undefined;
-            if (strategy !== undefined &&
-                strategy !== 'deny' &&
-                strategy !== 'command' &&
-                strategy !== 'mcp') {
-                throw new ConfigError('CONFIG_INVALID_TOOL_AUTH_NON_INTERACTIVE_STRATEGY', {
-                    strategy: String(strategy),
-                });
-            }
-            if (ni.command !== undefined) {
-                if (!isRecord(ni.command)) {
-                    throw new ConfigError('CONFIG_INVALID_TOOL_AUTH_NON_INTERACTIVE_COMMAND', {
-                        expected: 'object',
-                    });
-                }
-                if (!isString(ni.command.cmd)) {
-                    throw new ConfigError('CONFIG_INVALID_TOOL_AUTH_NON_INTERACTIVE_COMMAND_CMD', {
-                        expected: 'string',
-                    });
-                }
-                if (ni.command.timeoutMs !== undefined && !isNumber(ni.command.timeoutMs)) {
-                    throw new ConfigError('CONFIG_INVALID_TOOL_AUTH_NON_INTERACTIVE_COMMAND_TIMEOUT', {
-                        expected: 'number',
-                    });
-                }
-            }
-            if (ni.mcp !== undefined) {
-                if (!isRecord(ni.mcp)) {
-                    throw new ConfigError('CONFIG_INVALID_TOOL_AUTH_NON_INTERACTIVE_MCP', {
-                        expected: 'object',
-                    });
-                }
-                if (!isString(ni.mcp.server)) {
-                    throw new ConfigError('CONFIG_INVALID_TOOL_AUTH_NON_INTERACTIVE_MCP_SERVER', {
-                        expected: 'string',
-                    });
-                }
-                if (!isString(ni.mcp.tool)) {
-                    throw new ConfigError('CONFIG_INVALID_TOOL_AUTH_NON_INTERACTIVE_MCP_TOOL', {
-                        expected: 'string',
-                    });
-                }
-                if (ni.mcp.timeoutMs !== undefined && !isNumber(ni.mcp.timeoutMs)) {
-                    throw new ConfigError('CONFIG_INVALID_TOOL_AUTH_NON_INTERACTIVE_MCP_TIMEOUT', {
-                        expected: 'number',
-                    });
-                }
-            }
-            cfg.toolAuthorization.nonInteractive = {
-                strategy: strategy,
-                command: ni.command,
-                mcp: ni.mcp,
-            };
-        }
-        if (t.autoAllowRisk !== undefined) {
-            if (!isRecord(t.autoAllowRisk)) {
-                throw new ConfigError('CONFIG_INVALID_TOOL_AUTH_RISK', { expected: 'object' });
-            }
-            const r = t.autoAllowRisk;
-            if (r.low !== undefined && !isBoolean(r.low)) {
-                throw new ConfigError('CONFIG_INVALID_TOOL_AUTH_RISK_LOW', { expected: 'boolean' });
-            }
-            if (r.medium !== undefined && !isBoolean(r.medium)) {
-                throw new ConfigError('CONFIG_INVALID_TOOL_AUTH_RISK_MEDIUM', { expected: 'boolean' });
-            }
-            if (r.high !== undefined && !isBoolean(r.high)) {
-                throw new ConfigError('CONFIG_INVALID_TOOL_AUTH_RISK_HIGH', { expected: 'boolean' });
-            }
-            cfg.toolAuthorization.autoAllowRisk = {
-                low: r.low,
-                medium: r.medium,
-                high: r.high,
-            };
-        }
-        if (t.allowlist !== undefined) {
-            if (!isRecord(t.allowlist)) {
-                throw new ConfigError('CONFIG_INVALID_TOOL_AUTH_ALLOWLIST', { expected: 'object' });
-            }
-            const a = t.allowlist;
-            if (a.repoFile !== undefined && !isString(a.repoFile)) {
-                throw new ConfigError('CONFIG_INVALID_TOOL_AUTH_REPO_FILE', { expected: 'string' });
-            }
-            if (a.userFile !== undefined && !isString(a.userFile)) {
-                throw new ConfigError('CONFIG_INVALID_TOOL_AUTH_USER_FILE', { expected: 'string' });
-            }
-            cfg.toolAuthorization.allowlist = {
-                repoFile: a.repoFile,
-                userFile: a.userFile,
-            };
-        }
-        if (t.sessionTtlMs !== undefined) {
-            cfg.toolAuthorization.sessionTtlMs = t.sessionTtlMs;
-        }
-    }
-    return cfg;
+    const result = configFileV1Schema.safeParse(input);
+    if (result.success)
+        return result.data;
+    throw zodIssueToConfigError(result.error.issues[0]);
 }
 //# sourceMappingURL=validate.js.map