@abot-ai/runtime 1.5.0 → 1.7.0

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

@@ -0,0 +1,320 @@
+import type { AutomationCatalogOperation } from "../../automations/catalog.js";
+import type { AutomationService } from "../../automations/service.js";
+export declare const AUTOMATION_CATALOG_OPERATION_REF_MAX_LENGTH: number;
+type CatalogService = Pick<AutomationService, "catalog">;
+type AuthoringCatalog = Awaited<ReturnType<AutomationService["catalog"]>>;
+/** Opaque identity copied from discovery; consumers never synthesize or parse it. */
+export declare function automationCatalogOperationRef(operation: Pick<AutomationCatalogOperation, "toolName" | "operationId" | "contractVersion">): string;
+export declare function requireAutomationCatalogScope(params: Readonly<Record<string, unknown>>): string;
+/** Requested grant scope only; catalog reads do not establish draft existence. */
+export declare function automationAuthoringCatalogScope(automationId: string): {
+    kind: "automation";
+    automationId: string;
+} | {
+    kind: "pre_draft";
+    automationId?: undefined;
+};
+/** Validate the view-specific flat API before reading the canonical catalog. */
+export declare function readAutomationAuthoringCatalog(service: CatalogService, params: Readonly<Record<string, unknown>>): Promise<{
+    kind: "automation_authoring_catalog_index_v1";
+    grantsPermissions: false;
+    catalogScope: {
+        kind: "automation";
+        automationId: string;
+    } | {
+        kind: "pre_draft";
+        automationId?: undefined;
+    };
+    permissions: {
+        readonly kind: "automation_authoring_permissions_v1";
+        readonly version: 1;
+        readonly authority: "capability_contract";
+        readonly purpose: "Interpret catalog fields while authoring the user-requested Studio draft.";
+        readonly applicability: "Only the returned catalogScope and selected future workflow operations.";
+        readonly presenceEffect: "Reference only; does not authorize draft changes, permission grants, publication, activation or execution.";
+        readonly inventory: "Future workflow tools only; excludes Studio editing and scheduling tools. Their absence here does not establish current chat capability availability.";
+        readonly grantsPermissions: "False means this read grants no permissions; it does not report the current chat's permissions.";
+        readonly granted: "granted and grantedOperations describe the future workflow's existing grant in catalogScope. False does not prevent drafting that operation; execution still requires the applicable grant.";
+        readonly permissionMode: "Required permission mode for future workflow execution, not the current chat mode.";
+        readonly scope: "pre_draft has no automation identity or saved grant. automation identifies the requested grant scope; it does not prove a draft exists.";
+        readonly currentChat: "This catalog does not determine current chat authoring permission. Use the active runtime capability contract and approval policy.";
+    };
+    offset: number;
+    pageSize: number;
+    nextOffset: number | null;
+    operations: {
+        items: {
+            catalogGroups: readonly string[];
+            permissionMode: "full_access" | "full_plus";
+            effect: "read_only" | "mutating" | "mixed";
+            granted: boolean;
+            pluginName?: string | undefined;
+            ref: string;
+            toolName: string;
+            operationId: string;
+            contractVersion: number;
+            label: string;
+            labelTruncated: boolean;
+        }[];
+        offset: number;
+        totalCount: number;
+        omittedCount: number;
+        nextOffset: number | null;
+    };
+    models: {
+        items: {
+            provider?: string | undefined;
+            id: string;
+            label: string;
+            labelTruncated: boolean;
+        }[];
+        offset: number;
+        totalCount: number;
+        omittedCount: number;
+        nextOffset: number | null;
+    };
+    savedAgents: {
+        items: {
+            agentId: string;
+            revision: number;
+            title: string;
+            titleTruncated: boolean;
+            modelProfileId: string;
+        }[];
+        offset: number;
+        totalCount: number;
+        omittedCount: number;
+        nextOffset: number | null;
+    };
+} | {
+    kind: "automation_authoring_catalog_operation_v1";
+    catalogScope: {
+        kind: "automation";
+        automationId: string;
+    } | {
+        kind: "pre_draft";
+        automationId?: undefined;
+    };
+    permissions: {
+        readonly kind: "automation_authoring_permissions_v1";
+        readonly version: 1;
+        readonly authority: "capability_contract";
+        readonly purpose: "Interpret catalog fields while authoring the user-requested Studio draft.";
+        readonly applicability: "Only the returned catalogScope and selected future workflow operations.";
+        readonly presenceEffect: "Reference only; does not authorize draft changes, permission grants, publication, activation or execution.";
+        readonly inventory: "Future workflow tools only; excludes Studio editing and scheduling tools. Their absence here does not establish current chat capability availability.";
+        readonly grantsPermissions: "False means this read grants no permissions; it does not report the current chat's permissions.";
+        readonly granted: "granted and grantedOperations describe the future workflow's existing grant in catalogScope. False does not prevent drafting that operation; execution still requires the applicable grant.";
+        readonly permissionMode: "Required permission mode for future workflow execution, not the current chat mode.";
+        readonly scope: "pre_draft has no automation identity or saved grant. automation identifies the requested grant scope; it does not prove a draft exists.";
+        readonly currentChat: "This catalog does not determine current chat authoring permission. Use the active runtime capability contract and approval policy.";
+    };
+    grantsPermissions: false;
+    operation: {
+        toolName: string;
+        operationId: string;
+        contractVersion: number;
+        label: string;
+        pluginName?: string;
+        catalogGroups: readonly import("../../../capabilities/tool-types.js").ToolCatalogGroup[];
+        toolDescription?: string;
+        permissionMode: "full_access" | "full_plus";
+        effect: "read_only" | "mutating" | "mixed";
+        approval: "request_policy" | "always";
+        input: import("../../../capabilities/normal-invocation/contracts.js").ToolNormalInvocationInput;
+        payload?: import("../../../capabilities/normal-invocation/contracts.js").ToolNormalInvocationPayload;
+        attachmentInput?: import("../../../capabilities/normal-invocation/contracts.js").ToolNormalInvocationAttachmentInput;
+        selectionControlIds?: readonly string[];
+    };
+    granted: boolean;
+}>;
+/** A paged discovery view derived only from the configured automation catalog. */
+export declare function readAutomationAuthoringCatalogIndex(service: CatalogService, automationId: string, offset: unknown): Promise<{
+    kind: "automation_authoring_catalog_index_v1";
+    grantsPermissions: false;
+    catalogScope: {
+        kind: "automation";
+        automationId: string;
+    } | {
+        kind: "pre_draft";
+        automationId?: undefined;
+    };
+    permissions: {
+        readonly kind: "automation_authoring_permissions_v1";
+        readonly version: 1;
+        readonly authority: "capability_contract";
+        readonly purpose: "Interpret catalog fields while authoring the user-requested Studio draft.";
+        readonly applicability: "Only the returned catalogScope and selected future workflow operations.";
+        readonly presenceEffect: "Reference only; does not authorize draft changes, permission grants, publication, activation or execution.";
+        readonly inventory: "Future workflow tools only; excludes Studio editing and scheduling tools. Their absence here does not establish current chat capability availability.";
+        readonly grantsPermissions: "False means this read grants no permissions; it does not report the current chat's permissions.";
+        readonly granted: "granted and grantedOperations describe the future workflow's existing grant in catalogScope. False does not prevent drafting that operation; execution still requires the applicable grant.";
+        readonly permissionMode: "Required permission mode for future workflow execution, not the current chat mode.";
+        readonly scope: "pre_draft has no automation identity or saved grant. automation identifies the requested grant scope; it does not prove a draft exists.";
+        readonly currentChat: "This catalog does not determine current chat authoring permission. Use the active runtime capability contract and approval policy.";
+    };
+    offset: number;
+    pageSize: number;
+    nextOffset: number | null;
+    operations: {
+        items: {
+            catalogGroups: readonly string[];
+            permissionMode: "full_access" | "full_plus";
+            effect: "read_only" | "mutating" | "mixed";
+            granted: boolean;
+            pluginName?: string | undefined;
+            ref: string;
+            toolName: string;
+            operationId: string;
+            contractVersion: number;
+            label: string;
+            labelTruncated: boolean;
+        }[];
+        offset: number;
+        totalCount: number;
+        omittedCount: number;
+        nextOffset: number | null;
+    };
+    models: {
+        items: {
+            provider?: string | undefined;
+            id: string;
+            label: string;
+            labelTruncated: boolean;
+        }[];
+        offset: number;
+        totalCount: number;
+        omittedCount: number;
+        nextOffset: number | null;
+    };
+    savedAgents: {
+        items: {
+            agentId: string;
+            revision: number;
+            title: string;
+            titleTruncated: boolean;
+            modelProfileId: string;
+        }[];
+        offset: number;
+        totalCount: number;
+        omittedCount: number;
+        nextOffset: number | null;
+    };
+}>;
+/** Shared bounded projection; preparation reuses its already-read catalog snapshot. */
+export declare function projectAutomationAuthoringCatalogIndex(catalog: AuthoringCatalog, offset: number, automationId: string): {
+    kind: "automation_authoring_catalog_index_v1";
+    grantsPermissions: false;
+    catalogScope: {
+        kind: "automation";
+        automationId: string;
+    } | {
+        kind: "pre_draft";
+        automationId?: undefined;
+    };
+    permissions: {
+        readonly kind: "automation_authoring_permissions_v1";
+        readonly version: 1;
+        readonly authority: "capability_contract";
+        readonly purpose: "Interpret catalog fields while authoring the user-requested Studio draft.";
+        readonly applicability: "Only the returned catalogScope and selected future workflow operations.";
+        readonly presenceEffect: "Reference only; does not authorize draft changes, permission grants, publication, activation or execution.";
+        readonly inventory: "Future workflow tools only; excludes Studio editing and scheduling tools. Their absence here does not establish current chat capability availability.";
+        readonly grantsPermissions: "False means this read grants no permissions; it does not report the current chat's permissions.";
+        readonly granted: "granted and grantedOperations describe the future workflow's existing grant in catalogScope. False does not prevent drafting that operation; execution still requires the applicable grant.";
+        readonly permissionMode: "Required permission mode for future workflow execution, not the current chat mode.";
+        readonly scope: "pre_draft has no automation identity or saved grant. automation identifies the requested grant scope; it does not prove a draft exists.";
+        readonly currentChat: "This catalog does not determine current chat authoring permission. Use the active runtime capability contract and approval policy.";
+    };
+    offset: number;
+    pageSize: number;
+    nextOffset: number | null;
+    operations: {
+        items: {
+            catalogGroups: readonly string[];
+            permissionMode: "full_access" | "full_plus";
+            effect: "read_only" | "mutating" | "mixed";
+            granted: boolean;
+            pluginName?: string | undefined;
+            ref: string;
+            toolName: string;
+            operationId: string;
+            contractVersion: number;
+            label: string;
+            labelTruncated: boolean;
+        }[];
+        offset: number;
+        totalCount: number;
+        omittedCount: number;
+        nextOffset: number | null;
+    };
+    models: {
+        items: {
+            provider?: string | undefined;
+            id: string;
+            label: string;
+            labelTruncated: boolean;
+        }[];
+        offset: number;
+        totalCount: number;
+        omittedCount: number;
+        nextOffset: number | null;
+    };
+    savedAgents: {
+        items: {
+            agentId: string;
+            revision: number;
+            title: string;
+            titleTruncated: boolean;
+            modelProfileId: string;
+        }[];
+        offset: number;
+        totalCount: number;
+        omittedCount: number;
+        nextOffset: number | null;
+    };
+};
+/** Resolve an exact, current operation reference without granting or selecting it. */
+export declare function readAutomationAuthoringCatalogOperation(service: CatalogService, automationId: string, toolName: string, operationId: string, contractVersion: number): Promise<{
+    kind: "automation_authoring_catalog_operation_v1";
+    catalogScope: {
+        kind: "automation";
+        automationId: string;
+    } | {
+        kind: "pre_draft";
+        automationId?: undefined;
+    };
+    permissions: {
+        readonly kind: "automation_authoring_permissions_v1";
+        readonly version: 1;
+        readonly authority: "capability_contract";
+        readonly purpose: "Interpret catalog fields while authoring the user-requested Studio draft.";
+        readonly applicability: "Only the returned catalogScope and selected future workflow operations.";
+        readonly presenceEffect: "Reference only; does not authorize draft changes, permission grants, publication, activation or execution.";
+        readonly inventory: "Future workflow tools only; excludes Studio editing and scheduling tools. Their absence here does not establish current chat capability availability.";
+        readonly grantsPermissions: "False means this read grants no permissions; it does not report the current chat's permissions.";
+        readonly granted: "granted and grantedOperations describe the future workflow's existing grant in catalogScope. False does not prevent drafting that operation; execution still requires the applicable grant.";
+        readonly permissionMode: "Required permission mode for future workflow execution, not the current chat mode.";
+        readonly scope: "pre_draft has no automation identity or saved grant. automation identifies the requested grant scope; it does not prove a draft exists.";
+        readonly currentChat: "This catalog does not determine current chat authoring permission. Use the active runtime capability contract and approval policy.";
+    };
+    grantsPermissions: false;
+    operation: {
+        toolName: string;
+        operationId: string;
+        contractVersion: number;
+        label: string;
+        pluginName?: string;
+        catalogGroups: readonly import("../../../capabilities/tool-types.js").ToolCatalogGroup[];
+        toolDescription?: string;
+        permissionMode: "full_access" | "full_plus";
+        effect: "read_only" | "mutating" | "mixed";
+        approval: "request_policy" | "always";
+        input: import("../../../capabilities/normal-invocation/contracts.js").ToolNormalInvocationInput;
+        payload?: import("../../../capabilities/normal-invocation/contracts.js").ToolNormalInvocationPayload;
+        attachmentInput?: import("../../../capabilities/normal-invocation/contracts.js").ToolNormalInvocationAttachmentInput;
+        selectionControlIds?: readonly string[];
+    };
+    granted: boolean;
+}>;
+export {};

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

@@ -0,0 +1,158 @@
+import { TOOL_NORMAL_INVOCATION_IDENTIFIER_MAX_LENGTH } from "../../../capabilities/normal-invocation/contracts.js";
+import { AUTOMATION_AUTHORING_REFERENCE } from "../automation-builder/authoring-reference.js";
+// Percent-encoding expands one UTF-16 unit by at most nine characters.
+// Both canonical identifiers are bounded; preserve every safe integer version too.
+export const AUTOMATION_CATALOG_OPERATION_REF_MAX_LENGTH = 2 * TOOL_NORMAL_INVOCATION_IDENTIFIER_MAX_LENGTH * 9 + 2 + String(Number.MAX_SAFE_INTEGER).length;
+const PAGE_SIZE = 50;
+const LABEL_MAX_LENGTH = 160;
+function isCatalogIndexOffset(value) {
+    if (typeof value !== "number" || !Number.isSafeInteger(value))
+        return false;
+    if (value < 0)
+        return false;
+    return value <= 2_147_483_647;
+}
+function catalogPage(items, offset) {
+    const page = items.slice(offset, offset + PAGE_SIZE);
+    const omittedCount = Math.max(0, items.length - offset - page.length);
+    return { items: page, offset, totalCount: items.length, omittedCount,
+        nextOffset: omittedCount > 0 ? offset + page.length : null };
+}
+function operationKey(operation) {
+    return JSON.stringify([operation.toolName, operation.operationId, operation.contractVersion]);
+}
+/** Opaque identity copied from discovery; consumers never synthesize or parse it. */
+export function automationCatalogOperationRef(operation) {
+    return `${encodeURIComponent(operation.toolName)}/${encodeURIComponent(operation.operationId)}@${operation.contractVersion}`;
+}
+function isCatalogReferenceName(value) {
+    if (typeof value !== "string")
+        return false;
+    if (value.length < 1 || value.length > 64)
+        return false;
+    return value.trim() === value && value.trim().length > 0;
+}
+function isCatalogAutomationId(value) {
+    if (typeof value !== "string")
+        return false;
+    if (value.trim().length === 0)
+        return false;
+    return value.length <= 128;
+}
+export function requireAutomationCatalogScope(params) {
+    if (params.automationId === undefined)
+        return "";
+    if (!isCatalogAutomationId(params.automationId))
+        throw new Error("automation_catalog_parameters_invalid");
+    return params.automationId;
+}
+/** Requested grant scope only; catalog reads do not establish draft existence. */
+export function automationAuthoringCatalogScope(automationId) {
+    return automationId
+        ? { kind: "automation", automationId }
+        : { kind: "pre_draft" };
+}
+function isCatalogContractVersion(value) {
+    if (typeof value !== "number" || !Number.isSafeInteger(value))
+        return false;
+    if (value < 1)
+        return false;
+    return value <= 2_147_483_647;
+}
+function requireCatalogOperationReference(params) {
+    const { toolName, operationId, contractVersion } = params;
+    if (!isCatalogReferenceName(toolName))
+        throw new Error("automation_catalog_operation_reference_invalid");
+    if (!isCatalogReferenceName(operationId))
+        throw new Error("automation_catalog_operation_reference_invalid");
+    if (!isCatalogContractVersion(contractVersion))
+        throw new Error("automation_catalog_operation_reference_invalid");
+    return { toolName, operationId, contractVersion };
+}
+function hasCatalogOperationReferenceFields(params) {
+    return ["toolName", "operationId", "contractVersion"].some((key) => params[key] !== undefined);
+}
+/** Validate the view-specific flat API before reading the canonical catalog. */
+export async function readAutomationAuthoringCatalog(service, params) {
+    const automationId = requireAutomationCatalogScope(params);
+    const isIndexView = params.view === "index";
+    const hasUnexpectedIndexReference = isIndexView && hasCatalogOperationReferenceFields(params);
+    if (hasUnexpectedIndexReference)
+        throw new Error("automation_catalog_parameters_invalid");
+    if (isIndexView) {
+        return readAutomationAuthoringCatalogIndex(service, automationId, params.offset === undefined ? 0 : params.offset);
+    }
+    const isOperationView = params.view === "operation";
+    if (!isOperationView)
+        throw new Error("automation_catalog_view_invalid");
+    const hasUnexpectedOperationOffset = params.offset !== undefined;
+    if (hasUnexpectedOperationOffset)
+        throw new Error("automation_catalog_parameters_invalid");
+    const reference = requireCatalogOperationReference(params);
+    return readAutomationAuthoringCatalogOperation(service, automationId, reference.toolName, reference.operationId, reference.contractVersion);
+}
+/** A paged discovery view derived only from the configured automation catalog. */
+export async function readAutomationAuthoringCatalogIndex(service, automationId, offset) {
+    if (!isCatalogIndexOffset(offset))
+        throw new Error("automation_offset_invalid");
+    const catalog = await service.catalog(automationId);
+    return projectAutomationAuthoringCatalogIndex(catalog, offset, automationId);
+}
+/** Shared bounded projection; preparation reuses its already-read catalog snapshot. */
+export function projectAutomationAuthoringCatalogIndex(catalog, offset, automationId) {
+    const granted = new Set(catalog.operations.map(operationKey));
+    const operations = catalogPage([...catalog.grantableOperations]
+        .sort((left, right) => operationKey(left).localeCompare(operationKey(right)))
+        .map((operation) => ({
+        ref: automationCatalogOperationRef(operation),
+        toolName: operation.toolName, operationId: operation.operationId,
+        contractVersion: operation.contractVersion,
+        label: operation.label.slice(0, LABEL_MAX_LENGTH),
+        labelTruncated: operation.label.length > LABEL_MAX_LENGTH,
+        ...(operation.pluginName ? { pluginName: operation.pluginName } : {}),
+        catalogGroups: operation.catalogGroups, permissionMode: operation.permissionMode,
+        effect: operation.effect, granted: granted.has(operationKey(operation)),
+    })), offset);
+    const models = catalogPage([...catalog.models]
+        .sort((left, right) => left.id.localeCompare(right.id))
+        .map((model) => ({
+        id: model.id, label: model.label.slice(0, LABEL_MAX_LENGTH),
+        labelTruncated: model.label.length > LABEL_MAX_LENGTH,
+        ...(model.provider ? { provider: model.provider } : {}),
+    })), offset);
+    const savedAgents = catalogPage([...catalog.savedAgents]
+        .sort((left, right) => left.id.localeCompare(right.id))
+        .map((agent) => ({
+        agentId: agent.id, revision: agent.revision,
+        title: agent.title.slice(0, LABEL_MAX_LENGTH),
+        titleTruncated: agent.title.length > LABEL_MAX_LENGTH,
+        modelProfileId: agent.modelProfileId,
+    })), offset);
+    const totalCount = Math.max(operations.totalCount, models.totalCount, savedAgents.totalCount);
+    return {
+        kind: "automation_authoring_catalog_index_v1", grantsPermissions: false,
+        catalogScope: automationAuthoringCatalogScope(automationId),
+        permissions: AUTOMATION_AUTHORING_REFERENCE.permissions,
+        offset, pageSize: PAGE_SIZE,
+        // Every collection advances by the same page size; none can lose an intermediate page.
+        nextOffset: offset + PAGE_SIZE < totalCount ? offset + PAGE_SIZE : null,
+        operations, models, savedAgents,
+    };
+}
+/** Resolve an exact, current operation reference without granting or selecting it. */
+export async function readAutomationAuthoringCatalogOperation(service, automationId, toolName, operationId, contractVersion) {
+    const catalog = await service.catalog(automationId);
+    const matchesReference = (operation) => operation.toolName === toolName && operation.operationId === operationId &&
+        operation.contractVersion === contractVersion;
+    const selected = catalog.grantableOperations.find(matchesReference);
+    if (!selected)
+        throw new Error("automation_catalog_operation_not_found");
+    const { fixedParams: _fixedParams, outputChannels: _outputChannels, ...operation } = selected;
+    return {
+        kind: "automation_authoring_catalog_operation_v1",
+        catalogScope: automationAuthoringCatalogScope(automationId),
+        permissions: AUTOMATION_AUTHORING_REFERENCE.permissions,
+        grantsPermissions: false, operation,
+        granted: catalog.operations.some(matchesReference),
+    };
+}

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

@@ -0,0 +1,140 @@
+/** Flat authoring conveniences project into the existing canonical draft mutation contract. */
+export declare const automationAuthoringInputOperations: readonly [{
+    readonly operationId: "bind_step_result";
+    readonly summary: "Bind one named agent input or tool control to an exact earlier step result, preserving other inputs. Select text or data explicitly; pointer is a JSON pointer for data only. Placement never passes outputs automatically. This does not set a tool payload; use set_tool_payload for that.";
+    readonly effect: "mutating";
+    readonly approval: "request_policy";
+    readonly fixedParams: {
+        readonly action: "bind_step_result";
+    };
+    readonly input: {
+        readonly type: "object";
+        readonly additionalProperties: false;
+        readonly properties: {
+            readonly inputName: {
+                readonly type: "string";
+                readonly minLength: 1;
+                readonly maxLength: 64;
+            };
+            readonly sourceNodeId: {
+                readonly type: "string";
+                readonly minLength: 1;
+                readonly maxLength: 128;
+            };
+            readonly select: {
+                readonly type: "string";
+                readonly enum: readonly ["text", "data"];
+            };
+            readonly pointer: {
+                readonly type: "string";
+                readonly minLength: 1;
+                readonly maxLength: 512;
+            };
+            readonly automationId: {
+                readonly type: "string";
+                readonly minLength: 1;
+                readonly maxLength: 128;
+            };
+            readonly expectedRevision: {
+                readonly type: "integer";
+                readonly minimum: 1;
+                readonly maximum: 2147483647;
+            };
+            readonly nodeId: {
+                readonly type: "string";
+                readonly minLength: 1;
+                readonly maxLength: 128;
+            };
+        };
+        readonly required: readonly [...string[], "inputName", "sourceNodeId", "select"];
+    };
+}, {
+    readonly operationId: "set_step_literal";
+    readonly summary: "Set one named agent input or tool control to a literal while preserving other inputs. valueJson is only the raw JSON value (string, number, boolean, null, array or object), without a binding wrapper, bounded to 4096 UTF-8 bytes. The Runtime constructs the literal binding.";
+    readonly effect: "mutating";
+    readonly approval: "request_policy";
+    readonly fixedParams: {
+        readonly action: "set_step_literal";
+    };
+    readonly input: {
+        readonly type: "object";
+        readonly additionalProperties: false;
+        readonly properties: {
+            readonly inputName: {
+                readonly type: "string";
+                readonly minLength: 1;
+                readonly maxLength: 64;
+            };
+            readonly valueJson: {
+                readonly type: "string";
+                readonly minLength: 1;
+                readonly maxLength: 4096;
+            };
+            readonly automationId: {
+                readonly type: "string";
+                readonly minLength: 1;
+                readonly maxLength: 128;
+            };
+            readonly expectedRevision: {
+                readonly type: "integer";
+                readonly minimum: 1;
+                readonly maximum: 2147483647;
+            };
+            readonly nodeId: {
+                readonly type: "string";
+                readonly minLength: 1;
+                readonly maxLength: 128;
+            };
+        };
+        readonly required: readonly [...string[], "inputName", "valueJson"];
+    };
+}, {
+    readonly operationId: "select_agent_tool";
+    readonly summary: "Select one exact catalog operation for an agent and set usage to available or required. Updates the same exact reference without duplicating it, preserving other selections. Selection does not grant permission, publish or run the automation.";
+    readonly effect: "mutating";
+    readonly approval: "request_policy";
+    readonly fixedParams: {
+        readonly action: "select_agent_tool";
+    };
+    readonly input: {
+        readonly type: "object";
+        readonly additionalProperties: false;
+        readonly properties: {
+            readonly toolName: {
+                readonly type: "string";
+                readonly minLength: 1;
+                readonly maxLength: 64;
+            };
+            readonly operationId: {
+                readonly type: "string";
+                readonly minLength: 1;
+                readonly maxLength: 64;
+            };
+            readonly contractVersion: {
+                readonly type: "integer";
+                readonly minimum: 1;
+                readonly maximum: 2147483647;
+            };
+            readonly usage: {
+                readonly type: "string";
+                readonly enum: readonly ["available", "required"];
+            };
+            readonly automationId: {
+                readonly type: "string";
+                readonly minLength: 1;
+                readonly maxLength: 128;
+            };
+            readonly expectedRevision: {
+                readonly type: "integer";
+                readonly minimum: 1;
+                readonly maximum: 2147483647;
+            };
+            readonly nodeId: {
+                readonly type: "string";
+                readonly minLength: 1;
+                readonly maxLength: 128;
+            };
+        };
+        readonly required: readonly [...string[], "toolName", "operationId", "contractVersion", "usage"];
+    };
+}];

package/dist/src/runtime/capabilities/automations/authoring-input-contracts.js

@@ -0,0 +1,36 @@
+const id = { type: "string", minLength: 1, maxLength: 128 };
+const name = { type: "string", minLength: 1, maxLength: 64 };
+const positiveInteger = { type: "integer", minimum: 1, maximum: 2_147_483_647 };
+const node = { automationId: id, expectedRevision: positiveInteger, nodeId: id };
+const requiredNode = ["automationId", "expectedRevision", "nodeId"];
+/** Flat authoring conveniences project into the existing canonical draft mutation contract. */
+export const automationAuthoringInputOperations = [
+    {
+        operationId: "bind_step_result",
+        summary: "Bind one named agent input or tool control to an exact earlier step result, preserving other inputs. Select text or data explicitly; pointer is a JSON pointer for data only. Placement never passes outputs automatically. This does not set a tool payload; use set_tool_payload for that.",
+        effect: "mutating", approval: "request_policy", fixedParams: { action: "bind_step_result" },
+        input: { type: "object", additionalProperties: false,
+            properties: { ...node, inputName: name, sourceNodeId: id,
+                select: { type: "string", enum: ["text", "data"] },
+                pointer: { type: "string", minLength: 1, maxLength: 512 } },
+            required: [...requiredNode, "inputName", "sourceNodeId", "select"] },
+    },
+    {
+        operationId: "set_step_literal",
+        summary: "Set one named agent input or tool control to a literal while preserving other inputs. valueJson is only the raw JSON value (string, number, boolean, null, array or object), without a binding wrapper, bounded to 4096 UTF-8 bytes. The Runtime constructs the literal binding.",
+        effect: "mutating", approval: "request_policy", fixedParams: { action: "set_step_literal" },
+        input: { type: "object", additionalProperties: false,
+            properties: { ...node, inputName: name,
+                valueJson: { type: "string", minLength: 1, maxLength: 4_096 } },
+            required: [...requiredNode, "inputName", "valueJson"] },
+    },
+    {
+        operationId: "select_agent_tool",
+        summary: "Select one exact catalog operation for an agent and set usage to available or required. Updates the same exact reference without duplicating it, preserving other selections. Selection does not grant permission, publish or run the automation.",
+        effect: "mutating", approval: "request_policy", fixedParams: { action: "select_agent_tool" },
+        input: { type: "object", additionalProperties: false,
+            properties: { ...node, toolName: name, operationId: name, contractVersion: positiveInteger,
+                usage: { type: "string", enum: ["available", "required"] } },
+            required: [...requiredNode, "toolName", "operationId", "contractVersion", "usage"] },
+    },
+];

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

@@ -0,0 +1,9 @@
+import type { AutomationService } from "../../automations/service.js";
+export declare function isAutomationAuthoringInputAction(action: string): boolean;
+/** The parser and revision-checked draft service remain the sole mutation authority. */
+export declare function executeAutomationAuthoringInput(service: AutomationService, params: Record<string, unknown>): Promise<{
+    automationId: string;
+    revision: number;
+    newNodeIds: readonly string[];
+    sourceId?: string;
+}>;