@abot-ai/runtime 1.0.0 → 1.2.0

package/dist/src/runtime/orchestration/role-calls/command-dispatch.js

@@ -1,12 +1,10 @@
-import { isRuntimeDelegateRoleId, RUNTIME_ROOT_ROLE_ID, } from "../roles.js";
-import { createRoleCapabilitySelectionFingerprint, normalizeRoleCapabilitySelectionProjection, } from "./capability-selection-reconsideration.js";
-import { isRoleCapabilityId, ROLE_CAPABILITY_INVOCATION_INTENT_MAX_LENGTH, ROLE_CAPABILITY_REFERENCE_DATA_MAX_LENGTH, } from "./contracts.js";
-import { bindRoleCallPlanChild, plannerPlanHasOpenItems, settleRoleCallPlanChild, } from "./plan.js";
-import { parseRoleCallWorkerCapabilityScope, } from "./worker-capability-scope.js";
-import { isRoleCallWorkingDirectoryRoleId, normalizeEstablishedRoleCallWorkingDirectory, } from "./working-directory.js";
-import { hasCapabilityAuthority } from "./candidate-validation.js";
-import { areOwnedDependencyResults, commit, findCall, isBoundedText, isExactJsonObjectString, isExactResultValidForCall, isOptionalBoundedText, isRoleCapabilityDeclaredEffect, isSettledObservedEffectCompatible, isValidCapabilityResultReferences, reject, sameStringArray, } from "./reducer-primitives.js";
-export function dispatchRoleCallCommand(state, command, policy) {
+import { beginCapabilityBatch, settleCapabilityBatch, } from "./command-dispatch/capability-batch-transitions.js";
+import { beginCapabilityExecution, settleCapabilityExecution, } from "./command-dispatch/capability-execution-transitions.js";
+import { reconsiderCapabilitySelection } from "./command-dispatch/capability-selection-transition.js";
+import { establishWorkingDirectory, updateCapabilityScope, } from "./command-dispatch/call-scope-transitions.js";
+import { openChild, returnChild, } from "./command-dispatch/child-transitions.js";
+import { completeRootResponse, createRoot, } from "./command-dispatch/root-transitions.js";
+export function dispatchRoleCallCommand(state, command, policy, admittedHeadRevision) {
     switch (command.type) {
         case "create_root":
             return createRoot(state);
@@ -15,7 +13,7 @@ export function dispatchRoleCallCommand(state, command, policy) {
         case "open_child":
             return openChild(state, command, policy);
         case "return_child":
-            return returnChild(state, command, policy);
+            return returnChild(state, command, policy, admittedHeadRevision);
         case "begin_capability_execution":
             return beginCapabilityExecution(state, command, policy);
         case "settle_capability_execution":
@@ -32,575 +30,3 @@ export function dispatchRoleCallCommand(state, command, policy) {
             return reconsiderCapabilitySelection(state, command, policy);
     }
 }
-function createRoot(state) {
-    if (state.phase !== "empty" || state.rootCallId !== null) {
-        return reject(state, "root_already_created");
-    }
-    const callId = nextCallId(state);
-    const root = {
-        callId,
-        parentCallId: null,
-        roleId: RUNTIME_ROOT_ROLE_ID,
-        depth: 0,
-        objective: null,
-        dependencyResultRefs: [],
-        status: "active",
-        childCallIds: [],
-        activationCount: 1,
-        resultRef: null,
-    };
-    return commit({
-        ...state,
-        phase: "running",
-        rootCallId: callId,
-        activeCallId: callId,
-        callSequence: state.callSequence + 1,
-        calls: [...state.calls, root],
-    }, { type: "root_created", callId });
-}
-function completeRootResponse(state, command, policy) {
-    const { callId, response } = command;
-    if (state.phase === "empty") {
-        return reject(state, "root_missing");
-    }
-    const root = findCall(state, callId);
-    if (state.phase !== "running" ||
-        callId !== state.rootCallId ||
-        state.activeCallId !== callId ||
-        root?.roleId !== RUNTIME_ROOT_ROLE_ID ||
-        root.status !== "active") {
-        return reject(state, "root_response_not_allowed");
-    }
-    if (!isBoundedText(response, policy.limits.maxResponseChars)) {
-        return reject(state, "invalid_command");
-    }
-    return commit({
-        ...state,
-        phase: "completed",
-        activeCallId: null,
-        rootResponse: policy.authority.terminalTextMode === "exact"
-            ? response
-            : response.trim(),
-        calls: replaceCall(state.calls, {
-            ...root,
-            status: "completed",
-        }),
-    }, { type: "root_response_committed", callId });
-}
-function establishWorkingDirectory(state, command, policy) {
-    const { callId, invocationAttempt, workingDirectory } = command;
-    const call = findCall(state, callId);
-    if (state.phase !== "running" ||
-        state.activeCallId !== callId ||
-        !hasCapabilityAuthority(policy.authority, state, call) ||
-        call.status !== "active" ||
-        call.activationCount !== invocationAttempt ||
-        call.workingDirectory !== undefined) {
-        return reject(state, "working_directory_establishment_invalid");
-    }
-    const normalized = normalizeEstablishedRoleCallWorkingDirectory(workingDirectory);
-    if (!normalized) {
-        return reject(state, "working_directory_establishment_invalid");
-    }
-    return commit({
-        ...state,
-        calls: replaceCall(state.calls, {
-            ...call,
-            workingDirectory: normalized,
-        }),
-    }, { type: "working_directory_established", callId });
-}
-function reconsiderCapabilitySelection(state, command, policy) {
-    const { callId, invocationAttempt, steeringVersion, selection } = command;
-    const call = findCall(state, callId);
-    const activeScope = call?.workerCapabilityScope?.catalogGroupIds;
-    if (state.phase !== "running" ||
-        state.activeCallId !== callId ||
-        !hasCapabilityAuthority(policy.authority, state, call) ||
-        call.status !== "active" ||
-        call.activationCount !== invocationAttempt ||
-        !activeScope ||
-        !sameStringArray(activeScope, selection.activeCapabilityCatalogGroupIds) ||
-        (call.workingDirectory !== undefined &&
-            selection.workingDirectory !== call.workingDirectory) ||
-        !Number.isSafeInteger(steeringVersion) ||
-        steeringVersion < 0) {
-        return reject(state, "capability_selection_reconsideration_invalid");
-    }
-    const normalizedSelection = normalizeRoleCapabilitySelectionProjection(selection);
-    if (!normalizedSelection) {
-        return reject(state, "capability_selection_reconsideration_invalid");
-    }
-    const fingerprint = createRoleCapabilitySelectionFingerprint({
-        steeringVersion,
-        selection: normalizedSelection,
-    });
-    const reconsideration = {
-        invocationAttempt,
-        steeringVersion,
-        fingerprint,
-        selection: normalizedSelection,
-    };
-    return commit({
-        ...state,
-        calls: replaceCall(state.calls, {
-            ...call,
-            activationCount: call.activationCount + 1,
-            lastCapabilitySelectionReconsideration: reconsideration,
-        }),
-    }, {
-        type: "capability_selection_reconsidered",
-        callId,
-        invocationAttempt,
-        fingerprint,
-    });
-}
-function openChild(state, command, policy) {
-    const { callerCallId, objective, workerCapabilityScope, workingDirectory, dependencyResultRefs = [], plannerPlan, } = command;
-    const roleId = command.roleId;
-    if (state.phase === "empty") {
-        return reject(state, "root_missing");
-    }
-    if (roleId === RUNTIME_ROOT_ROLE_ID) {
-        return reject(state, "supervisor_child_forbidden");
-    }
-    if (!isRuntimeDelegateRoleId(roleId)) {
-        return reject(state, "invalid_command");
-    }
-    if (!policy.authority.availableSubordinateContractIds.includes(roleId)) {
-        return reject(state, "child_role_not_authorized");
-    }
-    if (workerCapabilityScope && roleId !== "worker") {
-        return reject(state, "invalid_command");
-    }
-    if (workingDirectory !== undefined &&
-        !isRoleCallWorkingDirectoryRoleId(roleId)) {
-        return reject(state, "invalid_command");
-    }
-    const caller = findCall(state, callerCallId);
-    if (state.phase !== "running" ||
-        state.activeCallId !== callerCallId ||
-        caller?.status !== "active") {
-        return reject(state, "caller_not_active");
-    }
-    if (!isBoundedText(objective, policy.limits.maxObjectiveChars)) {
-        return reject(state, "invalid_command");
-    }
-    if (!areOwnedDependencyResults(state, caller, dependencyResultRefs)) {
-        return reject(state, "child_dependency_invalid");
-    }
-    const depth = caller.depth + 1;
-    if (depth > policy.limits.maxDepth) {
-        return reject(state, "depth_limit_exceeded");
-    }
-    if (state.calls.length >= policy.limits.maxCalls) {
-        return reject(state, "call_limit_exceeded");
-    }
-    const childCallId = nextCallId(state);
-    const planBinding = bindRoleCallPlanChild({
-        state,
-        caller,
-        childCallId,
-        childObjective: objective,
-        ...(plannerPlan ? { binding: plannerPlan } : {}),
-        policy,
-    });
-    if (!planBinding.ok) {
-        return reject(state, planBinding.code, planBinding.issues);
-    }
-    const child = {
-        callId: childCallId,
-        parentCallId: callerCallId,
-        roleId,
-        depth,
-        objective: objective.trim(),
-        ...(workerCapabilityScope ? { workerCapabilityScope } : {}),
-        ...(workingDirectory !== undefined ? { workingDirectory } : {}),
-        dependencyResultRefs: [...dependencyResultRefs],
-        status: "active",
-        childCallIds: [],
-        activationCount: 1,
-        resultRef: null,
-    };
-    return commit({
-        ...state,
-        activeCallId: childCallId,
-        callSequence: state.callSequence + 1,
-        plans: planBinding.plans,
-        calls: [
-            ...replaceCall(state.calls, {
-                ...caller,
-                status: "waiting_for_child",
-                childCallIds: [...caller.childCallIds, childCallId],
-            }),
-            child,
-        ],
-    }, {
-        type: "child_opened",
-        callerCallId,
-        childCallId,
-        ...(planBinding.planItemIds
-            ? { planItemIds: planBinding.planItemIds }
-            : {}),
-    });
-}
-function returnChild(state, command, policy) {
-    const { callerCallId, childCallId, outcome, summary } = command;
-    if (state.phase === "empty") {
-        return reject(state, "root_missing");
-    }
-    const caller = findCall(state, callerCallId);
-    const child = findCall(state, childCallId);
-    if (state.phase !== "running" ||
-        state.activeCallId !== childCallId ||
-        child?.status !== "active" ||
-        child.parentCallId !== callerCallId ||
-        caller?.status !== "waiting_for_child" ||
-        !caller.childCallIds.includes(childCallId)) {
-        return reject(state, "child_return_mismatch");
-    }
-    if (child.roleId === RUNTIME_ROOT_ROLE_ID ||
-        (outcome !== "completed" && outcome !== "failed") ||
-        !isBoundedText(summary, policy.limits.maxResultChars)) {
-        return reject(state, "invalid_command");
-    }
-    const resultRef = nextResultRef(state);
-    const result = {
-        resultRef,
-        producerCallId: childCallId,
-        roleId: child.roleId,
-        outcome,
-        summary: summary.trim(),
-    };
-    if (child.roleId === "planner" &&
-        outcome === "completed" &&
-        plannerPlanHasOpenItems(state.plans, child.callId)) {
-        return reject(state, "planner_plan_incomplete");
-    }
-    const planSettlement = settleRoleCallPlanChild({
-        state,
-        caller,
-        childCallId,
-        outcome,
-    });
-    if (!planSettlement.ok) {
-        return reject(state, planSettlement.code);
-    }
-    return commit({
-        ...state,
-        activeCallId: callerCallId,
-        resultSequence: state.resultSequence + 1,
-        plans: planSettlement.plans,
-        calls: replaceCall(replaceCall(state.calls, {
-            ...caller,
-            status: "active",
-            activationCount: caller.activationCount + 1,
-        }), {
-            ...child,
-            status: "completed",
-            resultRef,
-        }),
-        results: [...state.results, result],
-    }, {
-        type: "child_returned",
-        callerCallId,
-        childCallId,
-        resultRef,
-        ...(planSettlement.planItemIds
-            ? { planItemIds: planSettlement.planItemIds }
-            : {}),
-    });
-}
-function beginCapabilityExecution(state, command, policy) {
-    const { callId, invocationAttempt, capabilityId, declaredEffect, intent, controlsJson, } = command;
-    const call = findCall(state, callId);
-    if (state.phase !== "running" ||
-        state.activeCallId !== callId ||
-        !hasCapabilityAuthority(policy.authority, state, call) ||
-        call.status !== "active") {
-        return reject(state, "capability_caller_invalid");
-    }
-    if (call.activationCount !== invocationAttempt) {
-        return reject(state, "capability_invocation_mismatch");
-    }
-    if (!isRoleCapabilityId(capabilityId) ||
-        !isRoleCapabilityDeclaredEffect(declaredEffect) ||
-        !isBoundedText(intent, ROLE_CAPABILITY_INVOCATION_INTENT_MAX_LENGTH) ||
-        !isExactJsonObjectString(controlsJson)) {
-        return reject(state, "invalid_command");
-    }
-    if (state.capabilityExecutions.length >= policy.limits.maxCapabilityExecutions) {
-        return reject(state, "capability_execution_limit_exceeded");
-    }
-    const executionId = nextCapabilityExecutionId(state);
-    const execution = {
-        executionId,
-        callId,
-        invocationAttempt,
-        capabilityId,
-        declaredEffect,
-        intent: intent.trim(),
-        controlsJson,
-        status: "running",
-        outcome: null,
-        observedEffect: null,
-        summary: null,
-    };
-    return commit({
-        ...state,
-        capabilityExecutionSequence: state.capabilityExecutionSequence + 1,
-        calls: replaceCall(state.calls, {
-            ...call,
-            status: "waiting_for_capability",
-        }),
-        capabilityExecutions: [...state.capabilityExecutions, execution],
-    }, {
-        type: "capability_execution_begun",
-        callId,
-        executionId,
-    });
-}
-function settleCapabilityExecution(state, command, policy) {
-    const { callId, executionId, outcome, observedEffect, summary, referenceData, references, exactResult, } = command;
-    const call = findCall(state, callId);
-    const execution = findCapabilityExecution(state, executionId);
-    const ownedRunning = state.capabilityExecutions.filter((candidate) => candidate.callId === callId && candidate.status === "running");
-    if (state.phase !== "running" ||
-        state.activeCallId !== callId ||
-        !hasCapabilityAuthority(policy.authority, state, call) ||
-        call.status !== "waiting_for_capability" ||
-        execution?.status !== "running" ||
-        execution.callId !== callId ||
-        execution.invocationAttempt !== call.activationCount ||
-        ownedRunning.length !== 1) {
-        return reject(state, "capability_execution_mismatch");
-    }
-    if (!isBoundedText(summary, policy.limits.maxResultChars) ||
-        !isOptionalBoundedText(referenceData, ROLE_CAPABILITY_REFERENCE_DATA_MAX_LENGTH) ||
-        !isValidCapabilityResultReferences(references) ||
-        !isExactResultValidForCall(call, exactResult) ||
-        (outcome !== "succeeded" && outcome !== "failed") ||
-        !isSettledObservedEffectCompatible({
-            declaredEffect: execution.declaredEffect,
-            outcome,
-            observedEffect,
-        })) {
-        return reject(state, "capability_execution_mismatch");
-    }
-    return commit({
-        ...state,
-        calls: replaceCall(state.calls, {
-            ...call,
-            status: "active",
-            activationCount: call.activationCount + 1,
-        }),
-        capabilityExecutions: replaceCapabilityExecution(state.capabilityExecutions, {
-            ...execution,
-            status: "settled",
-            outcome,
-            observedEffect,
-            summary: summary.trim(),
-            ...(referenceData ? { referenceData } : {}),
-            ...(references && references.length > 0
-                ? { references: Object.freeze([...references]) }
-                : {}),
-            exactResult,
-        }),
-    }, {
-        type: "capability_execution_settled",
-        callId,
-        executionId,
-    });
-}
-function beginCapabilityBatch(state, command, policy) {
-    const { callId, invocationAttempt, entries } = command;
-    const call = findCall(state, callId);
-    if (state.phase !== "running" ||
-        state.activeCallId !== callId ||
-        !hasCapabilityAuthority(policy.authority, state, call) ||
-        call.status !== "active") {
-        return reject(state, "capability_caller_invalid");
-    }
-    if (call.activationCount !== invocationAttempt) {
-        return reject(state, "capability_invocation_mismatch");
-    }
-    if (!Array.isArray(entries) ||
-        entries.length < 2 ||
-        entries.some((entry) => !isRoleCapabilityId(entry.capabilityId) ||
-            entry.declaredEffect !== "observation" ||
-            !isBoundedText(entry.intent, ROLE_CAPABILITY_INVOCATION_INTENT_MAX_LENGTH) ||
-            !isExactJsonObjectString(entry.controlsJson))) {
-        return reject(state, "invalid_command");
-    }
-    if (state.capabilityExecutions.length + entries.length >
-        policy.limits.maxCapabilityExecutions) {
-        return reject(state, "capability_execution_limit_exceeded");
-    }
-    const executions = entries.map((entry, index) => ({
-        executionId: nextCapabilityExecutionId(state, index),
-        callId,
-        invocationAttempt,
-        capabilityId: entry.capabilityId,
-        declaredEffect: "observation",
-        intent: entry.intent.trim(),
-        controlsJson: entry.controlsJson,
-        status: "running",
-        outcome: null,
-        observedEffect: null,
-        summary: null,
-    }));
-    const executionIds = Object.freeze(executions.map((execution) => execution.executionId));
-    return commit({
-        ...state,
-        capabilityExecutionSequence: state.capabilityExecutionSequence + executions.length,
-        calls: replaceCall(state.calls, {
-            ...call,
-            status: "waiting_for_capability",
-        }),
-        capabilityExecutions: [...state.capabilityExecutions, ...executions],
-    }, {
-        type: "capability_batch_begun",
-        callId,
-        executionIds,
-    });
-}
-function updateCapabilityScope(state, command, policy) {
-    const { callId, invocationAttempt, mode, catalogGroupIds } = command;
-    const call = findCall(state, callId);
-    if (state.phase !== "running" ||
-        state.activeCallId !== callId ||
-        !hasCapabilityAuthority(policy.authority, state, call) ||
-        call.status !== "active") {
-        return reject(state, "capability_caller_invalid");
-    }
-    if (call.activationCount !== invocationAttempt) {
-        return reject(state, "capability_invocation_mismatch");
-    }
-    const requestedScope = parseRoleCallWorkerCapabilityScope({
-        catalogGroupIds,
-    });
-    if (!requestedScope) {
-        return reject(state, "invalid_command");
-    }
-    let nextScope;
-    if (mode === "open") {
-        if (call.workerCapabilityScope !== undefined) {
-            return reject(state, "capability_scope_update_invalid");
-        }
-        nextScope = requestedScope;
-    }
-    else {
-        const currentScope = call.workerCapabilityScope;
-        if (!currentScope ||
-            requestedScope.catalogGroupIds.some((groupId) => currentScope.catalogGroupIds.includes(groupId))) {
-            return reject(state, "capability_scope_update_invalid");
-        }
-        const extendedScope = parseRoleCallWorkerCapabilityScope({
-            catalogGroupIds: [
-                ...currentScope.catalogGroupIds,
-                ...requestedScope.catalogGroupIds,
-            ],
-        });
-        if (!extendedScope) {
-            return reject(state, "capability_scope_update_invalid");
-        }
-        nextScope = extendedScope;
-    }
-    return commit({
-        ...state,
-        calls: replaceCall(state.calls, {
-            ...call,
-            workerCapabilityScope: nextScope,
-            activationCount: call.activationCount + 1,
-        }),
-    }, {
-        type: "capability_scope_updated",
-        callId,
-        mode,
-        catalogGroupIds: nextScope.catalogGroupIds,
-    });
-}
-function settleCapabilityBatch(state, command, policy) {
-    const { callId, settlements } = command;
-    const call = findCall(state, callId);
-    const ownedRunning = state.capabilityExecutions.filter((execution) => execution.callId === callId && execution.status === "running");
-    if (state.phase !== "running" ||
-        state.activeCallId !== callId ||
-        !hasCapabilityAuthority(policy.authority, state, call) ||
-        call.status !== "waiting_for_capability" ||
-        ownedRunning.length < 2 ||
-        settlements.length !== ownedRunning.length ||
-        settlements.some((settlement, index) => settlement.executionId !== ownedRunning[index]?.executionId)) {
-        return reject(state, "capability_execution_mismatch");
-    }
-    for (let index = 0; index < settlements.length; index += 1) {
-        const settlement = settlements[index];
-        const execution = ownedRunning[index];
-        if (execution.invocationAttempt !== call.activationCount ||
-            execution.declaredEffect !== "observation" ||
-            !isBoundedText(settlement.summary, policy.limits.maxResultChars) ||
-            !isOptionalBoundedText(settlement.referenceData, ROLE_CAPABILITY_REFERENCE_DATA_MAX_LENGTH) ||
-            !isValidCapabilityResultReferences(settlement.references) ||
-            !isExactResultValidForCall(call, settlement.exactResult) ||
-            (settlement.outcome !== "succeeded" && settlement.outcome !== "failed") ||
-            !isSettledObservedEffectCompatible({
-                declaredEffect: execution.declaredEffect,
-                outcome: settlement.outcome,
-                observedEffect: settlement.observedEffect,
-            })) {
-            return reject(state, "capability_execution_mismatch");
-        }
-    }
-    const byExecutionId = new Map(settlements.map((settlement) => [settlement.executionId, settlement]));
-    return commit({
-        ...state,
-        calls: replaceCall(state.calls, {
-            ...call,
-            status: "active",
-            activationCount: call.activationCount + 1,
-        }),
-        capabilityExecutions: state.capabilityExecutions.map((execution) => {
-            const settlement = byExecutionId.get(execution.executionId);
-            return settlement
-                ? {
-                    ...execution,
-                    status: "settled",
-                    outcome: settlement.outcome,
-                    observedEffect: settlement.observedEffect,
-                    summary: settlement.summary.trim(),
-                    ...(settlement.referenceData
-                        ? { referenceData: settlement.referenceData }
-                        : {}),
-                    ...(settlement.references && settlement.references.length > 0
-                        ? {
-                            references: Object.freeze([...settlement.references]),
-                        }
-                        : {}),
-                    exactResult: settlement.exactResult,
-                }
-                : execution;
-        }),
-    }, {
-        type: "capability_batch_settled",
-        callId,
-        executionIds: Object.freeze(settlements.map((settlement) => settlement.executionId)),
-    });
-}
-function replaceCall(calls, replacement) {
-    return calls.map((call) => call.callId === replacement.callId ? replacement : call);
-}
-function findCapabilityExecution(state, executionId) {
-    return state.capabilityExecutions.find((execution) => execution.executionId === executionId);
-}
-function replaceCapabilityExecution(executions, replacement) {
-    return executions.map((execution) => execution.executionId === replacement.executionId ? replacement : execution);
-}
-function nextCallId(state) {
-    return `call-${state.callSequence + 1}`;
-}
-function nextResultRef(state) {
-    return `result-${state.resultSequence + 1}`;
-}
-function nextCapabilityExecutionId(state, offset = 0) {
-    return `capability-execution-${state.capabilityExecutionSequence + offset + 1}`;
-}