@abot-ai/runtime 1.0.0 → 1.2.0

package/dist/src/runtime/config/validation.js

@@ -1,477 +1,16 @@
-import { PATH_CONFIG_FIELDS, STRING_CONFIG_FIELDS, TIMEOUT_CONFIG_FIELDS, } from "./fields.js";
-import { hasOwnValue, isRecord } from "./utils.js";
-import { isRequestExecutionPolicyId, REQUEST_EXECUTION_POLICY_IDS, } from "./model-execution-policy.js";
-const ENV_VAR_NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
-export class RuntimeConfigValidationError extends Error {
-    configPath;
-    issues;
-    constructor(configPath, issues) {
-        super([
-            `Invalid runtime config at ${configPath}:`,
-            ...issues.map((issue) => `- ${issue}`),
-        ].join("\n"));
-        this.name = "RuntimeConfigValidationError";
-        this.configPath = configPath;
-        this.issues = issues;
-    }
-}
-function validateOptionalString(issues, record, key, displayKey = key) {
-    if (!hasOwnValue(record, key)) {
-        return;
-    }
-    const value = record[key];
-    if (typeof value !== "string" || value.trim().length === 0) {
-        issues.push(`${displayKey} must be a non-empty string`);
-    }
-}
-function validateOptionalSetupString(issues, record, key, displayKey, allowIncompleteSetup) {
-    const value = record[key];
-    if (allowIncompleteSetup &&
-        hasOwnValue(record, key) &&
-        typeof value === "string" &&
-        value.trim().length === 0) {
-        return;
-    }
-    validateOptionalString(issues, record, key, displayKey);
-}
-function validateOptionalEnvVarName(issues, record, key, displayKey = key) {
-    if (!hasOwnValue(record, key)) {
-        return;
-    }
-    const value = record[key];
-    if (typeof value !== "string" || value.trim().length === 0) {
-        issues.push(`${displayKey} must be a non-empty string`);
-        return;
-    }
-    if (!ENV_VAR_NAME_PATTERN.test(value.trim())) {
-        issues.push(`${displayKey} must be an environment variable name`);
-    }
-}
-function validateOptionalObject(issues, record, key, displayKey = key) {
-    if (!hasOwnValue(record, key)) {
-        return undefined;
-    }
-    const value = record[key];
-    if (!isRecord(value)) {
-        issues.push(`${displayKey} must be an object`);
-        return undefined;
-    }
-    return value;
-}
-function validateOptionalBoolean(issues, record, key, displayKey = key) {
-    if (!hasOwnValue(record, key)) {
-        return;
-    }
-    if (typeof record[key] !== "boolean") {
-        issues.push(`${displayKey} must be a boolean`);
-    }
-}
-function validateOptionalStringArray(issues, record, key, displayKey = key) {
-    if (!hasOwnValue(record, key)) {
-        return;
-    }
-    const value = record[key];
-    if (!Array.isArray(value)) {
-        issues.push(`${displayKey} must be an array of strings`);
-    }
-    else if (value.some((entry) => typeof entry !== "string")) {
-        issues.push(`${displayKey} must contain only strings`);
-    }
-}
-function validateOptionalModelModalityArray(issues, record, key, displayKey = key) {
-    if (!hasOwnValue(record, key)) {
-        return;
-    }
-    const value = record[key];
-    if (!Array.isArray(value)) {
-        issues.push(`${displayKey} must be an array of model modalities`);
-        return;
-    }
-    for (const entry of value) {
-        if (entry !== "text" && entry !== "image" && entry !== "audio") {
-            issues.push(`${displayKey} must contain only text, image, or audio`);
-            return;
-        }
-    }
-}
-function validateOptionalStringMap(issues, record, key, displayKey = key) {
-    if (!hasOwnValue(record, key)) {
-        return;
-    }
-    const value = record[key];
-    if (!isRecord(value)) {
-        issues.push(`${displayKey} must be an object`);
-        return;
-    }
-    for (const [entryKey, entryValue] of Object.entries(value)) {
-        if (typeof entryValue !== "string" || entryValue.trim().length === 0) {
-            issues.push(`${displayKey}.${entryKey} must be a non-empty string`);
-        }
-    }
-}
-function validateContext(issues, context, displayKey) {
-    if (hasOwnValue(context, "maxInputTokens")) {
-        issues.push(`${displayKey}.maxInputTokens is not supported; declare contextWindowTokens on the model profile`);
-    }
-    if (hasOwnValue(context, "maxConversationMessages")) {
-        issues.push(`${displayKey}.maxConversationMessages is not supported; current-session history is managed by runtime session memory`);
-    }
-    if (hasOwnValue(context, "maxToolObservationMessages")) {
-        issues.push(`${displayKey}.maxToolObservationMessages is not supported; tool observations are projected by their owning context contract`);
-    }
-    const formatTokenAccounting = validateOptionalObject(issues, context, "formatTokenAccounting", `${displayKey}.formatTokenAccounting`);
-    if (formatTokenAccounting) {
-        if (formatTokenAccounting.mode !== "none" &&
-            formatTokenAccounting.mode !== "estimate") {
-            issues.push(`${displayKey}.formatTokenAccounting.mode must be none or estimate`);
-        }
-        validateOptionalNonNegativeInteger(issues, formatTokenAccounting, "fixedOverheadTokens", `${displayKey}.formatTokenAccounting.fixedOverheadTokens`);
-    }
-    if (hasOwnValue(context, "artifactContextMode")) {
-        issues.push(`${displayKey}.artifactContextMode is not supported; artifact projection is owned by the capability context contract`);
-    }
-    const tokenEstimation = validateOptionalObject(issues, context, "tokenEstimation", `${displayKey}.tokenEstimation`);
-    if (tokenEstimation) {
-        validateOptionalPositiveNumber(issues, tokenEstimation, "asciiCharactersPerToken", `${displayKey}.tokenEstimation.asciiCharactersPerToken`);
-        validateOptionalPositiveNumber(issues, tokenEstimation, "nonAsciiBytesPerToken", `${displayKey}.tokenEstimation.nonAsciiBytesPerToken`);
-        validateOptionalPositiveNumber(issues, tokenEstimation, "messageOverheadTokens", `${displayKey}.tokenEstimation.messageOverheadTokens`);
-    }
-    if (hasOwnValue(context, "compaction")) {
-        issues.push(`${displayKey}.compaction is not supported; context compaction uses the runtime-owned 70 percent trigger`);
-    }
-}
-function validateGeneration(issues, generation, displayKey) {
-    if (hasOwnValue(generation, "maxOutputTokens")) {
-        issues.push(`${displayKey}.maxOutputTokens is not supported; remove it and let the provider enforce physical output capacity`);
-    }
-    validateOptionalNumber(issues, generation, "temperature", `${displayKey}.temperature`);
-    validateOptionalNumber(issues, generation, "topP", `${displayKey}.topP`);
-    if (hasOwnValue(generation, "reasoningEffort") &&
-        generation.reasoningEffort !== "none" &&
-        generation.reasoningEffort !== "minimal" &&
-        generation.reasoningEffort !== "low" &&
-        generation.reasoningEffort !== "medium" &&
-        generation.reasoningEffort !== "high" &&
-        generation.reasoningEffort !== "xhigh") {
-        issues.push(`${displayKey}.reasoningEffort must be none, minimal, low, medium, high, or xhigh`);
-    }
-}
-function validateOptionalInvocationProfiles(issues, record, key, displayKey) {
-    const invocationProfiles = validateOptionalObject(issues, record, key, displayKey);
-    if (!invocationProfiles) {
-        return;
-    }
-    for (const [profileId, profile] of Object.entries(invocationProfiles)) {
-        const profileKey = `${displayKey}.${profileId}`;
-        if (!isRecord(profile)) {
-            issues.push(`${profileKey} must be an object`);
-            continue;
-        }
-        validateOptionalString(issues, profile, "profileId", `${profileKey}.profileId`);
-        if (!hasOwnValue(profile, "profileId")) {
-            issues.push(`${profileKey}.profileId must be a non-empty string`);
-        }
-        const generation = validateOptionalObject(issues, profile, "generation", `${profileKey}.generation`);
-        if (generation) {
-            validateGeneration(issues, generation, `${profileKey}.generation`);
-        }
-        const context = validateOptionalObject(issues, profile, "context", `${profileKey}.context`);
-        if (context) {
-            validateContext(issues, context, `${profileKey}.context`);
-        }
-        if (hasOwnValue(profile, "format") &&
-            profile.format !== "json" &&
-            !isRecord(profile.format)) {
-            issues.push(`${profileKey}.format must be json or an object`);
-        }
-    }
-}
-function validateOptionalModelCalibrations(issues, record, key, displayKey) {
-    const calibrations = validateOptionalObject(issues, record, key, displayKey);
-    if (!calibrations) {
-        return;
-    }
-    for (const [slotId, calibration] of Object.entries(calibrations)) {
-        const slotKey = `${displayKey}.${slotId}`;
-        if (!isRecord(calibration)) {
-            issues.push(`${slotKey} must be an object`);
-            continue;
-        }
-        validateOptionalString(issues, calibration, "name", `${slotKey}.name`);
-        validateOptionalString(issues, calibration, "description", `${slotKey}.description`);
-        validateOptionalString(issues, calibration, "profileId", `${slotKey}.profileId`);
-        validateOptionalPositiveInteger(issues, calibration, "timeoutMs", `${slotKey}.timeoutMs`);
-        const generation = validateOptionalObject(issues, calibration, "generation", `${slotKey}.generation`);
-        if (generation) {
-            validateGeneration(issues, generation, `${slotKey}.generation`);
-        }
-        const context = validateOptionalObject(issues, calibration, "context", `${slotKey}.context`);
-        if (context) {
-            validateContext(issues, context, `${slotKey}.context`);
-        }
-        if (hasOwnValue(calibration, "format") &&
-            calibration.format !== "json" &&
-            !isRecord(calibration.format)) {
-            issues.push(`${slotKey}.format must be json or an object`);
-        }
-        validateOptionalStringArray(issues, calibration, "instructions", `${slotKey}.instructions`);
-    }
-}
-function validateOptionalNumber(issues, record, key, displayKey = key) {
-    if (!hasOwnValue(record, key)) {
-        return;
-    }
-    if (typeof record[key] !== "number" || !Number.isFinite(record[key])) {
-        issues.push(`${displayKey} must be a number`);
-    }
-}
-function validateOptionalPositiveNumber(issues, record, key, displayKey = key) {
-    if (!hasOwnValue(record, key)) {
-        return;
-    }
-    const value = record[key];
-    if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
-        issues.push(`${displayKey} must be a positive number`);
-    }
-}
-function validateOptionalPositiveInteger(issues, record, key, displayKey = key) {
-    if (!hasOwnValue(record, key)) {
-        return;
-    }
-    const value = record[key];
-    if (typeof value !== "number" ||
-        !Number.isFinite(value) ||
-        value <= 0 ||
-        !Number.isInteger(value)) {
-        issues.push(`${displayKey} must be a positive integer`);
-    }
-}
-function validateOptionalNonNegativeInteger(issues, record, key, displayKey = key) {
-    if (!hasOwnValue(record, key)) {
-        return;
-    }
-    const value = record[key];
-    if (typeof value !== "number" ||
-        !Number.isFinite(value) ||
-        value < 0 ||
-        !Number.isInteger(value)) {
-        issues.push(`${displayKey} must be a non-negative integer`);
-    }
-}
-export function validateModelProfileConfig(issues, profile, displayKey, options = { allowConfigRef: true }) {
-    validateOptionalSetupString(issues, profile, "configRef", `${displayKey}.configRef`, options.allowIncompleteSetup === true);
-    validateOptionalString(issues, profile, "label", `${displayKey}.label`);
-    validateOptionalSetupString(issues, profile, "provider", `${displayKey}.provider`, options.allowIncompleteSetup === true);
-    validateOptionalSetupString(issues, profile, "model", `${displayKey}.model`, options.allowIncompleteSetup === true);
-    validateOptionalPositiveInteger(issues, profile, "contextWindowTokens", `${displayKey}.contextWindowTokens`);
-    if (hasOwnValue(profile, "contextWindowTokens") &&
-        typeof profile.contextWindowTokens === "number" &&
-        !Number.isSafeInteger(profile.contextWindowTokens)) {
-        issues.push(`${displayKey}.contextWindowTokens must be a safe integer`);
-    }
-    if (!options.allowIncompleteSetup) {
-        if (options.allowConfigRef) {
-            if (!hasOwnValue(profile, "model") &&
-                !hasOwnValue(profile, "configRef")) {
-                issues.push(`${displayKey}.model or configRef must be provided`);
-            }
-        }
-        else if (!hasOwnValue(profile, "model")) {
-            issues.push(`${displayKey}.model must be provided`);
-        }
-        if ((!options.allowConfigRef || !hasOwnValue(profile, "configRef")) &&
-            !hasOwnValue(profile, "contextWindowTokens")) {
-            issues.push(`${displayKey}.contextWindowTokens must be provided`);
-        }
-    }
-    validateOptionalBoolean(issues, profile, "supportsThinking", `${displayKey}.supportsThinking`);
-    if (hasOwnValue(profile, "options") && !isRecord(profile.options)) {
-        issues.push(`${displayKey}.options must be an object`);
-    }
-    const capabilities = validateOptionalObject(issues, profile, "capabilities", `${displayKey}.capabilities`);
-    if (capabilities) {
-        validateOptionalModelModalityArray(issues, capabilities, "inputModalities", `${displayKey}.capabilities.inputModalities`);
-        validateOptionalModelModalityArray(issues, capabilities, "outputModalities", `${displayKey}.capabilities.outputModalities`);
-    }
-    const generation = validateOptionalObject(issues, profile, "generation", `${displayKey}.generation`);
-    if (generation) {
-        validateGeneration(issues, generation, `${displayKey}.generation`);
-    }
-    const context = validateOptionalObject(issues, profile, "context", `${displayKey}.context`);
-    if (context) {
-        validateContext(issues, context, `${displayKey}.context`);
-    }
-    const execution = validateOptionalObject(issues, profile, "execution", `${displayKey}.execution`);
-    if (execution) {
-        const keys = Object.keys(execution);
-        if (keys.some((key) => key !== "policy")) {
-            issues.push(`${displayKey}.execution may contain only: policy`);
-        }
-        if (hasOwnValue(execution, "policy") &&
-            !isRequestExecutionPolicyId(execution.policy)) {
-            issues.push(`${displayKey}.execution.policy must be one of: ${REQUEST_EXECUTION_POLICY_IDS.join(", ")}`);
-        }
-    }
-    validateOptionalModelCalibrations(issues, profile, "calibration", `${displayKey}.calibration`);
-}
-function validatePathConfigRecord(issues, paths, displayKey) {
-    for (const field of PATH_CONFIG_FIELDS) {
-        validateOptionalString(issues, paths, field.key, `${displayKey}.${field.key}`);
-    }
-}
-function validateEnvironmentConfig(issues, environment) {
-    validateOptionalString(issues, environment, "default", "environment.default");
-    const basePaths = validateOptionalObject(issues, environment, "paths", "environment.paths");
-    if (basePaths) {
-        validatePathConfigRecord(issues, basePaths, "environment.paths");
-    }
-    const profiles = validateOptionalObject(issues, environment, "profiles", "environment.profiles");
-    if (!profiles) {
-        return;
-    }
-    for (const [profileId, profile] of Object.entries(profiles)) {
-        if (!isRecord(profile)) {
-            issues.push(`environment.profiles.${profileId} must be an object`);
-            continue;
-        }
-        const paths = validateOptionalObject(issues, profile, "paths", `environment.profiles.${profileId}.paths`);
-        if (paths) {
-            validatePathConfigRecord(issues, paths, `environment.profiles.${profileId}.paths`);
-        }
-    }
-    const defaultProfileId = typeof environment.default === "string" ? environment.default.trim() : "";
-    if (defaultProfileId && !hasOwnValue(profiles, defaultProfileId)) {
-        issues.push("environment.default must match a key under environment.profiles");
-    }
-}
-function validateLoggingConfig(issues, logging) {
-    validateOptionalBoolean(issues, logging, "enabled", "logging.enabled");
-    const rotation = validateOptionalObject(issues, logging, "rotation", "logging.rotation");
-    if (!rotation) {
-        return;
-    }
-    for (const key of ["maxFileSizeMb", "maxFiles", "maxAgeDays"]) {
-        validateOptionalPositiveNumber(issues, rotation, key, `logging.rotation.${key}`);
-    }
-}
-function validateWebUiConfig(issues, webUi) {
-    validateOptionalBoolean(issues, webUi, "openOnRuntimeServiceStart", "webUi.openOnRuntimeServiceStart");
-    for (const key of Object.keys(webUi)) {
-        if (key !== "openOnRuntimeServiceStart") {
-            issues.push(`webUi.${key} is not a supported configuration field`);
-        }
-    }
-}
-function validateWebUiConfigSection(issues, config) {
-    const webUi = validateOptionalObject(issues, config, "webUi");
-    if (webUi) {
-        validateWebUiConfig(issues, webUi);
-    }
-}
-export function validateRuntimeWebUiConfig(config, configPath) {
-    const issues = [];
-    validateWebUiConfigSection(issues, config);
-    if (issues.length > 0) {
-        throw new RuntimeConfigValidationError(configPath, issues);
-    }
-}
-function validatePluginConfig(issues, plugins) {
-    validateOptionalBoolean(issues, plugins, "enabled", "plugins.enabled");
-    validateOptionalStringArray(issues, plugins, "allow", "plugins.allow");
-    validateOptionalStringArray(issues, plugins, "deny", "plugins.deny");
-    for (const key of Object.keys(plugins)) {
-        if (key !== "enabled" && key !== "allow" && key !== "deny") {
-            issues.push(`plugins.${key} is not a supported configuration field`);
-        }
-    }
-}
-function validateModelConfig(issues, models, options = {}) {
-    const providers = validateOptionalObject(issues, models, "providers");
-    if (providers) {
-        if (Object.keys(providers).length === 0 && !options.allowIncompleteSetup) {
-            issues.push("models.providers must declare at least one provider");
-        }
-        for (const [providerId, provider] of Object.entries(providers)) {
-            const providerKey = `models.providers.${providerId}`;
-            if (providerId.trim().length === 0) {
-                issues.push("models.providers keys must be non-empty strings");
-            }
-            if (!isRecord(provider)) {
-                issues.push(`${providerKey} must be an object`);
-                continue;
-            }
-            const providerTypeIsIncomplete = options.allowIncompleteSetup === true &&
-                (!hasOwnValue(provider, "type") ||
-                    (typeof provider.type === "string" &&
-                        provider.type.trim().length === 0));
-            if (!providerTypeIsIncomplete &&
-                (!hasOwnValue(provider, "type") ||
-                    typeof provider.type !== "string" ||
-                    !/^[A-Za-z][A-Za-z0-9._-]*$/u.test(provider.type.trim()))) {
-                issues.push(`${providerKey}.type must be a provider adapter identifier`);
-            }
-            validateOptionalString(issues, provider, "baseUrl", `${providerKey}.baseUrl`);
-            validateOptionalEnvVarName(issues, provider, "apiKeyEnv", `${providerKey}.apiKeyEnv`);
-            validateOptionalString(issues, provider, "keepAlive", `${providerKey}.keepAlive`);
-            validateOptionalObject(issues, provider, "settings", `${providerKey}.settings`);
-        }
-    }
-    else if (!hasOwnValue(models, "providers") &&
-        !options.allowIncompleteSetup) {
-        issues.push("models.providers must declare at least one provider");
-    }
-    const profiles = validateOptionalObject(issues, models, "profiles");
-    if (profiles) {
-        if (Object.keys(profiles).length === 0 && !options.allowIncompleteSetup) {
-            issues.push("models.profiles must declare at least one model profile");
-        }
-        for (const [profileId, profile] of Object.entries(profiles)) {
-            if (profileId.trim().length === 0) {
-                issues.push("models.profiles keys must be non-empty strings");
-            }
-            if (!isRecord(profile)) {
-                issues.push(`models.profiles.${profileId} must be an object`);
-                continue;
-            }
-            validateModelProfileConfig(issues, profile, `models.profiles.${profileId}`, {
-                allowConfigRef: true,
-                allowIncompleteSetup: options.allowIncompleteSetup,
-            });
-        }
-    }
-    else if (!hasOwnValue(models, "profiles") &&
-        !options.allowIncompleteSetup) {
-        issues.push("models.profiles must declare at least one model profile");
-    }
-    validateOptionalInvocationProfiles(issues, models, "invocationProfiles", "models.invocationProfiles");
-    const defaults = validateOptionalObject(issues, models, "defaults");
-    if (!defaults) {
-        return;
-    }
-    validateOptionalBoolean(issues, defaults, "overrideClientPreference", "models.defaults.overrideClientPreference");
-    validateOptionalString(issues, defaults, "profileId", "models.defaults.profileId");
-    validateOptionalStringMap(issues, defaults, "roles", "models.defaults.roles");
-    validateOptionalStringMap(issues, defaults, "steps", "models.defaults.steps");
-    const defaultContext = validateOptionalObject(issues, defaults, "context", "models.defaults.context");
-    if (defaultContext) {
-        validateContext(issues, defaultContext, "models.defaults.context");
-    }
-}
-function validateRootRequestRunnerConfig(issues, requestRunner, options = {}) {
-    const keys = Object.keys(requestRunner);
-    const unsupportedKeys = keys.filter((key) => key !== "configRef");
-    if (unsupportedKeys.length > 0 ||
-        (!options.allowIncompleteSetup && keys.length !== 1)) {
-        issues.push("requestRunner must contain exactly: configRef");
-    }
-    if (!hasOwnValue(requestRunner, "configRef")) {
-        if (!options.allowIncompleteSetup) {
-            issues.push("requestRunner.configRef is required");
-        }
-        return;
-    }
-    validateOptionalSetupString(issues, requestRunner, "configRef", "requestRunner.configRef", options.allowIncompleteSetup === true);
-}
+import { STRING_CONFIG_FIELDS } from "./fields.js";
+import { validateLongTermMemoryConfig } from "./long-term-memory.js";
+import { hasOwnValue } from "./utils.js";
+import { validateEnvironmentConfig } from "./validation/environment-config-validation.js";
+import { validateModelConfig } from "./validation/model-registry-validation.js";
+import { validatePathConfigRecord } from "./validation/path-config-validation.js";
+import { validateOptionalObject, validateOptionalString, } from "./validation/runtime-config-field-validation.js";
+import { RuntimeConfigValidationError, } from "./validation/runtime-config-validation-contract.js";
+import { validateFeatureFlagSections, validateLoggingConfig, validatePluginConfig, validateRootRequestRunnerConfig, validateRuntimeTimeouts, } from "./validation/runtime-root-section-validation.js";
+import { validateWebUiConfigSection } from "./validation/web-ui-config-validation.js";
+export { validateModelProfileConfig } from "./validation/model-profile-validation.js";
+export { validateRuntimeWebUiConfig } from "./validation/web-ui-config-validation.js";
+export { RuntimeConfigValidationError };
 export function validateRuntimeConfigFile(config, configPath, options = {}) {
     const issues = [];
     const record = config;
@@ -485,6 +24,7 @@ export function validateRuntimeConfigFile(config, configPath, options = {}) {
         "logging",
         "timeouts",
         "plugins",
+        "longTermMemory",
         "models",
         "requestRunner",
         "features",
@@ -509,15 +49,7 @@ export function validateRuntimeConfigFile(config, configPath, options = {}) {
     }
     const timeouts = validateOptionalObject(issues, record, "timeouts");
     if (timeouts) {
-        for (const field of TIMEOUT_CONFIG_FIELDS) {
-            if (!hasOwnValue(timeouts, field.key)) {
-                continue;
-            }
-            const value = timeouts[field.key];
-            if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
-                issues.push(`timeouts.${field.key} must be a positive number`);
-            }
-        }
+        validateRuntimeTimeouts(issues, timeouts);
     }
     const logging = validateOptionalObject(issues, record, "logging");
     if (logging) {
@@ -531,30 +63,26 @@ export function validateRuntimeConfigFile(config, configPath, options = {}) {
     if (models) {
         validateModelConfig(issues, models, options);
     }
-    else if (!hasOwnValue(record, "models") && !options.allowIncompleteSetup) {
+    const requiredModelsAreMissing = !models && !hasOwnValue(record, "models") && !options.allowIncompleteSetup;
+    if (requiredModelsAreMissing) {
         issues.push("models is required");
     }
+    validateLongTermMemoryConfig({
+        issues,
+        value: record.longTermMemory,
+        embeddingProfiles: models?.embeddingProfiles,
+    });
     const requestRunner = validateOptionalObject(issues, record, "requestRunner");
     if (requestRunner) {
         validateRootRequestRunnerConfig(issues, requestRunner, options);
     }
-    else if (!hasOwnValue(record, "requestRunner") &&
-        !options.allowIncompleteSetup) {
+    const requiredRequestRunnerIsMissing = !requestRunner &&
+        !hasOwnValue(record, "requestRunner") &&
+        !options.allowIncompleteSetup;
+    if (requiredRequestRunnerIsMissing) {
         issues.push("requestRunner.configRef is required");
     }
-    for (const key of ["features", "featureFlags"]) {
-        const flags = validateOptionalObject(issues, record, key);
-        if (!flags) {
-            continue;
-        }
-        for (const [flagName, value] of Object.entries(flags)) {
-            if (typeof value !== "boolean" &&
-                typeof value !== "number" &&
-                typeof value !== "string") {
-                issues.push(`${key}.${flagName} must be a boolean, number, or string`);
-            }
-        }
-    }
+    validateFeatureFlagSections(issues, record);
     if (issues.length > 0) {
         throw new RuntimeConfigValidationError(configPath, issues);
     }

package/dist/src/runtime/config.js

@@ -2,6 +2,7 @@ import { join } from "node:path";
 import { DEFAULT_RUNTIME_ID, DEFAULT_MODEL_GATEWAY_URL, } from "../shared/constants.js";
 import { loadDotEnvFile } from "../shared/load-dotenv.js";
 import { buildFeatureFlags, buildLoggingConfig, buildRuntimeModelConfiguration, buildPluginConfig, compactTimeouts, } from "./config/builders.js";
+import { buildLongTermMemoryConfig } from "./config/long-term-memory.js";
 import { DEFAULT_RUNTIME_AGENT_BRIDGE_URL, DEFAULT_RUNTIME_CONFIG_FILE, } from "./config/constants.js";
 import { validateEffectiveRuntimeModelConfig } from "./config/effective-model-config-validation.js";
 import { resolveRuntimeEnvironmentProfileSelection } from "./config/environment.js";
@@ -103,6 +104,7 @@ export function loadRuntimeConfig(options = {}) {
         }),
     });
     const loggingConfig = buildLoggingConfig(fileConfig, env);
+    const longTermMemory = buildLongTermMemoryConfig(fileConfig);
     const agentBridgeToken = readFirstString(env, ["AGENT_BRIDGE_TOKEN"]) ??
         readConfigString(fileConfig, "agentBridgeToken");
     return {
@@ -152,6 +154,7 @@ export function loadRuntimeConfig(options = {}) {
         logging: loggingConfig,
         ...(timeouts ? { timeouts } : {}),
         ...(pluginConfig ? { plugins: pluginConfig } : {}),
+        longTermMemory,
         ...(modelConfiguration.modelPolicy
             ? { models: modelConfiguration.modelPolicy }
             : {}),

package/dist/src/runtime/context/accepted-capability-action.d.ts

@@ -0,0 +1,11 @@
+import type { CapabilityJsonObject } from "../orchestration/capability-adapters/result.js";
+import type { RoleCallLedgerHead, RoleCapabilityExecution } from "../orchestration/role-calls/index.js";
+export type AcceptedCapabilityAction = Readonly<{
+    executionId: string;
+    capabilityId: string;
+    controls: CapabilityJsonObject;
+    declaredEffect: RoleCapabilityExecution["declaredEffect"];
+    workingDirectory: string | null;
+}>;
+/** Projects the exact non-payload controls committed with one execution. */
+export declare function projectAcceptedCapabilityAction(head: RoleCallLedgerHead, execution: RoleCapabilityExecution): AcceptedCapabilityAction;

package/dist/src/runtime/context/accepted-capability-action.js

@@ -0,0 +1,29 @@
+/** Projects the exact non-payload controls committed with one execution. */
+export function projectAcceptedCapabilityAction(head, execution) {
+    const originCall = head.state.calls.find(({ callId }) => callId === execution.callId);
+    if (!originCall) {
+        throw new Error("accepted_capability_action_origin_call_invalid");
+    }
+    return Object.freeze({
+        executionId: execution.executionId,
+        capabilityId: execution.capabilityId,
+        controls: parseAcceptedControls(execution.controlsJson),
+        declaredEffect: execution.declaredEffect,
+        workingDirectory: originCall.workingDirectory ?? null,
+    });
+}
+function parseAcceptedControls(controlsJson) {
+    let decoded;
+    try {
+        decoded = JSON.parse(controlsJson);
+    }
+    catch {
+        throw new Error("accepted_capability_action_controls_invalid");
+    }
+    if (decoded === null ||
+        typeof decoded !== "object" ||
+        Array.isArray(decoded)) {
+        throw new Error("accepted_capability_action_controls_invalid");
+    }
+    return Object.freeze(decoded);
+}

package/dist/src/runtime/context/capability-brief.d.ts

@@ -0,0 +1,25 @@
+import type { ChatMessage } from "../../model-gateway/types.js";
+import type { ToolAvailabilityEntry } from "../../capabilities/tool-types.js";
+import { type ToolAvailabilityOverviewGroup, type ToolAvailabilityOverviewLevel } from "../../plugin-sdk/tool-availability-overview.js";
+import type { projectRequestContext } from "./request-context.js";
+export declare const CAPABILITY_BRIEF_KIND = "runtime_capability_brief_v1";
+export declare const CAPABILITY_BRIEF_MAX_TOKENS = 512;
+export type CapabilityBriefLevel = ToolAvailabilityOverviewLevel | "none";
+export type CapabilityBriefProjection = Readonly<{
+    level: CapabilityBriefLevel;
+    message?: ChatMessage;
+    estimatedTokens: number;
+    budgetTokens: number;
+    reason: "complete_catalog" | "empty_catalog" | "insufficient_budget";
+}>;
+type ContextInput = Parameters<typeof projectRequestContext>[0];
+/** Optional availability metadata admitted against the full context estimate. */
+export declare function projectCapabilityBrief(params: Readonly<{
+    entries?: readonly ToolAvailabilityEntry[];
+    groups: readonly ToolAvailabilityOverviewGroup[];
+    context: ContextInput;
+    additionalBudgetMessages?: readonly ChatMessage[];
+}>): CapabilityBriefProjection;
+/** Consumers explicitly remove this optional reference at narrower phases. */
+export declare function isCapabilityBriefMessage(message: ChatMessage): boolean;
+export {};