@abot-ai/runtime 1.8.1 → 2.0.0

package/dist/src/runtime/automations/definition-input.js

@@ -1,3 +1,4 @@
+import { parseBoundModelReasoningPreference } from "../../shared/model-reasoning.js";
 import { Buffer } from "node:buffer";
 import { isAutomationRunFileName } from "./run-file-binding.js";
 import { AUTOMATION_GRAPH_LIMITS } from "./limits.js";
@@ -150,8 +151,9 @@ function node(value, path, depth) {
     }
     if (input.kind !== "agent")
         invalid(`${path}.kind`);
-    onlyKeys(input, ["kind", "id", "title", "onFailure", "modelProfileId", "agentMode", "roleInstructions", "prompt", "inputs", "tools", "result", "acceptance", "savedAgentOrigin"], path);
+    onlyKeys(input, ["kind", "id", "title", "onFailure", "modelProfileId", "agentMode", "reasoningPreference", "roleInstructions", "prompt", "inputs", "tools", "result", "acceptance", "savedAgentOrigin"], path);
     text(input.modelProfileId, `${path}.modelProfileId`, 128);
+    parseBoundModelReasoningPreference(input.reasoningPreference, String(input.modelProfileId));
     if (!["fast", "reasoning", "deep"].includes(String(input.agentMode)))
         invalid(`${path}.agentMode`);
     text(input.roleInstructions, `${path}.roleInstructions`);

package/dist/src/runtime/automations/draft-mutations.js

@@ -6,7 +6,7 @@ const DEFINITION_EDITABLE = new Set([
 ]);
 const NODE_EDITABLE = new Set([
     "title", "onFailure", "operation", "controls", "payload", "modelProfileId",
-    "agentMode", "roleInstructions", "prompt", "inputs", "tools", "result",
+    "agentMode", "reasoningPreference", "roleInstructions", "prompt", "inputs", "tools", "result",
     "acceptance", "savedAgentOrigin",
 ]);
 function error(code) {
@@ -131,6 +131,10 @@ function mutateNode(root, mutation) {
                 delete found.node.payload;
                 delete normalized.payload;
             }
+            if (normalized.reasoningPreference === null) {
+                delete found.node.reasoningPreference;
+                delete normalized.reasoningPreference;
+            }
             Object.assign(found.node, normalized);
             return;
         }

package/dist/src/runtime/automations/model-dependency-projection.d.ts

@@ -36,6 +36,8 @@ export declare function projectAutomationModelDependencies(config: RuntimeConfig
             timeoutMs: number;
             model: string;
             think?: import("../../shared/types.js").ModelReasoningLevel;
+            reasoningBudget?: import("../../shared/model-reasoning.js").ModelReasoningBudget;
+            reasoningControlSource?: "invocation" | "request" | "configuration" | "agent-mode";
             format?: import("../../model-gateway/types.js").ModelGatewayFormat;
             instructions: string[] | Readonly<{
                 blockCount: number;
@@ -45,7 +47,7 @@ export declare function projectAutomationModelDependencies(config: RuntimeConfig
             }> | undefined;
             modelStep: "learning.batch" | "supervisor.decision" | "supervisor.response" | "worker.decision" | "worker.result" | "capability.controls" | "planner.decision" | "planner.graph" | "reviewer.decision" | "degraded.finalization" | "execution.decision" | "execution.response" | "auditor.decision" | "context.compact" | "tool_payload.raw";
         } | {
-            unavailable: import("../../model-gateway/invocation-policy.js").ModelInvocationResolutionErrorCode;
+            unavailable: string;
             modelStep: "learning.batch" | "supervisor.decision" | "supervisor.response" | "worker.decision" | "worker.result" | "capability.controls" | "planner.decision" | "planner.graph" | "reviewer.decision" | "degraded.finalization" | "execution.decision" | "execution.response" | "auditor.decision" | "context.compact" | "tool_payload.raw";
             instructions: Readonly<{
                 blockCount: number;

package/dist/src/runtime/automations/model-dependency-projection.js

@@ -1,3 +1,4 @@
+import { ModelReasoningConfigurationError } from "../../shared/model-reasoning.js";
 import { ModelInvocationResolutionError, resolveModelInvocation, } from "../../model-gateway/invocation-policy.js";
 import { MODEL_STEPS } from "../../shared/model-steps.js";
 import { loadRequestRunnerConfig } from "../config/runner/loader.js";
@@ -35,6 +36,7 @@ function invocationDependency(input) {
     try {
         const invocation = resolveModelInvocation({
             agentMode: input.node.agentMode, modelPreference,
+            ...(input.node.reasoningPreference ? { reasoningPreference: input.node.reasoningPreference } : {}),
             modelStep: input.modelStep, modelPolicy: input.modelPolicy,
         });
         // Unused calibration slots and display labels are not execution dependencies.
@@ -46,7 +48,7 @@ function invocationDependency(input) {
         return { ...dependency, ...invocation, profile, timeoutMs: timeout.timeoutMs };
     }
     catch (error) {
-        if (!(error instanceof ModelInvocationResolutionError))
+        if (!(error instanceof ModelInvocationResolutionError) && !(error instanceof ModelReasoningConfigurationError))
             throw error;
         return { ...dependency, unavailable: error.code };
     }
@@ -62,7 +64,7 @@ export function projectAutomationModelDependencies(config, nodes) {
         : config.models;
     const selected = new Map();
     for (const node of nodes) {
-        const key = JSON.stringify([node.modelProfileId, node.agentMode]);
+        const key = JSON.stringify(node.reasoningPreference ? [node.modelProfileId, node.agentMode, node.reasoningPreference] : [node.modelProfileId, node.agentMode]);
         const hasTools = node.tools.length > 0 || selected.get(key)?.hasTools === true;
         selected.set(key, { node, hasTools });
     }

package/dist/src/runtime/automations/publication-validation.js

@@ -1,3 +1,4 @@
+import { captureRequestReasoningPreference } from "../request/reasoning-preference.js";
 import { resolveModelSelection } from "../model/model-selection.js";
 import { validateToolNormalInvocationInput, validateToolNormalInvocationPayload, } from "../../capabilities/normal-invocation/validator.js";
 import { compileAutomationGraph } from "./graph-validation.js";
@@ -142,6 +143,12 @@ export function validateAutomationPublication(input) {
             modelPolicy: input.config.models,
             modelExecutionPolicies: input.config.modelExecutionPolicies,
         });
+        try {
+            captureRequestReasoningPreference(node.reasoningPreference, selection);
+        }
+        catch (error) {
+            issues.push({ code: "automation_model_unavailable", path: `nodes.${node.id}.reasoningPreference`, message: String(error) });
+        }
         if (selection.execution.primaryProfileId !== node.modelProfileId) {
             issues.push({
                 code: "automation_model_unavailable",

package/dist/src/runtime/automations/saved-agent-management.js

@@ -27,6 +27,7 @@ function snapshotAgent(agent, id) {
         onFailure: agent.onFailure,
         modelProfileId: agent.modelProfileId,
         agentMode: agent.agentMode,
+        ...(agent.reasoningPreference ? { reasoningPreference: agent.reasoningPreference } : {}),
         roleInstructions: agent.roleInstructions,
         prompt: agent.prompt,
         inputs: {},

package/dist/src/runtime/automations/service.d.ts

@@ -15,7 +15,7 @@ export declare function createAutomationService(options: {
         latestRunId?: string | undefined;
         latestRunStatus?: import("../scheduler/contracts.js").SchedulerRunStatus | "stopping" | "completed_with_skips" | undefined;
         publishedRevision?: number;
-        status: "active" | "paused" | "draft" | "archived";
+        status: "archived" | "active" | "paused" | "draft";
         id: string;
         title: string;
         draftRevision: number;
@@ -155,6 +155,9 @@ export declare function createAutomationService(options: {
         }>[];
         models: {
             provider?: string | undefined;
+            reasoningControls?: {
+                budgetTokens: boolean;
+            } | undefined;
             id: string;
             label: string;
         }[];

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

@@ -1,3 +1,4 @@
+import { modelReasoningPreferenceSchema } from "../../../shared/model-reasoning-schema.js";
 import { AUTOMATION_DRAFT_BATCH_LIMITS } from "../../automations/draft-batch.js";
 import { AUTOMATION_GRAPH_LIMITS, DEFAULT_AUTOMATION_LIMITS } from "../../automations/limits.js";
 import { AUTOMATION_CREATION_RECIPE_LIMITS } from "./creation-recipe.js";
@@ -50,12 +51,13 @@ const agentTools = { $ref: "#/$defs/selectedTools" };
 const savedOrigin = object({ agentId: text(1), revision: integer });
 const sharedNode = { title: text(1), onFailure: choices("stop", "skip") };
 const toolFields = { operation, controls: map(binding), payload: binding };
-const agentFields = { modelProfileId: text(1), agentMode: choices("fast", "reasoning", "deep"),
+const reasoningPreference = { $ref: "#/$defs/reasoningPreference" };
+const agentFields = { reasoningPreference, modelProfileId: text(1), agentMode: choices("fast", "reasoning", "deep"),
     roleInstructions: text(), prompt: text(), inputs: map(binding), tools: agentTools,
     result, acceptance, savedAgentOrigin: savedOrigin };
 const toolNode = object({ kind: choices("tool"), ...sharedNode, ...toolFields }, ["payload"]);
-const agentNode = object({ kind: choices("agent"), ...sharedNode, ...agentFields }, ["acceptance", "savedAgentOrigin"]);
-const editableNodeFields = { ...sharedNode, ...toolFields, ...agentFields, payload: nullable(binding) };
+const agentNode = object({ kind: choices("agent"), ...sharedNode, ...agentFields }, ["acceptance", "savedAgentOrigin", "reasoningPreference"]);
+const editableNodeFields = { ...sharedNode, ...toolFields, ...agentFields, payload: nullable(binding), reasoningPreference: nullable(reasoningPreference) };
 const nodePatch = object(editableNodeFields, Object.keys(editableNodeFields));
 const schedule = { anyOf: [
         object({ kind: choices("timer"), delayMs: integer }),
@@ -92,13 +94,13 @@ const command = { anyOf: [
     ] };
 const recipeStep = { anyOf: [
         object({ key: text(1), kind: choices("tool"), ...sharedNode, ...toolFields }, ["onFailure", "controls", "payload"]),
-        object({ key: text(1), kind: choices("agent"), ...sharedNode, ...agentFields }, ["onFailure", "agentMode", "roleInstructions", "inputs", "tools", "result", "acceptance", "savedAgentOrigin"]),
+        object({ key: text(1), kind: choices("agent"), ...sharedNode, ...agentFields }, ["onFailure", "agentMode", "reasoningPreference", "roleInstructions", "inputs", "tools", "result", "acceptance", "savedAgentOrigin"]),
         object({ key: text(1), kind: choices("parallel"), branches: array(array({ $ref: "#/properties/steps/items" }, AUTOMATION_CREATION_RECIPE_LIMITS.executableNodes, 1), AUTOMATION_GRAPH_LIMITS.branchesPerGroup, 2) }),
     ] };
 const schema = { ...object({ version: { type: "integer", const: 1 },
         commands: array(command, AUTOMATION_DRAFT_BATCH_LIMITS.commands, 1),
         settings: { $ref: "#/$defs/definitionPatch" }, steps: array(recipeStep, AUTOMATION_CREATION_RECIPE_LIMITS.executableNodes),
-    }, ["commands", "settings", "steps"]), $defs: { valueBinding, definitionPatch, operationReference, selectedTools } };
+    }, ["commands", "settings", "steps"]), $defs: { valueBinding, definitionPatch, operationReference, selectedTools, reasoningPreference: modelReasoningPreferenceSchema } };
 /** Structural generation grammar. Canonical parsers own route exclusivity, references, bounds and graph semantics. */
 export const AUTOMATION_BUILDER_PAYLOAD_FORMAT = Object.freeze({
     type: "json_schema", name: "automation_draft_plan", strict: false, schema,

package/dist/src/runtime/capabilities/automation-builder/tool-module.js

@@ -1,9 +1,9 @@
+import { CORE_TOOL_CONTRACTS } from "../core-tool-contracts.js";
 import { Buffer } from "node:buffer";
 import { AUTOMATION_TOOL_EVENT_PRESENTATION } from "../automations/event-presentation.js";
 import { automationDraftPreparationReceipt } from "../automations/draft-operation-refs.js";
 import { AutomationDraftReceiptCapacityError, prepareAutomationDraftReceipt } from "../automations/draft-receipt-admission.js";
 import { AUTOMATION_DRAFT_BATCH_LIMITS, AutomationDraftBatchError, AutomationDraftBatchGraphError } from "../../automations/draft-batch.js";
-import { automationBuilderToolContract } from "./tool-contract.js";
 import { AUTOMATION_BUILDER_PAYLOAD_FORMAT } from "./payload-schema.js";
 import { compileAutomationCreationRecipe, hasAutomationCreationRecipe } from "./creation-recipe.js";
 function requiredText(params, key) {
@@ -41,7 +41,7 @@ function requireAcceptedDraftReceipt(output) {
 async function execute(service, params) {
     const action = requiredText(params, "action");
     const plan = parsePlanPayload(params);
-    const operation = automationBuilderToolContract.operations.find(({ operationId }) => operationId === action);
+    const operation = CORE_TOOL_CONTRACTS.automationBuilder.normalInvocation.operations.find(({ operationId }) => operationId === action);
     if (!operation)
         throw new Error("automation_action_unknown");
     let acceptedOutput;
@@ -76,7 +76,7 @@ function failureDetails(error) {
 export function createAutomationBuilderToolModule(getService, ready) {
     return {
         definition: {
-            name: "automation_builder",
+            name: CORE_TOOL_CONTRACTS.automationBuilder.name,
             eventPresentation: {
                 ...AUTOMATION_TOOL_EVENT_PRESENTATION,
                 metadata: {
@@ -91,7 +91,7 @@ export function createAutomationBuilderToolModule(getService, ready) {
             payloadChannelSpec: { params: ["planJson"], outputParam: "planJson", generationMode: "raw_text",
                 stages: [{ outputParam: "planJson", responseFormat: AUTOMATION_BUILDER_PAYLOAD_FORMAT }] },
         },
-        normalInvocation: automationBuilderToolContract,
+        normalInvocation: CORE_TOOL_CONTRACTS.automationBuilder.normalInvocation,
         async implementation(params, context) {
             try {
                 await ready();

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

@@ -63,6 +63,9 @@ export declare function readAutomationAuthoringCatalog(service: CatalogService,
     };
     models: {
         items: {
+            reasoningControls?: {
+                budgetTokens: boolean;
+            } | undefined;
             provider?: string | undefined;
             id: string;
             label: string;
@@ -177,6 +180,9 @@ export declare function readAutomationAuthoringCatalogIndex(service: CatalogServ
     };
     models: {
         items: {
+            reasoningControls?: {
+                budgetTokens: boolean;
+            } | undefined;
             provider?: string | undefined;
             id: string;
             label: string;
@@ -250,6 +256,9 @@ export declare function projectAutomationAuthoringCatalogIndex(catalog: Authorin
     };
     models: {
         items: {
+            reasoningControls?: {
+                budgetTokens: boolean;
+            } | undefined;
             provider?: string | undefined;
             id: string;
             label: string;

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/draft-index.d.ts

@@ -7,7 +7,7 @@ export declare function readAutomationDraftIndex(service: AutomationService, off
         automationId: string;
         title: string;
         revision: number;
-        status: "active" | "paused" | "draft" | "archived";
+        status: "archived" | "active" | "paused" | "draft";
     }[];
     nextOffset: number | null;
     omittedCount: number;

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,9 +1,11 @@
+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";
 import { automationDraftPreparationReceipt } from "./draft-operation-refs.js";
 import { AutomationDraftReceiptCapacityError, prepareAutomationDraftReceipt } from "./draft-receipt-admission.js";
 import { readAutomationDraftIndex } from "./draft-index.js";
-import { automationModelToolContract } from "./model-tool-contract.js";
 import { readAutomationAuthoringPreparation } from "./authoring-preparation.js";
 import { automationAuthoringCatalogScope, readAutomationAuthoringCatalog, readAutomationAuthoringCatalogIndex } from "./authoring-catalog.js";
 import { AUTOMATION_AUTHORING_REFERENCE } from "../automation-builder/authoring-reference.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"]) });
@@ -254,7 +263,7 @@ async function execute(service, params) {
 export function createAutomationDraftToolModule(getService, ready) {
     return {
         definition: {
-            name: "automations",
+            name: CORE_TOOL_CONTRACTS.automations.name,
             eventPresentation: AUTOMATION_TOOL_EVENT_PRESENTATION,
             description: "Inspect and make targeted edits to ABot Studio drafts. For a complete connected workflow or several related edits, prefer automation_builder create_automation_draft or apply_automation_draft_changes. Catalog discovery lists tools for the FUTURE workflow, not Studio editing commands; fetch operation detail only when needed. Successful edits return exact revision and newNodeIds for reuse; read_draft when state is unknown or after a revision conflict. Draft authoring only: the user grants permissions, publishes and runs automations.",
             routingCapability: "semantic_mutation",
@@ -262,14 +271,14 @@ export function createAutomationDraftToolModule(getService, ready) {
             developmentRoles: ["auxiliary"],
             controlsRefinement: "mechanical_when_complete",
         },
-        normalInvocation: automationModelToolContract,
+        normalInvocation: CORE_TOOL_CONTRACTS.automations.normalInvocation,
         async implementation(params, context) {
             try {
                 await ready();
                 context?.abortSignal?.throwIfAborted();
                 const result = await execute(getService(), params);
                 if (params.action === "read_draft") {
-                    const operation = automationModelToolContract.operations.find(({ operationId }) => operationId === "read_draft");
+                    const operation = CORE_TOOL_CONTRACTS.automations.normalInvocation.operations.find(({ operationId }) => operationId === "read_draft");
                     return prepareAutomationDraftReceipt(result, { tool: "automations", operation, params, mutationEvidence: false });
                 }
                 const isDraftMutation = !["list_drafts", "read_draft", "catalog", "browse_catalog", "prepare_draft", "validate_draft"].includes(String(params.action));

package/dist/src/runtime/capabilities/core-tool-contracts.d.ts

@@ -0,0 +1,29 @@
+import type { ToolNormalInvocationContract, ToolNormalInvocationOperation } from "../../capabilities/tool-types.js";
+/** One source for native definitions and their reserved plugin identities. */
+export declare const CORE_TOOL_CONTRACTS: Readonly<{
+    skills: Readonly<{
+        name: string;
+        normalInvocation: ToolNormalInvocationContract;
+        readApproval: "request_policy" | "automatic";
+    }>;
+    scheduling: Readonly<{
+        name: string;
+        normalInvocation: ToolNormalInvocationContract;
+        readApproval: "request_policy" | "automatic";
+    }>;
+    automations: Readonly<{
+        name: string;
+        normalInvocation: ToolNormalInvocationContract;
+        readApproval: "request_policy" | "automatic";
+    }>;
+    automationBuilder: Readonly<{
+        name: string;
+        normalInvocation: ToolNormalInvocationContract;
+        readApproval: "request_policy" | "automatic";
+    }>;
+}>;
+/** Core policy only; public plugins cannot opt out of request approval. */
+export declare function isCoreToolAutomaticRead(toolName: string, operation: Pick<ToolNormalInvocationOperation, "operationId" | "effect">): boolean;
+export declare function hasCoreToolContractCollision(capabilities: Readonly<Record<string, {
+    operations: Readonly<Record<string, unknown>>;
+}>>): boolean;

package/dist/src/runtime/capabilities/core-tool-contracts.js

@@ -0,0 +1,38 @@
+import { schedulingToolContract } from "./scheduling/tool-contract.js";
+import { automationModelToolContract } from "./automations/model-tool-contract.js";
+import { automationBuilderToolContract } from "./automation-builder/tool-contract.js";
+import { knowledgeSkillsToolContract } from "./knowledge-skills/tool-contract.js";
+function coreToolContract(name, normalInvocation, readApproval = "request_policy") {
+    return Object.freeze({ name, normalInvocation, readApproval });
+}
+/** One source for native definitions and their reserved plugin identities. */
+export const CORE_TOOL_CONTRACTS = Object.freeze({
+    skills: coreToolContract("abot_skills", knowledgeSkillsToolContract, "automatic"),
+    scheduling: coreToolContract("schedules", schedulingToolContract),
+    automations: coreToolContract("automations", automationModelToolContract),
+    automationBuilder: coreToolContract("automation_builder", automationBuilderToolContract),
+});
+const coreTools = Object.values(CORE_TOOL_CONTRACTS);
+const coreToolNames = new Set(coreTools.map(({ name }) => name));
+const coreOperationIds = new Set(coreTools.flatMap(({ normalInvocation }) => normalInvocation.operations.map(({ operationId }) => operationId)));
+/** Core policy only; public plugins cannot opt out of request approval. */
+export function isCoreToolAutomaticRead(toolName, operation) {
+    const core = coreTools.find(({ name }) => name === toolName);
+    if (core?.readApproval !== "automatic")
+        return false;
+    if (operation.effect !== "read_only")
+        return false;
+    return core.normalInvocation.operations.some((candidate) => candidate.operationId === operation.operationId && candidate.effect === "read_only");
+}
+export function hasCoreToolContractCollision(capabilities) {
+    for (const [name, capability] of Object.entries(capabilities)) {
+        const hasReservedToolName = coreToolNames.has(name);
+        if (hasReservedToolName)
+            return true;
+        const hasReservedOperationId = Object.keys(capability.operations)
+            .some((operationId) => coreOperationIds.has(operationId));
+        if (hasReservedOperationId)
+            return true;
+    }
+    return false;
+}

package/dist/src/runtime/capabilities/knowledge-skills/read-many.d.ts

@@ -0,0 +1,4 @@
+import type { ToolImplementationOutput } from "../../../capabilities/tool-types.js";
+import { type KnowledgeSkillStore } from "../../knowledge-skills/store.js";
+/** One ordinary read result; never report a partial document set as success. */
+export declare function executeKnowledgeSkillsReadMany(store: KnowledgeSkillStore, skillIds: unknown): ToolImplementationOutput;

package/dist/src/runtime/capabilities/knowledge-skills/read-many.js

@@ -0,0 +1,21 @@
+import { KNOWLEDGE_SKILL_READ_MAX_ITEMS, } from "../../knowledge-skills/store.js";
+import { knowledgeSkillDocumentsReadOutput, knowledgeSkillFailure } from "./tool-output.js";
+import { isKnowledgeSkillReadReference, resolveKnowledgeSkillReadTargets } from "./read-targets.js";
+function hasValidSkillIds(value) {
+    if (!Array.isArray(value))
+        return false;
+    if (value.length === 0 || value.length > KNOWLEDGE_SKILL_READ_MAX_ITEMS)
+        return false;
+    if (!value.every(isKnowledgeSkillReadReference))
+        return false;
+    return new Set(value).size === value.length;
+}
+/** One ordinary read result; never report a partial document set as success. */
+export function executeKnowledgeSkillsReadMany(store, skillIds) {
+    if (!hasValidSkillIds(skillIds))
+        return knowledgeSkillFailure("knowledge_skill_ids_invalid");
+    const resolved = resolveKnowledgeSkillReadTargets(store, skillIds);
+    if (!resolved.ok)
+        return knowledgeSkillFailure(resolved.errorCode);
+    return knowledgeSkillDocumentsReadOutput(resolved.skills);
+}

package/dist/src/runtime/capabilities/knowledge-skills/read-targets.d.ts

@@ -0,0 +1,13 @@
+import { type KnowledgeSkillDocument, type KnowledgeSkillStore } from "../../knowledge-skills/store.js";
+export declare const KNOWLEDGE_SKILL_READ_REFERENCE_MAX_LENGTH: number;
+export declare function isKnowledgeSkillReadReference(value: unknown): value is string;
+type ResolvedSkillRead = Readonly<{
+    ok: true;
+    skills: readonly KnowledgeSkillDocument[];
+}> | Readonly<{
+    ok: false;
+    errorCode: string;
+}>;
+/** Resolve exact IDs first, then full names, against the same Store used for discovery. */
+export declare function resolveKnowledgeSkillReadTargets(store: KnowledgeSkillStore, references: readonly string[]): ResolvedSkillRead;
+export {};

package/dist/src/runtime/capabilities/knowledge-skills/read-targets.js

@@ -0,0 +1,44 @@
+import { PERSONAL_SKILL_LIMITS } from "../../knowledge-skills/personal-contracts.js";
+import { isKnowledgeSkillId, KNOWLEDGE_SKILL_ID_MAX_LENGTH, KNOWLEDGE_SKILL_READ_MAX_ITEMS, } from "../../knowledge-skills/store.js";
+export const KNOWLEDGE_SKILL_READ_REFERENCE_MAX_LENGTH = Math.max(KNOWLEDGE_SKILL_ID_MAX_LENGTH, PERSONAL_SKILL_LIMITS.name);
+export function isKnowledgeSkillReadReference(value) {
+    if (typeof value !== "string")
+        return false;
+    if (value.length === 0 || value.length > KNOWLEDGE_SKILL_READ_REFERENCE_MAX_LENGTH)
+        return false;
+    return value.trim() === value;
+}
+function matchesSkillReadReference(skill, reference) {
+    if (skill.skillId === reference)
+        return true;
+    return skill.name === reference;
+}
+function exceedsSkillReadLimit(count) {
+    return count > KNOWLEDGE_SKILL_READ_MAX_ITEMS;
+}
+/** Resolve exact IDs first, then full names, against the same Store used for discovery. */
+export function resolveKnowledgeSkillReadTargets(store, references) {
+    let catalog;
+    const skills = new Map();
+    for (const reference of references) {
+        const exactId = isKnowledgeSkillId(reference) ? store.read(reference) : undefined;
+        const matches = exactId
+            ? [exactId]
+            : (catalog ??= store.list()).filter(({ name }) => name === reference);
+        if (matches.length === 0)
+            return { ok: false, errorCode: "knowledge_skill_not_found" };
+        for (const { skillId } of matches) {
+            const skill = exactId ?? skills.get(skillId) ?? store.read(skillId);
+            if (!skill)
+                return { ok: false, errorCode: "knowledge_skill_not_found" };
+            if (!matchesSkillReadReference(skill, reference))
+                return { ok: false, errorCode: "knowledge_skill_not_found" };
+            if (skills.has(skillId))
+                continue;
+            if (exceedsSkillReadLimit(skills.size + 1))
+                return { ok: false, errorCode: "knowledge_skill_read_limit_exceeded" };
+            skills.set(skillId, skill);
+        }
+    }
+    return { ok: true, skills: [...skills.values()] };
+}