@abot-ai/runtime 1.0.0 → 1.2.0

package/dist/src/runtime/config/runner/config-normalization.js

@@ -0,0 +1,109 @@
+import { REQUEST_INVOKED_STEP_IDS, } from "./contracts.js";
+import { loadRequestStepInstructionBlocks } from "./instruction-refs.js";
+import { invalidRuntimeConfig, requireConfigRecord, requireConfigString, requireExactConfigKeys, requirePositiveConfigInteger, } from "./validation.js";
+const registeredStepIds = new Set(REQUEST_INVOKED_STEP_IDS);
+export function assertRegisteredModelStepKeys(value, configPath, field) {
+    for (const stepId of Object.keys(value)) {
+        if (registeredStepIds.has(stepId)) {
+            continue;
+        }
+        throw invalidRuntimeConfig(configPath, field + " contains unregistered model step " + stepId);
+    }
+}
+export function parseRequestRunnerModelDefaults(root, configPath) {
+    const models = requireConfigRecord(root.models, configPath, "models");
+    requireExactConfigKeys(models, ["defaults"], configPath, "models");
+    const defaults = requireConfigRecord(models.defaults, configPath, "models.defaults");
+    requireExactConfigKeys(defaults, ["profileId", "steps"], configPath, "models.defaults");
+    const rawStepTargets = requireConfigRecord(defaults.steps, configPath, "models.defaults.steps");
+    assertRegisteredModelStepKeys(rawStepTargets, configPath, "models.defaults.steps");
+    return {
+        profileId: requireConfigString(defaults.profileId, configPath, "models.defaults.profileId"),
+        rawStepTargets,
+    };
+}
+export function parseRequestRunnerContext(root, configPath) {
+    const rawContext = requireConfigRecord(root.context, configPath, "context");
+    requireExactConfigKeys(rawContext, ["outputReserveTokens", "safetyReserveTokens", "attachmentReserveTokens"], configPath, "context");
+    return {
+        outputReserveTokens: requirePositiveConfigInteger(rawContext.outputReserveTokens, configPath, "context.outputReserveTokens"),
+        safetyReserveTokens: requirePositiveConfigInteger(rawContext.safetyReserveTokens, configPath, "context.safetyReserveTokens"),
+        attachmentReserveTokens: requirePositiveConfigInteger(rawContext.attachmentReserveTokens, configPath, "context.attachmentReserveTokens"),
+    };
+}
+function materializeModelStepTargets(rawStepTargets, configPath) {
+    return Object.fromEntries(REQUEST_INVOKED_STEP_IDS.map((stepId) => [
+        stepId,
+        Object.hasOwn(rawStepTargets, stepId)
+            ? requireConfigString(rawStepTargets[stepId], configPath, "models.defaults.steps." + stepId)
+            : stepId,
+    ]));
+}
+function assertRequestStepFields(step, configPath, field) {
+    for (const key of Object.keys(step)) {
+        if (key === "timeoutMs" || key === "instructionRefs") {
+            continue;
+        }
+        throw invalidRuntimeConfig(configPath, field + " may contain only: timeoutMs, instructionRefs");
+    }
+}
+function legacyStepOmitsRequiredTimeout(params, hasTimeout) {
+    return params.requireConfiguredTimeout && !hasTimeout;
+}
+function sparseStepOverrideIsEmpty(params, hasTimeout, hasInstructionRefs) {
+    return !params.requireConfiguredTimeout && !hasTimeout && !hasInstructionRefs;
+}
+function materializeRequestStep(stepId, params) {
+    const rawStep = params.rawSteps[stepId];
+    if (rawStep === undefined) {
+        return { timeoutMs: params.defaultTimeoutMs };
+    }
+    const field = "steps." + stepId;
+    const step = requireConfigRecord(rawStep, params.configPath, field);
+    assertRequestStepFields(step, params.configPath, field);
+    const hasTimeout = Object.hasOwn(step, "timeoutMs");
+    const hasInstructionRefs = Object.hasOwn(step, "instructionRefs");
+    if (legacyStepOmitsRequiredTimeout(params, hasTimeout)) {
+        throw invalidRuntimeConfig(params.configPath, field + ".timeoutMs is required by the legacy v1 format");
+    }
+    if (sparseStepOverrideIsEmpty(params, hasTimeout, hasInstructionRefs)) {
+        throw invalidRuntimeConfig(params.configPath, field + " must override timeoutMs or instructionRefs");
+    }
+    return {
+        timeoutMs: hasTimeout
+            ? requirePositiveConfigInteger(step.timeoutMs, params.configPath, field + ".timeoutMs")
+            : params.defaultTimeoutMs,
+        ...(hasInstructionRefs
+            ? {
+                instructionBlocks: loadRequestStepInstructionBlocks({
+                    configPath: params.configPath,
+                    stepId,
+                    rawRefs: step.instructionRefs,
+                }),
+            }
+            : {}),
+    };
+}
+function materializeRequestSteps(params) {
+    return Object.fromEntries(REQUEST_INVOKED_STEP_IDS.map((stepId) => [
+        stepId,
+        materializeRequestStep(stepId, params),
+    ]));
+}
+export function materializeRequestRunnerConfig(params) {
+    return {
+        models: {
+            defaults: {
+                profileId: params.modelDefaults.profileId,
+                steps: materializeModelStepTargets(params.modelDefaults.rawStepTargets, params.configPath),
+            },
+        },
+        context: params.context,
+        steps: materializeRequestSteps({
+            configPath: params.configPath,
+            defaultTimeoutMs: params.defaultTimeoutMs,
+            rawSteps: params.rawSteps,
+            requireConfiguredTimeout: params.requireConfiguredTimeout,
+        }),
+    };
+}

package/dist/src/runtime/config/runner/loader.d.ts

@@ -1,4 +1,4 @@
-import { type RequestRunnerConfig } from "./contracts.js";
+import type { RequestRunnerConfig } from "./contracts.js";
 export declare function loadRequestRunnerConfig(params: {
     configPath: string;
 }): RequestRunnerConfig;

package/dist/src/runtime/config/runner/loader.js

@@ -1,8 +1,7 @@
 import { readFileSync } from "node:fs";
 import { isAbsolute, resolve } from "node:path";
-import { REQUEST_INVOKED_STEP_IDS, } from "./contracts.js";
-import { loadRequestStepInstructionBlocks } from "./instruction-refs.js";
-import { formatConfigError, invalidRuntimeConfig, deepFreezeConfig, requireExactConfigKeys, requireConfigRecord, requireConfigString, requireConfigStringMap, requirePositiveConfigInteger, } from "./validation.js";
+import { deepFreezeConfig, formatConfigError } from "./validation.js";
+import { parseRequestRunnerConfig } from "./versioned-config.js";
 const configCache = new Map();
 export function loadRequestRunnerConfig(params) {
     const configuredPath = params.configPath.trim();
@@ -32,69 +31,3 @@ export function loadRequestRunnerConfig(params) {
     configCache.set(configPath, config);
     return config;
 }
-function parseRequestRunnerConfig(value, configPath) {
-    const root = requireConfigRecord(value, configPath, "root");
-    const models = requireConfigRecord(root.models, configPath, "models");
-    requireExactConfigKeys(models, ["defaults"], configPath, "models");
-    const modelDefaults = requireConfigRecord(models.defaults, configPath, "models.defaults");
-    requireExactConfigKeys(modelDefaults, ["profileId", "steps"], configPath, "models.defaults");
-    const profileId = requireConfigString(modelDefaults.profileId, configPath, "models.defaults.profileId");
-    const rawModelSteps = requireConfigRecord(modelDefaults.steps, configPath, "models.defaults.steps");
-    for (const stepId of REQUEST_INVOKED_STEP_IDS) {
-        if (!Object.hasOwn(rawModelSteps, stepId)) {
-            throw invalidRuntimeConfig(configPath, `models.defaults.steps.${stepId} must select a model profile or calibration slot`);
-        }
-    }
-    requireExactConfigKeys(rawModelSteps, REQUEST_INVOKED_STEP_IDS, configPath, "models.defaults.steps");
-    const modelSteps = requireConfigStringMap(rawModelSteps, configPath, "models.defaults.steps");
-    const rawContext = requireConfigRecord(root.context, configPath, "context");
-    requireExactConfigKeys(root, ["models", "context", "steps"], configPath, "root");
-    requireExactConfigKeys(rawContext, [
-        "outputReserveTokens",
-        "safetyReserveTokens",
-        "attachmentReserveTokens",
-    ], configPath, "context");
-    const context = {
-        outputReserveTokens: requirePositiveConfigInteger(rawContext.outputReserveTokens, configPath, "context.outputReserveTokens"),
-        safetyReserveTokens: requirePositiveConfigInteger(rawContext.safetyReserveTokens, configPath, "context.safetyReserveTokens"),
-        attachmentReserveTokens: requirePositiveConfigInteger(rawContext.attachmentReserveTokens, configPath, "context.attachmentReserveTokens"),
-    };
-    const rawSteps = requireConfigRecord(root.steps, configPath, "steps");
-    for (const stepId of REQUEST_INVOKED_STEP_IDS) {
-        if (!Object.hasOwn(rawSteps, stepId)) {
-            throw invalidRuntimeConfig(configPath, `steps.${stepId} is required`);
-        }
-    }
-    requireExactConfigKeys(rawSteps, REQUEST_INVOKED_STEP_IDS, configPath, "steps");
-    const steps = Object.fromEntries(REQUEST_INVOKED_STEP_IDS.map((stepId) => {
-        const rawStep = rawSteps[stepId];
-        const step = requireConfigRecord(rawStep, configPath, `steps.${stepId}`);
-        const hasInstructionRefs = Object.hasOwn(step, "instructionRefs");
-        requireExactConfigKeys(step, ["timeoutMs", ...(hasInstructionRefs ? ["instructionRefs"] : [])], configPath, `steps.${stepId}`);
-        return [
-            stepId,
-            {
-                timeoutMs: requirePositiveConfigInteger(step.timeoutMs, configPath, `steps.${stepId}.timeoutMs`),
-                ...(hasInstructionRefs
-                    ? {
-                        instructionBlocks: loadRequestStepInstructionBlocks({
-                            configPath,
-                            stepId,
-                            rawRefs: step.instructionRefs,
-                        }),
-                    }
-                    : {}),
-            },
-        ];
-    }));
-    return {
-        models: {
-            defaults: {
-                profileId,
-                steps: modelSteps,
-            },
-        },
-        context,
-        steps,
-    };
-}

package/dist/src/runtime/config/runner/model-policy.js

@@ -7,6 +7,9 @@ export function createRequestModelPolicy(params) {
         ...(params.platformPolicy?.profiles
             ? { profiles: params.platformPolicy.profiles }
             : {}),
+        ...(params.platformPolicy?.embeddingProfiles
+            ? { embeddingProfiles: params.platformPolicy.embeddingProfiles }
+            : {}),
         ...(params.platformPolicy?.invocationProfiles
             ? { invocationProfiles: params.platformPolicy.invocationProfiles }
             : {}),

package/dist/src/runtime/config/runner/schema-version.d.ts

@@ -0,0 +1,14 @@
+export declare const REQUEST_RUNNER_CONFIG_SCHEMA_VERSION: 2;
+export declare const LEGACY_REQUEST_STEP_TIMEOUT_MS = 90000;
+/**
+ * Exact Model Step baseline shipped in @abot-ai/runtime 1.0.0.
+ * Later steps may be absent from a legacy file and are filled by normalization.
+ */
+export declare const LEGACY_REQUEST_INVOKED_STEP_IDS: readonly ("supervisor.decision" | "supervisor.response" | "worker.decision" | "worker.result" | "planner.decision" | "planner.graph" | "reviewer.decision" | "degraded.finalization" | "execution.decision" | "execution.response" | "auditor.decision" | "context.compact" | "tool_payload.raw")[];
+export type RequestRunnerConfigFileVersion = "legacy-v1" | 2;
+export type VersionedRequestRunnerConfigRoot = Readonly<{
+    root: Record<string, unknown>;
+    version: RequestRunnerConfigFileVersion;
+}>;
+export declare function resolveRequestRunnerConfigFileVersion(value: unknown, configPath: string): VersionedRequestRunnerConfigRoot;
+export declare function assertSupportedRequestRunnerConfigVersion(value: unknown, configPath: string): void;

package/dist/src/runtime/config/runner/schema-version.js

@@ -0,0 +1,35 @@
+import { invalidRuntimeConfig, requireConfigRecord } from "./validation.js";
+export const REQUEST_RUNNER_CONFIG_SCHEMA_VERSION = 2;
+export const LEGACY_REQUEST_STEP_TIMEOUT_MS = 90_000;
+/**
+ * Exact Model Step baseline shipped in @abot-ai/runtime 1.0.0.
+ * Later steps may be absent from a legacy file and are filled by normalization.
+ */
+export const LEGACY_REQUEST_INVOKED_STEP_IDS = Object.freeze([
+    "supervisor.decision",
+    "supervisor.response",
+    "worker.decision",
+    "worker.result",
+    "planner.decision",
+    "planner.graph",
+    "reviewer.decision",
+    "degraded.finalization",
+    "execution.decision",
+    "execution.response",
+    "auditor.decision",
+    "context.compact",
+    "tool_payload.raw",
+]);
+export function resolveRequestRunnerConfigFileVersion(value, configPath) {
+    const root = requireConfigRecord(value, configPath, "root");
+    if (!Object.hasOwn(root, "schemaVersion")) {
+        return { root, version: "legacy-v1" };
+    }
+    if (root.schemaVersion === REQUEST_RUNNER_CONFIG_SCHEMA_VERSION) {
+        return { root, version: REQUEST_RUNNER_CONFIG_SCHEMA_VERSION };
+    }
+    throw invalidRuntimeConfig(configPath, "schemaVersion must be 2 or omitted for the legacy v1 format");
+}
+export function assertSupportedRequestRunnerConfigVersion(value, configPath) {
+    resolveRequestRunnerConfigFileVersion(value, configPath);
+}

package/dist/src/runtime/config/runner/versioned-config.d.ts

@@ -0,0 +1,2 @@
+import type { RequestRunnerConfig } from "./contracts.js";
+export declare function parseRequestRunnerConfig(value: unknown, configPath: string): RequestRunnerConfig;

package/dist/src/runtime/config/runner/versioned-config.js

@@ -0,0 +1,51 @@
+import { assertRegisteredModelStepKeys, materializeRequestRunnerConfig, parseRequestRunnerContext, parseRequestRunnerModelDefaults, } from "./config-normalization.js";
+import { LEGACY_REQUEST_INVOKED_STEP_IDS, LEGACY_REQUEST_STEP_TIMEOUT_MS, resolveRequestRunnerConfigFileVersion, } from "./schema-version.js";
+import { invalidRuntimeConfig, requireConfigRecord, requireExactConfigKeys, requirePositiveConfigInteger, } from "./validation.js";
+function assertLegacyStepCoverage(value, configPath, field) {
+    for (const stepId of LEGACY_REQUEST_INVOKED_STEP_IDS) {
+        if (Object.hasOwn(value, stepId)) {
+            continue;
+        }
+        throw invalidRuntimeConfig(configPath, field + "." + stepId + " is required by the legacy v1 format");
+    }
+}
+function parseLegacyRequestRunnerConfig(root, configPath) {
+    const context = parseRequestRunnerContext(root, configPath);
+    requireExactConfigKeys(root, ["models", "context", "steps"], configPath, "root");
+    const modelDefaults = parseRequestRunnerModelDefaults(root, configPath);
+    const rawSteps = requireConfigRecord(root.steps, configPath, "steps");
+    assertRegisteredModelStepKeys(rawSteps, configPath, "steps");
+    assertLegacyStepCoverage(modelDefaults.rawStepTargets, configPath, "models.defaults.steps");
+    assertLegacyStepCoverage(rawSteps, configPath, "steps");
+    return materializeRequestRunnerConfig({
+        configPath,
+        context,
+        defaultTimeoutMs: LEGACY_REQUEST_STEP_TIMEOUT_MS,
+        modelDefaults,
+        rawSteps,
+        requireConfiguredTimeout: true,
+    });
+}
+function parseSparseRequestRunnerConfig(root, configPath) {
+    const context = parseRequestRunnerContext(root, configPath);
+    requireExactConfigKeys(root, ["schemaVersion", "models", "context", "stepDefaults", "steps"], configPath, "root");
+    const stepDefaults = requireConfigRecord(root.stepDefaults, configPath, "stepDefaults");
+    requireExactConfigKeys(stepDefaults, ["timeoutMs"], configPath, "stepDefaults");
+    const rawSteps = requireConfigRecord(root.steps, configPath, "steps");
+    assertRegisteredModelStepKeys(rawSteps, configPath, "steps");
+    return materializeRequestRunnerConfig({
+        configPath,
+        context,
+        defaultTimeoutMs: requirePositiveConfigInteger(stepDefaults.timeoutMs, configPath, "stepDefaults.timeoutMs"),
+        modelDefaults: parseRequestRunnerModelDefaults(root, configPath),
+        rawSteps,
+        requireConfiguredTimeout: false,
+    });
+}
+export function parseRequestRunnerConfig(value, configPath) {
+    const versioned = resolveRequestRunnerConfigFileVersion(value, configPath);
+    if (versioned.version === "legacy-v1") {
+        return parseLegacyRequestRunnerConfig(versioned.root, configPath);
+    }
+    return parseSparseRequestRunnerConfig(versioned.root, configPath);
+}

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

@@ -142,6 +142,40 @@ function modelGatewayFormatSchema() {
         description: "Optional provider response format override for this invocation profile.",
     };
 }
+function embeddingProfilesSchema() {
+    return {
+        type: "object",
+        propertyNames: { minLength: 1 },
+        description: "Non-generative embedding profiles used by core services such as long-term memory.",
+        additionalProperties: {
+            type: "object",
+            properties: {
+                label: { type: "string", minLength: 1 },
+                provider: { type: "string", minLength: 1 },
+                model: { type: "string", minLength: 1 },
+                options: { type: "object", additionalProperties: true },
+            },
+            required: ["provider", "model"],
+            additionalProperties: false,
+        },
+    };
+}
+function longTermMemorySchema() {
+    return {
+        type: "object",
+        description: "Passive cross-session memory. Disabled unless the host opts in and binds an embedding profile.",
+        properties: {
+            enabled: { type: "boolean", default: false },
+            emitClientEvents: { type: "boolean", default: false },
+            embeddingProfileId: {
+                type: "string",
+                minLength: 1,
+                description: "Profile id under models.embeddingProfiles used for retrieval and indexing.",
+            },
+        },
+        additionalProperties: false,
+    };
+}
 function modelInvocationProfilesSchema() {
     return {
         type: "object",
@@ -323,6 +357,7 @@ export function createRuntimeConfigJsonSchema() {
                 },
             },
             plugins: pluginsSchema(),
+            longTermMemory: longTermMemorySchema(),
             models: {
                 type: "object",
                 description: "Model profiles and defaults consumed by model-gateway policy.",
@@ -435,6 +470,7 @@ export function createRuntimeConfigJsonSchema() {
                             ],
                         },
                     },
+                    embeddingProfiles: embeddingProfilesSchema(),
                     invocationProfiles: modelInvocationProfilesSchema(),
                     defaults: {
                         type: "object",

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

@@ -9,6 +9,7 @@ export type RuntimeConfigFile = {
     logging?: unknown;
     timeouts?: unknown;
     plugins?: unknown;
+    longTermMemory?: unknown;
     models?: unknown;
     requestRunner?: unknown;
     features?: unknown;

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

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

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

@@ -0,0 +1,41 @@
+import { hasOwnValue, isRecord } from "../utils.js";
+import { validateOptionalObject, validateOptionalString, } from "./runtime-config-field-validation.js";
+import { validatePathConfigRecord } from "./path-config-validation.js";
+function validateEnvironmentProfilePaths(issues, profileId, profile) {
+    if (!isRecord(profile)) {
+        issues.push(`environment.profiles.${profileId} must be an object`);
+        return;
+    }
+    const paths = validateOptionalObject(issues, profile, "paths", `environment.profiles.${profileId}.paths`);
+    if (!paths) {
+        return;
+    }
+    validatePathConfigRecord(issues, paths, `environment.profiles.${profileId}.paths`);
+}
+function hasUnknownDefaultEnvironmentProfile(environment, profiles) {
+    if (typeof environment.default !== "string") {
+        return false;
+    }
+    const defaultProfileId = environment.default.trim();
+    if (defaultProfileId.length === 0) {
+        return false;
+    }
+    return !hasOwnValue(profiles, defaultProfileId);
+}
+export 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)) {
+        validateEnvironmentProfilePaths(issues, profileId, profile);
+    }
+    if (hasUnknownDefaultEnvironmentProfile(environment, profiles)) {
+        issues.push("environment.default must match a key under environment.profiles");
+    }
+}

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

@@ -0,0 +1,2 @@
+export declare function validateModelContextConfig(issues: string[], context: Record<string, unknown>, displayKey: string): void;
+export declare function validateModelGenerationConfig(issues: string[], generation: Record<string, unknown>, displayKey: string): void;

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

@@ -0,0 +1,64 @@
+import { hasOwnValue } from "../utils.js";
+import { validateOptionalNonNegativeInteger, validateOptionalNumber, validateOptionalObject, validateOptionalPositiveNumber, } from "./runtime-config-field-validation.js";
+const SUPPORTED_MODEL_REASONING_EFFORTS = new Set([
+    "none",
+    "minimal",
+    "low",
+    "medium",
+    "high",
+    "xhigh",
+]);
+function validateFormatTokenAccounting(issues, formatTokenAccounting, displayKey) {
+    const modeIsSupported = formatTokenAccounting.mode === "none" ||
+        formatTokenAccounting.mode === "estimate";
+    if (!modeIsSupported) {
+        issues.push(`${displayKey}.mode must be none or estimate`);
+    }
+    validateOptionalNonNegativeInteger(issues, formatTokenAccounting, "fixedOverheadTokens", `${displayKey}.fixedOverheadTokens`);
+}
+function validateTokenEstimation(issues, tokenEstimation, displayKey) {
+    validateOptionalPositiveNumber(issues, tokenEstimation, "asciiCharactersPerToken", `${displayKey}.asciiCharactersPerToken`);
+    validateOptionalPositiveNumber(issues, tokenEstimation, "nonAsciiBytesPerToken", `${displayKey}.nonAsciiBytesPerToken`);
+    validateOptionalPositiveNumber(issues, tokenEstimation, "messageOverheadTokens", `${displayKey}.messageOverheadTokens`);
+}
+function hasUnsupportedReasoningEffort(generation) {
+    if (!hasOwnValue(generation, "reasoningEffort")) {
+        return false;
+    }
+    return !SUPPORTED_MODEL_REASONING_EFFORTS.has(generation.reasoningEffort);
+}
+export function validateModelContextConfig(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) {
+        validateFormatTokenAccounting(issues, formatTokenAccounting, `${displayKey}.formatTokenAccounting`);
+    }
+    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) {
+        validateTokenEstimation(issues, tokenEstimation, `${displayKey}.tokenEstimation`);
+    }
+    if (hasOwnValue(context, "compaction")) {
+        issues.push(`${displayKey}.compaction is not supported; context compaction uses the runtime-owned 70 percent trigger`);
+    }
+}
+export function validateModelGenerationConfig(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 (hasUnsupportedReasoningEffort(generation)) {
+        issues.push(`${displayKey}.reasoningEffort must be none, minimal, low, medium, high, or xhigh`);
+    }
+}

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

@@ -0,0 +1,2 @@
+export declare function validateOptionalInvocationProfiles(issues: string[], record: Record<string, unknown>, key: string, displayKey: string): void;
+export declare function validateOptionalModelCalibrations(issues: string[], record: Record<string, unknown>, key: string, displayKey: string): void;

package/dist/src/runtime/config/validation/model-invocation-override-validation.js

@@ -0,0 +1,72 @@
+import { hasOwnValue, isRecord } from "../utils.js";
+import { validateModelContextConfig, validateModelGenerationConfig, } from "./model-invocation-config-validation.js";
+import { validateOptionalObject, validateOptionalPositiveInteger, validateOptionalString, validateOptionalStringArray, } from "./runtime-config-field-validation.js";
+function hasUnsupportedModelInvocationFormat(config) {
+    if (!hasOwnValue(config, "format") || config.format === "json") {
+        return false;
+    }
+    return !isRecord(config.format);
+}
+function validateInvocationProfile(issues, profile, profileKey) {
+    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) {
+        validateModelGenerationConfig(issues, generation, `${profileKey}.generation`);
+    }
+    const context = validateOptionalObject(issues, profile, "context", `${profileKey}.context`);
+    if (context) {
+        validateModelContextConfig(issues, context, `${profileKey}.context`);
+    }
+    if (hasUnsupportedModelInvocationFormat(profile)) {
+        issues.push(`${profileKey}.format must be json or an object`);
+    }
+}
+export 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;
+        }
+        validateInvocationProfile(issues, profile, profileKey);
+    }
+}
+function validateModelCalibration(issues, calibration, slotKey) {
+    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) {
+        validateModelGenerationConfig(issues, generation, `${slotKey}.generation`);
+    }
+    const context = validateOptionalObject(issues, calibration, "context", `${slotKey}.context`);
+    if (context) {
+        validateModelContextConfig(issues, context, `${slotKey}.context`);
+    }
+    if (hasUnsupportedModelInvocationFormat(calibration)) {
+        issues.push(`${slotKey}.format must be json or an object`);
+    }
+    validateOptionalStringArray(issues, calibration, "instructions", `${slotKey}.instructions`);
+}
+export 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;
+        }
+        validateModelCalibration(issues, calibration, slotKey);
+    }
+}

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

@@ -0,0 +1,4 @@
+export declare function validateModelProfileConfig(issues: string[], profile: Record<string, unknown>, displayKey: string, options?: {
+    allowConfigRef: boolean;
+    allowIncompleteSetup?: boolean;
+}): void;