@abot-ai/runtime 1.0.0 → 1.2.0

package/dist/src/runtime/config/validation/model-profile-validation.js

@@ -0,0 +1,87 @@
+import { isRequestExecutionPolicyId, REQUEST_EXECUTION_POLICY_IDS, } from "../model-execution-policy.js";
+import { hasOwnValue, isRecord } from "../utils.js";
+import { validateModelContextConfig, validateModelGenerationConfig, } from "./model-invocation-config-validation.js";
+import { validateOptionalModelCalibrations } from "./model-invocation-override-validation.js";
+import { validateOptionalBoolean, validateOptionalModelModalityArray, validateOptionalObject, validateOptionalPositiveInteger, validateOptionalSetupString, validateOptionalString, } from "./runtime-config-field-validation.js";
+function hasUnsafeContextWindowTokenCount(profile) {
+    if (!hasOwnValue(profile, "contextWindowTokens")) {
+        return false;
+    }
+    if (typeof profile.contextWindowTokens !== "number") {
+        return false;
+    }
+    return !Number.isSafeInteger(profile.contextWindowTokens);
+}
+function validateRequiredModelReference(issues, profile, displayKey, allowConfigRef) {
+    const modelIsMissing = !hasOwnValue(profile, "model");
+    const configRefIsMissing = !hasOwnValue(profile, "configRef");
+    const modelOrConfigRefIsRequired = allowConfigRef && modelIsMissing && configRefIsMissing;
+    if (modelOrConfigRefIsRequired) {
+        issues.push(`${displayKey}.model or configRef must be provided`);
+    }
+    const directModelIsRequired = !allowConfigRef && modelIsMissing;
+    if (directModelIsRequired) {
+        issues.push(`${displayKey}.model must be provided`);
+    }
+}
+function validateRequiredContextWindowTokens(issues, profile, displayKey, allowConfigRef) {
+    const configRefProvidesProfileDefinition = allowConfigRef && hasOwnValue(profile, "configRef");
+    const contextWindowTokensAreMissing = !hasOwnValue(profile, "contextWindowTokens");
+    if (!configRefProvidesProfileDefinition && contextWindowTokensAreMissing) {
+        issues.push(`${displayKey}.contextWindowTokens must be provided`);
+    }
+}
+function validateRequiredModelProfileFields(issues, profile, displayKey, allowConfigRef, allowIncompleteSetup) {
+    if (allowIncompleteSetup) {
+        return;
+    }
+    validateRequiredModelReference(issues, profile, displayKey, allowConfigRef);
+    validateRequiredContextWindowTokens(issues, profile, displayKey, allowConfigRef);
+}
+function validateModelProfileCapabilities(issues, capabilities, displayKey) {
+    validateOptionalModelModalityArray(issues, capabilities, "inputModalities", `${displayKey}.inputModalities`);
+    validateOptionalModelModalityArray(issues, capabilities, "outputModalities", `${displayKey}.outputModalities`);
+}
+function validateModelExecutionPolicy(issues, execution, displayKey) {
+    const hasUnsupportedExecutionField = Object.keys(execution).some((key) => key !== "policy");
+    if (hasUnsupportedExecutionField) {
+        issues.push(`${displayKey} may contain only: policy`);
+    }
+    const hasUnsupportedExecutionPolicy = hasOwnValue(execution, "policy") &&
+        !isRequestExecutionPolicyId(execution.policy);
+    if (hasUnsupportedExecutionPolicy) {
+        issues.push(`${displayKey}.policy must be one of: ${REQUEST_EXECUTION_POLICY_IDS.join(", ")}`);
+    }
+}
+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 (hasUnsafeContextWindowTokenCount(profile)) {
+        issues.push(`${displayKey}.contextWindowTokens must be a safe integer`);
+    }
+    validateRequiredModelProfileFields(issues, profile, displayKey, options.allowConfigRef, options.allowIncompleteSetup);
+    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) {
+        validateModelProfileCapabilities(issues, capabilities, `${displayKey}.capabilities`);
+    }
+    const generation = validateOptionalObject(issues, profile, "generation", `${displayKey}.generation`);
+    if (generation) {
+        validateModelGenerationConfig(issues, generation, `${displayKey}.generation`);
+    }
+    const context = validateOptionalObject(issues, profile, "context", `${displayKey}.context`);
+    if (context) {
+        validateModelContextConfig(issues, context, `${displayKey}.context`);
+    }
+    const execution = validateOptionalObject(issues, profile, "execution", `${displayKey}.execution`);
+    if (execution) {
+        validateModelExecutionPolicy(issues, execution, `${displayKey}.execution`);
+    }
+    validateOptionalModelCalibrations(issues, profile, "calibration", `${displayKey}.calibration`);
+}

package/dist/src/runtime/config/validation/model-registry-validation.d.ts

@@ -0,0 +1,2 @@
+import type { RuntimeConfigValidationOptions } from "./runtime-config-validation-contract.js";
+export declare function validateModelConfig(issues: string[], models: Record<string, unknown>, options?: RuntimeConfigValidationOptions): void;

package/dist/src/runtime/config/validation/model-registry-validation.js

@@ -0,0 +1,118 @@
+import { validateEmbeddingProfiles } from "../embedding-profiles.js";
+import { hasOwnValue, isRecord } from "../utils.js";
+import { validateModelContextConfig } from "./model-invocation-config-validation.js";
+import { validateOptionalInvocationProfiles } from "./model-invocation-override-validation.js";
+import { validateModelProfileConfig } from "./model-profile-validation.js";
+import { validateOptionalBoolean, validateOptionalEnvVarName, validateOptionalObject, validateOptionalString, validateOptionalStringMap, } from "./runtime-config-field-validation.js";
+const PROVIDER_ADAPTER_IDENTIFIER_PATTERN = /^[A-Za-z][A-Za-z0-9._-]*$/u;
+function isAllowedIncompleteProviderType(provider, options) {
+    if (options.allowIncompleteSetup !== true) {
+        return false;
+    }
+    if (!hasOwnValue(provider, "type")) {
+        return true;
+    }
+    if (typeof provider.type !== "string") {
+        return false;
+    }
+    return provider.type.trim().length === 0;
+}
+function hasInvalidProviderAdapterIdentifier(provider, options) {
+    if (isAllowedIncompleteProviderType(provider, options)) {
+        return false;
+    }
+    if (!hasOwnValue(provider, "type")) {
+        return true;
+    }
+    if (typeof provider.type !== "string") {
+        return true;
+    }
+    return !PROVIDER_ADAPTER_IDENTIFIER_PATTERN.test(provider.type.trim());
+}
+function validateProviderEntry(issues, providerId, provider, options) {
+    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`);
+        return;
+    }
+    if (hasInvalidProviderAdapterIdentifier(provider, options)) {
+        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`);
+}
+function validateModelProviders(issues, models, options) {
+    const providers = validateOptionalObject(issues, models, "providers");
+    const requiredProvidersAreMissing = !hasOwnValue(models, "providers") && !options.allowIncompleteSetup;
+    if (requiredProvidersAreMissing) {
+        issues.push("models.providers must declare at least one provider");
+    }
+    if (!providers) {
+        return;
+    }
+    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)) {
+        validateProviderEntry(issues, providerId, provider, options);
+    }
+}
+function validateModelProfileEntry(issues, profileId, profile, options) {
+    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`);
+        return;
+    }
+    validateModelProfileConfig(issues, profile, `models.profiles.${profileId}`, {
+        allowConfigRef: true,
+        allowIncompleteSetup: options.allowIncompleteSetup,
+    });
+}
+function validateModelProfiles(issues, models, options) {
+    const profiles = validateOptionalObject(issues, models, "profiles");
+    const requiredProfilesAreMissing = !hasOwnValue(models, "profiles") && !options.allowIncompleteSetup;
+    if (requiredProfilesAreMissing) {
+        issues.push("models.profiles must declare at least one model profile");
+    }
+    if (!profiles) {
+        return;
+    }
+    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)) {
+        validateModelProfileEntry(issues, profileId, profile, options);
+    }
+}
+function validateModelDefaults(issues, models) {
+    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) {
+        validateModelContextConfig(issues, defaultContext, "models.defaults.context");
+    }
+}
+export function validateModelConfig(issues, models, options = {}) {
+    validateModelProviders(issues, models, options);
+    validateModelProfiles(issues, models, options);
+    validateOptionalInvocationProfiles(issues, models, "invocationProfiles", "models.invocationProfiles");
+    validateEmbeddingProfiles({
+        issues,
+        models,
+        allowIncompleteSetup: options.allowIncompleteSetup === true,
+    });
+    validateModelDefaults(issues, models);
+}

package/dist/src/runtime/config/validation/path-config-validation.d.ts

@@ -0,0 +1 @@
+export declare function validatePathConfigRecord(issues: string[], paths: Record<string, unknown>, displayKey: string): void;

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

@@ -0,0 +1,7 @@
+import { PATH_CONFIG_FIELDS } from "../fields.js";
+import { validateOptionalString } from "./runtime-config-field-validation.js";
+export function validatePathConfigRecord(issues, paths, displayKey) {
+    for (const field of PATH_CONFIG_FIELDS) {
+        validateOptionalString(issues, paths, field.key, `${displayKey}.${field.key}`);
+    }
+}

package/dist/src/runtime/config/validation/runtime-config-field-validation.d.ts

@@ -0,0 +1,12 @@
+export declare function validateOptionalString(issues: string[], record: Record<string, unknown>, key: string, displayKey?: string): void;
+export declare function validateOptionalSetupString(issues: string[], record: Record<string, unknown>, key: string, displayKey: string, allowIncompleteSetup: boolean): void;
+export declare function validateOptionalEnvVarName(issues: string[], record: Record<string, unknown>, key: string, displayKey?: string): void;
+export declare function validateOptionalObject(issues: string[], record: Record<string, unknown>, key: string, displayKey?: string): Record<string, unknown> | undefined;
+export declare function validateOptionalBoolean(issues: string[], record: Record<string, unknown>, key: string, displayKey?: string): void;
+export declare function validateOptionalStringArray(issues: string[], record: Record<string, unknown>, key: string, displayKey?: string): void;
+export declare function validateOptionalModelModalityArray(issues: string[], record: Record<string, unknown>, key: string, displayKey?: string): void;
+export declare function validateOptionalStringMap(issues: string[], record: Record<string, unknown>, key: string, displayKey?: string): void;
+export declare function validateOptionalNumber(issues: string[], record: Record<string, unknown>, key: string, displayKey?: string): void;
+export declare function validateOptionalPositiveNumber(issues: string[], record: Record<string, unknown>, key: string, displayKey?: string): void;
+export declare function validateOptionalPositiveInteger(issues: string[], record: Record<string, unknown>, key: string, displayKey?: string): void;
+export declare function validateOptionalNonNegativeInteger(issues: string[], record: Record<string, unknown>, key: string, displayKey?: string): void;

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

@@ -0,0 +1,158 @@
+import { hasOwnValue, isRecord } from "../utils.js";
+const ENV_VAR_NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
+function isNonEmptyConfigString(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
+function isAllowedIncompleteSetupString(record, key, allowIncompleteSetup) {
+    if (!allowIncompleteSetup) {
+        return false;
+    }
+    if (!hasOwnValue(record, key)) {
+        return false;
+    }
+    const value = record[key];
+    return typeof value === "string" && value.trim().length === 0;
+}
+function isFiniteNumber(value) {
+    return typeof value === "number" && Number.isFinite(value);
+}
+function isPositiveNumber(value) {
+    if (!isFiniteNumber(value)) {
+        return false;
+    }
+    return value > 0;
+}
+function isPositiveInteger(value) {
+    if (!isPositiveNumber(value)) {
+        return false;
+    }
+    return Number.isInteger(value);
+}
+function isNonNegativeInteger(value) {
+    if (!isFiniteNumber(value) || value < 0) {
+        return false;
+    }
+    return Number.isInteger(value);
+}
+export function validateOptionalString(issues, record, key, displayKey = key) {
+    if (!hasOwnValue(record, key)) {
+        return;
+    }
+    if (!isNonEmptyConfigString(record[key])) {
+        issues.push(`${displayKey} must be a non-empty string`);
+    }
+}
+export function validateOptionalSetupString(issues, record, key, displayKey, allowIncompleteSetup) {
+    if (isAllowedIncompleteSetupString(record, key, allowIncompleteSetup)) {
+        return;
+    }
+    validateOptionalString(issues, record, key, displayKey);
+}
+export function validateOptionalEnvVarName(issues, record, key, displayKey = key) {
+    if (!hasOwnValue(record, key)) {
+        return;
+    }
+    const value = record[key];
+    if (!isNonEmptyConfigString(value)) {
+        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`);
+    }
+}
+export 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;
+}
+export function validateOptionalBoolean(issues, record, key, displayKey = key) {
+    if (!hasOwnValue(record, key)) {
+        return;
+    }
+    if (typeof record[key] !== "boolean") {
+        issues.push(`${displayKey} must be a boolean`);
+    }
+}
+export 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`);
+        return;
+    }
+    if (value.some((entry) => typeof entry !== "string")) {
+        issues.push(`${displayKey} must contain only strings`);
+    }
+}
+export 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;
+        }
+    }
+}
+export 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`);
+        }
+    }
+}
+export function validateOptionalNumber(issues, record, key, displayKey = key) {
+    if (!hasOwnValue(record, key)) {
+        return;
+    }
+    if (!isFiniteNumber(record[key])) {
+        issues.push(`${displayKey} must be a number`);
+    }
+}
+export function validateOptionalPositiveNumber(issues, record, key, displayKey = key) {
+    if (!hasOwnValue(record, key)) {
+        return;
+    }
+    if (!isPositiveNumber(record[key])) {
+        issues.push(`${displayKey} must be a positive number`);
+    }
+}
+export function validateOptionalPositiveInteger(issues, record, key, displayKey = key) {
+    if (!hasOwnValue(record, key)) {
+        return;
+    }
+    if (!isPositiveInteger(record[key])) {
+        issues.push(`${displayKey} must be a positive integer`);
+    }
+}
+export function validateOptionalNonNegativeInteger(issues, record, key, displayKey = key) {
+    if (!hasOwnValue(record, key)) {
+        return;
+    }
+    if (!isNonNegativeInteger(record[key])) {
+        issues.push(`${displayKey} must be a non-negative integer`);
+    }
+}

package/dist/src/runtime/config/validation/runtime-config-validation-contract.d.ts

@@ -0,0 +1,9 @@
+export type RuntimeConfigValidationOptions = Readonly<{
+    /** Inspection-only mode. Canonical runtime loading always omits this flag. */
+    allowIncompleteSetup?: boolean;
+}>;
+export declare class RuntimeConfigValidationError extends Error {
+    readonly configPath: string;
+    readonly issues: string[];
+    constructor(configPath: string, issues: string[]);
+}

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

@@ -0,0 +1,13 @@
+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;
+    }
+}

package/dist/src/runtime/config/validation/runtime-root-section-validation.d.ts

@@ -0,0 +1,6 @@
+import type { RuntimeConfigValidationOptions } from "./runtime-config-validation-contract.js";
+export declare function validateLoggingConfig(issues: string[], logging: Record<string, unknown>): void;
+export declare function validatePluginConfig(issues: string[], plugins: Record<string, unknown>): void;
+export declare function validateRuntimeTimeouts(issues: string[], timeouts: Record<string, unknown>): void;
+export declare function validateRootRequestRunnerConfig(issues: string[], requestRunner: Record<string, unknown>, options: RuntimeConfigValidationOptions): void;
+export declare function validateFeatureFlagSections(issues: string[], record: Record<string, unknown>): void;

package/dist/src/runtime/config/validation/runtime-root-section-validation.js

@@ -0,0 +1,82 @@
+import { TIMEOUT_CONFIG_FIELDS } from "../fields.js";
+import { hasOwnValue } from "../utils.js";
+import { validateOptionalBoolean, validateOptionalObject, validateOptionalPositiveNumber, validateOptionalSetupString, validateOptionalStringArray, } from "./runtime-config-field-validation.js";
+export 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}`);
+    }
+}
+export 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)) {
+        const isUnsupportedPluginField = key !== "enabled" && key !== "allow" && key !== "deny";
+        if (isUnsupportedPluginField) {
+            issues.push(`plugins.${key} is not a supported configuration field`);
+        }
+    }
+}
+function hasInvalidRuntimeTimeout(value) {
+    if (typeof value !== "number") {
+        return true;
+    }
+    if (!Number.isFinite(value)) {
+        return true;
+    }
+    return value <= 0;
+}
+export function validateRuntimeTimeouts(issues, timeouts) {
+    for (const field of TIMEOUT_CONFIG_FIELDS) {
+        if (!hasOwnValue(timeouts, field.key)) {
+            continue;
+        }
+        if (hasInvalidRuntimeTimeout(timeouts[field.key])) {
+            issues.push(`timeouts.${field.key} must be a positive number`);
+        }
+    }
+}
+export function validateRootRequestRunnerConfig(issues, requestRunner, options) {
+    const keys = Object.keys(requestRunner);
+    const hasUnsupportedRequestRunnerFields = keys.some((key) => key !== "configRef");
+    const requiresExactlyOneRequestRunnerField = !options.allowIncompleteSetup && keys.length !== 1;
+    if (hasUnsupportedRequestRunnerFields ||
+        requiresExactlyOneRequestRunnerField) {
+        issues.push("requestRunner must contain exactly: configRef");
+    }
+    const configRefIsMissing = !hasOwnValue(requestRunner, "configRef");
+    if (configRefIsMissing && !options.allowIncompleteSetup) {
+        issues.push("requestRunner.configRef is required");
+    }
+    if (configRefIsMissing) {
+        return;
+    }
+    validateOptionalSetupString(issues, requestRunner, "configRef", "requestRunner.configRef", options.allowIncompleteSetup === true);
+}
+function hasUnsupportedFeatureFlagValue(value) {
+    if (typeof value === "boolean") {
+        return false;
+    }
+    if (typeof value === "number") {
+        return false;
+    }
+    return typeof value !== "string";
+}
+export function validateFeatureFlagSections(issues, record) {
+    for (const key of ["features", "featureFlags"]) {
+        const flags = validateOptionalObject(issues, record, key);
+        if (!flags) {
+            continue;
+        }
+        for (const [flagName, value] of Object.entries(flags)) {
+            if (hasUnsupportedFeatureFlagValue(value)) {
+                issues.push(`${key}.${flagName} must be a boolean, number, or string`);
+            }
+        }
+    }
+}

package/dist/src/runtime/config/validation/web-ui-config-validation.d.ts

@@ -0,0 +1,3 @@
+import type { RuntimeConfigFile } from "../types.js";
+export declare function validateWebUiConfigSection(issues: string[], config: Record<string, unknown>): void;
+export declare function validateRuntimeWebUiConfig(config: RuntimeConfigFile, configPath: string): void;

package/dist/src/runtime/config/validation/web-ui-config-validation.js

@@ -0,0 +1,26 @@
+import { validateOptionalBoolean, validateOptionalObject, } from "./runtime-config-field-validation.js";
+import { RuntimeConfigValidationError } from "./runtime-config-validation-contract.js";
+function isUnsupportedWebUiField(key) {
+    return key !== "openOnRuntimeServiceStart";
+}
+function validateWebUiConfig(issues, webUi) {
+    validateOptionalBoolean(issues, webUi, "openOnRuntimeServiceStart", "webUi.openOnRuntimeServiceStart");
+    for (const key of Object.keys(webUi)) {
+        if (isUnsupportedWebUiField(key)) {
+            issues.push(`webUi.${key} is not a supported configuration field`);
+        }
+    }
+}
+export 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);
+    }
+}

package/dist/src/runtime/config/validation.d.ts

@@ -1,17 +1,6 @@
 import type { RuntimeConfigFile } from "./types.js";
-type RuntimeConfigValidationOptions = Readonly<{
-    /** Inspection-only mode. Canonical runtime loading always omits this flag. */
-    allowIncompleteSetup?: boolean;
-}>;
-export declare class RuntimeConfigValidationError extends Error {
-    readonly configPath: string;
-    readonly issues: string[];
-    constructor(configPath: string, issues: string[]);
-}
-export declare function validateModelProfileConfig(issues: string[], profile: Record<string, unknown>, displayKey: string, options?: {
-    allowConfigRef: boolean;
-    allowIncompleteSetup?: boolean;
-}): void;
-export declare function validateRuntimeWebUiConfig(config: RuntimeConfigFile, configPath: string): void;
+import { RuntimeConfigValidationError, type RuntimeConfigValidationOptions } from "./validation/runtime-config-validation-contract.js";
+export { validateModelProfileConfig } from "./validation/model-profile-validation.js";
+export { validateRuntimeWebUiConfig } from "./validation/web-ui-config-validation.js";
+export { RuntimeConfigValidationError };
 export declare function validateRuntimeConfigFile(config: RuntimeConfigFile, configPath: string, options?: RuntimeConfigValidationOptions): void;
-export {};