@sortedyuan/maybecode 0.3.2 → 0.5.0

package/dist/configured.js

@@ -2,58 +2,49 @@ import { realpath, stat } from "node:fs/promises";
 import { homedir } from "node:os";
 import { dirname, isAbsolute, join, relative, resolve } from "node:path";
 import { pathToFileURL } from "node:url";
-import { loadMayConfig, updateDefaultMayModel, } from "@sortedyuan/config";
-import { resolveRunBudget } from "@sortedyuan/core";
+import { loadMayConfig, updateDefaultMayModel, } from "@sortedyuan/may/config";
+import { omitUndefined, resolveRunBudget } from "@sortedyuan/may/core";
 import { createMcpModelSampler, validateMcpServerOptions, } from "@sortedyuan/mcp";
-import { mcpHostService, mcpService } from "@sortedyuan/plugin-mcp";
-import { createSharedObservabilityPlugin, observabilityHostService, observabilityService } from "@sortedyuan/plugin-observability";
-import { services } from "@sortedyuan/plugin-services";
+import { mcpHostService, mcpService } from "@sortedyuan/mcp/plugin";
+import { createSharedObservabilityPlugin, observabilityHostService, observabilityService, } from "@sortedyuan/observability/plugin";
+import { services } from "@sortedyuan/may/services";
 import { createMaybeCodeResourcePlugins, createMaybeCodeSharedPlugins } from "./plugins/resources.js";
 import { createModelCapabilityResolver, createBuiltinProviderAdapterRegistry, withModelRetry, } from "@sortedyuan/providers";
-import { FileSessionStore } from "@sortedyuan/session/file-store";
-import { FilePermissionRuleStore } from "@sortedyuan/permissions/file-store";
+import { FileSessionStore } from "@sortedyuan/may/session/file-store";
+import { FilePermissionRuleStore } from "@sortedyuan/may/permissions/file-store";
 import { userInfo } from "node:os";
-import { FileSessionCatalog } from "@sortedyuan/session/catalog";
+import { FileSessionCatalog } from "@sortedyuan/may/session/catalog";
 import { MaybeCodeConfigError } from "./errors.js";
 import { createMaybeCodeModel, selectMaybeCodeModel, } from "./model.js";
-import { MAYBECODE_APPLICATION_ID, resolveMaybeCodeInstructionsDirectory, } from "./instructions.js";
+import { resolveMaybeCodeInstructionsDirectory } from "./instructions.js";
+import { readMaybeCodeSettings } from "./settings.js";
 import { MaybeCodeWorkspace } from "./workspace.js";
-import { PluginHost, loadPluginModules, parsePluginSelections } from "@sortedyuan/plugin";
+import { PluginHost, loadPluginModules } from "@sortedyuan/may/plugin";
 import { resolveMaybeCodeSkillDirectories } from "./skills.js";
 import { parsePermissionMode } from "./policy.js";
-import { resolveSubagentConfiguration } from "./subagents.js";
+import { resolveSubagentConfiguration, } from "@sortedyuan/coordination/delegation/configuration";
 export function getDefaultMaybeCodeDataDirectory() {
     return join(homedir(), ".may", "maybecode");
 }
-export function resolveMaybeCodeGit(config) {
-    const value = config.apps?.maybecode?.git;
-    if (value === undefined)
-        return {};
-    if (value === false)
-        return false;
-    if (!value || typeof value !== "object" || Array.isArray(value))
-        throw new MaybeCodeConfigError("apps.maybecode.git must be false or an object");
-    const fields = value;
-    const allowed = ["autoCommit", "readOnly", "dataRoot", "worktreesRoot", "excludedPaths"];
-    for (const name of Object.keys(fields))
-        if (!allowed.includes(name))
-            throw new MaybeCodeConfigError(`Unknown apps.maybecode.git field: ${name}`);
-    for (const name of ["autoCommit", "readOnly"])
-        if (fields[name] !== undefined && typeof fields[name] !== "boolean")
-            throw new MaybeCodeConfigError(`apps.maybecode.git.${name} must be boolean`);
-    for (const name of ["dataRoot", "worktreesRoot"])
-        if (fields[name] !== undefined && (typeof fields[name] !== "string" || !fields[name].trim()))
-            throw new MaybeCodeConfigError(`apps.maybecode.git.${name} must be a non-empty path`);
-    if (fields.excludedPaths !== undefined && (!Array.isArray(fields.excludedPaths) || fields.excludedPaths.some(path => typeof path !== "string" || !path.trim())))
-        throw new MaybeCodeConfigError("apps.maybecode.git.excludedPaths must contain non-empty paths");
+export function resolveMaybeCodeRecording(config) {
+    const settings = readMaybeCodeSettings(config);
     return {
-        ...(fields.autoCommit === undefined ? {} : { autoCommit: fields.autoCommit }),
-        ...(fields.readOnly === undefined ? {} : { readOnly: fields.readOnly }),
-        ...(fields.dataRoot === undefined ? {} : { dataRoot: resolveGitConfigurationPath(config.path, fields.dataRoot) }),
-        ...(fields.worktreesRoot === undefined ? {} : { worktreesRoot: resolveGitConfigurationPath(config.path, fields.worktreesRoot) }),
-        ...(fields.excludedPaths === undefined ? {} : { excludedPaths: fields.excludedPaths }),
+        requestRecording: settings.requestRecording ?? "required",
+        providerBodyRecording: settings.providerBodyRecording ?? false,
     };
 }
+export function resolveMaybeCodeGit(config) {
+    const git = readMaybeCodeSettings(config).git;
+    if (git === false)
+        return false;
+    return omitUndefined({
+        autoCommit: git?.autoCommit,
+        readOnly: git?.readOnly,
+        dataRoot: git?.dataRoot === undefined ? undefined : resolveGitConfigurationPath(config.path, git.dataRoot),
+        worktreesRoot: git?.worktreesRoot === undefined ? undefined : resolveGitConfigurationPath(config.path, git.worktreesRoot),
+        excludedPaths: git?.excludedPaths === undefined ? undefined : [...git.excludedPaths],
+    });
+}
 function resolveGitConfigurationPath(configPath, path) {
     if (path === "~")
         return homedir();
@@ -61,35 +52,28 @@ function resolveGitConfigurationPath(configPath, path) {
         return resolve(homedir(), path.slice(2));
     return resolve(dirname(configPath), path);
 }
+/** @experimental */
 export async function openConfiguredMaybeCode(options = {}, dependencies = {}) {
     const workspace = await resolveWorkspace(options.workspace ?? process.cwd());
     const loadConfig = dependencies.loadConfig ?? loadMayConfig;
-    const config = await loadConfig(options.configPath === undefined ? {} : { path: options.configPath });
+    const config = await loadConfig(omitUndefined({ path: options.configPath }));
+    const settings = readMaybeCodeSettings(config);
     const retry = options.retry ?? resolveMaybeCodeRetry(config);
-    const plugins = options.plugins ?? await loadPluginModules(parsePluginSelections(config.apps?.maybecode?.plugins), config.path);
-    const provided = (service) => plugins.some(plugin => plugin.provides?.some(candidate => candidate.id === service.id && candidate.scope === service.scope));
+    const plugins = options.plugins ?? (await loadPluginModules(settings.plugins ?? [], config.path));
+    const provided = (service) => plugins.some((plugin) => plugin.provides?.some((candidate) => candidate.id === service.id && candidate.scope === service.scope));
     const pluginModel = provided(services.model);
-    const configuredPermissionMode = config.apps?.maybecode?.permissionMode;
-    const configuredDelegationNotifications = options.delegationNotifications === undefined
-        ? config.apps?.maybecode?.delegationNotifications : options.delegationNotifications;
-    const delegationNotifications = configuredDelegationNotifications === undefined ? false : configuredDelegationNotifications;
-    if (typeof delegationNotifications !== "boolean")
-        throw new MaybeCodeConfigError("apps.maybecode.delegationNotifications must be boolean");
+    const { requestRecording, providerBodyRecording } = resolveMaybeCodeRecording(config);
+    const delegationNotifications = options.delegationNotifications ?? settings.delegationNotifications ?? false;
     const git = options.git ?? resolveMaybeCodeGit(config);
     const permissionMode = options.permissionMode === undefined
-        ? configuredPermissionMode === undefined ? "default" : parsePermissionMode(configuredPermissionMode)
+        ? (settings.permissionMode ?? "default")
         : parsePermissionMode(options.permissionMode);
-    const persistentRules = options.persistentRules ?? config.apps?.maybecode?.persistentRules ?? false;
-    if (typeof persistentRules !== "boolean")
-        throw new MaybeCodeConfigError("apps.maybecode.persistentRules must be boolean");
+    const persistentRules = options.persistentRules ?? settings.persistentRules ?? false;
     const skillDirectories = options.skillDirectories ?? resolveMaybeCodeSkillDirectories(config, workspace);
-    const runBudget = resolveRunBudget(options.runBudget ?? config.apps?.maybecode?.runBudget);
-    const capabilityResolver = dependencies.capabilityResolver ??
-        createModelCapabilityResolver();
+    const runBudget = resolveRunBudget(options.runBudget ?? settings.runBudget);
+    const capabilityResolver = dependencies.capabilityResolver ?? createModelCapabilityResolver();
     const adapterRegistry = dependencies.adapterRegistry ?? createBuiltinProviderAdapterRegistry({ resolver: capabilityResolver });
-    const selectionFor = (profile) => selectMaybeCodeModel(config, {
-        ...(profile === undefined ? {} : { model: profile }),
-    });
+    const selectionFor = (profile) => selectMaybeCodeModel(config, omitUndefined({ model: profile }));
     const configureModel = (profile, runtimeOptions = {}) => {
         const selected = selectionFor(profile);
         const selection = {
@@ -101,7 +85,7 @@ export async function openConfiguredMaybeCode(options = {}, dependencies = {}) {
             : dependencies.createModel(selection);
         const model = retry === false ? baseModel : withModelRetry(baseModel, retry);
         const contextBudget = options.contextBudget ?? createContextBudget(model, selection);
-        return {
+        return omitUndefined({
             model,
             modelInfo: {
                 profile: selection.profile,
@@ -109,41 +93,37 @@ export async function openConfiguredMaybeCode(options = {}, dependencies = {}) {
                 adapter: selection.adapter,
                 model: selection.model,
             },
-            ...(contextBudget === undefined ? {} : { contextBudget }),
-        };
+            contextBudget,
+        });
     };
     const initialModel = pluginModel ? undefined : configureModel(options.model);
-    const modelProfiles = pluginModel ? [] : Object.entries(config.models).map(([name, profile]) => {
-        const provider = config.providers[profile.provider];
-        const reasoningEffort = {
-            ...(provider.options ?? {}),
-            ...(profile.options ?? {}),
-        }.reasoningEffort;
-        return {
-            name,
-            provider: profile.provider,
-            adapter: profile.adapter ?? provider.adapter,
-            model: profile.model,
-            isDefault: config.defaultModel === name,
-            ...(typeof reasoningEffort === "string" ? { reasoningEffort } : {}),
-        };
-    });
-    const instructionsDirectory = options.instructions === undefined
-        ? resolveMaybeCodeInstructionsDirectory(config)
-        : undefined;
-    const autoCompactionMode = options.autoCompactionMode ??
-        (options.providerNativeAutoCompaction === undefined
-            ? resolveMaybeCodeAutoCompactionMode(config)
-            : options.providerNativeAutoCompaction ? "provider-native" : "prune-summary");
+    const modelProfiles = pluginModel
+        ? []
+        : Object.entries(config.models).map(([name, profile]) => {
+            const provider = config.providers[profile.provider];
+            const reasoningEffort = {
+                ...(provider.options ?? {}),
+                ...(profile.options ?? {}),
+            }.reasoningEffort;
+            return {
+                name,
+                provider: profile.provider,
+                adapter: profile.adapter ?? provider.adapter,
+                model: profile.model,
+                isDefault: config.defaultModel === name,
+                ...(typeof reasoningEffort === "string" ? { reasoningEffort } : {}),
+            };
+        });
+    const instructionsDirectory = options.instructions === undefined ? resolveMaybeCodeInstructionsDirectory(config) : undefined;
+    const autoCompactionMode = options.autoCompactionMode ?? resolveMaybeCodeAutoCompactionMode(config);
     const dataDirectory = resolve(options.dataDirectory ?? getDefaultMaybeCodeDataDirectory());
-    const observabilityOptions = provided(observabilityService) || provided(services.tracer) ? false : options.observability ??
-        resolveMaybeCodeObservability(config);
-    const subagents = resolveMaybeCodeSubagents(options.subagents, config);
+    const observabilityOptions = provided(observabilityService) || provided(services.tracer)
+        ? false
+        : (options.observability ?? resolveMaybeCodeObservability(config));
+    const subagents = resolveMaybeCodeSubagents(options.subagents, settings);
     const subagentCreateModel = (role) => role.model === undefined
         ? initialModel
-        : configureModel(role.model, role.reasoningEffort === undefined
-            ? {}
-            : { reasoningEffort: role.reasoningEffort });
+        : configureModel(role.model, role.reasoningEffort === undefined ? {} : { reasoningEffort: role.reasoningEffort });
     let mcp;
     let resourceHost;
     const workspaceResourceHosts = new Map();
@@ -171,43 +151,62 @@ export async function openConfiguredMaybeCode(options = {}, dependencies = {}) {
         }
     };
     const mcpForWorkspace = (nextWorkspace) => {
-        const next = provided(mcpService) ? false : options.mcp === undefined
-            ? resolveMaybeCodeMcp(config, nextWorkspace)
-            : options.mcp === false ? false : { ...options.mcp, servers: options.mcp.servers.map(server => {
-                    if (server.transport === "streamable-http")
-                        return server;
-                    const source = resolve(workspace, server.cwd ?? ".");
-                    const path = relative(workspace, source);
-                    const inside = path === "" || path !== ".." && !path.startsWith("..\\") && !path.startsWith("../") && !isAbsolute(path);
-                    return { ...server, cwd: inside ? resolve(nextWorkspace, path) : source };
-                }) };
+        const next = provided(mcpService)
+            ? false
+            : options.mcp === undefined
+                ? resolveMaybeCodeMcp(config, nextWorkspace)
+                : options.mcp === false
+                    ? false
+                    : {
+                        ...options.mcp,
+                        servers: options.mcp.servers.map((server) => {
+                            if (server.transport === "streamable-http")
+                                return server;
+                            const source = resolve(workspace, server.cwd ?? ".");
+                            const path = relative(workspace, source);
+                            const inside = path === "" ||
+                                (path !== ".." && !path.startsWith("..\\") && !path.startsWith("../") && !isAbsolute(path));
+                            return { ...server, cwd: inside ? resolve(nextWorkspace, path) : source };
+                        }),
+                    };
         if (next === false)
             return false;
-        const tracer = resourceHost?.provides(observabilityHostService) ? resourceHost.get(observabilityHostService).tracer : undefined;
+        const tracer = resourceHost?.provides(observabilityHostService)
+            ? resourceHost.get(observabilityHostService).tracer
+            : undefined;
         return {
             servers: next.servers,
-            ...(next.taskJournal === undefined ? {} : { taskJournal: next.taskJournal }),
-            ...(next.oauth === undefined ? {} : { oauth: next.oauth }),
-            ...(tracer === undefined ? {} : { tracer }),
-            ...(dependencies.openMcp === undefined ? {} : { open: dependencies.openMcp }),
+            ...omitUndefined({ taskJournal: next.taskJournal, oauth: next.oauth, tracer, open: dependencies.openMcp }),
             enableInteractions: options.mcpInteractions === true,
             hostServices: {
-                roots: async (context) => { checkHostOwner(context); return [{ uri: pathToFileURL(application.workspace).href, name: "MaybeCode workspace" }]; },
-                ...(pluginModel ? {} : { sampling: createMcpModelSampler((maxTokens, context) => {
-                        checkHostOwner(context);
-                        const selected = selectionFor(application.modelInfo?.profile);
-                        const selection = { ...selected, options: { ...selected.options, maxTokens, maxOutputTokens: maxTokens } };
-                        // sampling 使用独立 provider 实例和本次调用的模型预算。
-                        const model = dependencies.createModel === undefined ? createMaybeCodeModel(selection, dependencies.adapterRegistry) : dependencies.createModel(selection);
-                        return { model, name: selected.model };
-                    }) }),
+                roots: async (context) => {
+                    checkHostOwner(context);
+                    return [{ uri: pathToFileURL(application.workspace).href, name: "MaybeCode workspace" }];
+                },
+                ...(pluginModel
+                    ? {}
+                    : {
+                        sampling: createMcpModelSampler((maxTokens, context) => {
+                            checkHostOwner(context);
+                            const selected = selectionFor(application.application.modelInfo?.profile);
+                            const selection = {
+                                ...selected,
+                                options: { ...selected.options, maxTokens, maxOutputTokens: maxTokens },
+                            };
+                            // sampling 使用独立 provider 实例和本次调用的模型预算。
+                            const model = dependencies.createModel === undefined
+                                ? createMaybeCodeModel(selection, dependencies.adapterRegistry)
+                                : dependencies.createModel(selection);
+                            return { model, name: selected.model };
+                        }),
+                    }),
             },
             traceAttributes: { "may.agent.name": "maybecode" },
         };
     };
     const closeResources = async () => {
-        const results = await Promise.allSettled([...workspaceResourceHosts.values()].map(host => host.close()));
-        const failures = results.flatMap(result => result.status === "rejected" ? [result.reason] : []);
+        const results = await Promise.allSettled([...workspaceResourceHosts.values()].map((host) => host.close()));
+        const failures = results.flatMap((result) => (result.status === "rejected" ? [result.reason] : []));
         try {
             await resourceHost?.close();
         }
@@ -226,80 +225,82 @@ export async function openConfiguredMaybeCode(options = {}, dependencies = {}) {
             throw new AggregateError(failures, "MaybeCode configured resources failed to close");
     };
     try {
-        const resourcePlugins = createMaybeCodeResourcePlugins({ dataDirectory, observability: observabilityOptions, mcp: mcpForWorkspace(workspace) });
+        const resourcePlugins = createMaybeCodeResourcePlugins({
+            dataDirectory,
+            observability: observabilityOptions,
+            mcp: mcpForWorkspace(workspace),
+        });
         resourceHost = await PluginHost.create({ plugins: resourcePlugins });
         if (resourceHost.provides(mcpHostService))
             mcp = resourceHost.get(mcpHostService);
-        const observability = resourceHost.provides(observabilityHostService) ? resourceHost.get(observabilityHostService) : undefined;
+        const observability = resourceHost.provides(observabilityHostService)
+            ? resourceHost.get(observabilityHostService)
+            : undefined;
         const applicationPlugins = createMaybeCodeSharedPlugins(resourceHost, plugins);
         workspacePlugins.set(workspace, applicationPlugins);
         application = await MaybeCodeWorkspace.open({
             git,
-            ...await permissionsFor(workspace),
+            ...omitUndefined({ execution: settings.execution, fetch: settings.fetch }),
+            ...(await permissionsFor(workspace)),
             configureWorkspace: async (nextWorkspace) => {
                 const directories = options.skillDirectories ?? resolveMaybeCodeSkillDirectories(config, nextWorkspace);
                 let configuredPlugins = workspacePlugins.get(nextWorkspace);
                 if (configuredPlugins === undefined) {
-                    const nextHost = await PluginHost.create({ plugins: createMaybeCodeResourcePlugins({
-                            dataDirectory, observability: false, mcp: mcpForWorkspace(nextWorkspace),
-                        }) });
+                    const nextHost = await PluginHost.create({
+                        plugins: createMaybeCodeResourcePlugins({
+                            dataDirectory,
+                            observability: false,
+                            mcp: mcpForWorkspace(nextWorkspace),
+                        }),
+                    });
                     workspaceResourceHosts.set(nextWorkspace, nextHost);
                     configuredPlugins = createMaybeCodeSharedPlugins(nextHost, [
-                        ...(observability === undefined ? [] : [createSharedObservabilityPlugin(observability)]), ...plugins,
+                        ...(observability === undefined ? [] : [createSharedObservabilityPlugin(observability)]),
+                        ...plugins,
                     ]);
                     workspacePlugins.set(nextWorkspace, configuredPlugins);
                 }
-                return { plugins: configuredPlugins, ...await permissionsFor(nextWorkspace), ...(directories === false ? { skills: false } : { skillDirectories: directories }) };
+                return {
+                    plugins: configuredPlugins,
+                    ...(await permissionsFor(nextWorkspace)),
+                    ...(directories === false ? { skills: false } : { skillDirectories: directories }),
+                };
             },
             permissionMode,
+            requestRecording,
+            providerBodyRecording,
             delegationNotifications,
             workspace,
             ...(initialModel === undefined ? {} : { model: initialModel.model, modelInfo: initialModel.modelInfo }),
             modelProfiles,
-            ...(pluginModel ? {} : {
-                createModelConfiguration: (profile, runtimeOptions) => configureModel(profile, runtimeOptions),
-                resolveModelCapabilities: async (profile, options) => capabilityResolver.resolve(selectionFor(profile), options),
-            }),
+            ...(pluginModel
+                ? {}
+                : {
+                    createModelConfiguration: (profile, runtimeOptions) => configureModel(profile, runtimeOptions),
+                    resolveModelCapabilities: async (profile, options) => capabilityResolver.resolve(selectionFor(profile), options),
+                }),
             ...resolveDefaultModelPersistence(config, dependencies),
             store: new FileSessionStore(join(dataDirectory, "sessions")),
             plugins: applicationPlugins,
             catalog: new FileSessionCatalog(join(dataDirectory, "catalog.json")),
-            ...(mcp === undefined
-                ? {}
-                : { mcp }),
             closeOwnedResources: closeResources,
-            ...(options.sessionId === undefined
-                ? {}
-                : { sessionId: options.sessionId }),
-            ...(options.autoResume === undefined
-                ? {}
-                : { autoResume: options.autoResume }),
-            ...(options.contextFactory === undefined
-                ? {}
-                : { contextFactory: options.contextFactory }),
-            ...((options.contextBudget ?? initialModel?.contextBudget) === undefined
-                ? {}
-                : { contextBudget: options.contextBudget ?? initialModel.contextBudget }),
-            ...(options.compactionStrategy === undefined
-                ? {}
-                : { compactionStrategy: options.compactionStrategy }),
-            ...(options.autoCompactionStrategies === undefined
-                ? {}
-                : { autoCompactionStrategies: options.autoCompactionStrategies }),
             autoCompactionMode,
-            ...(options.contextSummarizer === undefined
-                ? {}
-                : { contextSummarizer: options.contextSummarizer }),
-            ...(options.instructions === undefined
-                ? {}
-                : { instructions: options.instructions }),
-            ...(instructionsDirectory === undefined
-                ? {}
-                : { instructionsDirectory }),
-            ...(options.maxSteps === undefined ? {} : { maxSteps: options.maxSteps }),
             runBudget,
-            ...(options.skills === undefined ? {} : { skills: options.skills }),
-            ...(options.goals === undefined ? {} : { goals: options.goals }),
+            ...omitUndefined({
+                mcp,
+                sessionId: options.sessionId,
+                autoResume: options.autoResume,
+                contextFactory: options.contextFactory,
+                contextBudget: options.contextBudget ?? initialModel?.contextBudget,
+                compactionStrategy: options.compactionStrategy,
+                autoCompactionStrategies: options.autoCompactionStrategies,
+                contextSummarizer: options.contextSummarizer,
+                instructions: options.instructions,
+                instructionsDirectory,
+                maxSteps: options.maxSteps,
+                skills: options.skills,
+                goals: options.goals,
+            }),
             ...(subagents === false
                 ? { subagents: false }
                 : {
@@ -312,7 +313,9 @@ export async function openConfiguredMaybeCode(options = {}, dependencies = {}) {
                     },
                 }),
             ...(skillDirectories === false
-                ? (options.skills === undefined ? { skills: false } : {})
+                ? options.skills === undefined
+                    ? { skills: false }
+                    : {}
                 : { skillDirectories }),
         });
         return application;
@@ -328,164 +331,77 @@ export async function openConfiguredMaybeCode(options = {}, dependencies = {}) {
     }
 }
 export function resolveMaybeCodeMcp(config, workspace, environment = process.env) {
-    const value = config.apps?.[MAYBECODE_APPLICATION_ID]?.mcpServers;
-    if (value === undefined || value === false)
+    const servers = readMaybeCodeSettings(config).mcpServers;
+    if (servers === undefined || servers === false)
         return false;
-    const servers = objectValue(value, "apps.maybecode.mcpServers");
     const resolved = [];
-    for (const [id, raw] of Object.entries(servers)) {
-        if (!/^[A-Za-z0-9_-]+$/u.test(id)) {
-            throw new MaybeCodeConfigError(`apps.maybecode.mcpServers server id "${id}" may contain only letters, digits, underscores, and hyphens`);
-        }
-        const field = `apps.maybecode.mcpServers.${id}`;
-        const server = objectValue(raw, field);
-        rejectUnknownOptions(server, [
-            "enabled",
-            "required",
-            "transport",
-            "protocolMode",
-            "host",
-            "tasks",
-            "url",
-            "headers",
-            "auth",
-            "command",
-            "args",
-            "cwd",
-            "env",
-            "requestTimeoutMs",
-            "maxTotalTimeoutMs",
-            "maxBufferSize",
-            "stderrMaxBytes",
-        ], field);
-        if (server.enabled !== undefined && typeof server.enabled !== "boolean") {
-            throw new MaybeCodeConfigError(`${field}.enabled must be a boolean`);
-        }
+    for (const [id, server] of Object.entries(servers)) {
         if (server.enabled === false)
             continue;
-        if (server.required !== undefined && typeof server.required !== "boolean") {
-            throw new MaybeCodeConfigError(`${field}.required must be a boolean`);
-        }
-        if (server.transport !== undefined && server.transport !== "stdio" &&
-            server.transport !== "streamable-http") {
-            throw new MaybeCodeConfigError(`${field}.transport must be "stdio" or "streamable-http"`);
-        }
-        if (server.protocolMode !== undefined && server.protocolMode !== "legacy" &&
-            server.protocolMode !== "auto") {
-            throw new MaybeCodeConfigError(`${field}.protocolMode must be "legacy" or "auto"`);
-        }
-        const requestTimeoutMs = optionalPositiveInteger(server.requestTimeoutMs, `${field}.requestTimeoutMs`);
-        const maxTotalTimeoutMs = optionalPositiveInteger(server.maxTotalTimeoutMs, `${field}.maxTotalTimeoutMs`);
-        const common = {
+        const field = `apps.maybecode.mcpServers.${id}`;
+        const common = omitUndefined({
             id,
-            ...(server.required === undefined ? {} : { required: server.required }),
-            ...(server.protocolMode === undefined ? {} : { protocolMode: server.protocolMode }),
-            ...(server.tasks === undefined ? {} : { tasks: server.tasks }),
-            ...(server.host === undefined ? {} : { host: objectValue(server.host, `${field}.host`) }),
-            ...(requestTimeoutMs === undefined ? {} : { requestTimeoutMs }),
-            ...(maxTotalTimeoutMs === undefined ? {} : { maxTotalTimeoutMs }),
-        };
+            required: server.required,
+            protocolMode: server.protocolMode,
+            tasks: server.tasks,
+            host: server.host,
+            requestTimeoutMs: server.requestTimeoutMs,
+            maxTotalTimeoutMs: server.maxTotalTimeoutMs,
+        });
         if (server.transport === "streamable-http") {
-            for (const key of ["command", "args", "cwd", "env", "maxBufferSize", "stderrMaxBytes"]) {
-                if (key in server)
-                    throw new MaybeCodeConfigError(`${field}.${key} is stdio-only`);
-            }
-            const headers = resolveMcpEnvironment(server.headers, `${field}.headers`, environment);
-            const endpoint = {
+            const endpoint = omitUndefined({
                 ...common,
                 transport: "streamable-http",
-                url: nonEmptyString(server.url, `${field}.url`),
-                ...(headers === undefined ? {} : { headers }),
-                ...(server.auth === undefined ? {} : { auth: objectValue(server.auth, `${field}.auth`) }),
-            };
+                url: server.url,
+                headers: resolveMcpEnvironment(server.headers, `${field}.headers`, environment),
+                auth: server.auth,
+            });
             try {
                 validateMcpServerOptions(endpoint);
             }
             catch (error) {
-                throw new MaybeCodeConfigError(error instanceof Error ? error.message : "Invalid MCP endpoint");
+                throw new MaybeCodeConfigError(error.message, { cause: error });
             }
             resolved.push(endpoint);
             continue;
         }
-        for (const key of ["url", "headers", "auth"]) {
-            if (key in server)
-                throw new MaybeCodeConfigError(`${field}.${key} requires streamable-http`);
-        }
-        const command = nonEmptyString(server.command, `${field}.command`);
-        const args = optionalStringArray(server.args, `${field}.args`);
-        const cwd = server.cwd === undefined
-            ? workspace
-            : resolve(workspace, nonEmptyString(server.cwd, `${field}.cwd`));
-        const env = resolveMcpEnvironment(server.env, `${field}.env`, environment);
-        const maxBufferSize = optionalPositiveInteger(server.maxBufferSize, `${field}.maxBufferSize`);
-        const stderrMaxBytes = optionalPositiveInteger(server.stderrMaxBytes, `${field}.stderrMaxBytes`);
-        resolved.push({
+        resolved.push(omitUndefined({
             ...common,
-            command,
-            ...(args === undefined ? {} : { args }),
-            cwd,
-            ...(env === undefined ? {} : { env }),
-            ...(maxBufferSize === undefined ? {} : { maxBufferSize }),
-            ...(stderrMaxBytes === undefined ? {} : { stderrMaxBytes }),
-        });
+            command: server.command,
+            args: server.args,
+            cwd: server.cwd === undefined ? workspace : resolve(workspace, server.cwd),
+            env: resolveMcpEnvironment(server.env, `${field}.env`, environment),
+            maxBufferSize: server.maxBufferSize,
+            stderrMaxBytes: server.stderrMaxBytes,
+        }));
     }
     return { servers: resolved };
 }
 export function resolveMaybeCodeObservability(config) {
-    const value = config.apps?.[MAYBECODE_APPLICATION_ID]?.observability;
-    if (value === undefined || value === false)
+    const observability = readMaybeCodeSettings(config).observability;
+    if (observability === undefined || observability === false)
         return false;
-    if (typeof value !== "object" || value === null || Array.isArray(value)) {
-        throw new MaybeCodeConfigError("apps.maybecode.observability must be false or an object");
-    }
-    const candidate = value;
-    rejectUnknownOptions(candidate, [
-        "enabled",
-        "exporter",
-        "file",
-        "samplingRatio",
-        "retentionDays",
-        "batch",
-    ], "apps.maybecode.observability");
-    const enabled = candidate.enabled;
-    if (enabled !== undefined && typeof enabled !== "boolean") {
-        throw new MaybeCodeConfigError("apps.maybecode.observability.enabled must be a boolean");
-    }
-    if (candidate.exporter !== undefined && candidate.exporter !== "file") {
-        throw new MaybeCodeConfigError('apps.maybecode.observability.exporter must be "file"');
-    }
-    const file = candidate.file === undefined
-        ? undefined
-        : nonEmptyString(candidate.file, "apps.maybecode.observability.file");
-    const samplingRatio = optionalRatio(candidate.samplingRatio, "apps.maybecode.observability.samplingRatio");
-    const retentionDays = optionalPositiveInteger(candidate.retentionDays, "apps.maybecode.observability.retentionDays");
-    const batch = candidate.batch === undefined
-        ? {}
-        : objectValue(candidate.batch, "apps.maybecode.observability.batch");
-    rejectUnknownOptions(batch, ["maxQueueSize", "maxExportBatchSize", "scheduledDelayMs"], "apps.maybecode.observability.batch");
-    const maxQueueSize = optionalPositiveInteger(batch.maxQueueSize, "apps.maybecode.observability.batch.maxQueueSize");
-    const maxExportBatchSize = optionalPositiveInteger(batch.maxExportBatchSize, "apps.maybecode.observability.batch.maxExportBatchSize");
-    const scheduledDelayMs = optionalNonNegativeNumber(batch.scheduledDelayMs, "apps.maybecode.observability.batch.scheduledDelayMs");
-    if ((maxExportBatchSize ?? 512) > (maxQueueSize ?? 2_048)) {
+    const batch = observability.batch ?? {};
+    if ((batch.maxExportBatchSize ?? 512) > (batch.maxQueueSize ?? 2_048)) {
         throw new MaybeCodeConfigError("apps.maybecode.observability.batch.maxExportBatchSize cannot exceed maxQueueSize");
     }
-    if (enabled === false)
+    if (observability.enabled === false)
         return false;
-    return {
-        ...(file === undefined ? {} : { file }),
-        ...(samplingRatio === undefined ? {} : { samplingRatio }),
-        ...(retentionDays === undefined ? {} : { retentionDays }),
-        ...(maxQueueSize === undefined ? {} : { maxQueueSize }),
-        ...(maxExportBatchSize === undefined ? {} : { maxExportBatchSize }),
-        ...(scheduledDelayMs === undefined ? {} : { scheduledDelayMs }),
-    };
+    return omitUndefined({
+        file: observability.file,
+        samplingRatio: observability.samplingRatio,
+        retentionDays: observability.retentionDays,
+        maxQueueSize: batch.maxQueueSize,
+        maxExportBatchSize: batch.maxExportBatchSize,
+        scheduledDelayMs: batch.scheduledDelayMs,
+    });
 }
-function resolveMaybeCodeSubagents(value, config) {
+function resolveMaybeCodeSubagents(value, settings) {
     if (value === false)
         return false;
     if (value?.configuration !== undefined)
         return value;
-    const resolved = resolveSubagentConfiguration(config);
+    const resolved = resolveSubagentConfiguration(settings.subagents);
     if (resolved === false)
         return false;
     return { ...(value ?? {}), configuration: resolved };
@@ -503,63 +419,24 @@ function resolveDefaultModelPersistence(config, dependencies) {
     };
 }
 export function resolveMaybeCodeAutoCompactionMode(config) {
-    const value = config.apps?.[MAYBECODE_APPLICATION_ID]?.autoCompaction;
-    if (value === undefined)
-        return "prune-summary";
-    if (typeof value !== "object" || value === null || Array.isArray(value)) {
-        throw new MaybeCodeConfigError("apps.maybecode.autoCompaction must be an object");
-    }
-    const { mode, providerNative } = value;
-    if (providerNative !== undefined && typeof providerNative !== "boolean") {
-        throw new MaybeCodeConfigError("apps.maybecode.autoCompaction.providerNative must be a boolean");
-    }
-    if (mode === undefined)
-        return providerNative === true ? "provider-native" : "prune-summary";
-    if (mode !== "prune-summary" && mode !== "history-reference" && mode !== "provider-native") {
-        throw new MaybeCodeConfigError("apps.maybecode.autoCompaction.mode must be prune-summary, history-reference, or provider-native");
-    }
-    return mode;
-}
-/** @deprecated Use resolveMaybeCodeAutoCompactionMode instead. */
-export function resolveProviderNativeAutoCompaction(config) {
-    return resolveMaybeCodeAutoCompactionMode(config) === "provider-native";
+    return readMaybeCodeSettings(config).autoCompaction?.mode ?? "prune-summary";
 }
 export function resolveMaybeCodeRetry(config) {
-    const value = config.apps?.[MAYBECODE_APPLICATION_ID]?.retry;
-    if (value === undefined)
-        return {};
-    if (value === false)
+    const retry = readMaybeCodeSettings(config).retry;
+    if (retry === false)
         return false;
-    if (typeof value !== "object" || value === null || Array.isArray(value)) {
-        throw new MaybeCodeConfigError("apps.maybecode.retry must be false or an object");
-    }
-    const retry = value;
-    const maxAttempts = optionalPositiveInteger(retry.maxAttempts, "apps.maybecode.retry.maxAttempts");
-    const baseDelayMs = optionalNonNegativeNumber(retry.baseDelayMs, "apps.maybecode.retry.baseDelayMs");
-    const maxDelayMs = optionalNonNegativeNumber(retry.maxDelayMs, "apps.maybecode.retry.maxDelayMs");
-    const jitterRatio = optionalRatio(retry.jitterRatio, "apps.maybecode.retry.jitterRatio");
-    if ((baseDelayMs ?? 500) > (maxDelayMs ?? 8_000)) {
+    if ((retry?.baseDelayMs ?? 500) > (retry?.maxDelayMs ?? 8_000)) {
         throw new MaybeCodeConfigError("apps.maybecode.retry.baseDelayMs cannot exceed maxDelayMs");
     }
-    return {
-        ...(maxAttempts === undefined ? {} : { maxAttempts }),
-        ...(baseDelayMs === undefined ? {} : { baseDelayMs }),
-        ...(maxDelayMs === undefined ? {} : { maxDelayMs }),
-        ...(jitterRatio === undefined ? {} : { jitterRatio }),
-    };
+    return { ...retry };
 }
 function createContextBudget(model, selection) {
-    const contextWindowTokens = model.limits?.contextWindowTokens ??
-        selection.limits?.contextWindowTokens;
-    const outputReserveTokens = model.limits?.maxOutputTokens ??
-        selection.limits?.maxOutputTokens;
+    const contextWindowTokens = model.limits?.contextWindowTokens ?? selection.limits?.contextWindowTokens;
+    const outputReserveTokens = model.limits?.maxOutputTokens ?? selection.limits?.maxOutputTokens;
     if (contextWindowTokens === undefined && outputReserveTokens === undefined) {
         return undefined;
     }
-    return {
-        ...(contextWindowTokens === undefined ? {} : { contextWindowTokens }),
-        ...(outputReserveTokens === undefined ? {} : { outputReserveTokens }),
-    };
+    return omitUndefined({ contextWindowTokens, outputReserveTokens });
 }
 async function resolveWorkspace(workspace) {
     if (process.platform === "win32" && /^[A-Za-z]:(?:$|[^\\/])/u.test(workspace)) {
@@ -574,58 +451,11 @@ async function resolveWorkspace(workspace) {
     }
     return path;
 }
-function optionalPositiveInteger(value, field) {
-    if (value === undefined)
-        return undefined;
-    if (!Number.isSafeInteger(value) || value < 1) {
-        throw new MaybeCodeConfigError(`${field} must be a positive safe integer`);
-    }
-    return value;
-}
-function optionalNonNegativeNumber(value, field) {
-    if (value === undefined)
-        return undefined;
-    if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
-        throw new MaybeCodeConfigError(`${field} must be a non-negative number`);
-    }
-    return value;
-}
-function optionalRatio(value, field) {
-    const number = optionalNonNegativeNumber(value, field);
-    if (number !== undefined && number > 1) {
-        throw new MaybeCodeConfigError(`${field} must be between 0 and 1`);
-    }
-    return number;
-}
-function nonEmptyString(value, field) {
-    if (typeof value !== "string" || value.trim() === "") {
-        throw new MaybeCodeConfigError(`${field} must be a non-empty string`);
-    }
-    return value;
-}
-function objectValue(value, field) {
-    if (typeof value !== "object" || value === null || Array.isArray(value)) {
-        throw new MaybeCodeConfigError(`${field} must be an object`);
-    }
-    return value;
-}
-function optionalStringArray(value, field) {
-    if (value === undefined)
-        return undefined;
-    if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
-        throw new MaybeCodeConfigError(`${field} must be an array of strings`);
-    }
-    return [...value];
-}
-function resolveMcpEnvironment(value, field, environment) {
-    if (value === undefined)
+function resolveMcpEnvironment(configured, field, environment) {
+    if (configured === undefined)
         return undefined;
-    const configured = objectValue(value, field);
     const resolved = {};
     for (const [name, raw] of Object.entries(configured)) {
-        if (name === "" || typeof raw !== "string") {
-            throw new MaybeCodeConfigError(`${field} must contain string values`);
-        }
         resolved[name] = raw.replace(/\$\{([A-Za-z_][A-Za-z0-9_]*)\}/gu, (_match, environmentName) => {
             const replacement = environment[environmentName];
             if (replacement === undefined) {
@@ -636,11 +466,4 @@ function resolveMcpEnvironment(value, field, environment) {
     }
     return resolved;
 }
-function rejectUnknownOptions(value, allowed, field) {
-    const names = new Set(allowed);
-    const unknown = Object.keys(value).find((name) => !names.has(name));
-    if (unknown !== undefined) {
-        throw new MaybeCodeConfigError(`${field}.${unknown} is not supported`);
-    }
-}
 //# sourceMappingURL=configured.js.map