@abot-ai/runtime 1.9.0 → 2.0.0

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

@@ -119,6 +119,7 @@ export function projectAutomationAuthoringCatalogIndex(catalog, offset, automati
         id: model.id, label: model.label.slice(0, LABEL_MAX_LENGTH),
         labelTruncated: model.label.length > LABEL_MAX_LENGTH,
         ...(model.provider ? { provider: model.provider } : {}),
+        ...(model.reasoningControls ? { reasoningControls: model.reasoningControls } : {}),
     })), offset);
     const savedAgents = catalogPage([...catalog.savedAgents]
         .sort((left, right) => left.id.localeCompare(right.id))

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

@@ -36,6 +36,9 @@ export declare function readAutomationAuthoringPreparation(service: CatalogServi
     }[];
     models: {
         items: {
+            reasoningControls?: {
+                budgetTokens: boolean;
+            } | undefined;
             provider?: string | undefined;
             id: string;
             label: string;

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

@@ -1,3 +1,4 @@
+import { modelReasoningControlProperties } from "../model-reasoning-controls.js";
 import { automationAuthoringCatalogOperations } from "./authoring-catalog-contract.js";
 import { automationAuthoringInputOperations } from "./authoring-input-contracts.js";
 const text = (maximum = 4_096) => ({
@@ -45,10 +46,10 @@ export const automationDraftToolContract = {
         operation("remove_folder_source", "Remove the optional folder source.", common, ["automationId", "expectedRevision"]),
         operation("set_run_inputs", "Set named static run inputs using a bounded JSON object, not a whole automation definition.", { ...common, inputsJson: text() }, ["automationId", "expectedRevision", "inputsJson"]),
         operation("set_limits", "Set only supplied positive run limits; omitted limits keep their current values.", { ...common, maxConcurrentNodes: revision, maxModelCallsPerRun: revision, maxToolCallsPerRun: revision, maxRunDurationMs: revision, maxRunsPerDay: revision, maxStoredArtifactBytes: revision, stopReportDeadlineMs: revision }, ["automationId", "expectedRevision"]),
-        operation("add_agent", "Add an agent at the exact position. Placement does not pass earlier outputs; use the returned node ID with bind_step_result to connect each needed earlier result.", { ...common, parentSequenceId: id, index, title: optionalText(160), modelProfileId: optionalText(128), agentMode: choice("fast", "reasoning", "deep"), roleInstructions: optionalText(), prompt: optionalText(), onFailure: choice("stop", "skip") }, ["automationId", "expectedRevision", "parentSequenceId", "index", "title", "modelProfileId", "agentMode", "roleInstructions", "prompt", "onFailure"]),
+        operation("add_agent", "Add an agent at the exact position. Placement does not pass earlier outputs; use the returned node ID with bind_step_result to connect each needed earlier result.", { ...common, parentSequenceId: id, index, title: optionalText(160), modelProfileId: optionalText(128), agentMode: choice("fast", "reasoning", "deep"), ...modelReasoningControlProperties, roleInstructions: optionalText(), prompt: optionalText(), onFailure: choice("stop", "skip") }, ["automationId", "expectedRevision", "parentSequenceId", "index", "title", "modelProfileId", "agentMode", "roleInstructions", "prompt", "onFailure"]),
         operation("add_saved_agent", "Add an exact saved-agent revision as a draft step. It does not inherit an automation grant.", { ...common, parentSequenceId: id, index, agentId: id, agentRevision: revision }, ["automationId", "expectedRevision", "parentSequenceId", "index", "agentId", "agentRevision"]),
         operation("add_tool", "Add a tool step by exact catalog operation reference. Set each input with set_step_literal or bind_step_result; advanced bindings use set_tool_controls.", { ...common, parentSequenceId: id, index, title: optionalText(160), toolName: text(64), operationId: text(64), contractVersion: revision, onFailure: choice("stop", "skip") }, ["automationId", "expectedRevision", "parentSequenceId", "index", "title", "toolName", "operationId", "contractVersion", "onFailure"]),
-        operation("edit_agent", "Edit selected agent fields without rewriting its other configuration.", { ...node, modelProfileId: optionalText(128), agentMode: choice("fast", "reasoning", "deep"), roleInstructions: optionalText(), prompt: optionalText() }, ["automationId", "expectedRevision", "nodeId"]),
+        operation("edit_agent", "Edit selected agent fields without rewriting its other configuration.", { ...node, modelProfileId: optionalText(128), agentMode: choice("fast", "reasoning", "deep"), ...modelReasoningControlProperties, roleInstructions: optionalText(), prompt: optionalText() }, ["automationId", "expectedRevision", "nodeId"]),
         operation("set_step_policy", "Set a step's title or failure behavior; skip continues after a failed step, stop ends the run.", { ...node, title: optionalText(160), onFailure: choice("stop", "skip") }, ["automationId", "expectedRevision", "nodeId"]),
         ...automationAuthoringInputOperations,
         operation("set_agent_inputs", "Advanced: replace all named agent inputs with canonical bindings JSON. Prefer bind_step_result for one earlier result. Example: {\"source\":{\"kind\":\"node_result\",\"nodeId\":\"<id>\",\"select\":\"text\"}}. Unbound outputs are not passed.", { ...node, bindingsJson: text() }, ["automationId", "expectedRevision", "nodeId", "bindingsJson"]),

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

@@ -1,3 +1,5 @@
+import { readCreatedModelReasoningControls, readUpdatedModelReasoningControls } from "../model-reasoning-controls.js";
+import { findAutomationStep } from "../../automations/step-evidence-effects.js";
 import { CORE_TOOL_CONTRACTS } from "../core-tool-contracts.js";
 import { Buffer } from "node:buffer";
 import { AUTOMATION_TOOL_EVENT_PRESENTATION } from "./event-presentation.js";
@@ -43,11 +45,12 @@ function jsonArray(params, key) {
         throw new Error("automation_graph_invalid");
     return value;
 }
-function supplied(params, keys) {
-    const patch = Object.fromEntries(keys
-        .filter((key) => params[key] !== undefined)
-        .map((key) => [key, params[key]]));
-    if (Object.keys(patch).length === 0)
+function supplied(params, keys, parsedPatch = {}) {
+    const patch = { ...Object.fromEntries(keys
+            .filter((key) => params[key] !== undefined)
+            .map((key) => [key, params[key]])), ...parsedPatch };
+    const hasNoSuppliedFields = Object.keys(patch).length === 0;
+    if (hasNoSuppliedFields)
         throw new Error("automation_graph_invalid");
     return patch;
 }
@@ -188,6 +191,7 @@ async function execute(service, params) {
             index: requiredInteger(params, "index"), nodeWithoutId: {
                 kind: "agent", title: params.title, onFailure: params.onFailure,
                 modelProfileId: params.modelProfileId, agentMode: params.agentMode,
+                ...readCreatedModelReasoningControls(params, params.modelProfileId),
                 roleInstructions: params.roleInstructions, prompt: params.prompt,
                 inputs: {}, tools: [], result: { kind: "text" },
             } });
@@ -213,9 +217,14 @@ async function execute(service, params) {
                     contractVersion: params.contractVersion }, controls: {},
             } });
     const nodeId = requiredText(params, "nodeId");
-    if (action === "edit_agent")
+    if (action === "edit_agent") {
+        const draft = await service.getDraft(automationId);
+        const target = draft && findAutomationStep(draft.definition.body, nodeId);
+        const previousProfileId = target?.kind === "agent" ? target.modelProfileId : undefined;
+        const profileId = params.modelProfileId ?? previousProfileId;
         return mutate(service, params, { kind: "update_node", nodeId,
-            patch: supplied(params, ["modelProfileId", "agentMode", "roleInstructions", "prompt"]) });
+            patch: supplied(params, ["modelProfileId", "agentMode", "roleInstructions", "prompt"], readUpdatedModelReasoningControls(params, previousProfileId, profileId)) });
+    }
     if (action === "set_step_policy")
         return mutate(service, params, { kind: "update_node", nodeId,
             patch: supplied(params, ["title", "onFailure"]) });

package/dist/src/runtime/capabilities/model-reasoning-controls.d.ts

@@ -0,0 +1,23 @@
+import { type ModelReasoningPreference } from "../../shared/model-reasoning.js";
+/** Flat v1 tool inputs project to the canonical nested Runtime request contract. */
+export declare const modelReasoningControlProperties: {
+    reasoningMode: {
+        type: "string";
+        enum: string[];
+    };
+    reasoningBudgetTokens: {
+        type: "integer";
+        minimum: number;
+        maximum: number;
+    };
+};
+export declare function readModelReasoningControlPatch(params: Readonly<Record<string, unknown>>, profileId: unknown): {
+    reasoningPreference?: ModelReasoningPreference | null;
+};
+/** Tool model switches inherit the new profile unless controls are explicit. */
+export declare function readUpdatedModelReasoningControls(params: Readonly<Record<string, unknown>>, previousProfileId: unknown, nextProfileId: unknown): {
+    reasoningPreference?: ModelReasoningPreference | null;
+};
+export declare function readCreatedModelReasoningControls(params: Readonly<Record<string, unknown>>, profileId: unknown): {
+    reasoningPreference?: ModelReasoningPreference;
+};

package/dist/src/runtime/capabilities/model-reasoning-controls.js

@@ -0,0 +1,56 @@
+import { MAX_REASONING_BUDGET_TOKENS, ModelReasoningConfigurationError, parseModelReasoningPreference, } from "../../shared/model-reasoning.js";
+/** Flat v1 tool inputs project to the canonical nested Runtime request contract. */
+export const modelReasoningControlProperties = {
+    reasoningMode: {
+        type: "string",
+        enum: ["inherit", "off", "budget", "server-default"],
+    },
+    reasoningBudgetTokens: {
+        type: "integer",
+        minimum: 0,
+        maximum: MAX_REASONING_BUDGET_TOKENS,
+    },
+};
+function hasUnboundReasoningTokenControl(params) {
+    if (params.reasoningBudgetTokens === undefined)
+        return false;
+    return params.reasoningMode !== "budget";
+}
+export function readModelReasoningControlPatch(params, profileId) {
+    if (hasUnboundReasoningTokenControl(params))
+        throw new ModelReasoningConfigurationError("invalid_reasoning_preference", "reasoningBudgetTokens requires reasoningMode=budget");
+    if (params.reasoningMode === undefined)
+        return {};
+    if (params.reasoningMode === "inherit")
+        return { reasoningPreference: null };
+    const preference = parseModelReasoningPreference({
+        profileId,
+        mode: params.reasoningMode,
+        ...(params.reasoningBudgetTokens !== undefined
+            ? { budgetTokens: params.reasoningBudgetTokens }
+            : {}),
+    });
+    return { reasoningPreference: preference };
+}
+function hasChangedReasoningModelProfile(previousProfileId, nextProfileId) {
+    if (typeof previousProfileId !== "string")
+        return false;
+    if (typeof nextProfileId !== "string")
+        return false;
+    return previousProfileId !== nextProfileId;
+}
+/** Tool model switches inherit the new profile unless controls are explicit. */
+export function readUpdatedModelReasoningControls(params, previousProfileId, nextProfileId) {
+    const patch = readModelReasoningControlPatch(params, nextProfileId);
+    if ("reasoningPreference" in patch)
+        return patch;
+    if (!hasChangedReasoningModelProfile(previousProfileId, nextProfileId))
+        return patch;
+    return { reasoningPreference: null };
+}
+export function readCreatedModelReasoningControls(params, profileId) {
+    const patch = readModelReasoningControlPatch(params, profileId);
+    if (!patch.reasoningPreference)
+        return {};
+    return { reasoningPreference: patch.reasoningPreference };
+}

package/dist/src/runtime/capabilities/scheduling/create-operations.js

@@ -1,3 +1,4 @@
+import { modelReasoningControlProperties } from "../model-reasoning-controls.js";
 import { scheduleDetailProperties, scheduleTimingProperties, } from "./tool-input-properties.js";
 function createScheduleOperation(kind, timingSummary, timingFields, requiredTiming = timingFields) {
     return {
@@ -11,6 +12,7 @@ function createScheduleOperation(kind, timingSummary, timingFields, requiredTimi
             additionalProperties: false,
             properties: {
                 ...scheduleDetailProperties,
+                ...modelReasoningControlProperties,
                 timeZone: scheduleTimingProperties.timeZone,
                 ...Object.fromEntries(timingFields.map((field) => [field, scheduleTimingProperties[field]])),
             },

package/dist/src/runtime/capabilities/scheduling/job-list-page.d.ts

@@ -14,6 +14,7 @@ export declare function createSchedulerJobPage(jobs: readonly SchedulerJob[], pa
         title: string;
         modelProfileId: string;
         agentMode: import("../../../shared/types.js").AgentMode;
+        reasoningPreference?: import("../../../shared/model-reasoning.js").ModelReasoningPreference;
         toolPermissionMode: import("../../scheduler/tool-permission-mode.js").SchedulerToolPermissionMode;
         timeZone: string;
         schedule: import("../../scheduler/contracts.js").SchedulerTimedSchedule;

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

@@ -1,3 +1,4 @@
+import { readCreatedModelReasoningControls, readUpdatedModelReasoningControls } from "../model-reasoning-controls.js";
 import { CORE_TOOL_CONTRACTS } from "../core-tool-contracts.js";
 import { resolveModelSelection } from "../../model/model-selection.js";
 import { requireCreateCalendarTimeZone } from "./create-time-zone.js";
@@ -42,11 +43,12 @@ function scheduleInput(params) {
         };
     throw new Error("schedule_kind_required");
 }
-function updateInput(params, config) {
+function updateInput(params, config, modelProfileId) {
     if (params.modelProfileId !== undefined) {
         requireAvailableScheduleModel(config, params.modelProfileId);
     }
     return {
+        ...readUpdatedModelReasoningControls(params, modelProfileId, params.modelProfileId ?? modelProfileId),
         ...(params.title !== undefined
             ? { title: requireText(params.title, "title") }
             : {}),
@@ -91,6 +93,7 @@ export function createSchedulingToolModule(service, config, ready) {
                 prompt: requireText(params.prompt, "prompt"),
                 modelProfileId: requireText(selection.execution.primaryProfileId, "model"),
                 agentMode: selection.agentMode,
+                ...readCreatedModelReasoningControls(params, selection.execution.primaryProfileId),
                 timeZone: params.timeZone
                     ? requireText(params.timeZone, "time_zone")
                     : Intl.DateTimeFormat().resolvedOptions().timeZone,
@@ -109,7 +112,7 @@ export function createSchedulingToolModule(service, config, ready) {
                 runs: [...(await service.listRuns(id, { limit: 20 }))].reverse(),
             };
         if (action === "update")
-            return service.update(id, updateInput(params, config));
+            return service.update(id, updateInput(params, config, job.modelProfileId));
         if (action === "pause")
             return service.pause(id);
         if (action === "resume")

package/dist/src/runtime/capabilities/scheduling/update-operations.js

@@ -1,7 +1,9 @@
+import { modelReasoningControlProperties } from "../model-reasoning-controls.js";
 import { scheduleDetailProperties, scheduleTextField, scheduleTimingProperties, } from "./tool-input-properties.js";
 const editableJobProperties = {
     jobId: scheduleTextField(200),
     ...scheduleDetailProperties,
+    ...modelReasoningControlProperties,
     modelProfileId: scheduleTextField(200),
     agentMode: { type: "string", enum: ["fast", "reasoning", "deep"] },
     timeZone: scheduleTimingProperties.timeZone,

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

@@ -1,3 +1,5 @@
+import { parseModelReasoningBudgetByMode } from "../../shared/model-reasoning-modes.js";
+import { parseModelReasoningBudget } from "../../shared/model-reasoning.js";
 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";
@@ -316,6 +318,8 @@ export function buildModelGenerationConfig(value) {
     if (!isRecord(value)) {
         return undefined;
     }
+    const reasoningBudget = parseModelReasoningBudget(value.reasoningBudget);
+    const reasoningBudgetByMode = parseModelReasoningBudgetByMode(value.reasoningBudgetByMode);
     const temperature = readOptionalNumber(value, "temperature");
     const topP = readOptionalNumber(value, "topP");
     const reasoningEffort = value.reasoningEffort === "none" ||
@@ -330,6 +334,8 @@ export function buildModelGenerationConfig(value) {
         ...(temperature !== undefined ? { temperature } : {}),
         ...(topP !== undefined ? { topP } : {}),
         ...(reasoningEffort ? { reasoningEffort } : {}),
+        ...(reasoningBudget ? { reasoningBudget } : {}),
+        ...(reasoningBudgetByMode ? { reasoningBudgetByMode } : {}),
     };
     return Object.keys(config).length > 0 ? config : undefined;
 }

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

@@ -1,3 +1,5 @@
+import { validateEffectiveReasoningBudgets } from "./model-reasoning-validation.js";
+import { validateLlamaCppProfileCapabilities } from "./llamacpp-profile-validation.js";
 import { validateProfileContextCapacity, } from "./model-context-capacity.js";
 import { RuntimeConfigValidationError } from "./validation.js";
 function hasConfiguredProfile(profiles, profileId) {
@@ -41,6 +43,8 @@ function validateStepTarget(params) {
 export function validateEffectiveRuntimeModelConfig(params) {
     const issues = [];
     const capacityIssues = [];
+    validateEffectiveReasoningBudgets(issues, params.modelPolicy);
+    validateLlamaCppProfileCapabilities(issues, params.modelPolicy);
     const providers = params.modelPolicy?.providers ?? {};
     const profiles = params.modelPolicy?.profiles ?? {};
     const invocationProfiles = params.modelPolicy?.invocationProfiles ?? {};

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

@@ -0,0 +1,3 @@
+import type { ModelGatewayPolicyConfig } from "../../model-gateway/types.js";
+/** The current adapter is text-only even when the underlying server has a projector. */
+export declare function validateLlamaCppProfileCapabilities(issues: string[], policy?: ModelGatewayPolicyConfig): void;

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

@@ -0,0 +1,15 @@
+function requestsUnsupportedLlamaImageInput(profile, policy) {
+    if (policy.providers?.[profile.provider ?? ""]?.type !== "llamacpp")
+        return false;
+    return profile.capabilities?.inputModalities?.includes("image") === true;
+}
+/** The current adapter is text-only even when the underlying server has a projector. */
+export function validateLlamaCppProfileCapabilities(issues, policy) {
+    if (!policy)
+        return;
+    for (const [id, profile] of Object.entries(policy.profiles ?? {})) {
+        if (!requestsUnsupportedLlamaImageInput(profile, policy))
+            continue;
+        issues.push(`models.profiles.${id}.capabilities.inputModalities: the llamacpp adapter supports text only`);
+    }
+}

package/dist/src/runtime/config/model-reasoning-schema.d.ts

@@ -0,0 +1,40 @@
+export declare const modelReasoningBudgetSchema: {
+    description: string;
+    oneOf: ({
+        type: string;
+        additionalProperties: boolean;
+        required: string[];
+        properties: {
+            mode: {
+                const: string;
+            };
+            tokens: {
+                type: string;
+                minimum: number;
+                maximum: number;
+            };
+        };
+    } | {
+        type: string;
+        additionalProperties: boolean;
+        required: string[];
+        properties: {
+            mode: {
+                const: string;
+            };
+            tokens?: undefined;
+        };
+    })[];
+};
+export declare const modelReasoningBudgetByModeSchema: {
+    type: string;
+    description: string;
+    additionalProperties: boolean;
+    properties: {
+        [k: string]: {
+            type: string;
+            minimum: number;
+            maximum: number;
+        };
+    };
+};

package/dist/src/runtime/config/model-reasoning-schema.js

@@ -0,0 +1,38 @@
+import { MAX_REASONING_BUDGET_TOKENS } from "../../shared/model-reasoning.js";
+export const modelReasoningBudgetSchema = {
+    description: "Reasoning-only budget for a declared budget-capable model. Zero disables thinking. Omit to inherit.",
+    oneOf: [
+        {
+            type: "object",
+            additionalProperties: false,
+            required: ["mode", "tokens"],
+            properties: {
+                mode: { const: "tokens" },
+                tokens: {
+                    type: "integer",
+                    minimum: 0,
+                    maximum: MAX_REASONING_BUDGET_TOKENS,
+                },
+            },
+        },
+        {
+            type: "object",
+            additionalProperties: false,
+            required: ["mode"],
+            properties: { mode: { const: "server-default" } },
+        },
+    ],
+};
+export const modelReasoningBudgetByModeSchema = {
+    type: "object",
+    description: "Optional llama.cpp token budgets for main-step Low/Reasoning/Deep presets. Omit to inherit; {} clears the inherited map. A provided map replaces the whole parent map. Zero disables thinking; positive mode budgets enable it.",
+    additionalProperties: false,
+    properties: Object.fromEntries(["fast", "reasoning", "deep"].map((mode) => [
+        mode,
+        {
+            type: "integer",
+            minimum: 0,
+            maximum: MAX_REASONING_BUDGET_TOKENS,
+        },
+    ])),
+};

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

@@ -0,0 +1,3 @@
+import type { ModelGatewayPolicyConfig } from "../../model-gateway/types.js";
+/** Run after configRef materialization, before accepting any Runtime request. */
+export declare function validateEffectiveReasoningBudgets(issues: string[], policy: ModelGatewayPolicyConfig | undefined): void;

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

@@ -0,0 +1,37 @@
+import { supportsModelReasoningBudget } from "../../shared/model-reasoning.js";
+function validateBoundBudget(issues, policy, profile, budget, path) {
+    if (budget === undefined)
+        return;
+    if (!profile)
+        return; // The model-reference owner diagnoses missing targets.
+    const provider = policy.providers?.[profile.provider ?? ""];
+    if (supportsModelReasoningBudget({
+        provider: provider?.type ?? "",
+        supportsThinking: profile.supportsThinking,
+    }))
+        return;
+    issues.push(`${path} requires a llamacpp profile with supportsThinking: true`);
+}
+function validateGenerationBudgets(issues, policy, profile, generation, path) {
+    for (const key of ["reasoningBudget", "reasoningBudgetByMode"]) {
+        validateBoundBudget(issues, policy, profile, generation?.[key], `${path}.${key}`);
+    }
+}
+/** Run after configRef materialization, before accepting any Runtime request. */
+export function validateEffectiveReasoningBudgets(issues, policy) {
+    if (!policy)
+        return;
+    const profiles = policy.profiles ?? {};
+    for (const [id, profile] of Object.entries(profiles)) {
+        validateGenerationBudgets(issues, policy, profile, profile.generation, `models.profiles.${id}.generation`);
+        for (const [slot, calibration] of Object.entries(profile.calibration ?? {})) {
+            const target = calibration.profileId
+                ? profiles[calibration.profileId]
+                : profile;
+            validateGenerationBudgets(issues, policy, target, calibration.generation, `models.profiles.${id}.calibration.${slot}.generation`);
+        }
+    }
+    for (const [id, invocation] of Object.entries(policy.invocationProfiles ?? {})) {
+        validateGenerationBudgets(issues, policy, profiles[invocation.profileId], invocation.generation, `models.invocationProfiles.${id}.generation`);
+    }
+}

package/dist/src/runtime/config/runner/step-instructions.d.ts

@@ -1,6 +1,7 @@
 import type { ChatMessage, ModelTokenEstimationConfig } from "../../../model-gateway/types.js";
 import type { ModelStep } from "../../../shared/model-steps.js";
 import type { RequestRunnerConfig } from "./contracts.js";
+export type ConfiguredStepInstructionPolicy = "omit";
 export type ConfiguredStepInstructionMetadata = Readonly<{
     blockCount: number;
     characterCount: number;
@@ -13,11 +14,13 @@ export type ConfiguredStepInstructionMetadata = Readonly<{
 export declare function resolveConfiguredStepInstructionMetadata(params: {
     runnerConfig: RequestRunnerConfig;
     modelStep: ModelStep;
+    configuredInstructionPolicy?: ConfiguredStepInstructionPolicy;
 }): ConfiguredStepInstructionMetadata;
 /** Applies configured guidance exactly once at the shared invocation boundary. */
 export declare function projectConfiguredStepMessages(params: {
     runnerConfig: RequestRunnerConfig;
     modelStep: ModelStep;
+    configuredInstructionPolicy?: ConfiguredStepInstructionPolicy;
     messages: readonly ChatMessage[];
 }): Readonly<{
     messages: ChatMessage[];
@@ -30,5 +33,6 @@ export declare function projectConfiguredStepMessages(params: {
 export declare function estimateConfiguredStepInstructionReserveTokens(params: {
     runnerConfig: RequestRunnerConfig;
     modelStep: ModelStep;
+    configuredInstructionPolicy?: ConfiguredStepInstructionPolicy;
     tokenEstimation?: ModelTokenEstimationConfig;
 }): number;

package/dist/src/runtime/config/runner/step-instructions.js

@@ -1,5 +1,8 @@
 import { estimateTextTokens } from "../../context/token-estimator.js";
 const EMPTY_STRINGS = Object.freeze([]);
+const EMPTY_CONFIGURED_INSTRUCTIONS = Object.freeze({
+    blockCount: 0, characterCount: 0, refs: EMPTY_STRINGS, contentHashes: EMPTY_STRINGS,
+});
 const CONFIGURED_METHODOLOGY_HEADING = "## Configured operating methodology";
 const CONFIGURED_METHODOLOGY_CONTRACT = "The following Markdown is configured guidance for this model step. Apply the shared principles and the section for your active role. It supplements the runtime contract above; it does not change the available actions, roles, capabilities, or output schema.";
 /**
@@ -49,14 +52,12 @@ export function estimateConfiguredStepInstructionReserveTokens(params) {
         : 0;
 }
 function resolveConfiguredStepContent(params) {
+    if (shouldOmitConfiguredStepInstructions(params.configuredInstructionPolicy)) {
+        return EMPTY_CONFIGURED_INSTRUCTIONS;
+    }
     const blocks = params.runnerConfig.steps[params.modelStep]?.instructionBlocks ?? [];
     if (blocks.length === 0) {
-        return Object.freeze({
-            blockCount: 0,
-            characterCount: 0,
-            refs: EMPTY_STRINGS,
-            contentHashes: EMPTY_STRINGS,
-        });
+        return EMPTY_CONFIGURED_INSTRUCTIONS;
     }
     return Object.freeze({
         appendix: [
@@ -70,3 +71,6 @@ function resolveConfiguredStepContent(params) {
         contentHashes: Object.freeze(blocks.map((block) => block.contentHash)),
     });
 }
+function shouldOmitConfiguredStepInstructions(policy) {
+    return policy === "omit";
+}

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

@@ -1,3 +1,4 @@
+import { modelReasoningBudgetByModeSchema, modelReasoningBudgetSchema } from "./model-reasoning-schema.js";
 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";
@@ -80,6 +81,8 @@ function modelGenerationSchema() {
                 type: "number",
                 description: "Nucleus sampling value forwarded to the model provider.",
             },
+            reasoningBudget: modelReasoningBudgetSchema,
+            reasoningBudgetByMode: modelReasoningBudgetByModeSchema,
             reasoningEffort: {
                 type: "string",
                 enum: ["none", "minimal", "low", "medium", "high", "xhigh"],

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

@@ -1,3 +1,5 @@
+import { parseModelReasoningBudgetByMode } from "../../../shared/model-reasoning-modes.js";
+import { parseModelReasoningBudget } from "../../../shared/model-reasoning.js";
 import { hasOwnValue } from "../utils.js";
 import { validateOptionalNonNegativeInteger, validateOptionalNumber, validateOptionalObject, validateOptionalPositiveNumber, } from "./runtime-config-field-validation.js";
 const SUPPORTED_MODEL_REASONING_EFFORTS = new Set([
@@ -53,6 +55,18 @@ export function validateModelContextConfig(issues, context, displayKey) {
     }
 }
 export function validateModelGenerationConfig(issues, generation, displayKey) {
+    try {
+        parseModelReasoningBudget(generation.reasoningBudget);
+    }
+    catch (error) {
+        issues.push(`${displayKey}.reasoningBudget: ${String(error)}`);
+    }
+    try {
+        parseModelReasoningBudgetByMode(generation.reasoningBudgetByMode);
+    }
+    catch (error) {
+        issues.push(`${displayKey}.reasoningBudgetByMode: ${String(error)}`);
+    }
     if (hasOwnValue(generation, "maxOutputTokens")) {
         issues.push(`${displayKey}.maxOutputTokens is not supported; remove it and let the provider enforce physical output capacity`);
     }

package/dist/src/runtime/context/compacted-capability-result-receipt.d.ts

@@ -4,4 +4,6 @@ type CompactedResultContent = Pick<RequestToolResult, "adapterResult" | "referen
 export declare function projectCompactedCapabilityResultReceipt<Result extends CompactedResultContent>(result: Result): Readonly<Omit<Omit<Result, "adapterResult"> & {
     summary: string;
 }, "referenceData">>;
+/** The caller must verify that the registered output belongs to the covered source. */
+export declare function projectCompactedRegisteredOutputSummary(summary: string, registeredOutput: string | undefined): string;
 export {};

package/dist/src/runtime/context/compacted-capability-result-receipt.js

@@ -4,19 +4,20 @@ export function projectCompactedCapabilityResultReceipt(result) {
     const { adapterResult: _adapterResult, ...metadata } = result;
     const receipt = {
         ...metadata,
-        summary: isSummaryCoveredByCompactedResult(result)
-            ? "Result evidence is available in the verified compacted source."
-            : result.summary,
+        summary: projectCompactedRegisteredOutputSummary(result.summary, result.adapterResult?.kind === "registered_tool_execution_result_v1"
+            ? result.adapterResult.result.output
+            : undefined),
     };
     if (!isReferenceDataCoveredByCompactedResult(result))
         return Object.freeze(receipt);
     const { referenceData: _referenceData, ...coveredReceipt } = receipt;
     return Object.freeze(coveredReceipt);
 }
-function isSummaryCoveredByCompactedResult(result) {
-    if (result.adapterResult?.kind !== "registered_tool_execution_result_v1")
-        return false;
-    return result.summary === result.adapterResult.result.output;
+/** The caller must verify that the registered output belongs to the covered source. */
+export function projectCompactedRegisteredOutputSummary(summary, registeredOutput) {
+    return summary === registeredOutput
+        ? "Result evidence is available in the verified compacted source."
+        : summary;
 }
 function isReferenceDataCoveredByCompactedResult(result) {
     if (isReferenceDataRepresentedByAdapterResult(result))

package/dist/src/runtime/context/execution-compacted-evidence.d.ts

@@ -21,6 +21,10 @@ type ExecutionEvidenceProjection = Readonly<{
     objective: string;
     callId: string;
     store?: RequestContextCompactionStore;
+    updates?: readonly Readonly<{
+        text: string;
+    }>[];
+    sourceRevision?: number;
     results: readonly ExecutionEvidenceIdentity[];
 }>;
 /** Resolve only source digests; never transfer the root's continuation authority. */

package/dist/src/runtime/context/execution-compacted-evidence.js

@@ -1,15 +1,11 @@
-import { executionCompactionScopeId } from "./execution-compaction-objective.js";
+import { resolveExecutionEvidenceCheckpoint } from "./execution-compaction-checkpoint-selection.js";
 import { isDeepStrictEqual } from "node:util";
-import { MODEL_STEPS } from "../../shared/model-steps.js";
-import { createSemanticCompactionSha256Fingerprint, } from "./semantic-compaction/contracts.js";
 /** Resolve only source digests; never transfer the root's continuation authority. */
 export function resolveExecutionCompactedSources(params) {
     const store = params.store;
     if (!store)
         return undefined;
-    const checkpoint = store
-        .findByCallIds([params.callId])
-        .find((candidate) => canReuseExecutionCheckpoint(candidate, params));
+    const checkpoint = resolveExecutionEvidenceCheckpoint(params);
     if (!checkpoint)
         return undefined;
     const digests = new Map(checkpoint.sourceDigests.map((digest) => [digest.sourceRef, digest]));
@@ -33,23 +29,6 @@ export function resolveExecutionCompactedSources(params) {
         sources: Object.freeze(sources),
     });
 }
-function canReuseExecutionCheckpoint(checkpoint, params) {
-    if (checkpoint.requestId !== params.requestId)
-        return false;
-    if (checkpoint.callId !== params.callId)
-        return false;
-    if (checkpoint.roleId !== "supervisor")
-        return false;
-    if (checkpoint.scopeId !== executionCompactionScopeId(params))
-        return false;
-    if (checkpoint.currentRequestFingerprint !==
-        createSemanticCompactionSha256Fingerprint(params.prompt))
-        return false;
-    if (checkpoint.objectiveFingerprint !==
-        createSemanticCompactionSha256Fingerprint(params.objective))
-        return false;
-    return checkpoint.allowedConsumers.includes(MODEL_STEPS.EXECUTION_DECISION);
-}
 export function matchesCompactedExecutionResult(content, result) {
     const message = readCompactionRecord(content);
     if (message?.role !== "tool")