@abot-ai/runtime 1.6.0 → 1.8.0

package/dist/src/runtime/capabilities/automation-builder/payload-instructions.d.ts

@@ -1,6 +1,6 @@
 /** Complete grammar is supplied as bounded passive evidence by prepare_draft. */
-export declare const AUTOMATION_BUILDER_PAYLOAD_INSTRUCTIONS = "Return only JSON following authoringReference from prepare_draft. Use version:1 with commands:[{as,mutation}] for existing drafts. Save all related changes together; new nodes omit id and use earlier aliases in bindings. Outputs never pass implicitly. Agent inputs and tool controls are binding maps; payload is a separate binding. Match exact operation schemas and model IDs. Choose each tool's documented output channel: text may be counts/status only; data without pointer passes the whole structured result when provided. Use data pointers only for known fields; agents need declared JSON output for data bindings. Inputs, limits, controls and selected tools replace their entire field. Never invent schedules or execute future steps.";
+export declare const AUTOMATION_BUILDER_PAYLOAD_INSTRUCTIONS = "Return only JSON following authoringReference from prepare_draft. Use version:1 with commands:[{as,mutation}] for existing drafts. Save all related changes together; new nodes omit id and use earlier aliases in bindings. Outputs never pass implicitly. Agent inputs and tool controls are binding maps; payload is a separate binding. Match exact operation schemas and model IDs. Choose output channels using the selected operation.outputChannels and authoringReference.bindings. Agents need declared JSON results for data. Inputs, limits, controls and selected tools replace their entire field. Never invent schedules or execute future steps.";
 export declare const AUTOMATION_BUILDER_CREATE_SUMMARY = "Create the entire connected automation from settings and ordered steps in one write; Runtime generates IDs and positions. Discover with browse_catalog, then prepare_draft for exact schemas and the authoring reference for planJson. Returns revision 1, generated IDs and the exact saved draft for inspection; no empty draft or separate step edits are needed. Saves only a draft; the user grants permissions, publishes and runs it.";
 export declare const AUTOMATION_BUILDER_APPLY_SUMMARY = "Save related edits atomically. Use the saved draft from read_draft or a builder receipt, with its revision as expectedRevision. operationRefs is the full inventory: select refs needed within preparation.operationRefLimit; use separate prepare_draft reads if needed. Returns the saved draft without another read. Invalid/stale plans save nothing. Single-field edits use this operation too. Users retain permission, publication and run control.";
 /** Creation describes workflow content; the capability compiles mechanical mutation structure. */
-export declare const AUTOMATION_BUILDER_CREATION_INSTRUCTIONS = "Return only JSON using {\"version\":1,\"settings\":{...},\"steps\":[{\"key\":\"first\",\"kind\":\"tool\"|\"agent\",...}]}. Follow authoringReference.createPlanExample and creationRules. settings is optional; steps are ordered with unique keys. Runtime generates IDs, parents, indices and mutation wrappers. Bind prior $key results explicitly. Tool steps need title and exact operation; agent steps need title, exact modelProfileId and prompt. Use documented defaults and tool schemas. Choose each operation's output channel: text may be a count/status summary; data without pointer passes its whole structured result when provided. Field pointers require known fields. Result and acceptance are sibling agent fields. A parallel step is {key,kind:parallel,branches:[stepArrays]}. Leave unspecified timing to the user. Save only an inactive draft; never execute future steps.";
+export declare const AUTOMATION_BUILDER_CREATION_INSTRUCTIONS = "Return only JSON using {\"version\":1,\"settings\":{...},\"steps\":[{\"key\":\"first\",\"kind\":\"tool\"|\"agent\",...}]}. Follow authoringReference.createPlanExample and creationRules. settings is optional; steps are ordered with unique keys. Runtime generates IDs, parents, indices and mutation wrappers. Bind prior $key results explicitly. Tool steps need title and exact operation; agent steps need title, exact modelProfileId and prompt. Use documented defaults and tool schemas. Choose output channels using the selected operation.outputChannels and authoringReference.bindings. Agents need declared JSON results for data. Result and acceptance are sibling agent fields. A parallel step is {key,kind:parallel,branches:[stepArrays]}. Leave unspecified timing to the user. Save only an inactive draft; never execute future steps.";

package/dist/src/runtime/capabilities/automation-builder/payload-instructions.js

@@ -1,6 +1,6 @@
 /** Complete grammar is supplied as bounded passive evidence by prepare_draft. */
-export const AUTOMATION_BUILDER_PAYLOAD_INSTRUCTIONS = "Return only JSON following authoringReference from prepare_draft. Use version:1 with commands:[{as,mutation}] for existing drafts. Save all related changes together; new nodes omit id and use earlier aliases in bindings. Outputs never pass implicitly. Agent inputs and tool controls are binding maps; payload is a separate binding. Match exact operation schemas and model IDs. Choose each tool's documented output channel: text may be counts/status only; data without pointer passes the whole structured result when provided. Use data pointers only for known fields; agents need declared JSON output for data bindings. Inputs, limits, controls and selected tools replace their entire field. Never invent schedules or execute future steps.";
+export const AUTOMATION_BUILDER_PAYLOAD_INSTRUCTIONS = "Return only JSON following authoringReference from prepare_draft. Use version:1 with commands:[{as,mutation}] for existing drafts. Save all related changes together; new nodes omit id and use earlier aliases in bindings. Outputs never pass implicitly. Agent inputs and tool controls are binding maps; payload is a separate binding. Match exact operation schemas and model IDs. Choose output channels using the selected operation.outputChannels and authoringReference.bindings. Agents need declared JSON results for data. Inputs, limits, controls and selected tools replace their entire field. Never invent schedules or execute future steps.";
 export const AUTOMATION_BUILDER_CREATE_SUMMARY = "Create the entire connected automation from settings and ordered steps in one write; Runtime generates IDs and positions. Discover with browse_catalog, then prepare_draft for exact schemas and the authoring reference for planJson. Returns revision 1, generated IDs and the exact saved draft for inspection; no empty draft or separate step edits are needed. Saves only a draft; the user grants permissions, publishes and runs it.";
 export const AUTOMATION_BUILDER_APPLY_SUMMARY = "Save related edits atomically. Use the saved draft from read_draft or a builder receipt, with its revision as expectedRevision. operationRefs is the full inventory: select refs needed within preparation.operationRefLimit; use separate prepare_draft reads if needed. Returns the saved draft without another read. Invalid/stale plans save nothing. Single-field edits use this operation too. Users retain permission, publication and run control.";
 /** Creation describes workflow content; the capability compiles mechanical mutation structure. */
-export const AUTOMATION_BUILDER_CREATION_INSTRUCTIONS = "Return only JSON using {\"version\":1,\"settings\":{...},\"steps\":[{\"key\":\"first\",\"kind\":\"tool\"|\"agent\",...}]}. Follow authoringReference.createPlanExample and creationRules. settings is optional; steps are ordered with unique keys. Runtime generates IDs, parents, indices and mutation wrappers. Bind prior $key results explicitly. Tool steps need title and exact operation; agent steps need title, exact modelProfileId and prompt. Use documented defaults and tool schemas. Choose each operation's output channel: text may be a count/status summary; data without pointer passes its whole structured result when provided. Field pointers require known fields. Result and acceptance are sibling agent fields. A parallel step is {key,kind:parallel,branches:[stepArrays]}. Leave unspecified timing to the user. Save only an inactive draft; never execute future steps.";
+export const AUTOMATION_BUILDER_CREATION_INSTRUCTIONS = "Return only JSON using {\"version\":1,\"settings\":{...},\"steps\":[{\"key\":\"first\",\"kind\":\"tool\"|\"agent\",...}]}. Follow authoringReference.createPlanExample and creationRules. settings is optional; steps are ordered with unique keys. Runtime generates IDs, parents, indices and mutation wrappers. Bind prior $key results explicitly. Tool steps need title and exact operation; agent steps need title, exact modelProfileId and prompt. Use documented defaults and tool schemas. Choose output channels using the selected operation.outputChannels and authoringReference.bindings. Agents need declared JSON results for data. Result and acceptance are sibling agent fields. A parallel step is {key,kind:parallel,branches:[stepArrays]}. Leave unspecified timing to the user. Save only an inactive draft; never execute future steps.";

package/dist/src/runtime/capabilities/automation-builder/tool-contract.d.ts

@@ -22,7 +22,7 @@ export declare const automationBuilderToolContract: {
         };
         readonly selectionControlIds: readonly ["title"];
         readonly payload: {
-            readonly instructions: "Return only JSON using {\"version\":1,\"settings\":{...},\"steps\":[{\"key\":\"first\",\"kind\":\"tool\"|\"agent\",...}]}. Follow authoringReference.createPlanExample and creationRules. settings is optional; steps are ordered with unique keys. Runtime generates IDs, parents, indices and mutation wrappers. Bind prior $key results explicitly. Tool steps need title and exact operation; agent steps need title, exact modelProfileId and prompt. Use documented defaults and tool schemas. Choose each operation's output channel: text may be a count/status summary; data without pointer passes its whole structured result when provided. Field pointers require known fields. Result and acceptance are sibling agent fields. A parallel step is {key,kind:parallel,branches:[stepArrays]}. Leave unspecified timing to the user. Save only an inactive draft; never execute future steps.";
+            readonly instructions: "Return only JSON using {\"version\":1,\"settings\":{...},\"steps\":[{\"key\":\"first\",\"kind\":\"tool\"|\"agent\",...}]}. Follow authoringReference.createPlanExample and creationRules. settings is optional; steps are ordered with unique keys. Runtime generates IDs, parents, indices and mutation wrappers. Bind prior $key results explicitly. Tool steps need title and exact operation; agent steps need title, exact modelProfileId and prompt. Use documented defaults and tool schemas. Choose output channels using the selected operation.outputChannels and authoringReference.bindings. Agents need declared JSON results for data. Result and acceptance are sibling agent fields. A parallel step is {key,kind:parallel,branches:[stepArrays]}. Leave unspecified timing to the user. Save only an inactive draft; never execute future steps.";
             readonly kind: "raw_text";
             readonly param: "planJson";
             readonly minBytes: 2;
@@ -59,7 +59,7 @@ export declare const automationBuilderToolContract: {
             readonly param: "planJson";
             readonly minBytes: 2;
             readonly maxBytes: number;
-            readonly instructions: "Return only JSON following authoringReference from prepare_draft. Use version:1 with commands:[{as,mutation}] for existing drafts. Save all related changes together; new nodes omit id and use earlier aliases in bindings. Outputs never pass implicitly. Agent inputs and tool controls are binding maps; payload is a separate binding. Match exact operation schemas and model IDs. Choose each tool's documented output channel: text may be counts/status only; data without pointer passes the whole structured result when provided. Use data pointers only for known fields; agents need declared JSON output for data bindings. Inputs, limits, controls and selected tools replace their entire field. Never invent schedules or execute future steps.";
+            readonly instructions: "Return only JSON following authoringReference from prepare_draft. Use version:1 with commands:[{as,mutation}] for existing drafts. Save all related changes together; new nodes omit id and use earlier aliases in bindings. Outputs never pass implicitly. Agent inputs and tool controls are binding maps; payload is a separate binding. Match exact operation schemas and model IDs. Choose output channels using the selected operation.outputChannels and authoringReference.bindings. Agents need declared JSON results for data. Inputs, limits, controls and selected tools replace their entire field. Never invent schedules or execute future steps.";
         };
     }];
 };

package/dist/src/runtime/capabilities/automations/authoring-catalog.js

@@ -147,7 +147,7 @@ export async function readAutomationAuthoringCatalogOperation(service, automatio
     const selected = catalog.grantableOperations.find(matchesReference);
     if (!selected)
         throw new Error("automation_catalog_operation_not_found");
-    const { fixedParams: _fixedParams, ...operation } = selected;
+    const { fixedParams: _fixedParams, outputChannels: _outputChannels, ...operation } = selected;
     return {
         kind: "automation_authoring_catalog_operation_v1",
         catalogScope: automationAuthoringCatalogScope(automationId),

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,
+    };
+}