@abot-ai/runtime 1.6.0 → 1.7.0

package/dist/src/runtime/capabilities/automations/authoring-preparation.d.ts

@@ -21,6 +21,7 @@ export declare function readAutomationAuthoringPreparation(service: CatalogServi
         operationId: string;
         contractVersion: number;
         label: string;
+        outputChannels?: import("../../../capabilities/tool-types.js").ToolNormalInvocationOperation["outputChannels"];
         pluginName?: string;
         catalogGroups: readonly import("../../../capabilities/tool-types.js").ToolCatalogGroup[];
         toolDescription?: string;
@@ -106,7 +107,7 @@ export declare function readAutomationAuthoringPreparation(service: CatalogServi
             readonly steps: readonly [{
                 readonly key: "evidence";
                 readonly kind: "tool";
-                readonly title: "Read structured evidence";
+                readonly title: "Read text evidence";
                 readonly operation: {
                     readonly toolName: "catalog_tool";
                     readonly operationId: "catalog_operation";
@@ -122,7 +123,7 @@ export declare function readAutomationAuthoringPreparation(service: CatalogServi
                     readonly evidence: {
                         readonly kind: "node_result";
                         readonly nodeId: "$evidence";
-                        readonly select: "data";
+                        readonly select: "text";
                     };
                 };
             }];
@@ -385,10 +386,15 @@ export declare function readAutomationAuthoringPreparation(service: CatalogServi
                 };
             };
             readonly channels: {
-                readonly text: "Tool display output; may be counts/status only, not serialized data.";
-                readonly data: "Structured tool output, when provided. Omit pointer to pass it whole, without knowing field names.";
+                readonly text: "Saved text.";
+                readonly data: "Separate optional JSON; no implicit Text channel.";
             };
-            readonly policy: "Use literal for constants, run_input for definition.inputs. node_result needs a succeeded earlier node; no implicit output. Select the operation's documented channel: data for records/ids, text when sufficient. Optional data-only RFC6901 pointer: /field, /items/0; escape ~ as ~0 and / as ~1. Never invent fields or execute future steps to inspect output.";
+            readonly outputChannels: {
+                content: string;
+                metadata: string;
+                conditional: string;
+            };
+            readonly policy: "literal=constants; run_input=definition.inputs; node_result needs prior success. Follow operation.outputChannels; absent=unknown. Whole data needs no pointer. RFC6901 pointers need documented fields (/items/0; ~ as ~0, / as ~1). Never execute steps for output discovery.";
             readonly files: "run_file resolves a new file for each run under its working directory; fileName is one portable filename, no path. source_files requires a configured source and an agent consumer. source_file index selects the frozen batch entry; field=snapshot_path|original_path|version.";
             readonly parallel: "branch_results is agent-only after the referenced parallel join; it supplies each branch's settled tail output/status. A failed/skipped source has no successful node_result for downstream bindings.";
         };

package/dist/src/runtime/capabilities/automations/tool-module.js

@@ -110,7 +110,7 @@ async function execute(service, params) {
         return { kind: "automation_authoring_catalog_v1", grantsPermissions: false,
             catalogScope: automationAuthoringCatalogScope(automationId),
             permissions: AUTOMATION_AUTHORING_REFERENCE.permissions,
-            operations: catalog.grantableOperations.map(({ fixedParams: _fixedParams, ...operation }) => operation),
+            operations: catalog.grantableOperations.map(({ fixedParams: _fixedParams, outputChannels: _outputChannels, ...operation }) => operation),
             grantedOperations: catalog.operations.map(({ toolName, operationId, contractVersion }) => ({ toolName, operationId, contractVersion })),
             models: catalog.models,
             savedAgents: catalog.savedAgents.map((agent) => ({

package/dist/src/runtime/capabilities/request-permission-catalog.d.ts

@@ -1,8 +1,10 @@
 import { type ToolPermissionMode } from "../../capabilities/tool-permission-mode.js";
 import type { RegisteredToolNormalInvocation, ToolDefinition } from "../../capabilities/tool-types.js";
 import type { ToolRegistry } from "../ports.js";
+import { type RuntimeModelPluginConfig } from "../config/model-plugin-config.js";
 /** One lazy registration snapshot; any declared restriction wins across projections. */
-export declare function captureRequestPermissionCatalog(registry: ToolRegistry, mode: ToolPermissionMode): Readonly<{
+export declare function captureRequestPermissionCatalog(registry: ToolRegistry, mode: ToolPermissionMode, modelPlugins?: RuntimeModelPluginConfig): Readonly<{
+    isRequestToolBlockedForModel: (name: string) => boolean;
     listDefinitions: () => ToolDefinition[];
     listNormalInvocations: () => readonly RegisteredToolNormalInvocation[] | undefined;
     getDefinition: (name: string) => ToolDefinition | undefined;

package/dist/src/runtime/capabilities/request-permission-catalog.js

@@ -1,13 +1,22 @@
 import { permitsRequiredToolMode, } from "../../capabilities/tool-permission-mode.js";
+import { captureModelPluginConfig, } from "../config/model-plugin-config.js";
+import { matchesToolSelectionId } from "../../shared/tool-selection.js";
 /** One lazy registration snapshot; any declared restriction wins across projections. */
-export function captureRequestPermissionCatalog(registry, mode) {
+export function captureRequestPermissionCatalog(registry, mode, modelPlugins) {
+    const modelDeniedSelectors = captureModelPluginConfig(modelPlugins)?.deny ?? [];
     const definitions = Object.freeze([...registry.listDefinitions()]);
     const definitionByName = new Map(definitions.map((definition) => [definition.name, definition]));
     let registrations;
     let resolvedRegistrations = false;
     const registeredAllowedNames = new Set();
     const registeredDeniedNames = new Set();
-    const permitsDefinition = (definition) => permitsRequiredToolMode(mode, definition.requiredPermissionMode);
+    const registeredModelDeniedNames = new Set();
+    const isDefinitionBlockedForModel = (definition) => modelDeniedSelectors.some((selector) => matchesToolSelectionId(definition.pluginName ?? "", definition.name, selector));
+    const permitsDefinition = (definition) => {
+        if (isDefinitionBlockedForModel(definition))
+            return false;
+        return permitsRequiredToolMode(mode, definition.requiredPermissionMode);
+    };
     const permitsRegistration = (registration) => {
         const definition = definitionByName.get(registration.toolName);
         if (definition && !permitsDefinition(definition))
@@ -23,6 +32,8 @@ export function captureRequestPermissionCatalog(registry, mode) {
             return undefined;
         }
         for (const registration of source) {
+            if (isDefinitionBlockedForModel(registration.definition))
+                registeredModelDeniedNames.add(registration.toolName);
             const names = permitsRegistration(registration)
                 ? registeredAllowedNames
                 : registeredDeniedNames;
@@ -41,7 +52,15 @@ export function captureRequestPermissionCatalog(registry, mode) {
             return permitsDefinition(definition);
         return registeredAllowedNames.has(name);
     }
+    function isRequestToolBlockedForModel(name) {
+        resolveRegistrations();
+        if (registeredModelDeniedNames.has(name))
+            return true;
+        const definition = definitionByName.get(name);
+        return definition !== undefined && isDefinitionBlockedForModel(definition);
+    }
     return Object.freeze({
+        isRequestToolBlockedForModel,
         listDefinitions: () => definitions.filter(({ name }) => isRequestToolAvailable(name)),
         listNormalInvocations: resolveRegistrations,
         getDefinition: (name) => isRequestToolAvailable(name) ? definitionByName.get(name) : undefined,

package/dist/src/runtime/capabilities/request-permission-tool-registry.d.ts

@@ -1,4 +1,5 @@
 import { type ToolPermissionMode } from "../../capabilities/tool-permission-mode.js";
 import type { ToolRegistry } from "../ports.js";
+import type { RuntimeModelPluginConfig } from "../config/model-plugin-config.js";
 /** Captures user authority once; all discovery and execution use the same gate. */
-export declare function restrictToolRegistryToRequestMode(registry: ToolRegistry, mode: ToolPermissionMode): ToolRegistry;
+export declare function restrictToolRegistryToRequestMode(registry: ToolRegistry, mode: ToolPermissionMode, modelPlugins?: RuntimeModelPluginConfig): ToolRegistry;

package/dist/src/runtime/capabilities/request-permission-tool-registry.js

@@ -1,16 +1,24 @@
 import { captureRequestPermissionCatalog } from "./request-permission-catalog.js";
 /** Captures user authority once; all discovery and execution use the same gate. */
-export function restrictToolRegistryToRequestMode(registry, mode) {
-    const catalog = captureRequestPermissionCatalog(registry, mode);
+export function restrictToolRegistryToRequestMode(registry, mode, modelPlugins) {
+    const catalog = captureRequestPermissionCatalog(registry, mode, modelPlugins);
     const isRequestToolAvailable = catalog.isRequestToolAvailable;
-    const rejectUnavailableTool = (tool) => ({
-        ok: false,
-        tool,
-        output: "This tool is unavailable for the captured request permission mode.",
-        producedNewInformation: false,
-        error: "This tool is unavailable for the captured request permission mode.",
-        errorCode: "tool_permission_mode_required",
-    });
+    const rejectUnavailableTool = (tool) => {
+        const blockedForModel = catalog.isRequestToolBlockedForModel(tool);
+        const message = blockedForModel
+            ? "This tool is blocked for the selected request model profile."
+            : "This tool is unavailable for the captured request permission mode.";
+        return {
+            ok: false,
+            tool,
+            output: message,
+            producedNewInformation: false,
+            error: message,
+            errorCode: blockedForModel
+                ? "tool_model_policy_denied"
+                : "tool_permission_mode_required",
+        };
+    };
     const bindAuthority = (state) => ({
         ...state,
         requestContext: Object.freeze({

package/dist/src/runtime/capabilities/request-runtime-tool-registry.d.ts

@@ -1,5 +1,6 @@
 import type { ToolPermissionMode } from "../../capabilities/tool-permission-mode.js";
 import type { RuntimeConfig, ToolRegistry } from "../ports.js";
+import type { RuntimeModelPluginConfig } from "../config/model-plugin-config.js";
 import type { BoundRequestModelInvocationContext } from "../request/contracts.js";
 import type { ToolRequestAttachment } from "../../capabilities/tool-types.js";
 /**
@@ -10,6 +11,7 @@ import type { ToolRequestAttachment } from "../../capabilities/tool-types.js";
 export declare function createRequestRuntimeToolRegistry(params: Readonly<{
     request: BoundRequestModelInvocationContext;
     toolPermissionMode?: ToolPermissionMode;
+    modelPlugins?: RuntimeModelPluginConfig;
     requestAttachments?: readonly ToolRequestAttachment[];
     runtimeConfig?: RuntimeConfig;
     requestWorkingDirectory?: string;

package/dist/src/runtime/capabilities/request-runtime-tool-registry.js

@@ -9,7 +9,7 @@ import { bindRequestToolRegistry } from "./request-bound-tool-registry.js";
  */
 export function createRequestRuntimeToolRegistry(params) {
     const registry = restrictToolRegistryToRequestMode(params.toolRegistryOverride ??
-        createConfiguredToolRegistry(params.runtimeConfig, []), params.toolPermissionMode ?? "ask");
+        createConfiguredToolRegistry(params.runtimeConfig, []), params.toolPermissionMode ?? "ask", params.modelPlugins);
     return bindRequestToolRegistry({
         registry,
         modelInvoker: createRequestToolModelInvoker(params.request),

package/dist/src/runtime/capabilities/scheduling/create-operations.d.ts

@@ -1,6 +1,7 @@
 export declare const scheduleCreateOperations: readonly [Readonly<{
     operationId: string;
     summary: string;
+    outputChannels?: import("../../../capabilities/tool-types.js").ToolNormalInvocationOutputChannels;
     input: import("../../../capabilities/tool-types.js").ToolNormalInvocationInput;
     selectionControlIds?: readonly string[];
     fixedParams?: Readonly<Record<string, import("../../../capabilities/tool-types.js").ToolNormalInvocationFixedValue>>;
@@ -11,6 +12,7 @@ export declare const scheduleCreateOperations: readonly [Readonly<{
 }>, Readonly<{
     operationId: string;
     summary: string;
+    outputChannels?: import("../../../capabilities/tool-types.js").ToolNormalInvocationOutputChannels;
     input: import("../../../capabilities/tool-types.js").ToolNormalInvocationInput;
     selectionControlIds?: readonly string[];
     fixedParams?: Readonly<Record<string, import("../../../capabilities/tool-types.js").ToolNormalInvocationFixedValue>>;
@@ -21,6 +23,7 @@ export declare const scheduleCreateOperations: readonly [Readonly<{
 }>, Readonly<{
     operationId: string;
     summary: string;
+    outputChannels?: import("../../../capabilities/tool-types.js").ToolNormalInvocationOutputChannels;
     input: import("../../../capabilities/tool-types.js").ToolNormalInvocationInput;
     selectionControlIds?: readonly string[];
     fixedParams?: Readonly<Record<string, import("../../../capabilities/tool-types.js").ToolNormalInvocationFixedValue>>;
@@ -31,6 +34,7 @@ export declare const scheduleCreateOperations: readonly [Readonly<{
 }>, Readonly<{
     operationId: string;
     summary: string;
+    outputChannels?: import("../../../capabilities/tool-types.js").ToolNormalInvocationOutputChannels;
     input: import("../../../capabilities/tool-types.js").ToolNormalInvocationInput;
     selectionControlIds?: readonly string[];
     fixedParams?: Readonly<Record<string, import("../../../capabilities/tool-types.js").ToolNormalInvocationFixedValue>>;
@@ -41,6 +45,7 @@ export declare const scheduleCreateOperations: readonly [Readonly<{
 }>, Readonly<{
     operationId: string;
     summary: string;
+    outputChannels?: import("../../../capabilities/tool-types.js").ToolNormalInvocationOutputChannels;
     input: import("../../../capabilities/tool-types.js").ToolNormalInvocationInput;
     selectionControlIds?: readonly string[];
     fixedParams?: Readonly<Record<string, import("../../../capabilities/tool-types.js").ToolNormalInvocationFixedValue>>;
@@ -51,6 +56,7 @@ export declare const scheduleCreateOperations: readonly [Readonly<{
 }>, Readonly<{
     operationId: string;
     summary: string;
+    outputChannels?: import("../../../capabilities/tool-types.js").ToolNormalInvocationOutputChannels;
     input: import("../../../capabilities/tool-types.js").ToolNormalInvocationInput;
     selectionControlIds?: readonly string[];
     fixedParams?: Readonly<Record<string, import("../../../capabilities/tool-types.js").ToolNormalInvocationFixedValue>>;

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

@@ -1,7 +1,7 @@
 import { readFileSync } from "node:fs";
 import { dirname, isAbsolute, resolve } from "node:path";
 import { DEFAULT_RUNTIME_LOGGING_ENABLED, DEFAULT_RUNTIME_LOG_ROTATION_CONFIG, } from "./constants.js";
-import { isRequestExecutionPolicyId } from "./model-execution-policy.js";
+import { buildRuntimeModelExecutionPolicy } from "./model-execution-policy.js";
 import { RuntimeConfigValidationError, validateModelProfileConfig, } from "./validation.js";
 import { readConfigPositiveInt, isRecord, readNestedConfigString, readNestedConfigStringArray, readOptionalBoolean, readOptionalStringMap, } from "./utils.js";
 export function compactTimeouts(timeouts) {
@@ -56,7 +56,9 @@ export function buildPluginConfig(config) {
     const enabled = readOptionalBoolean(config.plugins, "enabled");
     const allow = readNestedConfigStringArray(config.plugins, "allow");
     const deny = readNestedConfigStringArray(config.plugins, "deny");
+    const disabledPluginIds = readNestedConfigStringArray(config.plugins, "disabledPluginIds");
     const pluginConfig = {
+        ...(disabledPluginIds ? { disabledPluginIds } : {}),
         ...(enabled !== undefined ? { enabled } : {}),
         ...(allow ? { allow } : {}),
         ...(deny ? { deny } : {}),
@@ -432,10 +434,9 @@ function buildModelProfiles(profiles, options) {
         if (modelProfile) {
             gatewayEntries.push([profileId, modelProfile]);
         }
-        const execution = isRecord(source.execution) ? source.execution : undefined;
-        if (execution && isRequestExecutionPolicyId(execution.policy)) {
-            executionEntries.push([profileId, { policy: execution.policy }]);
-        }
+        const execution = buildRuntimeModelExecutionPolicy(source);
+        if (execution)
+            executionEntries.push([profileId, execution]);
     }
     return {
         ...(gatewayEntries.length > 0

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

@@ -1,3 +1,4 @@
+import { validateProfileContextCapacity, } from "./model-context-capacity.js";
 import { RuntimeConfigValidationError } from "./validation.js";
 function hasConfiguredProfile(profiles, profileId) {
     return !!profileId && Object.hasOwn(profiles, profileId);
@@ -8,40 +9,6 @@ function hasConfiguredInvocationProfile(invocationProfiles, profileId) {
 function hasConfiguredCalibrationSlot(profiles, slotId) {
     return Object.values(profiles).some((profile) => Object.hasOwn(profile.calibration ?? {}, slotId));
 }
-function readPositiveSafeInteger(value) {
-    return typeof value === "number" &&
-        Number.isSafeInteger(value) &&
-        value > 0
-        ? value
-        : undefined;
-}
-function validateProfileContextCapacity(params) {
-    const field = `models.profiles.${params.profileId}.contextWindowTokens`;
-    const declared = readPositiveSafeInteger(params.profile.contextWindowTokens);
-    if (declared === undefined) {
-        params.issues.push(`${field} must declare the physical context-window capacity as a positive safe integer`);
-        return;
-    }
-    let effective = declared;
-    if (params.providerType === "ollama" &&
-        Object.hasOwn(params.profile.options ?? {}, "num_ctx")) {
-        const allocated = readPositiveSafeInteger(params.profile.options?.num_ctx);
-        if (allocated === undefined) {
-            params.issues.push(`models.profiles.${params.profileId}.options.num_ctx must be a positive safe integer when configured`);
-            return;
-        }
-        effective = Math.min(effective, allocated);
-    }
-    const profileFormatReserve = params.profile.context?.formatTokenAccounting?.fixedOverheadTokens ?? 0;
-    const defaultFormatReserve = params.defaultContext?.formatTokenAccounting?.fixedOverheadTokens ?? 0;
-    const configuredReserve = params.runnerConfig.context.outputReserveTokens +
-        params.runnerConfig.context.safetyReserveTokens +
-        params.runnerConfig.context.attachmentReserveTokens +
-        Math.max(profileFormatReserve, defaultFormatReserve);
-    if (configuredReserve >= effective) {
-        params.issues.push(`models.profiles.${params.profileId} effective context window ${effective} must exceed configured output, safety, attachment, and format reserves ${configuredReserve}`);
-    }
-}
 function validateProfileReference(params) {
     if (!hasConfiguredProfile(params.profiles, params.profileId)) {
         params.issues.push(`${params.field} references unknown model profile ${params.profileId}`);
@@ -73,6 +40,7 @@ function validateStepTarget(params) {
  */
 export function validateEffectiveRuntimeModelConfig(params) {
     const issues = [];
+    const capacityIssues = [];
     const providers = params.modelPolicy?.providers ?? {};
     const profiles = params.modelPolicy?.profiles ?? {};
     const invocationProfiles = params.modelPolicy?.invocationProfiles ?? {};
@@ -92,6 +60,7 @@ export function validateEffectiveRuntimeModelConfig(params) {
         }
         validateProfileContextCapacity({
             issues,
+            capacityIssues,
             profileId,
             profile,
             ...(providerId && providers[providerId]
@@ -169,6 +138,6 @@ export function validateEffectiveRuntimeModelConfig(params) {
         });
     }
     if (issues.length > 0) {
-        throw new RuntimeConfigValidationError(params.configPath, issues);
+        throw new RuntimeConfigValidationError(params.configPath, issues, capacityIssues);
     }
 }

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

@@ -137,6 +137,10 @@ export const RUNTIME_CONFIG_SCHEMA_FIELDS = [
         env: [field.env],
         description: field.description,
     })),
+    {
+        path: "webUi.pageSize", type: "positive-number", defaultValue: "20",
+        description: "Sessions and messages per Web UI history page, including SPARK.",
+    },
     {
         path: "webUi.openOnRuntimeServiceStart",
         type: "boolean",
@@ -185,6 +189,12 @@ export const RUNTIME_CONFIG_SCHEMA_FIELDS = [
         defaultValue: "[]",
         description: "Installed plugin or capability ids denied after applying the allow-list.",
     },
+    {
+        path: "plugins.disabledPluginIds",
+        type: "string-array",
+        defaultValue: "[]",
+        description: "Exact plugin ids disabled independently of tool selectors. Entries are literal ids, not wildcards.",
+    },
     {
         path: "models.providers",
         type: "object-map",
@@ -210,6 +220,11 @@ export const RUNTIME_CONFIG_SCHEMA_FIELDS = [
         type: "object-map",
         description: "Per-model calibration slots keyed by semantic slot id. Runtime step config maps modelStep names to these slot ids. Slots may tune timeout, generation, context, format, and short model-specific instructions.",
     },
+    {
+        path: "models.profiles.<profileId>.plugins.deny",
+        type: "string-array",
+        description: "Additional denied plugin or capability selectors for requests selected by this model profile, including configRef profiles. Global plugin restrictions still apply.",
+    },
     {
         path: "models.profiles.<profileId>.execution.policy",
         type: "non-empty-string",

package/dist/src/runtime/config/model-context-capacity.d.ts

@@ -0,0 +1,20 @@
+import type { ModelContextConfig, ModelGatewayPolicyConfig } from "../../model-gateway/types.js";
+import type { RequestRunnerConfig } from "./runner/contracts.js";
+export type ModelContextCapacityIssue = Readonly<{
+    profileId: string;
+    declaredTokens: number;
+    effectiveTokens: number;
+    reservedTokens: number;
+    minimumTokens: number;
+    allocationTokens?: number;
+}>;
+/** Keeps the admission invariant and its diagnostic evidence in one owner. */
+export declare function validateProfileContextCapacity(params: {
+    issues: string[];
+    capacityIssues: ModelContextCapacityIssue[];
+    profileId: string;
+    profile: NonNullable<ModelGatewayPolicyConfig["profiles"]>[string];
+    providerType?: string;
+    runnerConfig: RequestRunnerConfig;
+    defaultContext?: ModelContextConfig;
+}): void;

package/dist/src/runtime/config/model-context-capacity.js

@@ -0,0 +1,55 @@
+function readPositiveContextCapacity(value) {
+    if (typeof value !== "number")
+        return undefined;
+    if (!Number.isSafeInteger(value))
+        return undefined;
+    if (value <= 0)
+        return undefined;
+    return value;
+}
+function hasConfiguredOllamaContextAllocation(providerType, profile) {
+    if (providerType !== "ollama")
+        return false;
+    return Object.hasOwn(profile.options ?? {}, "num_ctx");
+}
+function hasInsufficientModelContextCapacity(effectiveTokens, reservedTokens) {
+    return reservedTokens >= effectiveTokens;
+}
+/** Keeps the admission invariant and its diagnostic evidence in one owner. */
+export function validateProfileContextCapacity(params) {
+    const field = `models.profiles.${params.profileId}.contextWindowTokens`;
+    const declaredTokens = readPositiveContextCapacity(params.profile.contextWindowTokens);
+    if (declaredTokens === undefined) {
+        params.issues.push(`${field} must declare the physical context-window capacity as a positive safe integer`);
+        return;
+    }
+    const hasAllocation = hasConfiguredOllamaContextAllocation(params.providerType, params.profile);
+    const allocationTokens = hasAllocation
+        ? readPositiveContextCapacity(params.profile.options?.num_ctx)
+        : undefined;
+    const hasInvalidOllamaAllocation = hasAllocation && allocationTokens === undefined;
+    if (hasInvalidOllamaAllocation) {
+        params.issues.push(`models.profiles.${params.profileId}.options.num_ctx must be a positive safe integer when configured`);
+        return;
+    }
+    const effectiveTokens = allocationTokens === undefined
+        ? declaredTokens
+        : Math.min(declaredTokens, allocationTokens);
+    const profileFormatReserve = params.profile.context?.formatTokenAccounting?.fixedOverheadTokens ?? 0;
+    const defaultFormatReserve = params.defaultContext?.formatTokenAccounting?.fixedOverheadTokens ?? 0;
+    const reservedTokens = params.runnerConfig.context.outputReserveTokens +
+        params.runnerConfig.context.safetyReserveTokens +
+        params.runnerConfig.context.attachmentReserveTokens +
+        Math.max(profileFormatReserve, defaultFormatReserve);
+    if (!hasInsufficientModelContextCapacity(effectiveTokens, reservedTokens))
+        return;
+    params.issues.push(`models.profiles.${params.profileId} effective context window ${effectiveTokens} must exceed configured output, safety, attachment, and format reserves ${reservedTokens}`);
+    params.capacityIssues.push({
+        profileId: params.profileId,
+        declaredTokens,
+        effectiveTokens,
+        reservedTokens,
+        minimumTokens: reservedTokens + 1,
+        ...(allocationTokens === undefined ? {} : { allocationTokens }),
+    });
+}

package/dist/src/runtime/config/model-execution-policy.d.ts

@@ -1,13 +1,17 @@
+import { type RuntimeModelPluginConfig } from "./model-plugin-config.js";
 export declare const REQUEST_EXECUTION_POLICY_IDS: readonly ["supervisor-worker-v1", "execution-agent-v1"];
 export type RequestExecutionPolicyId = (typeof REQUEST_EXECUTION_POLICY_IDS)[number];
 export declare const DEFAULT_REQUEST_EXECUTION_POLICY_ID: RequestExecutionPolicyId;
 export type RuntimeModelExecutionPolicy = Readonly<{
-    policy: RequestExecutionPolicyId;
+    policy?: RequestExecutionPolicyId;
+    plugins?: RuntimeModelPluginConfig;
 }>;
 export type RuntimeModelExecutionPolicies = Readonly<Record<string, RuntimeModelExecutionPolicy>>;
 export type RequestExecutionPolicySelection = Readonly<{
     policy: RequestExecutionPolicyId;
     primaryProfileId?: string;
+    plugins?: RuntimeModelPluginConfig;
     source: "model_profile" | "default";
 }>;
 export declare function isRequestExecutionPolicyId(value: unknown): value is RequestExecutionPolicyId;
+export declare function buildRuntimeModelExecutionPolicy(source: Record<string, unknown>): RuntimeModelExecutionPolicy | undefined;

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

@@ -1,3 +1,5 @@
+import { buildModelPluginConfig, } from "./model-plugin-config.js";
+import { isRecord } from "./utils.js";
 export const REQUEST_EXECUTION_POLICY_IDS = [
     "supervisor-worker-v1",
     "execution-agent-v1",
@@ -6,3 +8,17 @@ export const DEFAULT_REQUEST_EXECUTION_POLICY_ID = "supervisor-worker-v1";
 export function isRequestExecutionPolicyId(value) {
     return REQUEST_EXECUTION_POLICY_IDS.some((policyId) => policyId === value);
 }
+export function buildRuntimeModelExecutionPolicy(source) {
+    const execution = isRecord(source.execution) ? source.execution : undefined;
+    const configuredPolicy = execution?.policy;
+    const policy = isRequestExecutionPolicyId(configuredPolicy)
+        ? configuredPolicy
+        : undefined;
+    const plugins = buildModelPluginConfig(source.plugins);
+    if (!policy && !plugins)
+        return undefined;
+    return {
+        ...(policy ? { policy } : {}),
+        ...(plugins ? { plugins } : {}),
+    };
+}

package/dist/src/runtime/config/model-plugin-config.d.ts

@@ -0,0 +1,8 @@
+/** Runtime-only restrictions for the canonical request model profile. */
+export type RuntimeModelPluginConfig = Readonly<{
+    deny?: readonly string[];
+}>;
+export declare function captureModelPluginConfig(config: RuntimeModelPluginConfig | undefined): RuntimeModelPluginConfig | undefined;
+export declare function buildModelPluginConfig(value: unknown): RuntimeModelPluginConfig | undefined;
+export declare function validateModelPluginConfig(issues: string[], profile: Record<string, unknown>, displayKey: string): void;
+export declare function modelPluginConfigSchema(): Record<string, unknown>;

package/dist/src/runtime/config/model-plugin-config.js

@@ -0,0 +1,40 @@
+import { readNestedConfigStringArray } from "./utils.js";
+import { validateOptionalObject, validateOptionalStringArray, } from "./validation/runtime-config-field-validation.js";
+export function captureModelPluginConfig(config) {
+    const deny = readNestedConfigStringArray(config, "deny");
+    if (!deny)
+        return undefined;
+    return Object.freeze({ deny: Object.freeze(deny.sort()) });
+}
+export function buildModelPluginConfig(value) {
+    const deny = readNestedConfigStringArray(value, "deny");
+    return captureModelPluginConfig(deny ? { deny } : undefined);
+}
+function isSupportedModelPluginField(key) {
+    return key === "deny";
+}
+export function validateModelPluginConfig(issues, profile, displayKey) {
+    const plugins = validateOptionalObject(issues, profile, "plugins", `${displayKey}.plugins`);
+    if (!plugins)
+        return;
+    for (const key of Object.keys(plugins)) {
+        if (isSupportedModelPluginField(key))
+            continue;
+        issues.push(`${displayKey}.plugins.${key} is not a supported configuration field`);
+    }
+    validateOptionalStringArray(issues, plugins, "deny", `${displayKey}.plugins.deny`);
+}
+export function modelPluginConfigSchema() {
+    return {
+        type: "object",
+        description: "Runtime-only restrictions applied to the entire request selected by this model profile. Global plugin restrictions still apply.",
+        properties: {
+            deny: {
+                type: "array",
+                items: { type: "string" },
+                description: "Denied plugin IDs, capability names, plugin.capability selectors, or *. These restrictions do not depend on per-step model overrides.",
+            },
+        },
+        additionalProperties: false,
+    };
+}

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

@@ -1,3 +1,4 @@
+import { modelPluginConfigSchema } from "./model-plugin-config.js";
 import { DEFAULT_MEMORY_RECALL_CALL_LIMIT } from "../long-term-memory/recall-policy.js";
 import { PATH_CONFIG_FIELDS, STRING_CONFIG_FIELDS, TIMEOUT_CONFIG_FIELDS, } from "./fields.js";
 import { DEFAULT_RUNTIME_LOGGING_ENABLED, DEFAULT_RUNTIME_LOG_ROTATION_CONFIG, } from "./constants.js";
@@ -269,6 +270,7 @@ function pluginsSchema() {
                 default: ["*"],
             },
             deny: stringArraySchema("Installed plugin or capability ids denied after applying the allow-list."),
+            disabledPluginIds: stringArraySchema("Exact plugin ids disabled independently of tool selectors. Entries are literal ids, not wildcards."),
         },
         additionalProperties: false,
     };
@@ -310,8 +312,9 @@ export function createRuntimeConfigJsonSchema() {
             },
             webUi: {
                 type: "object",
-                description: "Local Web UI startup behavior.",
+                description: "Local Web UI behavior.",
                 properties: {
+                    pageSize: { type: "integer", minimum: 1, default: 20, description: "Sessions and messages per Web UI history page, including SPARK." },
                     openOnRuntimeServiceStart: {
                         type: "boolean",
                         default: false,
@@ -456,6 +459,7 @@ export function createRuntimeConfigJsonSchema() {
                                 },
                                 generation: modelGenerationSchema(),
                                 context: modelContextSchema(),
+                                plugins: modelPluginConfigSchema(),
                                 execution: {
                                     type: "object",
                                     description: "Runtime-only request execution policy for this model profile. Omission selects supervisor-worker-v1; execution-agent-v1 is an explicit per-profile opt-in. This metadata is not forwarded to the model gateway.",

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

@@ -1,3 +1,4 @@
+import { validateModelPluginConfig } from "../model-plugin-config.js";
 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";
@@ -79,6 +80,7 @@ export function validateModelProfileConfig(issues, profile, displayKey, options
     if (context) {
         validateModelContextConfig(issues, context, `${displayKey}.context`);
     }
+    validateModelPluginConfig(issues, profile, displayKey);
     const execution = validateOptionalObject(issues, profile, "execution", `${displayKey}.execution`);
     if (execution) {
         validateModelExecutionPolicy(issues, execution, `${displayKey}.execution`);

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

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

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

@@ -1,11 +1,13 @@
 export class RuntimeConfigValidationError extends Error {
+    capacityIssues;
     configPath;
     issues;
-    constructor(configPath, issues) {
+    constructor(configPath, issues, capacityIssues = []) {
         super([
             `Invalid runtime config at ${configPath}:`,
             ...issues.map((issue) => `- ${issue}`),
         ].join("\n"));
+        this.capacityIssues = capacityIssues;
         this.name = "RuntimeConfigValidationError";
         this.configPath = configPath;
         this.issues = issues;