@abot-ai/runtime 1.0.0 → 1.2.0

package/dist/src/runtime/adapters/registered-tool-payload-related-artifacts.js

@@ -0,0 +1,84 @@
+import { readFile, stat } from "node:fs/promises";
+import { resolveRuntimeTargetPath } from "../capabilities/runtime-target-path.js";
+import { projectWorkerCapabilityDependencyArtifactReceipts, } from "../orchestration/worker-capabilities/assignment-provenance.js";
+import { projectWorkerPayloadPlannerItemProvenance } from "../orchestration/worker-capabilities/payload-source-provenance.js";
+import { WORKER_CAPABILITY_RELATED_ARTIFACT_CONTEXT_MAX_CHARS, WORKER_CAPABILITY_RELATED_ARTIFACT_CONTEXT_MAX_COUNT, } from "../orchestration/worker-capabilities/payload-contracts.js";
+export async function resolveRegisteredToolPayloadRelatedArtifactContexts(params) {
+    if (params.contextScope !== "target_with_artifacts") {
+        return Object.freeze([]);
+    }
+    const dependencyReceipts = projectWorkerCapabilityDependencyArtifactReceipts(projectWorkerPayloadPlannerItemProvenance(params.assignmentProvenance, params.call), params.call);
+    const receipts = [
+        ...projectSameCallArtifactReceipts(params.settledCapabilityResults),
+        ...dependencyReceipts,
+    ];
+    return loadRelatedArtifactContexts(params, receipts);
+}
+function projectSameCallArtifactReceipts(results) {
+    return results.flatMap((result) => {
+        if (result.outcome !== "succeeded")
+            return [];
+        return (result.references ?? []).map((reference) => Object.freeze({
+            sourceExecutionId: result.executionId,
+            targetPath: reference.target,
+        }));
+    });
+}
+async function loadRelatedArtifactContexts(params, receipts) {
+    const currentTarget = resolveCurrentTarget(params);
+    const resolvedTargets = new Set();
+    const artifacts = [];
+    let totalCharacters = 0;
+    for (const receipt of receipts) {
+        let resolvedTarget;
+        try {
+            resolvedTarget = resolveRuntimeTargetPath(receipt.targetPath, params.sharedState);
+        }
+        catch {
+            continue;
+        }
+        if (resolvedTarget === currentTarget ||
+            resolvedTargets.has(resolvedTarget)) {
+            continue;
+        }
+        resolvedTargets.add(resolvedTarget);
+        try {
+            const targetStat = await stat(resolvedTarget);
+            if (!targetStat.isFile())
+                continue;
+            const content = await readFile(resolvedTarget, "utf8");
+            if (content.length + totalCharacters >
+                WORKER_CAPABILITY_RELATED_ARTIFACT_CONTEXT_MAX_CHARS) {
+                continue;
+            }
+            artifacts.push(Object.freeze({
+                sourceExecutionId: receipt.sourceExecutionId,
+                targetPath: receipt.targetPath,
+                presentation: "full",
+                content,
+            }));
+            totalCharacters += content.length;
+            if (artifacts.length >= WORKER_CAPABILITY_RELATED_ARTIFACT_CONTEXT_MAX_COUNT) {
+                return Object.freeze(artifacts);
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    return Object.freeze(artifacts);
+}
+function resolveCurrentTarget(params) {
+    const rawTarget = params.targetParam
+        ? params.controls[params.targetParam]
+        : undefined;
+    if (typeof rawTarget !== "string" || rawTarget.trim().length === 0) {
+        return undefined;
+    }
+    try {
+        return resolveRuntimeTargetPath(rawTarget.trim(), params.sharedState);
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/src/runtime/adapters/registered-tool-worker-capabilities/catalog.js

@@ -71,11 +71,18 @@ function projectWorkerDescriptor(definition, operation, stagedPayloadPlan) {
     if (!controls.ok) {
         throw new RegisteredToolWorkerCapabilityCompositionError("operation_controls_unsupported", operation.operationId);
     }
-    const selectionControlIds = definition.payloadChannelSpec?.targetRole === "operation_target"
+    const payloadTargetControlId = definition.payloadChannelSpec?.targetRole === "operation_target"
         ? definition.payloadChannelSpec.targetParam
-            ? [definition.payloadChannelSpec.targetParam]
-            : undefined
-        : [];
+        : undefined;
+    const selectionControlIds = definition.payloadChannelSpec?.targetRole === "operation_target" &&
+        !payloadTargetControlId
+        ? undefined
+        : Object.freeze([
+            ...new Set([
+                ...(operation.selectionControlIds ?? []),
+                ...(payloadTargetControlId ? [payloadTargetControlId] : []),
+            ]),
+        ]);
     const controlsPartition = partitionWorkerCapabilityControlsSchema(controls.value, selectionControlIds);
     if (!controlsPartition.ok || selectionControlIds === undefined) {
         throw new RegisteredToolWorkerCapabilityCompositionError("operation_target_control_invalid", operation.operationId);
@@ -101,7 +108,14 @@ function projectWorkerDescriptor(definition, operation, stagedPayloadPlan) {
         ...(definition.controlsRefinement
             ? { controlsRefinement: definition.controlsRefinement }
             : {}),
+        ...(operation.payload
+            ? { requiresPayloadAuthoringObjective: true }
+            : {}),
         catalogGroups,
+        routingCapability: definition.routingCapability,
+        ...(definition.developmentRoles
+            ? { developmentRoles: Object.freeze([...definition.developmentRoles]) }
+            : {}),
     });
 }
 function projectRuntimePathControlIds(definition, operation, controls) {

package/dist/src/runtime/adapters/registered-tool-worker-capabilities/execution.js

@@ -1,9 +1,12 @@
 import { assertWorkerCapabilityWithinScope, projectWorkerCapabilityScope, WorkerCapabilityScopeError, } from "../../orchestration/worker-capabilities/index.js";
 import { traceRegisteredToolWorkerCapabilityExecutionCompleted, traceRegisteredToolWorkerCapabilityExecutionFailed, traceRegisteredToolWorkerCapabilityExecutionStarted, } from "../registered-tool-worker-capability-diagnostics.js";
 import { RegisteredToolWorkerCapabilityCompositionError, RegisteredToolWorkerCapabilityExecutionError, } from "./errors.js";
-import { executionFreshnessRejection, prepareOperationPayload, } from "./payload-lifecycle.js";
+import { executionFreshnessRejection, payloadRejection, prepareOperationPayload, } from "./payload-lifecycle.js";
 import { attachTargetReferences, observeExternalResult, projectSelectedTargetReferences, } from "./result-observer.js";
 import { resolveEffectiveOperationTargetControls } from "./runtime-path-controls.js";
+import { createRegisteredToolPreparationAttemptFingerprint } from "../registered-tool-normal-invocations/shared/action-fingerprint.js";
+import { createWorkerCapabilityPreparationFailureFingerprint } from "../../orchestration/worker-capabilities/preparation-fingerprint.js";
+import { createDeferredPayloadObservability } from "./payload-observability.js";
 export function projectWorkerAdapters(params) {
     const projections = new Map();
     for (const projection of params.executor.operations) {
@@ -37,97 +40,162 @@ export function projectWorkerAdapters(params) {
     }));
 }
 function createWorkerAdapter(params) {
-    const operationId = params.projection.operation.operationId;
-    const operationEffect = params.projection.operation.effect;
     return Object.freeze({
         descriptor: params.descriptor,
+        async prepare(input) {
+            return prepareRegisteredToolWorkerAdapter(params, input);
+        },
         async execute(input) {
-            try {
-                const capabilityScope = projectWorkerCapabilityScope({
-                    entries: params.scopeDescriptors,
-                    scope: input.call.workerCapabilityScope,
-                    descriptorOf: (descriptor) => descriptor,
-                });
-                assertWorkerCapabilityWithinScope(capabilityScope, params.descriptor);
-            }
-            catch (error) {
-                const scopedError = error instanceof WorkerCapabilityScopeError
-                    ? new RegisteredToolWorkerCapabilityCompositionError(error.issueCode, operationId)
-                    : error;
-                traceRegisteredToolWorkerCapabilityExecutionFailed(params.diagnostic, operationId, input.call, input.executionId, scopedError, error instanceof WorkerCapabilityScopeError
-                    ? error.issueCode
-                    : "capability_scope_validation_failed");
-                throw scopedError;
-            }
-            traceRegisteredToolWorkerCapabilityExecutionStarted(params.diagnostic, operationId, input.call, input.executionId, input.intent.length, Object.keys(input.controls).length);
-            try {
-                const effectiveControls = resolveEffectiveOperationTargetControls({
-                    descriptor: params.descriptor,
-                    controls: input.controls,
-                    runtimePathBindings: params.projection.runtimePathBindings ?? Object.freeze([]),
-                    workingDirectory: input.call.workingDirectory,
-                    sharedState: params.sharedState,
-                });
-                const selectedTargetReferences = projectSelectedTargetReferences(params.projection, effectiveControls, input.call.parentCallId === null
-                    ? params.descriptor.selectionControlIds
-                    : undefined);
-                const preparedPayload = await prepareOperationPayload({
-                    projection: params.projection,
-                    executor: params.executor,
-                    sharedState: params.sharedState,
-                    ...(params.payloadAuthor
-                        ? { payloadAuthor: params.payloadAuthor }
-                        : {}),
-                    call: input.call,
-                    executionId: input.executionId,
-                    descriptor: params.descriptor,
-                    intent: input.intent,
-                    controls: effectiveControls,
-                    ...(input.dependencyResults
-                        ? { dependencyResults: input.dependencyResults }
-                        : {}),
-                    settledCapabilityResults: input.settledCapabilityResults,
-                    diagnostic: params.diagnostic,
-                    ...(input.executionFreshness
-                        ? { executionFreshness: input.executionFreshness }
-                        : {}),
-                });
-                const completeRejectedExecution = (rejectedExecution) => {
-                    const canonicalResult = Object.freeze({
-                        ...rejectedExecution.result,
-                        exactResult: rejectedExecution.exactResult,
-                    });
-                    const preparedResult = attachTargetReferences(canonicalResult, selectedTargetReferences);
-                    traceRegisteredToolWorkerCapabilityExecutionCompleted(params.diagnostic, operationId, input.call, input.executionId, preparedResult, "rejected", {
-                        sourceIssueCode: rejectedExecution.sourceIssueCode,
-                        summaryProjection: "runtime_rejection",
-                        completionActions: Object.freeze([]),
-                    });
-                    return preparedResult;
-                };
-                if (preparedPayload.status === "rejected") {
-                    return completeRejectedExecution(preparedPayload);
+            const preparationInput = Object.freeze({
+                ...input,
+                preparationId: input.executionId,
+            });
+            const prepared = await prepareRegisteredToolWorkerAdapter(params, preparationInput);
+            return prepared.execute(input.executionId);
+        },
+    });
+}
+async function prepareRegisteredToolWorkerAdapter(params, input) {
+    const operationId = params.projection.operation.operationId;
+    const payloadObservability = createDeferredPayloadObservability({
+        executor: params.executor,
+        diagnostic: params.diagnostic,
+        operationId,
+        call: input.call,
+    });
+    try {
+        return await prepareRegisteredToolWorkerCapability(params, input, payloadObservability);
+    }
+    catch (error) {
+        if (error instanceof Error && error.name === "AbortError")
+            throw error;
+        const actionFingerprint = createWorkerCapabilityPreparationFailureFingerprint({
+            capabilityId: params.descriptor.capabilityId,
+            controls: input.controls,
+            ...(input.call.workingDirectory
+                ? { workingDirectory: input.call.workingDirectory }
+                : {}),
+            error,
+        });
+        return Object.freeze({
+            ...(actionFingerprint ? { actionFingerprint } : {}),
+            acceptedControls: input.controls,
+            execute: async (executionId) => {
+                try {
+                    payloadObservability.release(executionId);
+                }
+                catch (releaseError) {
+                    tracePreparedExecutionFailed(params, input, operationId, executionId, releaseError);
+                    throw releaseError;
                 }
+                tracePreparedExecutionFailed(params, input, operationId, executionId, error, registeredPreparationFailureIssueCode(error));
+                throw error;
+            },
+        });
+    }
+}
+async function prepareRegisteredToolWorkerCapability(params, input, payloadObservability) {
+    const operationId = params.projection.operation.operationId;
+    assertPreparedCapabilityScope(params, input, operationId);
+    const effectiveControls = resolveEffectiveOperationTargetControls({
+        descriptor: params.descriptor,
+        controls: input.controls,
+        runtimePathBindings: params.projection.runtimePathBindings ?? Object.freeze([]),
+        workingDirectory: input.call.workingDirectory,
+        sharedState: params.sharedState,
+    });
+    const selectedTargetReferences = projectSelectedTargetReferences(params.projection, effectiveControls, input.call.parentCallId === null
+        ? params.descriptor.selectionControlIds
+        : undefined);
+    const preparedPayload = await prepareOperationPayload({
+        projection: params.projection,
+        executor: payloadObservability.lifecycleEmitter,
+        sharedState: params.sharedState,
+        ...(params.payloadAuthor ? { payloadAuthor: params.payloadAuthor } : {}),
+        call: input.call,
+        ...(input.assignmentProvenance
+            ? { assignmentProvenance: input.assignmentProvenance }
+            : {}),
+        // The payload contract still names this correlation executionId. During
+        // prepare it is deliberately non-canonical and never enters the ledger.
+        executionId: input.preparationId,
+        descriptor: params.descriptor,
+        intent: input.intent,
+        ...(input.authoringObjective
+            ? { authoringObjective: input.authoringObjective }
+            : {}),
+        controls: effectiveControls,
+        ...(input.dependencyResults
+            ? { dependencyResults: input.dependencyResults }
+            : {}),
+        settledCapabilityResults: input.settledCapabilityResults,
+        deferPayloadStageMaterialized: payloadObservability.deferPayloadStageMaterialized,
+        ...(input.executionFreshness
+            ? { executionFreshness: input.executionFreshness }
+            : {}),
+    });
+    if (preparedPayload.status === "rejected") {
+        return preparedRuntimeRejection({
+            params,
+            input,
+            operationId,
+            effectiveControls,
+            selectedTargetReferences,
+            rejectedExecution: preparedPayload,
+            payloadObservability,
+        });
+    }
+    const normalPreparation = params.executor.prepare({
+        handle: params.projection.handle,
+        controls: effectiveControls,
+        ...(preparedPayload.body === undefined
+            ? {}
+            : { payload: preparedPayload.body }),
+        ...(preparedPayload.materializedParams === undefined
+            ? {}
+            : { materializedParams: preparedPayload.materializedParams }),
+        intent: input.intent,
+    });
+    if (normalPreparation.status === "rejected") {
+        const canonicalRejection = payloadRejection(normalPreparation.code, normalPreparation.message);
+        return preparedRuntimeRejection({
+            params,
+            input,
+            operationId,
+            effectiveControls,
+            selectedTargetReferences,
+            rejectedExecution: canonicalRejection,
+            payloadObservability,
+            ...(preparedPayload.body === undefined
+                ? {}
+                : { payload: preparedPayload.body }),
+            ...(preparedPayload.materializedParams === undefined
+                ? {}
+                : { materializedParams: preparedPayload.materializedParams }),
+        });
+    }
+    return Object.freeze({
+        actionFingerprint: normalPreparation.actionFingerprint,
+        acceptedControls: normalPreparation.acceptedControls,
+        execute: async (executionId) => {
+            try {
+                payloadObservability.release(executionId);
+                tracePreparedExecutionStarted(params, input, operationId, executionId);
                 const rejectedExecution = executionFreshnessRejection(input.executionFreshness);
                 if (rejectedExecution) {
-                    return completeRejectedExecution(rejectedExecution);
+                    return completeRuntimeRejection({
+                        params,
+                        input,
+                        operationId,
+                        executionId,
+                        selectedTargetReferences,
+                        rejectedExecution,
+                    });
                 }
-                const externalResult = await params.executor.execute({
-                    handle: params.projection.handle,
-                    controls: effectiveControls,
-                    ...(preparedPayload.body === undefined
-                        ? {}
-                        : { payload: preparedPayload.body }),
-                    ...(preparedPayload.materializedParams === undefined
-                        ? {}
-                        : {
-                            materializedParams: preparedPayload.materializedParams,
-                        }),
-                    intent: input.intent,
-                });
-                const observed = observeExternalResult(externalResult, operationEffect, input.call.parentCallId === null);
+                const externalResult = await normalPreparation.execute();
+                const observed = observeExternalResult(externalResult, params.projection.operation.effect, input.call.parentCallId === null);
                 const observedResult = attachTargetReferences(observed.result, selectedTargetReferences);
-                traceRegisteredToolWorkerCapabilityExecutionCompleted(params.diagnostic, operationId, input.call, input.executionId, observedResult, externalResult.status, {
+                traceRegisteredToolWorkerCapabilityExecutionCompleted(params.diagnostic, operationId, input.call, executionId, observedResult, externalResult.status, {
                     ...(observed.sourceIssueCode
                         ? { sourceIssueCode: observed.sourceIssueCode }
                         : {}),
@@ -145,11 +213,77 @@ function createWorkerAdapter(params) {
                 return observedResult;
             }
             catch (error) {
-                traceRegisteredToolWorkerCapabilityExecutionFailed(params.diagnostic, operationId, input.call, input.executionId, error, error instanceof RegisteredToolWorkerCapabilityExecutionError
-                    ? error.issueCode
-                    : "execution_failed");
+                tracePreparedExecutionFailed(params, input, operationId, executionId, error);
+                throw error;
+            }
+        },
+    });
+}
+function preparedRuntimeRejection(input) {
+    return Object.freeze({
+        actionFingerprint: createRegisteredToolPreparationAttemptFingerprint({
+            operationId: input.operationId,
+            controls: input.effectiveControls,
+            rejectionCode: input.rejectedExecution.sourceIssueCode,
+            ...(input.payload === undefined ? {} : { payload: input.payload }),
+            ...(input.materializedParams === undefined
+                ? {}
+                : { materializedParams: input.materializedParams }),
+        }),
+        acceptedControls: input.effectiveControls,
+        execute: async (executionId) => {
+            try {
+                input.payloadObservability.release(executionId);
+                tracePreparedExecutionStarted(input.params, input.input, input.operationId, executionId);
+                return completeRuntimeRejection({ ...input, executionId });
+            }
+            catch (error) {
+                tracePreparedExecutionFailed(input.params, input.input, input.operationId, executionId, error);
                 throw error;
             }
         },
     });
 }
+function completeRuntimeRejection(input) {
+    const canonicalResult = Object.freeze({
+        ...input.rejectedExecution.result,
+        exactResult: input.rejectedExecution.exactResult,
+    });
+    const preparedResult = attachTargetReferences(canonicalResult, input.selectedTargetReferences);
+    traceRegisteredToolWorkerCapabilityExecutionCompleted(input.params.diagnostic, input.operationId, input.input.call, input.executionId, preparedResult, "rejected", {
+        sourceIssueCode: input.rejectedExecution.sourceIssueCode,
+        summaryProjection: "runtime_rejection",
+        completionActions: Object.freeze([]),
+    });
+    return preparedResult;
+}
+function assertPreparedCapabilityScope(params, input, operationId) {
+    try {
+        const capabilityScope = projectWorkerCapabilityScope({
+            entries: params.scopeDescriptors,
+            scope: input.call.workerCapabilityScope,
+            descriptorOf: (descriptor) => descriptor,
+        });
+        assertWorkerCapabilityWithinScope(capabilityScope, params.descriptor);
+    }
+    catch (error) {
+        const scopedError = error instanceof WorkerCapabilityScopeError
+            ? new RegisteredToolWorkerCapabilityCompositionError(error.issueCode, operationId)
+            : error;
+        throw scopedError;
+    }
+}
+function tracePreparedExecutionStarted(params, input, operationId, executionId) {
+    traceRegisteredToolWorkerCapabilityExecutionStarted(params.diagnostic, operationId, input.call, executionId, input.intent.length, Object.keys(input.controls).length);
+}
+function tracePreparedExecutionFailed(params, input, operationId, executionId, error, issueCode = error instanceof RegisteredToolWorkerCapabilityExecutionError
+    ? error.issueCode
+    : "execution_failed") {
+    traceRegisteredToolWorkerCapabilityExecutionFailed(params.diagnostic, operationId, input.call, executionId, error, issueCode);
+}
+function registeredPreparationFailureIssueCode(error) {
+    return error instanceof RegisteredToolWorkerCapabilityExecutionError ||
+        error instanceof RegisteredToolWorkerCapabilityCompositionError
+        ? error.issueCode
+        : "execution_failed";
+}

package/dist/src/runtime/adapters/registered-tool-worker-capabilities/failure-outcome-fingerprint.d.ts

@@ -0,0 +1,7 @@
+import type { CapabilityAdapterResult } from "../../orchestration/capability-adapters/index.js";
+import type { RoleOperationOutcomeFingerprint } from "../../orchestration/role-calls/index.js";
+/**
+ * Owns stable failure interpretation for the registered-tool adapter. The
+ * generic capability engine receives only the resulting opaque identity.
+ */
+export declare function createRegisteredToolWorkerFailureOutcomeFingerprint(exactResult: CapabilityAdapterResult): RoleOperationOutcomeFingerprint | null;

package/dist/src/runtime/adapters/registered-tool-worker-capabilities/failure-outcome-fingerprint.js

@@ -0,0 +1,84 @@
+import { createHash } from "node:crypto";
+/**
+ * Owns stable failure interpretation for the registered-tool adapter. The
+ * generic capability engine receives only the resulting opaque identity.
+ */
+export function createRegisteredToolWorkerFailureOutcomeFingerprint(exactResult) {
+    try {
+        if (exactResult.kind === "runtime_capability_rejection_v1") {
+            return digest([
+                "registered_tool_runtime_rejection_v1",
+                exactResult.stage,
+                exactResult.code,
+            ]);
+        }
+        if (exactResult.kind === "registered_tool_execution_result_v1") {
+            const discriminants = registeredToolFailureDiscriminants(exactResult.result);
+            if (discriminants.length > 0) {
+                return digest(["registered_tool_execution_failure_v1", discriminants]);
+            }
+        }
+        return digest([
+            "registered_tool_canonical_failure_v1",
+            canonicalValue(exactResult),
+        ]);
+    }
+    catch {
+        return null;
+    }
+}
+function digest(value) {
+    return `sha256:${createHash("sha256")
+        .update(JSON.stringify(value))
+        .digest("hex")}`;
+}
+function registeredToolFailureDiscriminants(input) {
+    const discriminants = [];
+    const errorCode = input.errorCode?.trim();
+    if (errorCode) {
+        discriminants.push(Object.freeze(["error_code", errorCode]));
+    }
+    if (input.exitCode !== undefined) {
+        if (!Number.isFinite(input.exitCode)) {
+            throw new Error("registered_tool_failure_exit_code_invalid");
+        }
+        discriminants.push(Object.freeze(["exit_code", input.exitCode]));
+    }
+    return Object.freeze(discriminants);
+}
+function canonicalValue(value) {
+    if (value === null ||
+        typeof value === "string" ||
+        typeof value === "boolean") {
+        return value;
+    }
+    if (typeof value === "number") {
+        if (!Number.isFinite(value)) {
+            throw new Error("registered_tool_failure_number_invalid");
+        }
+        return value;
+    }
+    if (Array.isArray(value)) {
+        return Object.freeze(value.map((entry) => canonicalValue(entry)));
+    }
+    if (!isPlainRecord(value)) {
+        throw new Error("registered_tool_failure_value_invalid");
+    }
+    return Object.freeze(Object.entries(value)
+        .sort(([left], [right]) => compareText(left, right))
+        .map(([key, entry]) => Object.freeze([key, canonicalValue(entry)])));
+}
+function isPlainRecord(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return false;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}
+function compareText(left, right) {
+    if (left < right)
+        return -1;
+    if (left > right)
+        return 1;
+    return 0;
+}

package/dist/src/runtime/adapters/registered-tool-worker-capabilities/payload-lifecycle.d.ts

@@ -1,21 +1,23 @@
 import type { ToolExecutionSharedState } from "../../../capabilities/tool-types.js";
 import type { CapabilityAdapterResult } from "../../orchestration/capability-adapters/index.js";
 import type { WorkerCapabilityAdapterResult, WorkerCapabilityExecutionFreshness, WorkerCapabilityPayloadAuthor } from "../../orchestration/worker-capabilities/index.js";
-import type { RegisteredToolNormalInvocationExecutor, RegisteredToolNormalInvocationProjection } from "../registered-tool-normal-invocations.js";
-import type { RegisteredToolWorkerCapabilityProviderDiagnostic } from "../registered-tool-worker-capability-diagnostics.js";
+import type { RegisteredToolNormalInvocationProjection } from "../registered-tool-normal-invocations.js";
+import type { PayloadLifecycleEmitter, PayloadStageMaterializationDetails } from "./payload-observability.js";
 export declare function prepareOperationPayload(params: Readonly<{
     projection: RegisteredToolNormalInvocationProjection;
-    executor: RegisteredToolNormalInvocationExecutor;
+    executor: PayloadLifecycleEmitter;
     sharedState: ToolExecutionSharedState;
     payloadAuthor?: WorkerCapabilityPayloadAuthor;
     call: Parameters<WorkerCapabilityPayloadAuthor["author"]>[0]["call"];
+    assignmentProvenance?: Parameters<WorkerCapabilityPayloadAuthor["author"]>[0]["assignmentProvenance"];
     executionId: string;
     descriptor: Parameters<WorkerCapabilityPayloadAuthor["author"]>[0]["descriptor"];
     intent: string;
+    authoringObjective?: string;
     controls: Readonly<Record<string, unknown>>;
     dependencyResults?: Parameters<WorkerCapabilityPayloadAuthor["author"]>[0]["dependencyResults"];
     settledCapabilityResults: Parameters<WorkerCapabilityPayloadAuthor["author"]>[0]["settledCapabilityResults"];
-    diagnostic: RegisteredToolWorkerCapabilityProviderDiagnostic;
+    deferPayloadStageMaterialized(details: PayloadStageMaterializationDetails): void;
     executionFreshness?: WorkerCapabilityExecutionFreshness;
 }>): Promise<Readonly<{
     status: "ready";

package/dist/src/runtime/adapters/registered-tool-worker-capabilities/payload-lifecycle.js

@@ -1,4 +1,4 @@
-import { resolveRegisteredToolPayloadRelatedArtifactContexts } from "../registered-tool-payload-plan.js";
+import { resolveRegisteredToolPayloadRelatedArtifactContexts } from "../registered-tool-payload-related-artifacts.js";
 import { normalizePayloadAuthoringResult } from "./payload-authoring-result.js";
 import { executionFreshnessRejection, payloadRejection, rejectPayloadLifecycle, STEERING_SUPERSEDED_BEFORE_EXTERNAL_EXECUTION, STEERING_SUPERSEDED_SUMMARY, } from "./payload-rejection.js";
 import { prepareStagedOperationPayload } from "./payload-stages.js";
@@ -11,15 +11,21 @@ export async function prepareOperationPayload(params) {
             sharedState: params.sharedState,
             ...(params.payloadAuthor ? { payloadAuthor: params.payloadAuthor } : {}),
             call: params.call,
+            ...(params.assignmentProvenance
+                ? { assignmentProvenance: params.assignmentProvenance }
+                : {}),
             executionId: params.executionId,
             descriptor: params.descriptor,
             intent: params.intent,
+            ...(params.authoringObjective
+                ? { authoringObjective: params.authoringObjective }
+                : {}),
             controls: params.controls,
             ...(params.dependencyResults
                 ? { dependencyResults: params.dependencyResults }
                 : {}),
             settledCapabilityResults: params.settledCapabilityResults,
-            diagnostic: params.diagnostic,
+            deferPayloadStageMaterialized: params.deferPayloadStageMaterialized,
             ...(params.executionFreshness
                 ? { executionFreshness: params.executionFreshness }
                 : {}),
@@ -52,12 +58,22 @@ export async function prepareOperationPayload(params) {
             targetParam: params.projection.payloadContextPlan?.targetParam,
             controls: params.controls,
             sharedState: params.sharedState,
+            call: params.call,
+            ...(params.assignmentProvenance
+                ? { assignmentProvenance: params.assignmentProvenance }
+                : {}),
             settledCapabilityResults: params.settledCapabilityResults,
         });
         rawAuthored = await params.payloadAuthor.author({
             call: params.call,
+            ...(params.assignmentProvenance
+                ? { assignmentProvenance: params.assignmentProvenance }
+                : {}),
             executionId: params.executionId,
             descriptor: params.descriptor,
+            ...(params.authoringObjective
+                ? { authoringObjective: params.authoringObjective }
+                : {}),
             controls: params.controls,
             contextScope,
             ...(params.dependencyResults