@abot-ai/runtime 1.0.0 → 1.2.0

package/dist/src/runtime/steps/worker-decision/parser/capability-batch-validation.js

@@ -0,0 +1,135 @@
+import { WORKER_CAPABILITY_INTENT_MAX_LENGTH, } from "../contracts.js";
+import { workerCapabilityBatchExecutionSlotId } from "../format.js";
+import { parseCapabilityInvocation } from "./capability-invocation-validation.js";
+import { readWorkerDecisionRecord, validateExactWorkerDecisionKeys, } from "./decision-shape-validation.js";
+import { createWorkerDecisionIssue } from "./validation-contract.js";
+export function validateCapabilityBatchDecision(record, context, issues) {
+    validateExactWorkerDecisionKeys(record, ["action", "invocations"], issues);
+    const invocations = readCapabilityBatchInvocations(record.invocations, context);
+    if (!hasAllowedCapabilityBatchSize(invocations, context)) {
+        issues.push(createWorkerDecisionIssue("worker_capability_batch_size_invalid", "decision.invocations"));
+        return {};
+    }
+    const acceptedBatchInvocations = [];
+    invocations.forEach((input, index) => {
+        const pendingSlotId = capabilityBatchPendingSlotId(context, index);
+        const path = pendingSlotId
+            ? `decision.invocations.${pendingSlotId}`
+            : `decision.invocations[${index}]`;
+        const invocationRecord = readWorkerDecisionRecord(input);
+        if (!invocationRecord) {
+            issues.push(createWorkerDecisionIssue("worker_capability_batch_item_invalid", path));
+            return;
+        }
+        const pendingInvocation = pendingCapabilityBatchInvocation(context, index);
+        const invocation = parseCapabilityInvocation({
+            record: invocationRecord,
+            path,
+            includesActionKey: false,
+            observationOnly: true,
+            executionRequiresPendingInvocation: false,
+            decisionPhase: context.decisionPhase,
+            availableCapabilities: context.availableCapabilities,
+            pendingInvocation,
+            pendingSlotId,
+        }, issues);
+        if (!canAcceptObservationBatchInvocation(context, invocationRecord, invocation, pendingInvocation)) {
+            return;
+        }
+        acceptedBatchInvocations.push(projectAcceptedCapabilityInvocation(context, invocationRecord, invocation, pendingInvocation));
+    });
+    return { acceptedBatchInvocations };
+}
+function readCapabilityBatchInvocations(value, context) {
+    if (context.decisionPhase === "capability_execution") {
+        return readPendingCapabilityBatchExecutionSlots(value, context.pendingCapabilityBatchSelection?.length);
+    }
+    return Array.isArray(value) ? value : undefined;
+}
+function capabilityBatchPendingSlotId(context, index) {
+    if (context.decisionPhase !== "capability_execution")
+        return undefined;
+    return workerCapabilityBatchExecutionSlotId(index);
+}
+function pendingCapabilityBatchInvocation(context, index) {
+    if (context.decisionPhase !== "capability_execution")
+        return undefined;
+    return context.pendingCapabilityBatchSelection?.[index];
+}
+function hasAllowedCapabilityBatchSize(invocations, context) {
+    if (!invocations)
+        return false;
+    if (context.decisionPhase === "capability_execution") {
+        if (!context.pendingCapabilityBatchSelection)
+            return false;
+        return (invocations.length === context.pendingCapabilityBatchSelection.length);
+    }
+    if (invocations.length < 2)
+        return false;
+    if (!Number.isInteger(context.maxBatchCapabilityExecutions))
+        return false;
+    if (context.maxBatchCapabilityExecutions < 2)
+        return false;
+    return invocations.length <= context.maxBatchCapabilityExecutions;
+}
+function canAcceptObservationBatchInvocation(context, invocationRecord, invocation, pendingInvocation) {
+    if (invocation.selectedCapability?.effect !== "observation")
+        return false;
+    if (!pendingInvocation &&
+        !hasValidGeneratedCapabilityIdentity(invocationRecord)) {
+        return false;
+    }
+    if (context.decisionPhase === "capability_execution") {
+        return invocation.controls !== undefined;
+    }
+    if (!invocation.controlsPartition?.selectionControlIds.length)
+        return true;
+    return invocation.selectionControls !== undefined;
+}
+function hasValidGeneratedCapabilityIdentity(invocation) {
+    if (typeof invocation.capabilityId !== "string")
+        return false;
+    if (typeof invocation.intent !== "string")
+        return false;
+    if (invocation.intent.trim().length === 0)
+        return false;
+    return invocation.intent.length <= WORKER_CAPABILITY_INTENT_MAX_LENGTH;
+}
+function projectAcceptedCapabilityInvocation(context, invocationRecord, invocation, pendingInvocation) {
+    const capabilityId = pendingInvocation?.capabilityId ??
+        invocationRecord.capabilityId;
+    const intent = pendingInvocation?.intent ?? invocationRecord.intent.trim();
+    const authoringObjective = pendingInvocation?.authoringObjective ?? invocation.authoringObjective;
+    if (context.decisionPhase === "capability_execution") {
+        return Object.freeze({
+            capabilityId,
+            intent,
+            ...(authoringObjective ? { authoringObjective } : {}),
+            controls: invocation.controls,
+        });
+    }
+    return Object.freeze({
+        capabilityId,
+        intent,
+        ...(authoringObjective ? { authoringObjective } : {}),
+        ...(invocation.selectionControls
+            ? { selectionControls: invocation.selectionControls }
+            : {}),
+    });
+}
+function readPendingCapabilityBatchExecutionSlots(value, expectedCount) {
+    const record = readWorkerDecisionRecord(value);
+    if (!record || expectedCount === undefined)
+        return undefined;
+    const expectedSlotIds = Array.from({ length: expectedCount }, (_, index) => workerCapabilityBatchExecutionSlotId(index));
+    const actualSlotIds = Object.keys(record);
+    if (!hasExactPendingBatchExecutionSlots(actualSlotIds, expectedSlotIds)) {
+        return undefined;
+    }
+    return expectedSlotIds.map((slotId) => record[slotId]);
+}
+function hasExactPendingBatchExecutionSlots(actualSlotIds, expectedSlotIds) {
+    if (actualSlotIds.length !== expectedSlotIds.length)
+        return false;
+    return actualSlotIds.every((slotId) => expectedSlotIds.includes(slotId));
+}

package/dist/src/runtime/steps/worker-decision/parser/capability-controls-validation.d.ts

@@ -0,0 +1,6 @@
+import type { WorkerDecisionValidationIssue } from "../contracts.js";
+import { type WorkerCapabilityControls, type WorkerCapabilityControlsPartition, type WorkerCapabilityDescriptor } from "../../../orchestration/worker-capabilities/index.js";
+import type { CapabilityInvocationValidationInput } from "./validation-contract.js";
+export declare function partitionSelectedCapabilityControls(selectedCapability: WorkerCapabilityDescriptor | undefined, capabilityPath: string, issues: WorkerDecisionValidationIssue[]): WorkerCapabilityControlsPartition | undefined;
+export declare function validateCapabilitySelectionControls(params: CapabilityInvocationValidationInput, selectedCapability: WorkerCapabilityDescriptor | undefined, controlsPartition: WorkerCapabilityControlsPartition | undefined, issues: WorkerDecisionValidationIssue[]): WorkerCapabilityControls | undefined;
+export declare function validateCapabilityExecutionControls(params: CapabilityInvocationValidationInput, selectedCapability: WorkerCapabilityDescriptor | undefined, controlsPartition: WorkerCapabilityControlsPartition | undefined, issues: WorkerDecisionValidationIssue[]): WorkerCapabilityControls | undefined;

package/dist/src/runtime/steps/worker-decision/parser/capability-controls-validation.js

@@ -0,0 +1,132 @@
+import { mergeWorkerCapabilityControls, partitionWorkerCapabilityControlsSchema, validateWorkerCapabilityRemainingControls, validateWorkerCapabilitySelectionControls, } from "../../../orchestration/worker-capabilities/index.js";
+import { readWorkerDecisionRecord } from "./decision-shape-validation.js";
+import { createWorkerDecisionIssue, hasObservationOnlyCapabilityMismatch, } from "./validation-contract.js";
+export function partitionSelectedCapabilityControls(selectedCapability, capabilityPath, issues) {
+    if (!selectedCapability)
+        return undefined;
+    const partition = partitionWorkerCapabilityControlsSchema(selectedCapability.controls, selectedCapability.selectionControlIds);
+    if (partition.ok)
+        return partition.value;
+    issues.push(createWorkerDecisionIssue("worker_capability_controls_schema_invalid", capabilityPath));
+    return undefined;
+}
+export function validateCapabilitySelectionControls(params, selectedCapability, controlsPartition, issues) {
+    if (!selectedCapability)
+        return undefined;
+    if (hasObservationOnlyCapabilityMismatch(params, selectedCapability)) {
+        return undefined;
+    }
+    if (!controlsPartition)
+        return undefined;
+    if (params.decisionPhase !== "capability_selection")
+        return undefined;
+    if (controlsPartition.selectionControlIds.length === 0)
+        return undefined;
+    const selectionControls = validateWorkerCapabilitySelectionControls(controlsPartition, normalizeGeneratedCapabilityControls(params.record.selectionControls, controlsPartition.selectionSchema));
+    if (selectionControls.ok)
+        return selectionControls.value;
+    issues.push(createWorkerCapabilityControlsIssue({
+        issueCode: selectionControls.issueCode,
+        controlId: selectionControls.controlId,
+        path: selectionControls.controlId
+            ? `${params.path}.selectionControls.${selectionControls.controlId}`
+            : `${params.path}.selectionControls`,
+        capability: selectedCapability,
+        schema: controlsPartition.selectionSchema,
+        pendingSlotId: params.pendingSlotId,
+    }));
+    return undefined;
+}
+export function validateCapabilityExecutionControls(params, selectedCapability, controlsPartition, issues) {
+    if (!selectedCapability) {
+        reportNonObjectExecutionControls(params, issues);
+        return undefined;
+    }
+    if (hasObservationOnlyCapabilityMismatch(params, selectedCapability)) {
+        reportNonObjectExecutionControls(params, issues);
+        return undefined;
+    }
+    if (!controlsPartition) {
+        reportNonObjectExecutionControls(params, issues);
+        return undefined;
+    }
+    if (params.decisionPhase !== "capability_execution") {
+        reportNonObjectExecutionControls(params, issues);
+        return undefined;
+    }
+    const remainingControls = validateWorkerCapabilityRemainingControls(controlsPartition, normalizeGeneratedCapabilityControls(params.record.controls, controlsPartition.remainingSchema));
+    if (!remainingControls.ok) {
+        issues.push(createWorkerCapabilityControlsIssue({
+            issueCode: remainingControls.issueCode,
+            controlId: remainingControls.controlId,
+            path: remainingControls.controlId
+                ? `${params.path}.controls.${remainingControls.controlId}`
+                : `${params.path}.controls`,
+            capability: selectedCapability,
+            schema: controlsPartition.remainingSchema,
+            pendingSlotId: params.pendingSlotId,
+        }));
+        return undefined;
+    }
+    const mergedControls = mergeWorkerCapabilityControls(controlsPartition, {
+        selectionControls: params.pendingInvocation?.selectionControls ?? {},
+        remainingControls: remainingControls.value,
+    });
+    if (mergedControls.ok)
+        return mergedControls.value;
+    issues.push(createWorkerCapabilityControlsIssue({
+        issueCode: mergedControls.issueCode,
+        controlId: mergedControls.controlId,
+        path: mergedControls.controlId
+            ? `${params.path}.controls.${mergedControls.controlId}`
+            : `${params.path}.controls`,
+        capability: selectedCapability,
+        schema: controlsPartition.remainingSchema,
+        pendingSlotId: params.pendingSlotId,
+    }));
+    return undefined;
+}
+function reportNonObjectExecutionControls(params, issues) {
+    if (params.decisionPhase !== "capability_execution")
+        return;
+    if (readWorkerDecisionRecord(params.record.controls))
+        return;
+    issues.push(createWorkerDecisionIssue("worker_capability_controls_not_object", `${params.path}.controls`));
+}
+function normalizeGeneratedCapabilityControls(value, schema) {
+    const record = readWorkerDecisionRecord(value);
+    if (!record)
+        return value;
+    const required = new Set(schema.required);
+    return Object.fromEntries(Object.entries(record).filter(([controlId, controlValue]) => shouldRetainGeneratedCapabilityControl(controlId, controlValue, required, schema)));
+}
+function shouldRetainGeneratedCapabilityControl(controlId, controlValue, required, schema) {
+    if (controlValue !== null)
+        return true;
+    if (required.has(controlId))
+        return true;
+    return !Object.prototype.hasOwnProperty.call(schema.properties, controlId);
+}
+function createWorkerCapabilityControlsIssue(params) {
+    const code = `worker_capability_${params.issueCode}`;
+    if (!requiresDetailedCapabilityControlsIssue(params.issueCode)) {
+        return createWorkerDecisionIssue(code, params.path);
+    }
+    return createWorkerDecisionIssue(code, params.path, `${pendingCapabilityBindingMessage(params)} ${capabilityControlProblemMessage(params)} Allowed control IDs: ${JSON.stringify(Object.keys(params.schema.properties))}. Required control IDs: ${JSON.stringify(params.schema.required)}.`);
+}
+function requiresDetailedCapabilityControlsIssue(issueCode) {
+    return (issueCode === "controls_unknown" ||
+        issueCode === "controls_required_missing");
+}
+function pendingCapabilityBindingMessage(params) {
+    if (params.pendingSlotId) {
+        return `Pending slot ${JSON.stringify(params.pendingSlotId)} is frozen to capabilityId ${JSON.stringify(params.capability.capabilityId)}.`;
+    }
+    return `Pending capabilityId is ${JSON.stringify(params.capability.capabilityId)}.`;
+}
+function capabilityControlProblemMessage(params) {
+    if (params.issueCode === "controls_unknown") {
+        return `Control ${JSON.stringify(params.controlId)} is not allowed for this capability.`;
+    }
+    return `Required control ${JSON.stringify(params.controlId)} is missing for this capability.`;
+}

package/dist/src/runtime/steps/worker-decision/parser/capability-invocation-validation.d.ts

@@ -0,0 +1,4 @@
+import { type WorkerDecisionValidationIssue } from "../contracts.js";
+import type { ActionValidation, CapabilityInvocationValidation, CapabilityInvocationValidationInput, DecisionValidationContext } from "./validation-contract.js";
+export declare function validateSingleCapabilityDecision(record: Record<string, unknown>, context: DecisionValidationContext, issues: WorkerDecisionValidationIssue[]): ActionValidation;
+export declare function parseCapabilityInvocation(params: CapabilityInvocationValidationInput, issues: WorkerDecisionValidationIssue[]): CapabilityInvocationValidation;

package/dist/src/runtime/steps/worker-decision/parser/capability-invocation-validation.js

@@ -0,0 +1,104 @@
+import { WORKER_CAPABILITY_AUTHORING_OBJECTIVE_MAX_LENGTH, WORKER_CAPABILITY_INTENT_MAX_LENGTH, } from "../contracts.js";
+import { partitionSelectedCapabilityControls, validateCapabilityExecutionControls, validateCapabilitySelectionControls, } from "./capability-controls-validation.js";
+import { validateBoundedWorkerDecisionText, validateExactWorkerDecisionKeys, } from "./decision-shape-validation.js";
+import { createWorkerDecisionIssue, hasObservationOnlyCapabilityMismatch, } from "./validation-contract.js";
+export function validateSingleCapabilityDecision(record, context, issues) {
+    if (hasMissingPendingCapabilityRefinement(context)) {
+        issues.push(createWorkerDecisionIssue("worker_capability_refinement_invalid", "decision.action"));
+    }
+    const invocation = parseCapabilityInvocation({
+        record,
+        path: "decision",
+        includesActionKey: true,
+        observationOnly: false,
+        executionRequiresPendingInvocation: true,
+        decisionPhase: context.decisionPhase,
+        availableCapabilities: context.availableCapabilities,
+        pendingInvocation: context.pendingCapabilitySelection,
+        pendingSlotId: undefined,
+    }, issues);
+    return {
+        acceptedControls: invocation.controls,
+        acceptedAuthoringObjective: invocation.authoringObjective,
+        acceptedSelectionControls: invocation.selectionControls,
+    };
+}
+function hasMissingPendingCapabilityRefinement(context) {
+    if (context.decisionPhase !== "capability_execution")
+        return false;
+    return context.pendingCapabilitySelection === undefined;
+}
+export function parseCapabilityInvocation(params, issues) {
+    const selectedCapability = resolveCapabilityInvocationDescriptor(params, issues);
+    if (params.decisionPhase === "capability_selection") {
+        validateBoundedWorkerDecisionText(params.record.intent, WORKER_CAPABILITY_INTENT_MAX_LENGTH, "worker_capability_intent_invalid", `${params.path}.intent`, issues);
+    }
+    const controlsPartition = partitionSelectedCapabilityControls(selectedCapability, `${params.path}.capabilityId`, issues);
+    validateExactWorkerDecisionKeys(params.record, expectedCapabilityInvocationKeys(params, controlsPartition?.selectionControlIds.length ?? 0, selectedCapability), issues, params.path);
+    const selectionControls = validateCapabilitySelectionControls(params, selectedCapability, controlsPartition, issues);
+    const controls = validateCapabilityExecutionControls(params, selectedCapability, controlsPartition, issues);
+    const authoringObjective = validateCapabilityAuthoringObjective(params, selectedCapability, issues);
+    return {
+        selectedCapability,
+        controlsPartition,
+        authoringObjective,
+        selectionControls,
+        controls,
+    };
+}
+function resolveCapabilityInvocationDescriptor(params, issues) {
+    if (params.pendingInvocation) {
+        return params.availableCapabilities.find((capability) => capability.capabilityId === params.pendingInvocation?.capabilityId);
+    }
+    if (executionRequiresPendingCapabilityInvocation(params))
+        return undefined;
+    if (typeof params.record.capabilityId !== "string") {
+        issues.push(createWorkerDecisionIssue("worker_capability_id_invalid", `${params.path}.capabilityId`));
+        return undefined;
+    }
+    const selectedCapability = params.availableCapabilities.find((capability) => capability.capabilityId === params.record.capabilityId);
+    if (!selectedCapability) {
+        issues.push(createWorkerDecisionIssue("worker_capability_unavailable", `${params.path}.capabilityId`));
+        return undefined;
+    }
+    if (hasObservationOnlyCapabilityMismatch(params, selectedCapability)) {
+        issues.push(createWorkerDecisionIssue("worker_capability_batch_effect_invalid", `${params.path}.capabilityId`));
+    }
+    return selectedCapability;
+}
+function executionRequiresPendingCapabilityInvocation(params) {
+    if (params.decisionPhase !== "capability_execution")
+        return false;
+    return params.executionRequiresPendingInvocation;
+}
+function expectedCapabilityInvocationKeys(params, selectionControlCount, selectedCapability) {
+    const keys = params.includesActionKey ? ["action"] : [];
+    if (params.decisionPhase === "capability_execution") {
+        keys.push("controls");
+        return keys;
+    }
+    keys.push("capabilityId", "intent");
+    if (selectedCapability?.requiresPayloadAuthoringObjective) {
+        keys.push("authoringObjective");
+    }
+    if (selectionControlCount > 0)
+        keys.push("selectionControls");
+    return keys;
+}
+function validateCapabilityAuthoringObjective(params, selectedCapability, issues) {
+    if (!selectedCapability?.requiresPayloadAuthoringObjective)
+        return undefined;
+    if (params.decisionPhase === "capability_execution") {
+        return params.pendingInvocation?.authoringObjective;
+    }
+    validateBoundedWorkerDecisionText(params.record.authoringObjective, WORKER_CAPABILITY_AUTHORING_OBJECTIVE_MAX_LENGTH, "worker_capability_authoring_objective_invalid", `${params.path}.authoringObjective`, issues);
+    const value = params.record.authoringObjective;
+    if (typeof value !== "string")
+        return undefined;
+    if (value.trim().length === 0)
+        return undefined;
+    if (value.length > WORKER_CAPABILITY_AUTHORING_OBJECTIVE_MAX_LENGTH) {
+        return undefined;
+    }
+    return value.trim();
+}

package/dist/src/runtime/steps/worker-decision/parser/decision-shape-validation.d.ts

@@ -0,0 +1,4 @@
+import type { WorkerDecisionValidationIssue } from "../contracts.js";
+export declare function readWorkerDecisionRecord(value: unknown): Record<string, unknown> | undefined;
+export declare function validateExactWorkerDecisionKeys(record: Record<string, unknown>, expectedKeys: readonly string[], issues: WorkerDecisionValidationIssue[], path?: string): void;
+export declare function validateBoundedWorkerDecisionText(value: unknown, maximumLength: number, code: string, path: string, issues: WorkerDecisionValidationIssue[]): void;

package/dist/src/runtime/steps/worker-decision/parser/decision-shape-validation.js

@@ -0,0 +1,28 @@
+import { createWorkerDecisionIssue } from "./validation-contract.js";
+export function readWorkerDecisionRecord(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+        return undefined;
+    }
+    return value;
+}
+export function validateExactWorkerDecisionKeys(record, expectedKeys, issues, path = "decision") {
+    const expected = new Set(expectedKeys);
+    const actual = Object.keys(record);
+    const hasExpectedKeyCount = actual.length === expected.size;
+    const containsOnlyExpectedKeys = actual.every((key) => expected.has(key));
+    if (hasExpectedKeyCount && containsOnlyExpectedKeys)
+        return;
+    issues.push(createWorkerDecisionIssue("worker_decision_shape_invalid", path));
+}
+export function validateBoundedWorkerDecisionText(value, maximumLength, code, path, issues) {
+    if (hasValidBoundedWorkerDecisionText(value, maximumLength))
+        return;
+    issues.push(createWorkerDecisionIssue(code, path));
+}
+function hasValidBoundedWorkerDecisionText(value, maximumLength) {
+    if (typeof value !== "string")
+        return false;
+    if (value.trim().length === 0)
+        return false;
+    return value.length <= maximumLength;
+}

package/dist/src/runtime/steps/worker-decision/parser/pending-capability-selection-validation.d.ts

@@ -0,0 +1,4 @@
+import type { DecisionValidationContext } from "./validation-contract.js";
+type PendingSelectionValidationOptions = Pick<DecisionValidationContext, "decisionPhase" | "pendingCapabilitySelection" | "pendingCapabilityBatchSelection" | "availableCapabilities" | "maxBatchCapabilityExecutions">;
+export declare function validatePendingSelectionOptions(options: PendingSelectionValidationOptions): void;
+export {};

package/dist/src/runtime/steps/worker-decision/parser/pending-capability-selection-validation.js

@@ -0,0 +1,105 @@
+import { WORKER_CAPABILITY_AUTHORING_OBJECTIVE_MAX_LENGTH } from "../contracts.js";
+import { WORKER_CAPABILITY_INTENT_MAX_LENGTH } from "../contracts.js";
+import { partitionWorkerCapabilityControlsSchema, validateWorkerCapabilitySelectionControls, } from "../../../orchestration/worker-capabilities/index.js";
+export function validatePendingSelectionOptions(options) {
+    if (options.decisionPhase === "capability_selection") {
+        rejectUnexpectedPendingCapabilitySelection(options);
+        return;
+    }
+    if (!hasExactlyOnePendingCapabilitySelection(options)) {
+        throw new Error("worker_pending_capability_selection_invalid");
+    }
+    if (options.pendingCapabilitySelection) {
+        validatePendingSingleCapabilitySelection(options);
+        return;
+    }
+    if (!hasValidPendingCapabilityBatchSelection(options)) {
+        throw new Error("worker_pending_capability_batch_selection_invalid");
+    }
+}
+function rejectUnexpectedPendingCapabilitySelection(options) {
+    if (!hasUnexpectedPendingCapabilitySelection(options))
+        return;
+    throw new Error("worker_pending_capability_selection_unexpected");
+}
+function hasUnexpectedPendingCapabilitySelection(options) {
+    if (options.pendingCapabilitySelection !== undefined)
+        return true;
+    return options.pendingCapabilityBatchSelection !== undefined;
+}
+function hasExactlyOnePendingCapabilitySelection(options) {
+    const hasSingle = options.pendingCapabilitySelection !== undefined;
+    const hasBatch = options.pendingCapabilityBatchSelection !== undefined;
+    return hasSingle !== hasBatch;
+}
+function validatePendingSingleCapabilitySelection(options) {
+    const pending = options.pendingCapabilitySelection;
+    const descriptor = options.availableCapabilities.find(({ capabilityId }) => capabilityId === pending.capabilityId);
+    if (isValidPendingSingleSelection(pending, descriptor))
+        return;
+    throw new Error("worker_pending_capability_selection_invalid");
+}
+function isValidPendingSingleSelection(pending, descriptor) {
+    if (!descriptor)
+        return false;
+    if (!hasValidPendingCapabilityIntent(pending))
+        return false;
+    if (!hasExpectedPendingSelectionControls(pending, descriptor))
+        return false;
+    return hasExpectedPendingAuthoringObjective(pending, descriptor);
+}
+function hasValidPendingCapabilityBatchSelection(options) {
+    const pendingBatch = options.pendingCapabilityBatchSelection;
+    if (!Array.isArray(pendingBatch))
+        return false;
+    if (pendingBatch.length < 2)
+        return false;
+    if (!Number.isInteger(options.maxBatchCapabilityExecutions))
+        return false;
+    if (pendingBatch.length > options.maxBatchCapabilityExecutions)
+        return false;
+    return pendingBatch.every((pending) => isValidPendingObservationBatchItem(pending, options.availableCapabilities));
+}
+function isValidPendingObservationBatchItem(pending, availableCapabilities) {
+    const descriptor = availableCapabilities.find(({ capabilityId }) => capabilityId === pending.capabilityId);
+    if (!descriptor)
+        return false;
+    if (descriptor.effect !== "observation")
+        return false;
+    if (!hasValidPendingCapabilityIntent(pending))
+        return false;
+    if (!hasExpectedPendingSelectionControls(pending, descriptor))
+        return false;
+    return hasExpectedPendingAuthoringObjective(pending, descriptor);
+}
+function hasValidPendingCapabilityIntent(pending) {
+    if (pending.intent.trim() !== pending.intent)
+        return false;
+    if (pending.intent.length === 0)
+        return false;
+    return pending.intent.length <= WORKER_CAPABILITY_INTENT_MAX_LENGTH;
+}
+function hasExpectedPendingAuthoringObjective(pending, descriptor) {
+    const required = descriptor.requiresPayloadAuthoringObjective === true;
+    if (Object.hasOwn(pending, "authoringObjective") !== required)
+        return false;
+    if (!required)
+        return true;
+    const value = pending.authoringObjective;
+    if (typeof value !== "string")
+        return false;
+    if (value.trim() !== value)
+        return false;
+    if (value.length === 0)
+        return false;
+    return value.length <= WORKER_CAPABILITY_AUTHORING_OBJECTIVE_MAX_LENGTH;
+}
+function hasExpectedPendingSelectionControls(pending, descriptor) {
+    const partition = partitionWorkerCapabilityControlsSchema(descriptor.controls, descriptor.selectionControlIds);
+    if (!partition.ok)
+        return false;
+    const expected = partition.value.selectionControlIds.length > 0;
+    if (Object.hasOwn(pending, "selectionControls") !== expected)
+        return false;
+    return validateWorkerCapabilitySelectionControls(partition.value, pending.selectionControls ?? {}).ok;
+}

package/dist/src/runtime/steps/worker-decision/parser/validation-contract.d.ts

@@ -0,0 +1,50 @@
+import type { WorkerControlDecision, WorkerDecisionPhase, WorkerDecisionValidationIssue } from "../contracts.js";
+import type { WorkerCapabilityControls, WorkerCapabilityControlsPartition, WorkerCapabilityDescriptor } from "../../../orchestration/worker-capabilities/index.js";
+export type WorkerDecisionAction = WorkerControlDecision["action"];
+export type PendingCapabilityInvocation = Readonly<{
+    capabilityId: string;
+    intent: string;
+    authoringObjective?: string;
+    selectionControls?: WorkerCapabilityControls;
+}>;
+export type AcceptedCapabilityInvocation = Readonly<{
+    capabilityId: string;
+    intent: string;
+    authoringObjective?: string;
+    selectionControls?: WorkerCapabilityControls;
+    controls?: WorkerCapabilityControls;
+}>;
+export type DecisionValidationContext = Readonly<{
+    decisionPhase: WorkerDecisionPhase;
+    allowedActions: readonly WorkerDecisionAction[];
+    pendingCapabilitySelection?: PendingCapabilityInvocation;
+    pendingCapabilityBatchSelection?: readonly PendingCapabilityInvocation[];
+    availableCapabilities: readonly WorkerCapabilityDescriptor[];
+    maxBatchCapabilityExecutions: number;
+}>;
+export type ActionValidation = Readonly<{
+    acceptedControls?: WorkerCapabilityControls;
+    acceptedAuthoringObjective?: string;
+    acceptedSelectionControls?: WorkerCapabilityControls;
+    acceptedBatchInvocations?: readonly AcceptedCapabilityInvocation[];
+}>;
+export type CapabilityInvocationValidation = Readonly<{
+    selectedCapability?: WorkerCapabilityDescriptor;
+    controlsPartition?: WorkerCapabilityControlsPartition;
+    authoringObjective?: string;
+    selectionControls?: WorkerCapabilityControls;
+    controls?: WorkerCapabilityControls;
+}>;
+export type CapabilityInvocationValidationInput = Readonly<{
+    record: Record<string, unknown>;
+    path: string;
+    includesActionKey: boolean;
+    observationOnly: boolean;
+    executionRequiresPendingInvocation: boolean;
+    decisionPhase: WorkerDecisionPhase;
+    availableCapabilities: readonly WorkerCapabilityDescriptor[];
+    pendingInvocation: PendingCapabilityInvocation | undefined;
+    pendingSlotId: string | undefined;
+}>;
+export declare function hasObservationOnlyCapabilityMismatch(params: Pick<CapabilityInvocationValidationInput, "observationOnly">, selectedCapability: WorkerCapabilityDescriptor): boolean;
+export declare function createWorkerDecisionIssue(code: string, path: string, message?: string): WorkerDecisionValidationIssue;

package/dist/src/runtime/steps/worker-decision/parser/validation-contract.js

@@ -0,0 +1,19 @@
+import { WORKER_DECISION_ACTIONS } from "../contracts.js";
+export function hasObservationOnlyCapabilityMismatch(params, selectedCapability) {
+    if (!params.observationOnly)
+        return false;
+    return selectedCapability.effect !== "observation";
+}
+export function createWorkerDecisionIssue(code, path, message) {
+    return {
+        code,
+        path,
+        message: message ?? defaultWorkerDecisionIssueMessage(code),
+    };
+}
+function defaultWorkerDecisionIssueMessage(code) {
+    if (code === "worker_action_invalid") {
+        return `Action must be one of: ${WORKER_DECISION_ACTIONS.join(", ")}.`;
+    }
+    return `Worker decision failed ${code}.`;
+}

package/dist/src/runtime/steps/worker-decision/parser.d.ts

@@ -1,17 +1,21 @@
 import { type WorkerDecisionPhase, type WorkerDecisionDiagnosticContext, type WorkerDecisionParseResult } from "./contracts.js";
-import { type WorkerCapabilityControls, type WorkerCapabilityDescriptor } from "../../orchestration/worker-capabilities/index.js";
+import type { WorkerCapabilityControls, WorkerCapabilityDescriptor } from "../../orchestration/worker-capabilities/index.js";
+import type { WorkerDecisionAction } from "./parser/validation-contract.js";
 export declare function parseWorkerDecisionOutput(text: string, diagnostic?: WorkerDecisionDiagnosticContext, options?: Readonly<{
     availableCapabilities?: readonly WorkerCapabilityDescriptor[];
     maxBatchCapabilityExecutions?: number;
     decisionPhase?: WorkerDecisionPhase;
+    allowedActions?: readonly WorkerDecisionAction[];
     pendingCapabilitySelection?: Readonly<{
         capabilityId: string;
         intent: string;
+        authoringObjective?: string;
         selectionControls?: WorkerCapabilityControls;
     }>;
     pendingCapabilityBatchSelection?: readonly Readonly<{
         capabilityId: string;
         intent: string;
+        authoringObjective?: string;
         selectionControls?: WorkerCapabilityControls;
     }>[];
 }>): WorkerDecisionParseResult;