@abot-ai/runtime 1.0.0 → 1.2.0

package/dist/src/runtime/orchestration/worker-capabilities/execution.js

@@ -1,56 +1,28 @@
-import { ROLE_CAPABILITY_REFERENCE_DATA_MAX_LENGTH, ROLE_CAPABILITY_RESULT_REFERENCE_LIMIT_MAX, ROLE_CAPABILITY_RESULT_REFERENCE_TARGET_MAX_LENGTH, ROLE_CALL_RESULT_MAX_LENGTH, resolveRoleCallTransactions, } from "../role-calls/index.js";
-import { traceWorkerCapabilityContextProjected, traceWorkerCapabilityContextRejected, traceWorkerCapabilityExecutionCompleted, traceWorkerCapabilityExecutionFailed, traceWorkerCapabilityExecutionStarted, traceWorkerCapabilityResultRejected, traceWorkerCapabilityStateRejected, } from "./diagnostics.js";
-import { projectWorkerSettledCapabilityResults } from "./settled-results.js";
-import { assertWorkerCapabilityWithinScope, WorkerCapabilityScopeError, } from "./scope.js";
-import { captureLegacyCapabilityAdapterResult, normalizeCapabilityAdapterResult, } from "../capability-adapters/result.js";
-const TECHNICAL_EXECUTION_FAILURE_SUMMARY = "The capability failed before returning a valid result.";
-const INVALID_EXECUTION_RESULT_SUMMARY = "The capability returned an invalid result.";
-const OVERSIZED_EXECUTION_RESULT_SUMMARY = "The capability result exceeded the Runtime evidence size limit.";
+import { assertExecutionCapabilityScope, projectExecutionSettledCapabilityResults, } from "./execution/context-projection.js";
+import { createPreparationId, deduplicatePreparedInvocations, prepareBoundInvocation, } from "./execution/invocation-preparation.js";
+import { beginAndSettlePreparedBatch, beginAndSettlePreparedSingle, } from "./execution/ledger-transaction.js";
+import { projectWorkerCapabilityPayloadSourceProvenance } from "./payload-source-provenance.js";
 export async function executeBoundWorkerCapability(params) {
     assertExecutionCapabilityScope(params.capabilityScope, params.adapter.descriptor, params.diagnostic);
-    let settledCapabilityResults;
-    try {
-        settledCapabilityResults = projectWorkerSettledCapabilityResults({
-            ledger: params.ledger,
-            head: params.currentHead,
-            call: params.call,
-        });
-    }
-    catch (error) {
-        const issueCode = settledResultProjectionIssueCode(error);
-        traceWorkerCapabilityContextRejected(params.diagnostic, params.adapter.descriptor, issueCode);
-        throw new Error(`worker_capability_context_rejected:${issueCode}`);
-    }
-    traceWorkerCapabilityContextProjected(params.diagnostic, params.adapter.descriptor, settledCapabilityResults);
-    const transactions = resolveRoleCallTransactions(params.ledger);
-    const begunResult = await transactions.beginCapabilityExecution({
-        expectedHead: params.currentHead,
-        callId: params.call.callId,
-        invocationAttempt: params.call.activationCount,
-        capabilityId: params.adapter.descriptor.capabilityId,
-        declaredEffect: params.adapter.descriptor.effect,
-        intent: params.intent,
-        controlsJson: JSON.stringify(params.controls),
+    const settledCapabilityResults = projectExecutionSettledCapabilityResults({
+        ledger: params.ledger,
+        head: params.currentHead,
+        call: params.call,
+        descriptors: [params.adapter.descriptor],
+        diagnostic: params.diagnostic,
     });
-    if (!begunResult.ok) {
-        traceWorkerCapabilityStateRejected(params.diagnostic, params.adapter.descriptor, {
-            phase: "begin",
-            issueCode: begunResult.issueCode,
-        });
-        throw stateRejection("begin", begunResult.issueCode);
-    }
-    const begun = begunResult.commit;
-    const executionId = begun.effect.executionId;
-    traceWorkerCapabilityExecutionStarted(params.diagnostic, params.adapter.descriptor, executionId, params.intent.length, Object.keys(params.controls).length);
-    const result = await executeAndNormalizeAdapter({
+    const assignmentProvenance = projectPayloadSourceProvenance(params);
+    const prepared = await prepareBoundInvocation({
         context: params.context,
         call: params.call,
-        execute: params.adapter.execute,
+        ...(assignmentProvenance ? { assignmentProvenance } : {}),
+        adapter: params.adapter,
         intent: params.intent,
+        ...(params.authoringObjective
+            ? { authoringObjective: params.authoringObjective }
+            : {}),
         controls: params.controls,
-        descriptor: params.adapter.descriptor,
-        diagnostic: params.diagnostic,
-        executionId,
+        preparationId: createPreparationId(params.call, 0),
         settledCapabilityResults,
         ...(params.dependencyResults
             ? { dependencyResults: params.dependencyResults }
@@ -59,342 +31,120 @@ export async function executeBoundWorkerCapability(params) {
             ? { executionFreshness: params.executionFreshness }
             : {}),
     });
-    const settledResult = await transactions.settleCapabilityExecution({
-        expectedHead: begun.head,
-        callId: params.call.callId,
-        executionId,
-        outcome: result.outcome,
-        observedEffect: result.observedEffect,
-        summary: result.summary,
-        ...(result.referenceData ? { referenceData: result.referenceData } : {}),
-        ...(result.references ? { references: result.references } : {}),
-        exactResult: result.exactResult,
+    return beginAndSettlePreparedSingle({
+        currentHead: params.currentHead,
+        ledger: params.ledger,
+        call: params.call,
+        invocation: Object.freeze({
+            adapter: params.adapter,
+            intent: params.intent,
+            ...(params.authoringObjective
+                ? { authoringObjective: params.authoringObjective }
+                : {}),
+            controls: params.controls,
+            prepared,
+        }),
+        diagnostic: params.diagnostic,
+        ...(params.executionFreshness
+            ? { executionFreshness: params.executionFreshness }
+            : {}),
     });
-    if (!settledResult.ok) {
-        traceWorkerCapabilityStateRejected(params.diagnostic, params.adapter.descriptor, {
-            phase: "settle",
-            issueCode: settledResult.issueCode,
-            executionId,
-        });
-        throw stateRejection("settle", settledResult.issueCode);
-    }
-    traceWorkerCapabilityExecutionCompleted(params.diagnostic, params.adapter.descriptor, result, executionId);
-    return Object.freeze({ executionId });
 }
 export async function executeBoundWorkerCapabilityBatch(params) {
-    if (params.invocations.length < 2 ||
-        params.invocations.some(({ adapter }) => adapter.descriptor.effect !== "observation")) {
+    if (!isExecutableObservationBatch(params.invocations)) {
         throw new Error("worker_capability_batch_invalid");
     }
     for (const { adapter } of params.invocations) {
         assertExecutionCapabilityScope(params.capabilityScope, adapter.descriptor, params.diagnostic);
     }
-    let settledCapabilityResults;
-    try {
-        settledCapabilityResults = projectWorkerSettledCapabilityResults({
+    const settledCapabilityResults = projectExecutionSettledCapabilityResults({
+        ledger: params.ledger,
+        head: params.currentHead,
+        call: params.call,
+        descriptors: params.invocations.map(({ adapter }) => adapter.descriptor),
+        diagnostic: params.diagnostic,
+    });
+    const preparedInvocations = await Promise.all(params.invocations.map(async (invocation, index) => {
+        const assignmentProvenance = projectPayloadSourceProvenance({
             ledger: params.ledger,
-            head: params.currentHead,
+            currentHead: params.currentHead,
             call: params.call,
+            adapter: invocation.adapter,
         });
-    }
-    catch (error) {
-        const issueCode = settledResultProjectionIssueCode(error);
-        for (const { adapter } of params.invocations) {
-            traceWorkerCapabilityContextRejected(params.diagnostic, adapter.descriptor, issueCode);
-        }
-        throw new Error(`worker_capability_context_rejected:${issueCode}`);
-    }
-    for (const { adapter } of params.invocations) {
-        traceWorkerCapabilityContextProjected(params.diagnostic, adapter.descriptor, settledCapabilityResults);
-    }
-    const transactions = resolveRoleCallTransactions(params.ledger);
-    const begunResult = await transactions.beginCapabilityBatch({
-        expectedHead: params.currentHead,
-        callId: params.call.callId,
-        invocationAttempt: params.call.activationCount,
-        entries: params.invocations.map(({ adapter, intent, controls }) => ({
-            capabilityId: adapter.descriptor.capabilityId,
-            declaredEffect: "observation",
-            intent,
-            controlsJson: JSON.stringify(controls),
-        })),
-    });
-    if (!begunResult.ok) {
-        for (const { adapter } of params.invocations) {
-            traceWorkerCapabilityStateRejected(params.diagnostic, adapter.descriptor, { phase: "begin", issueCode: begunResult.issueCode });
-        }
-        throw stateRejection("begin", begunResult.issueCode);
-    }
-    const begun = begunResult.commit;
-    const executionIds = begun.effect.executionIds;
-    params.invocations.forEach((invocation, index) => {
-        traceWorkerCapabilityExecutionStarted(params.diagnostic, invocation.adapter.descriptor, executionIds[index], invocation.intent.length, Object.keys(invocation.controls).length);
-    });
-    const results = await Promise.all(params.invocations.map((invocation, index) => executeAndNormalizeAdapter({
-        context: params.context,
+        return Object.freeze({
+            ...invocation,
+            prepared: await prepareBoundInvocation({
+                context: params.context,
+                call: params.call,
+                ...(assignmentProvenance ? { assignmentProvenance } : {}),
+                adapter: invocation.adapter,
+                intent: invocation.intent,
+                ...(invocation.authoringObjective
+                    ? { authoringObjective: invocation.authoringObjective }
+                    : {}),
+                controls: invocation.controls,
+                preparationId: createPreparationId(params.call, index),
+                settledCapabilityResults,
+                ...(params.dependencyResults
+                    ? { dependencyResults: params.dependencyResults }
+                    : {}),
+                ...(params.executionFreshness
+                    ? { executionFreshness: params.executionFreshness }
+                    : {}),
+            }),
+        });
+    }));
+    const uniqueInvocations = deduplicatePreparedInvocations(preparedInvocations);
+    return settlePreparedInvocationBatch({
+        currentHead: params.currentHead,
+        ledger: params.ledger,
         call: params.call,
-        execute: invocation.adapter.execute,
-        intent: invocation.intent,
-        controls: invocation.controls,
-        descriptor: invocation.adapter.descriptor,
+        invocations: uniqueInvocations,
         diagnostic: params.diagnostic,
-        executionId: executionIds[index],
-        settledCapabilityResults,
-        ...(params.dependencyResults
-            ? { dependencyResults: params.dependencyResults }
-            : {}),
         ...(params.executionFreshness
             ? { executionFreshness: params.executionFreshness }
             : {}),
-    })));
-    const settledResult = await transactions.settleCapabilityBatch({
-        expectedHead: begun.head,
-        callId: params.call.callId,
-        settlements: results.map((result, index) => ({
-            executionId: executionIds[index],
-            outcome: result.outcome,
-            observedEffect: result.observedEffect,
-            summary: result.summary,
-            ...(result.referenceData ? { referenceData: result.referenceData } : {}),
-            ...(result.references ? { references: result.references } : {}),
-            exactResult: result.exactResult,
-        })),
-    });
-    if (!settledResult.ok) {
-        params.invocations.forEach((invocation, index) => {
-            traceWorkerCapabilityStateRejected(params.diagnostic, invocation.adapter.descriptor, {
-                phase: "settle",
-                issueCode: settledResult.issueCode,
-                executionId: executionIds[index],
-            });
-        });
-        throw stateRejection("settle", settledResult.issueCode);
-    }
-    params.invocations.forEach((invocation, index) => {
-        traceWorkerCapabilityExecutionCompleted(params.diagnostic, invocation.adapter.descriptor, results[index], executionIds[index]);
     });
-    return Object.freeze({ executionIds: Object.freeze([...executionIds]) });
-}
-function assertExecutionCapabilityScope(projection, descriptor, diagnostic) {
-    try {
-        assertWorkerCapabilityWithinScope(projection, descriptor);
-    }
-    catch (error) {
-        const issueCode = error instanceof WorkerCapabilityScopeError
-            ? error.issueCode
-            : "capability_scope_validation_failed";
-        traceWorkerCapabilityContextRejected(diagnostic, descriptor, issueCode);
-        throw new Error(`worker_capability_rejected:${issueCode}`);
-    }
-}
-function settledResultProjectionIssueCode(error) {
-    if (error instanceof Error &&
-        (error.message === "worker_settled_results_head_stale" ||
-            error.message === "worker_settled_results_call_invalid" ||
-            error.message === "worker_settled_results_execution_invalid")) {
-        return error.message;
-    }
-    return "worker_settled_results_projection_failed";
-}
-async function executeAndNormalizeAdapter(params) {
-    let rawResult;
-    try {
-        rawResult = await params.execute(Object.freeze({
-            context: params.context,
-            call: params.call,
-            executionId: params.executionId,
-            intent: params.intent,
-            controls: params.controls,
-            settledCapabilityResults: params.settledCapabilityResults,
-            ...(params.dependencyResults
-                ? { dependencyResults: params.dependencyResults }
-                : {}),
-            ...(params.executionFreshness
-                ? { executionFreshness: params.executionFreshness }
-                : {}),
-        }));
-    }
-    catch (error) {
-        if (error instanceof Error && error.name === "AbortError") {
-            throw error;
-        }
-        traceWorkerCapabilityExecutionFailed(params.diagnostic, params.descriptor, error, params.executionId);
-        return attachCanonicalExactResult(technicalFailure(adapterExecutionFailureSummary(error)));
-    }
-    let normalized;
-    try {
-        normalized = normalizeAdapterResult(rawResult, params.descriptor.effect);
-    }
-    catch (error) {
-        normalized = {
-            ok: false,
-            issueCode: exactResultNormalizationIssueCode(error),
-        };
-    }
-    if (!normalized.ok) {
-        traceWorkerCapabilityResultRejected(params.diagnostic, params.descriptor, normalized.issueCode, params.executionId);
-        return attachCanonicalExactResult(technicalFailure(normalized.issueCode === "adapter_result_too_large"
-            ? OVERSIZED_EXECUTION_RESULT_SUMMARY
-            : INVALID_EXECUTION_RESULT_SUMMARY));
-    }
-    return normalized.value;
 }
-function adapterExecutionFailureSummary(error) {
-    if (error instanceof Error) {
-        if (error.message.endsWith("canonical_result_result_too_large")) {
-            return OVERSIZED_EXECUTION_RESULT_SUMMARY;
-        }
-        if (error.message.endsWith("canonical_result_result_invalid") ||
-            error.message.endsWith("canonical_result_result_not_json_safe")) {
-            return INVALID_EXECUTION_RESULT_SUMMARY;
-        }
-    }
-    return TECHNICAL_EXECUTION_FAILURE_SUMMARY;
-}
-function exactResultNormalizationIssueCode(error) {
-    if (error instanceof Error &&
-        error.message.startsWith("capability_exact_result_invalid:")) {
-        const code = error.message.slice("capability_exact_result_invalid:".length);
-        if (code === "result_invalid" ||
-            code === "result_not_json_safe" ||
-            code === "result_too_large") {
-            return `adapter_${code}`;
-        }
-    }
-    return "adapter_result_unreadable";
-}
-function normalizeAdapterResult(input, declaredEffect) {
-    if (typeof input !== "object" || input === null || Array.isArray(input)) {
-        return { ok: false, issueCode: "adapter_result_not_object" };
-    }
-    const keys = Object.keys(input);
-    if (keys.length < 3 ||
-        keys.length > 6 ||
-        !keys.includes("outcome") ||
-        !keys.includes("observedEffect") ||
-        !keys.includes("summary") ||
-        keys.some((key) => key !== "outcome" &&
-            key !== "observedEffect" &&
-            key !== "summary" &&
-            key !== "referenceData" &&
-            key !== "references" &&
-            key !== "exactResult")) {
-        return { ok: false, issueCode: "adapter_result_shape_invalid" };
-    }
-    if (typeof input.summary !== "string" ||
-        input.summary.trim().length === 0 ||
-        input.summary.length > ROLE_CALL_RESULT_MAX_LENGTH) {
-        return { ok: false, issueCode: "adapter_result_summary_invalid" };
-    }
-    if (input.referenceData !== undefined &&
-        (typeof input.referenceData !== "string" ||
-            input.referenceData.trim().length === 0 ||
-            input.referenceData.length > ROLE_CAPABILITY_REFERENCE_DATA_MAX_LENGTH)) {
-        return { ok: false, issueCode: "adapter_result_reference_data_invalid" };
-    }
-    const references = normalizeResultReferences(input.references);
-    if (references === null) {
-        return { ok: false, issueCode: "adapter_result_references_invalid" };
-    }
-    if (input.outcome === "succeeded") {
-        if (!isSuccessfulObservedEffectCompatible(input.observedEffect, declaredEffect)) {
-            return { ok: false, issueCode: "observed_effect_mismatch" };
-        }
-        return {
-            ok: true,
-            value: attachCanonicalExactResult(Object.freeze({
-                outcome: "succeeded",
-                observedEffect: input.observedEffect,
-                summary: input.summary.trim(),
-                ...(input.referenceData
-                    ? { referenceData: input.referenceData.trim() }
-                    : {}),
-                ...(references ? { references } : {}),
-            }), input),
-        };
-    }
-    if (input.outcome === "failed") {
-        if (!isFailedObservedEffectCompatible(input.observedEffect, declaredEffect)) {
-            return { ok: false, issueCode: "failed_effect_invalid" };
-        }
-        return {
-            ok: true,
-            value: attachCanonicalExactResult(Object.freeze({
-                outcome: "failed",
-                observedEffect: input.observedEffect,
-                summary: input.summary.trim(),
-                ...(input.referenceData
-                    ? { referenceData: input.referenceData.trim() }
-                    : {}),
-                ...(references ? { references } : {}),
-            }), input),
-        };
-    }
-    return { ok: false, issueCode: "adapter_result_outcome_invalid" };
-}
-function attachCanonicalExactResult(normalized, raw = normalized) {
-    const exact = raw.exactResult === undefined
-        ? captureLegacyCapabilityAdapterResult(raw)
-        : normalizeCapabilityAdapterResult(raw.exactResult);
-    if (!exact.ok) {
-        throw new Error(`capability_exact_result_invalid:${exact.code}`);
+function projectPayloadSourceProvenance(params) {
+    if (params.call.roleId !== "worker" ||
+        params.adapter?.descriptor.requiresPayloadAuthoringObjective !== true) {
+        return undefined;
     }
-    return Object.freeze({
-        ...normalized,
-        exactResult: exact.value,
+    return projectWorkerCapabilityPayloadSourceProvenance({
+        ledger: params.ledger,
+        head: params.currentHead,
+        call: params.call,
     });
 }
-function normalizeResultReferences(input) {
-    if (input === undefined)
-        return undefined;
-    if (!Array.isArray(input) ||
-        input.length > ROLE_CAPABILITY_RESULT_REFERENCE_LIMIT_MAX) {
-        return null;
-    }
-    const targets = new Set();
-    const references = [];
-    for (const candidate of input) {
-        if (typeof candidate !== "object" ||
-            candidate === null ||
-            Array.isArray(candidate)) {
-            return null;
-        }
-        const reference = candidate;
-        if (Object.keys(reference).length !== 2 ||
-            reference.kind !== "tool_target" ||
-            typeof reference.target !== "string" ||
-            reference.target.trim().length === 0 ||
-            reference.target.length >
-                ROLE_CAPABILITY_RESULT_REFERENCE_TARGET_MAX_LENGTH) {
-            return null;
-        }
-        const target = reference.target.trim();
-        if (targets.has(target))
-            return null;
-        targets.add(target);
-        references.push(Object.freeze({ kind: "tool_target", target }));
+async function settlePreparedInvocationBatch(params) {
+    if (params.invocations.length === 1) {
+        return settleCollapsedPreparedBatch(params);
     }
-    return Object.freeze(references);
+    return beginAndSettlePreparedBatch(params);
 }
-function isSuccessfulObservedEffectCompatible(observedEffect, declaredEffect) {
-    return declaredEffect === "mixed"
-        ? observedEffect === "observation" || observedEffect === "mutation"
-        : observedEffect === declaredEffect;
-}
-function isFailedObservedEffectCompatible(observedEffect, declaredEffect) {
-    return (observedEffect === "none" ||
-        observedEffect === "indeterminate" ||
-        observedEffect === "observation" ||
-        (observedEffect === "mutation" &&
-            (declaredEffect === "mutation" || declaredEffect === "mixed")));
+async function settleCollapsedPreparedBatch(params) {
+    const result = await beginAndSettlePreparedSingle({
+        currentHead: params.currentHead,
+        ledger: params.ledger,
+        call: params.call,
+        invocation: params.invocations[0],
+        diagnostic: params.diagnostic,
+        ...(params.executionFreshness
+            ? { executionFreshness: params.executionFreshness }
+            : {}),
+    });
+    return projectSingleAttemptAsBatch(result);
 }
-function technicalFailure(summary) {
+function projectSingleAttemptAsBatch(result) {
+    if ("commit" in result)
+        return result;
     return Object.freeze({
-        outcome: "failed",
-        observedEffect: "indeterminate",
-        summary,
+        executionIds: Object.freeze([result.executionId]),
     });
 }
-function stateRejection(phase, code) {
-    return new Error(`worker_capability_${phase}_rejected:${code}`);
+function isExecutableObservationBatch(invocations) {
+    if (invocations.length < 2)
+        return false;
+    return invocations.every(({ adapter }) => adapter.descriptor.effect === "observation");
 }

package/dist/src/runtime/orchestration/worker-capabilities/index.d.ts

@@ -1,8 +1,13 @@
+export * from "./batch-selection.js";
 export * from "./binding.js";
 export * from "./controls.js";
 export * from "./contracts.js";
+export * from "./assignment-provenance.js";
+export * from "./errors.js";
+export * from "./outcome-fingerprint.js";
 export * from "./payload-author.js";
 export * from "./payload-contracts.js";
+export { isWorkerCapabilityPayloadSourceProvenanceValid, projectWorkerPayloadPlannerItemProvenance, projectWorkerPayloadRequestSourceProjection, } from "./payload-source-provenance.js";
 export * from "./scope.js";
 export * from "./selection-controls.js";
 export * from "./settled-results.js";

package/dist/src/runtime/orchestration/worker-capabilities/index.js

@@ -1,8 +1,13 @@
+export * from "./batch-selection.js";
 export * from "./binding.js";
 export * from "./controls.js";
 export * from "./contracts.js";
+export * from "./assignment-provenance.js";
+export * from "./errors.js";
+export * from "./outcome-fingerprint.js";
 export * from "./payload-author.js";
 export * from "./payload-contracts.js";
+export { isWorkerCapabilityPayloadSourceProvenanceValid, projectWorkerPayloadPlannerItemProvenance, projectWorkerPayloadRequestSourceProjection, } from "./payload-source-provenance.js";
 export * from "./scope.js";
 export * from "./selection-controls.js";
 export * from "./settled-results.js";

package/dist/src/runtime/orchestration/worker-capabilities/outcome-fingerprint.d.ts

@@ -0,0 +1,8 @@
+import type { RoleOperationOutcomeFingerprint } from "../role-calls/index.js";
+/**
+ * Keeps thrown adapter failures distinct without persisting their raw values.
+ * Unsafe or unstable thrown values deliberately produce no tracking identity.
+ */
+export declare function createWorkerCapabilityExecutionErrorOutcomeFingerprint(error: unknown): RoleOperationOutcomeFingerprint | undefined;
+/** Keeps distinct adapter contract violations separate without exposing them. */
+export declare function createWorkerCapabilityResultRejectionOutcomeFingerprint(issueCode: string): RoleOperationOutcomeFingerprint;

package/dist/src/runtime/orchestration/worker-capabilities/outcome-fingerprint.js

@@ -0,0 +1,21 @@
+import { createHash } from "node:crypto";
+import { createStableWorkerCapabilityErrorFingerprint } from "./error-fingerprint.js";
+/**
+ * Keeps thrown adapter failures distinct without persisting their raw values.
+ * Unsafe or unstable thrown values deliberately produce no tracking identity.
+ */
+export function createWorkerCapabilityExecutionErrorOutcomeFingerprint(error) {
+    return createStableWorkerCapabilityErrorFingerprint({
+        domain: "execute",
+        error,
+    });
+}
+/** Keeps distinct adapter contract violations separate without exposing them. */
+export function createWorkerCapabilityResultRejectionOutcomeFingerprint(issueCode) {
+    return digest(["adapter_result_rejection_v1", issueCode]);
+}
+function digest(value) {
+    return `sha256:${createHash("sha256")
+        .update(JSON.stringify(value))
+        .digest("hex")}`;
+}

package/dist/src/runtime/orchestration/worker-capabilities/payload-assignment-validation.d.ts

@@ -0,0 +1,3 @@
+import type { WorkerCapabilityPayloadAuthor } from "./payload-contracts.js";
+/** Validates payload assignment ownership before any model boundary is built. */
+export declare function isWorkerCapabilityPayloadAssignmentValid(input: Parameters<WorkerCapabilityPayloadAuthor["author"]>[0], principalKind: "worker" | "root", requestId: string): boolean;

package/dist/src/runtime/orchestration/worker-capabilities/payload-assignment-validation.js

@@ -0,0 +1,30 @@
+import { WORKER_CAPABILITY_AUTHORING_OBJECTIVE_MAX_LENGTH } from "./contracts.js";
+import { isWorkerCapabilityPayloadSourceProvenanceValid } from "./payload-source-provenance.js";
+/** Validates payload assignment ownership before any model boundary is built. */
+export function isWorkerCapabilityPayloadAssignmentValid(input, principalKind, requestId) {
+    if (principalKind === "root") {
+        return (input.assignmentProvenance === undefined &&
+            !Object.hasOwn(input, "authoringObjective") &&
+            hasExecutionId(input.executionId));
+    }
+    if (!hasExecutionId(input.executionId))
+        return false;
+    if (!isWorkerCapabilityPayloadSourceProvenanceValid(input.assignmentProvenance, input.call, requestId)) {
+        return false;
+    }
+    if (input.descriptor.requiresPayloadAuthoringObjective !== true)
+        return false;
+    if (!Object.hasOwn(input, "authoringObjective"))
+        return false;
+    return isValidAuthoringObjective(input.authoringObjective);
+}
+function hasExecutionId(executionId) {
+    return typeof executionId === "string" && executionId.length > 0;
+}
+function isValidAuthoringObjective(value) {
+    if (typeof value !== "string")
+        return false;
+    if (value.trim() !== value || value.length === 0)
+        return false;
+    return value.length <= WORKER_CAPABILITY_AUTHORING_OBJECTIVE_MAX_LENGTH;
+}