@abot-ai/runtime 1.0.0

package/dist/src/runtime/steps/worker-decision/input/canonical-state.js

@@ -0,0 +1,167 @@
+import { isToolCatalogGroupId, } from "../../../../capabilities/tool-types.js";
+import { isRoleCapabilityId, projectRoleCallAssignmentScope, } from "../../../orchestration/role-calls/index.js";
+import { WORKER_CAPABILITY_COUNT_MAX, WORKER_CAPABILITY_SUMMARY_MAX_LENGTH, normalizeWorkerCapabilityControlsSchema, partitionWorkerCapabilityControlsSchema, } from "../../../orchestration/worker-capabilities/index.js";
+import { projectSemanticCompactionDependencyResults } from "../../../context/semantic-compaction/index.js";
+import { projectWorkerCapabilityResumeContext } from "../ledger-projection.js";
+import { WORKER_DECISION_MODEL_STEP, } from "../contracts.js";
+import { projectEffectiveWorkerSelectionControlIds } from "../runtime-path-refinement.js";
+export function prepareWorkerCanonicalState(request, options, callIdentity) {
+    const canonicalSource = options.capabilitySource ?? options.capabilityResume;
+    const assignmentScope = canonicalSource
+        ? projectRoleCallAssignmentScope({
+            head: canonicalSource.head,
+            call: options.call,
+            modelStep: WORKER_DECISION_MODEL_STEP,
+        })
+        : undefined;
+    const dependencyResults = canonicalSource
+        ? projectSemanticCompactionDependencyResults({
+            requestId: request.requestId,
+            prompt: request.prompt,
+            head: canonicalSource.head,
+            call: options.call,
+            consumer: WORKER_DECISION_MODEL_STEP,
+            ...(request.contextCompactionStore
+                ? { store: request.contextCompactionStore }
+                : {}),
+        })
+        : requireNoUnresolvedDependencies(options.call);
+    const resume = options.capabilityResume
+        ? projectWorkerCapabilityResumeContext(options.capabilityResume.ledger, options.capabilityResume.head, {
+            callId: callIdentity.callId,
+            ...(hasBatchCapabilityResume(options.capabilityResume)
+                ? { executionIds: options.capabilityResume.executionIds }
+                : { executionId: options.capabilityResume.executionId }),
+        })
+        : undefined;
+    if (resume !== undefined && resume.requestId !== request.requestId) {
+        throw new Error("worker_capability_resume_request_mismatch");
+    }
+    return Object.freeze({
+        canonicalSource,
+        assignmentScope,
+        dependencyResults,
+        resume,
+    });
+}
+function hasBatchCapabilityResume(source) {
+    return "executionIds" in source;
+}
+function requireNoUnresolvedDependencies(call) {
+    if (call.dependencyResultRefs.length > 0) {
+        throw new Error("worker_dependency_source_missing");
+    }
+    return Object.freeze([]);
+}
+export function projectCapabilities(params) {
+    const { requestId, call, binding, authorityLedger, deferRuntimePathControls, } = params;
+    if (binding === undefined)
+        return Object.freeze([]);
+    if (!Object.isFrozen(binding) ||
+        binding.ledger !== authorityLedger ||
+        binding.requestId !== requestId ||
+        binding.callId !== call.callId ||
+        binding.invocationAttempt !== call.activationCount ||
+        !Array.isArray(binding.capabilities) ||
+        !Object.isFrozen(binding.capabilities) ||
+        binding.capabilities.length > WORKER_CAPABILITY_COUNT_MAX) {
+        throw new Error("worker_capability_binding_projection_invalid");
+    }
+    const seen = new Set();
+    const capabilities = binding.capabilities.map((descriptor) => {
+        const descriptorKeys = typeof descriptor === "object" && descriptor !== null
+            ? Object.keys(descriptor)
+            : [];
+        if (typeof descriptor !== "object" ||
+            descriptor === null ||
+            !Object.isFrozen(descriptor) ||
+            descriptorKeys.length < 5 ||
+            descriptorKeys.length > 8 ||
+            descriptorKeys.some((key) => key !== "capabilityId" &&
+                key !== "summary" &&
+                key !== "effect" &&
+                key !== "controls" &&
+                key !== "selectionControlIds" &&
+                key !== "runtimePathControlIds" &&
+                key !== "controlsRefinement" &&
+                key !== "catalogGroups") ||
+            !isRoleCapabilityId(descriptor.capabilityId) ||
+            seen.has(descriptor.capabilityId) ||
+            typeof descriptor.summary !== "string" ||
+            descriptor.summary.trim().length === 0 ||
+            descriptor.summary.length > WORKER_CAPABILITY_SUMMARY_MAX_LENGTH ||
+            (descriptor.effect !== "observation" &&
+                descriptor.effect !== "mutation" &&
+                descriptor.effect !== "mixed") ||
+            (descriptor.controlsRefinement !== undefined &&
+                descriptor.controlsRefinement !== "mechanical_when_complete") ||
+            !Array.isArray(descriptor.catalogGroups) ||
+            descriptor.catalogGroups.length === 0 ||
+            descriptor.catalogGroups.some((groupId) => !isToolCatalogGroupId(groupId)) ||
+            new Set(descriptor.catalogGroups).size !== descriptor.catalogGroups.length) {
+            throw new Error("worker_capability_binding_projection_invalid");
+        }
+        const controls = normalizeWorkerCapabilityControlsSchema(descriptor.controls);
+        if (!controls.ok) {
+            throw new Error("worker_capability_binding_projection_invalid");
+        }
+        const controlsPartition = partitionWorkerCapabilityControlsSchema(controls.value, descriptor.selectionControlIds);
+        if (!controlsPartition.ok) {
+            throw new Error("worker_capability_binding_projection_invalid");
+        }
+        const runtimePathControlIds = descriptor.runtimePathControlIds ?? [];
+        if (!Array.isArray(runtimePathControlIds) ||
+            new Set(runtimePathControlIds).size !== runtimePathControlIds.length ||
+            runtimePathControlIds.some((controlId) => typeof controlId !== "string" ||
+                !Object.hasOwn(controls.value.properties, controlId))) {
+            throw new Error("worker_capability_binding_projection_invalid");
+        }
+        const effectiveSelectionControlIds = projectEffectiveWorkerSelectionControlIds({
+            selectionControlIds: controlsPartition.value.selectionControlIds,
+            runtimePathControlIds,
+        }, deferRuntimePathControls);
+        seen.add(descriptor.capabilityId);
+        return Object.freeze({
+            capabilityId: descriptor.capabilityId,
+            summary: descriptor.summary,
+            effect: descriptor.effect,
+            controls: controls.value,
+            ...(effectiveSelectionControlIds.length > 0
+                ? {
+                    selectionControlIds: effectiveSelectionControlIds,
+                }
+                : {}),
+            ...(runtimePathControlIds.length > 0
+                ? { runtimePathControlIds: Object.freeze([...runtimePathControlIds]) }
+                : {}),
+            ...(descriptor.controlsRefinement
+                ? { controlsRefinement: descriptor.controlsRefinement }
+                : {}),
+            catalogGroups: Object.freeze([...descriptor.catalogGroups]),
+        });
+    });
+    return Object.freeze(capabilities);
+}
+export function validateCanonicalSources(params) {
+    const { requestId, call, capabilitySource, resumeSource } = params;
+    if (capabilitySource &&
+        resumeSource &&
+        (capabilitySource.ledger !== resumeSource.ledger ||
+            capabilitySource.head !== resumeSource.head)) {
+        throw new Error("worker_capability_sources_mismatch");
+    }
+    const source = capabilitySource ?? resumeSource;
+    if (!source)
+        return;
+    if (source.ledger.current() !== source.head) {
+        throw new Error("worker_capability_source_head_stale");
+    }
+    const canonicalCall = source.head.state.calls.find((candidate) => candidate.callId === source.head.state.activeCallId);
+    if (source.head.state.requestId !== requestId ||
+        source.head.state.phase !== "running") {
+        throw new Error("worker_capability_source_request_mismatch");
+    }
+    if (canonicalCall !== call) {
+        throw new Error("worker_capability_source_call_mismatch");
+    }
+}

package/dist/src/runtime/steps/worker-decision/input/capability-selection.d.ts

@@ -0,0 +1,9 @@
+import { type WorkerCapabilityDescriptor } from "../../../orchestration/worker-capabilities/index.js";
+import type { PreparedWorkerCapabilitySelection, WorkerDecisionCapabilityResumeSource, WorkerDecisionCapabilitySource, WorkerDecisionInputOptions, WorkerSelectedCapabilityBatchExecution, WorkerSelectedCapabilityExecution } from "./types.js";
+export declare function prepareWorkerCapabilitySelection(options: WorkerDecisionInputOptions, projectedCapabilities: readonly WorkerCapabilityDescriptor[]): PreparedWorkerCapabilitySelection;
+export declare function canOfferCapabilityBatch(params: {
+    capabilities: readonly WorkerCapabilityDescriptor[];
+    canonicalSource: WorkerDecisionCapabilitySource | WorkerDecisionCapabilityResumeSource | undefined;
+    selectedCapabilityBatchExecution: WorkerSelectedCapabilityBatchExecution | undefined;
+    selectedCapabilityExecution: WorkerSelectedCapabilityExecution | undefined;
+}): boolean;

package/dist/src/runtime/steps/worker-decision/input/capability-selection.js

@@ -0,0 +1,135 @@
+import { isRoleCapabilityId } from "../../../orchestration/role-calls/index.js";
+import { WORKER_CAPABILITY_INTENT_MAX_LENGTH, partitionWorkerCapabilityControlsSchema, validateWorkerCapabilitySelectionControls, } from "../../../orchestration/worker-capabilities/index.js";
+export function prepareWorkerCapabilitySelection(options, projectedCapabilities) {
+    const selectedCapabilityExecution = options.selectedCapabilityExecution
+        ? normalizeSelectedCapabilityExecution(options.selectedCapabilityExecution, projectedCapabilities)
+        : undefined;
+    const selectedCapabilityBatchExecution = options.selectedCapabilityBatchExecution
+        ? normalizeSelectedCapabilityBatchExecution(options.selectedCapabilityBatchExecution, projectedCapabilities)
+        : undefined;
+    if (selectedCapabilityExecution && selectedCapabilityBatchExecution) {
+        throw new Error("worker_selected_capability_execution_ambiguous");
+    }
+    const pendingCapabilitySelection = selectedCapabilityExecution
+        ? projectPendingCapabilitySelection(selectedCapabilityExecution)
+        : undefined;
+    const pendingCapabilityBatchSelection = selectedCapabilityBatchExecution
+        ? Object.freeze(selectedCapabilityBatchExecution.invocations.map(projectPendingCapabilitySelection))
+        : undefined;
+    return Object.freeze({
+        capabilities: selectExecutionCapabilities(projectedCapabilities, selectedCapabilityExecution, selectedCapabilityBatchExecution),
+        ...(selectedCapabilityExecution ? { selectedCapabilityExecution } : {}),
+        ...(selectedCapabilityBatchExecution
+            ? { selectedCapabilityBatchExecution }
+            : {}),
+        ...(pendingCapabilitySelection ? { pendingCapabilitySelection } : {}),
+        ...(pendingCapabilityBatchSelection
+            ? { pendingCapabilityBatchSelection }
+            : {}),
+        executionPending: selectedCapabilityExecution !== undefined ||
+            selectedCapabilityBatchExecution !== undefined,
+    });
+}
+function projectPendingCapabilitySelection(selection) {
+    return Object.freeze({
+        capabilityId: selection.capabilityId,
+        intent: selection.intent,
+        ...(selection.selectionControls
+            ? { selectionControls: selection.selectionControls }
+            : {}),
+    });
+}
+function selectExecutionCapabilities(projectedCapabilities, selectedCapabilityExecution, selectedCapabilityBatchExecution) {
+    if (selectedCapabilityExecution) {
+        return Object.freeze(projectedCapabilities.filter(({ capabilityId }) => capabilityId === selectedCapabilityExecution.capabilityId));
+    }
+    if (!selectedCapabilityBatchExecution)
+        return projectedCapabilities;
+    const selectedCapabilityIds = new Set(selectedCapabilityBatchExecution.invocations.map(({ capabilityId }) => capabilityId));
+    return Object.freeze(projectedCapabilities.filter(({ capabilityId }) => selectedCapabilityIds.has(capabilityId)));
+}
+function normalizeSelectedCapabilityExecution(input, capabilities) {
+    const descriptor = capabilities.find(({ capabilityId }) => capabilityId === input?.capabilityId);
+    if (typeof input !== "object" ||
+        input === null ||
+        !isRoleCapabilityId(input.capabilityId) ||
+        typeof input.intent !== "string" ||
+        input.intent.trim().length === 0 ||
+        input.intent.trim().length > WORKER_CAPABILITY_INTENT_MAX_LENGTH ||
+        typeof input.guidance !== "string" ||
+        !descriptor) {
+        throw new Error("worker_selected_capability_execution_invalid");
+    }
+    const controlsPartition = partitionWorkerCapabilityControlsSchema(descriptor.controls, descriptor.selectionControlIds);
+    const hasSelectionControls = Object.hasOwn(input, "selectionControls");
+    const selectionControls = controlsPartition.ok
+        ? validateWorkerCapabilitySelectionControls(controlsPartition.value, input.selectionControls ?? {})
+        : controlsPartition;
+    if (!controlsPartition.ok ||
+        !selectionControls.ok ||
+        hasSelectionControls !==
+            controlsPartition.value.selectionControlIds.length > 0) {
+        throw new Error("worker_selected_capability_execution_invalid");
+    }
+    return Object.freeze({
+        capabilityId: input.capabilityId,
+        intent: input.intent.trim(),
+        ...(controlsPartition.value.selectionControlIds.length > 0
+            ? { selectionControls: selectionControls.value }
+            : {}),
+        guidance: input.guidance.trim(),
+    });
+}
+function normalizeSelectedCapabilityBatchExecution(input, capabilities) {
+    if (typeof input !== "object" ||
+        input === null ||
+        !Array.isArray(input.invocations) ||
+        input.invocations.length < 2) {
+        throw new Error("worker_selected_capability_batch_execution_invalid");
+    }
+    const invocations = input.invocations.map((invocation) => {
+        const descriptor = capabilities.find(({ capabilityId }) => capabilityId === invocation?.capabilityId);
+        if (typeof invocation !== "object" ||
+            invocation === null ||
+            !descriptor ||
+            descriptor.effect !== "observation" ||
+            typeof invocation.intent !== "string" ||
+            invocation.intent.trim().length === 0 ||
+            invocation.intent.length > WORKER_CAPABILITY_INTENT_MAX_LENGTH ||
+            typeof invocation.guidance !== "string") {
+            throw new Error("worker_selected_capability_batch_execution_invalid");
+        }
+        const controlsPartition = partitionWorkerCapabilityControlsSchema(descriptor.controls, descriptor.selectionControlIds);
+        const hasSelectionControls = Object.hasOwn(invocation, "selectionControls");
+        const selectionControls = controlsPartition.ok
+            ? validateWorkerCapabilitySelectionControls(controlsPartition.value, invocation.selectionControls ?? {})
+            : controlsPartition;
+        if (!controlsPartition.ok ||
+            !selectionControls.ok ||
+            hasSelectionControls !==
+                controlsPartition.value.selectionControlIds.length > 0) {
+            throw new Error("worker_selected_capability_batch_execution_invalid");
+        }
+        return Object.freeze({
+            capabilityId: descriptor.capabilityId,
+            intent: invocation.intent.trim(),
+            ...(controlsPartition.value.selectionControlIds.length > 0
+                ? { selectionControls: selectionControls.value }
+                : {}),
+            guidance: invocation.guidance.trim(),
+        });
+    });
+    return Object.freeze({ invocations: Object.freeze(invocations) });
+}
+export function canOfferCapabilityBatch(params) {
+    if (params.selectedCapabilityBatchExecution)
+        return true;
+    if (params.selectedCapabilityExecution)
+        return false;
+    if (!params.canonicalSource)
+        return false;
+    const remaining = params.canonicalSource.head.policy.limits.maxCapabilityExecutions -
+        params.canonicalSource.head.state.capabilityExecutions.length;
+    return (remaining >= 2 &&
+        params.capabilities.some(({ effect }) => effect === "observation"));
+}

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

@@ -0,0 +1,9 @@
+import type { WorkerCapabilityDescriptor } from "../../../orchestration/worker-capabilities/index.js";
+import type { PreparedWorkerCapabilitySelection, PreparedWorkerDecisionContract, WorkerDecisionCapabilityResumeSource, WorkerDecisionCapabilitySource, WorkerDecisionInputOptions } from "./types.js";
+export declare function prepareWorkerDecisionContract(params: Readonly<{
+    options: WorkerDecisionInputOptions;
+    projectedCapabilities: readonly WorkerCapabilityDescriptor[];
+    eligibleSessionArtifactPaths: readonly string[];
+    canonicalSource: WorkerDecisionCapabilitySource | WorkerDecisionCapabilityResumeSource | undefined;
+    capabilitySelection: PreparedWorkerCapabilitySelection;
+}>): PreparedWorkerDecisionContract;

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

@@ -0,0 +1,92 @@
+import { projectWorkerCapabilityAffordances } from "../capability-affordances.js";
+import { projectWorkerCapabilitySelectionCatalog } from "../capability-catalog.js";
+import { normalizeWorkerCapabilitySelectionRejection } from "../capability-selection-rejection.js";
+import { WORKER_DECISION_ACTIONS } from "../contracts.js";
+import { createWorkerDecisionFormat } from "../format.js";
+import { canOfferCapabilityBatch } from "./capability-selection.js";
+export function prepareWorkerDecisionContract(params) {
+    const { capabilities, selectedCapabilityExecution, selectedCapabilityBatchExecution, pendingCapabilitySelection, pendingCapabilityBatchSelection, executionPending: capabilityExecutionPending, } = params.capabilitySelection;
+    const availableCapabilityIds = Object.freeze(capabilities.map((descriptor) => descriptor.capabilityId));
+    const availableCapabilityAffordances = projectWorkerCapabilityAffordances(capabilities);
+    const capabilitiesAvailable = capabilities.length > 0;
+    const sessionArtifactPathSelectionDeferred = !capabilityExecutionPending &&
+        params.eligibleSessionArtifactPaths.length > 0 &&
+        runtimePathSelectionWasDeferred(params.options.capabilitySource?.binding.capabilities, params.projectedCapabilities);
+    const capabilitySelectionRejection = !capabilityExecutionPending && params.options.capabilitySelectionRejection
+        ? normalizeWorkerCapabilitySelectionRejection(params.options.capabilitySelectionRejection, params.projectedCapabilities.map(({ capabilityId }) => capabilityId))
+        : undefined;
+    const selectionCatalog = projectWorkerCapabilitySelectionCatalog(capabilities);
+    const capabilityCatalogProjection = capabilityExecutionPending
+        ? "flat"
+        : selectionCatalog.kind;
+    const capabilityPromptPayload = capabilityExecutionPending
+        ? Object.freeze({ availableCapabilities: availableCapabilityAffordances })
+        : selectionCatalog.promptPayload;
+    const canInvokeSingleCapability = capabilitiesAvailable && !selectedCapabilityBatchExecution;
+    const canInvokeCapabilityBatch = canOfferCapabilityBatch({
+        capabilities,
+        canonicalSource: params.canonicalSource,
+        selectedCapabilityExecution,
+        selectedCapabilityBatchExecution,
+    });
+    const allowedActions = Object.freeze([
+        WORKER_DECISION_ACTIONS[0],
+        WORKER_DECISION_ACTIONS[1],
+        ...(canInvokeSingleCapability ? [WORKER_DECISION_ACTIONS[2]] : []),
+        ...(canInvokeCapabilityBatch ? [WORKER_DECISION_ACTIONS[3]] : []),
+    ]);
+    const remainingCapabilityExecutions = params.canonicalSource
+        ? params.canonicalSource.head.policy.limits.maxCapabilityExecutions -
+            params.canonicalSource.head.state.capabilityExecutions.length
+        : 0;
+    const maxBatchCapabilityExecutions = resolveMaxBatchCapabilityExecutions({
+        selectedCapabilityExecution,
+        selectedCapabilityBatchExecution,
+        remainingCapabilityExecutions,
+    });
+    const format = createWorkerDecisionFormat({
+        capabilities,
+        maxBatchCapabilityExecutions,
+        allowSingleCapabilityInvocation: !selectedCapabilityBatchExecution,
+        ...(pendingCapabilitySelection ? { pendingCapabilitySelection } : {}),
+        ...(pendingCapabilityBatchSelection
+            ? {
+                pendingCapabilityBatchSelection,
+            }
+            : {}),
+    });
+    return Object.freeze({
+        availableCapabilityIds,
+        availableCapabilityAffordances,
+        capabilitiesAvailable,
+        sessionArtifactPathSelectionDeferred,
+        capabilitySelectionRejection,
+        selectionCatalog,
+        capabilityCatalogProjection,
+        capabilityPromptPayload,
+        allowedActions,
+        maxBatchCapabilityExecutions,
+        format,
+    });
+}
+function resolveMaxBatchCapabilityExecutions(params) {
+    if (params.selectedCapabilityExecution)
+        return 0;
+    if (params.selectedCapabilityBatchExecution) {
+        return params.selectedCapabilityBatchExecution.invocations.length;
+    }
+    return Math.max(0, params.remainingCapabilityExecutions);
+}
+function runtimePathSelectionWasDeferred(sourceCapabilities, effectiveCapabilities) {
+    if (!sourceCapabilities)
+        return false;
+    return sourceCapabilities.some((source) => {
+        const effective = effectiveCapabilities.find(({ capabilityId }) => capabilityId === source.capabilityId);
+        if (!effective)
+            return false;
+        const effectiveSelectionControlIds = new Set(effective.selectionControlIds ?? []);
+        const runtimePathControlIds = new Set(source.runtimePathControlIds ?? []);
+        return (source.selectionControlIds ?? []).some((controlId) => runtimePathControlIds.has(controlId) &&
+            !effectiveSelectionControlIds.has(controlId));
+    });
+}

package/dist/src/runtime/steps/worker-decision/input/diagnostic-projection.d.ts

@@ -0,0 +1,4 @@
+import { projectWorkerDecisionCallIdentity, type WorkerDecisionDiagnosticContext } from "../contracts.js";
+import type { PreparedWorkerDecisionAssembly, PreparedWorkerDecisionSession, WorkerDecisionInputOptions } from "./types.js";
+export declare function traceWorkerDecisionInputProjection(session: PreparedWorkerDecisionSession, assembly: PreparedWorkerDecisionAssembly): void;
+export declare function resolveWorkerDecisionDiagnostic(requestId: string, options: WorkerDecisionInputOptions, callIdentity: ReturnType<typeof projectWorkerDecisionCallIdentity>): WorkerDecisionDiagnosticContext;

package/dist/src/runtime/steps/worker-decision/input/diagnostic-projection.js

@@ -0,0 +1,114 @@
+import { WORKER_DECISION_MODEL_STEP, } from "../contracts.js";
+import { traceWorkerCapabilityResultProjected, traceWorkerContextProjected, } from "../diagnostics.js";
+import { WORKER_SESSION_ARTIFACT_PATH_PROJECTION_MAX } from "../runtime-path-refinement.js";
+export function traceWorkerDecisionInputProjection(session, assembly) {
+    const { options, diagnostic, objective, sessionArtifactPathAvailableCount } = session;
+    const { assignmentScope, dependencyResults, resume } = session.canonicalState;
+    const { capabilities, selectedCapabilityExecution, selectedCapabilityBatchExecution, executionPending: capabilityExecutionPending, } = session.capabilitySelection;
+    const { availableCapabilityIds, availableCapabilityAffordances, capabilitiesAvailable, sessionArtifactPathSelectionDeferred, capabilitySelectionRejection, selectionCatalog, capabilityCatalogProjection, allowedActions, format, } = session.contract;
+    const { requestToolResultsMessage, continuationMessages } = assembly.references;
+    const { baseInstructions, configuredInstructionMetadata } = assembly.prompt;
+    const { context, referenceMessages, sessionArtifactPathProjection } = assembly.projection;
+    traceWorkerContextProjected({
+        diagnostic,
+        context,
+        format,
+        contextProjection: capabilityExecutionPending
+            ? "capability_execution_capsule"
+            : "worker_assignment",
+        objectiveLength: objective.length,
+        workingDirectory: options.call.workingDirectory,
+        capabilityIds: availableCapabilityIds,
+        capabilityAffordanceCharacterCount: measureWorkerCapabilityAffordanceCharacters({
+            capabilitiesAvailable,
+            capabilityExecutionPending,
+            availableCapabilityAffordances,
+            selectionCatalog,
+        }),
+        capabilityCatalogProjection,
+        capabilityCatalogGroupCount: capabilityExecutionPending
+            ? 0
+            : selectionCatalog.groupCount,
+        capabilityCatalogMembershipCount: capabilityExecutionPending
+            ? 0
+            : selectionCatalog.membershipCount,
+        capabilityCatalogGroupedCharacterCount: capabilityExecutionPending
+            ? 0
+            : selectionCatalog.groupedCharacterCount,
+        capabilityCatalogFlatCharacterCount: selectionCatalog.flatCharacterCount,
+        referenceMessageCount: referenceMessages.length,
+        continuationMessageCount: continuationMessages.length,
+        settledCapabilityResultCount: options.requestToolResults.results.length,
+        settledCapabilitySummaryLength: options.requestToolResults.results.reduce((total, result) => total + result.summary.length, 0),
+        settledCapabilityReferenceDataSourceLength: options.requestToolResults.results.reduce((total, result) => total + (result.referenceData?.length ?? 0), 0),
+        requestToolResultsProjection: resolveRequestToolResultsProjection(options),
+        requestToolResultsProjectedCharacterCount: requestToolResultsMessage?.content.length ?? 0,
+        dependencyResultRefs: dependencyResults.map((result) => result.resultRef),
+        dependencyResultSummaryLength: dependencyResults.reduce((total, result) => total + result.summary.length, 0),
+        assignmentScope,
+        allowedActions,
+        selectedCapabilityId: selectedCapabilityExecution?.capabilityId,
+        selectedCapabilityIds: selectedCapabilityBatchExecution?.invocations.map(({ capabilityId }) => capabilityId),
+        capabilitySelectionRejection,
+        executionGuidanceCharacterCount: measureExecutionGuidanceCharacters(selectedCapabilityExecution, selectedCapabilityBatchExecution),
+        baseInstructionCharacterCount: baseInstructions.length,
+        configuredInstructionBlockCount: configuredInstructionMetadata.blockCount,
+        configuredInstructionCharacterCount: configuredInstructionMetadata.characterCount,
+        configuredInstructionRefs: configuredInstructionMetadata.refs,
+        configuredInstructionContentHashes: configuredInstructionMetadata.contentHashes,
+        sessionArtifactPathSelectionDeferred,
+        sessionArtifactPathAvailableCount,
+        sessionArtifactPathBoundedCount: Math.min(sessionArtifactPathAvailableCount, WORKER_SESSION_ARTIFACT_PATH_PROJECTION_MAX),
+        sessionArtifactPathEligibleCount: session.eligibleSessionArtifactPaths.length,
+        sessionArtifactPathProjectedCount: sessionArtifactPathProjection?.projectedCount ?? 0,
+        sessionArtifactPathOmittedCount: sessionArtifactPathAvailableCount -
+            (sessionArtifactPathProjection?.projectedCount ?? 0),
+    });
+    if (resume) {
+        traceWorkerCapabilityResultProjected({
+            diagnostic,
+            resume,
+            referenceMessageCount: referenceMessages.length,
+            continuationMessageCount: continuationMessages.length,
+        });
+    }
+}
+export function resolveWorkerDecisionDiagnostic(requestId, options, callIdentity) {
+    if (options.diagnostic)
+        return options.diagnostic;
+    return {
+        requestId,
+        modelStep: WORKER_DECISION_MODEL_STEP,
+        decisionPhase: hasPendingCapabilityExecution(options)
+            ? "capability_execution"
+            : "capability_selection",
+        ...callIdentity,
+    };
+}
+function hasPendingCapabilityExecution(options) {
+    return Boolean(options.selectedCapabilityExecution ||
+        options.selectedCapabilityBatchExecution);
+}
+function measureWorkerCapabilityAffordanceCharacters(params) {
+    if (!params.capabilitiesAvailable)
+        return 0;
+    if (!params.capabilityExecutionPending) {
+        return params.selectionCatalog.projectedCharacterCount;
+    }
+    return JSON.stringify({
+        selectedCapabilityAffordances: params.availableCapabilityAffordances,
+    }).length;
+}
+function resolveRequestToolResultsProjection(options) {
+    if (options.requestToolResults.results.length === 0)
+        return "none";
+    return options.requestToolResultsContextMessage
+        ? "semantic_compaction"
+        : "canonical";
+}
+function measureExecutionGuidanceCharacters(selectedCapabilityExecution, selectedCapabilityBatchExecution) {
+    if (selectedCapabilityExecution) {
+        return selectedCapabilityExecution.guidance.length;
+    }
+    return (selectedCapabilityBatchExecution?.invocations.reduce((total, invocation) => total + invocation.guidance.length, 0) ?? 0);
+}

package/dist/src/runtime/steps/worker-decision/input/prompt-context.d.ts

@@ -0,0 +1,3 @@
+import type { PreparedWorkerDecisionSession, PreparedWorkerPromptContext, PreparedWorkerReferenceContext, ProjectedWorkerDecisionContext } from "./types.js";
+export declare function prepareWorkerPromptContext(session: PreparedWorkerDecisionSession, references: PreparedWorkerReferenceContext): PreparedWorkerPromptContext;
+export declare function projectWorkerDecisionContext(session: PreparedWorkerDecisionSession, references: PreparedWorkerReferenceContext, promptContext: PreparedWorkerPromptContext): ProjectedWorkerDecisionContext;