@abot-ai/runtime 1.0.0 → 1.2.0

package/dist/src/runtime/orchestration/worker-capabilities/binding/call-authority.d.ts

@@ -0,0 +1,29 @@
+import { type RoleCallFrame, type RoleCallLedger, type RoleCallLedgerHead } from "../../role-calls/index.js";
+import type { WorkerCapabilityExecutionFreshness } from "../contracts.js";
+import { type WorkerCapabilityDiagnosticContext } from "../diagnostics.js";
+type LiveCapabilityCall = Readonly<{
+    currentHead: RoleCallLedgerHead;
+    currentCall: RoleCallFrame;
+}>;
+type InitialBindingAuthority = Readonly<{
+    ok: true;
+    authoritativeCall: RoleCallFrame;
+}> | Readonly<{
+    ok: false;
+    issueCode: string;
+}>;
+export declare function inspectInitialBindingAuthority(params: {
+    requestId: string;
+    boundCall: RoleCallFrame;
+    initialHead: RoleCallLedgerHead;
+}): InitialBindingAuthority;
+export declare function resolveLiveCapabilityCall(params: {
+    requestId: string;
+    boundCall: RoleCallFrame;
+    ledger: RoleCallLedger;
+    diagnostic: WorkerCapabilityDiagnosticContext;
+    attemptedCapabilityId?: string;
+}): LiveCapabilityCall;
+export declare function normalizeExecutionFreshness(input: WorkerCapabilityExecutionFreshness | undefined): WorkerCapabilityExecutionFreshness | undefined;
+export declare function copyBoundCapabilityCall(call: RoleCallFrame): RoleCallFrame;
+export {};

package/dist/src/runtime/orchestration/worker-capabilities/binding/call-authority.js

@@ -0,0 +1,193 @@
+import { classifyRuntimeErrorType } from "../../../observability/error-type.js";
+import { hasRoleCallCapabilityAuthority, } from "../../role-calls/index.js";
+import { traceWorkerCapabilitySelectionRejected, } from "../diagnostics.js";
+import { isWorkerCapabilityBindingRejection, workerCapabilityBindingRejection, } from "./binding-rejection.js";
+export function inspectInitialBindingAuthority(params) {
+    const authoritativeCall = params.initialHead.state.calls.find((call) => call.callId === params.boundCall.callId);
+    if (params.initialHead.state.requestId !== params.requestId) {
+        return { ok: false, issueCode: "request_id_mismatch" };
+    }
+    if (params.initialHead.state.activeCallId !== params.boundCall.callId) {
+        return { ok: false, issueCode: "call_not_current" };
+    }
+    if (!authoritativeCall) {
+        return { ok: false, issueCode: "current_call_unavailable" };
+    }
+    const issueCode = validateExecutionCall(params.boundCall, authoritativeCall, params.initialHead);
+    if (issueCode)
+        return { ok: false, issueCode };
+    return { ok: true, authoritativeCall };
+}
+export function resolveLiveCapabilityCall(params) {
+    let currentHead;
+    let currentCall;
+    try {
+        currentHead = params.ledger.current();
+        assertLiveRequestAuthority(params, currentHead);
+        currentCall = currentHead.state.calls.find((call) => call.callId === params.boundCall.callId);
+    }
+    catch (error) {
+        if (isWorkerCapabilityBindingRejection(error))
+            throw error;
+        traceWorkerCapabilitySelectionRejected(params.diagnostic, {
+            issueCode: "current_call_read_failed",
+            errorType: classifyRuntimeErrorType(error),
+        });
+        throw workerCapabilityBindingRejection("current_call_read_failed");
+    }
+    if (!currentCall) {
+        traceWorkerCapabilitySelectionRejected(params.diagnostic, {
+            issueCode: "current_call_unavailable",
+        });
+        throw workerCapabilityBindingRejection("current_call_unavailable");
+    }
+    const bindingIssue = validateExecutionCall(params.boundCall, currentCall, currentHead);
+    if (bindingIssue) {
+        traceWorkerCapabilitySelectionRejected(params.diagnostic, {
+            issueCode: bindingIssue,
+            attemptedCallId: currentCall.callId,
+            attemptedInvocationAttempt: currentCall.activationCount,
+            ...(params.attemptedCapabilityId
+                ? { capabilityId: params.attemptedCapabilityId }
+                : {}),
+        });
+        throw workerCapabilityBindingRejection(bindingIssue);
+    }
+    return { currentHead, currentCall };
+}
+export function normalizeExecutionFreshness(input) {
+    if (input === undefined)
+        return undefined;
+    if (!isFreshnessSource(input))
+        return undefined;
+    const source = input;
+    return Object.freeze({
+        token: Object.freeze({
+            kind: "request_steering_v1",
+            version: input.token.version,
+            updates: Object.freeze(input.token.updates.map(({ sequence, text }) => Object.freeze({ sequence, text }))),
+        }),
+        isCurrent: () => source.isCurrent(),
+    });
+}
+export function copyBoundCapabilityCall(call) {
+    return Object.freeze({
+        ...call,
+        childCallIds: Object.freeze([...call.childCallIds]),
+        ...(call.workerCapabilityScope
+            ? {
+                workerCapabilityScope: Object.freeze({
+                    catalogGroupIds: Object.freeze([
+                        ...call.workerCapabilityScope.catalogGroupIds,
+                    ]),
+                }),
+            }
+            : {}),
+    });
+}
+function assertLiveRequestAuthority(params, currentHead) {
+    if (currentHead.state.requestId !== params.requestId) {
+        traceWorkerCapabilitySelectionRejected(params.diagnostic, {
+            issueCode: "request_id_mismatch",
+        });
+        throw workerCapabilityBindingRejection("request_id_mismatch");
+    }
+    if (currentHead.state.activeCallId !== params.boundCall.callId) {
+        traceWorkerCapabilitySelectionRejected(params.diagnostic, {
+            issueCode: "call_not_current",
+        });
+        throw workerCapabilityBindingRejection("call_not_current");
+    }
+}
+function validateExecutionCall(boundCall, currentCall, head) {
+    if (!isValidActiveRoleCapabilityCall(head, currentCall)) {
+        return "worker_call_invalid";
+    }
+    if (currentCall.callId !== boundCall.callId)
+        return "call_id_mismatch";
+    if (currentCall.roleId !== boundCall.roleId)
+        return "worker_call_invalid";
+    if (currentCall.parentCallId !== boundCall.parentCallId) {
+        return "parent_call_id_mismatch";
+    }
+    if (currentCall.depth !== boundCall.depth)
+        return "call_depth_mismatch";
+    if (currentCall.activationCount !== boundCall.activationCount) {
+        return "invocation_attempt_mismatch";
+    }
+    if (currentCall.workingDirectory !== boundCall.workingDirectory) {
+        return "working_directory_mismatch";
+    }
+    if (!sameWorkerCapabilityScope(currentCall.workerCapabilityScope, boundCall.workerCapabilityScope)) {
+        return "worker_capability_scope_mismatch";
+    }
+    return null;
+}
+function isValidActiveRoleCapabilityCall(head, call) {
+    if (call.status !== "active")
+        return false;
+    if (!Number.isInteger(call.activationCount))
+        return false;
+    if (call.activationCount < 1)
+        return false;
+    if (call.resultRef !== null)
+        return false;
+    if (!hasRoleCallCapabilityAuthority(head.policy.authority, head.state.rootCallId, call)) {
+        return false;
+    }
+    return hasValidRootOrDelegatedIdentity(head, call);
+}
+function hasValidRootOrDelegatedIdentity(head, call) {
+    const isRoot = call.callId === head.state.rootCallId && call.parentCallId === null;
+    if (isRoot)
+        return call.depth === 0 && call.objective === null;
+    if (call.parentCallId === null)
+        return false;
+    if (call.depth < 1)
+        return false;
+    if (call.objective === null)
+        return false;
+    return call.objective.trim().length > 0;
+}
+function sameWorkerCapabilityScope(left, right) {
+    if (left === undefined || right === undefined)
+        return left === right;
+    if (left.catalogGroupIds.length !== right.catalogGroupIds.length) {
+        return false;
+    }
+    return left.catalogGroupIds.every((groupId, index) => groupId === right.catalogGroupIds[index]);
+}
+function isFreshnessSource(input) {
+    if (typeof input !== "object" || input === null)
+        return false;
+    const candidate = input;
+    if (typeof candidate.isCurrent !== "function")
+        return false;
+    return isSteeringToken(candidate.token);
+}
+function isSteeringToken(input) {
+    if (typeof input !== "object" || input === null)
+        return false;
+    const candidate = input;
+    if (candidate.kind !== "request_steering_v1")
+        return false;
+    if (!Number.isSafeInteger(candidate.version))
+        return false;
+    if (candidate.version < 0)
+        return false;
+    if (!Array.isArray(candidate.updates))
+        return false;
+    if (candidate.updates.length !== candidate.version)
+        return false;
+    return candidate.updates.every((update, index) => isValidSteeringUpdate(update, index));
+}
+function isValidSteeringUpdate(input, zeroBasedIndex) {
+    if (typeof input !== "object" || input === null)
+        return false;
+    const update = input;
+    if (update.sequence !== zeroBasedIndex + 1)
+        return false;
+    if (typeof update.text !== "string")
+        return false;
+    return update.text.trim().length > 0;
+}

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

@@ -0,0 +1,11 @@
+import { type RoleCallDependencyResult, type RoleCallFrame, type RoleCallLedger } from "../../role-calls/index.js";
+import type { WorkerCapabilityAdapter, WorkerCapabilityBinding, WorkerCapabilityExecutionFreshness } from "../contracts.js";
+export declare function createRoleCapabilityBinding<TContext>(params: {
+    requestId: string;
+    context: TContext;
+    call: RoleCallFrame;
+    ledger: RoleCallLedger;
+    adapters: readonly WorkerCapabilityAdapter<TContext>[];
+    dependencyResults?: readonly RoleCallDependencyResult[];
+    executionFreshness?: WorkerCapabilityExecutionFreshness;
+}): WorkerCapabilityBinding<TContext>;

package/dist/src/runtime/orchestration/worker-capabilities/binding/create-binding.js

@@ -0,0 +1,109 @@
+import { parseRoleCallWorkerCapabilityScope, } from "../../role-calls/index.js";
+import { traceWorkerCapabilityBindingCreated, traceWorkerCapabilityBindingRejected, } from "../diagnostics.js";
+import { createBoundCapabilityCatalog } from "./adapter-catalog.js";
+import { workerCapabilityBindingRejection } from "./binding-rejection.js";
+import { BoundCapabilitySession } from "./bound-capability-session.js";
+import { copyBoundCapabilityCall, inspectInitialBindingAuthority, normalizeExecutionFreshness, } from "./call-authority.js";
+import { bindCapabilityDependencyResults } from "./dependency-results.js";
+export function createRoleCapabilityBinding(params) {
+    const boundCall = copyBoundCapabilityCall(params.call);
+    const emptyDiagnostic = createEmptyBindingDiagnostic(params.requestId, boundCall);
+    const executionFreshness = resolveBoundExecutionFreshness({
+        boundCall,
+        supplied: params.executionFreshness,
+        emptyDiagnostic,
+    });
+    const initialHead = readInitialLedgerHead(params.ledger, emptyDiagnostic);
+    const authority = inspectInitialBindingAuthority({
+        requestId: params.requestId,
+        boundCall,
+        initialHead,
+    });
+    if (!authority.ok) {
+        traceWorkerCapabilityBindingRejected(emptyDiagnostic, authority.issueCode);
+        throw workerCapabilityBindingRejection(authority.issueCode);
+    }
+    const dependencyResults = resolveBoundDependencyResults({
+        initialHead,
+        authoritativeCall: authority.authoritativeCall,
+        supplied: params.dependencyResults,
+        emptyDiagnostic,
+    });
+    const catalog = createBoundCapabilityCatalog({
+        adapters: params.adapters,
+        boundCall,
+        emptyDiagnostic,
+    });
+    const diagnostic = createBindingDiagnostic({
+        requestId: params.requestId,
+        boundCall,
+        capabilityScope: catalog.capabilityScope,
+    });
+    traceWorkerCapabilityBindingCreated(diagnostic);
+    const session = new BoundCapabilitySession({
+        requestId: params.requestId,
+        context: params.context,
+        boundCall,
+        ledger: params.ledger,
+        capabilities: catalog.capabilities,
+        byCapabilityId: catalog.byCapabilityId,
+        diagnostic,
+        capabilityScope: catalog.capabilityScope,
+        dependencyResults,
+        ...(executionFreshness ? { executionFreshness } : {}),
+    });
+    return session.toBinding();
+}
+function createEmptyBindingDiagnostic(requestId, boundCall) {
+    const diagnosticScope = parseRoleCallWorkerCapabilityScope(boundCall.workerCapabilityScope);
+    return {
+        requestId,
+        call: boundCall,
+        capabilityIds: Object.freeze([]),
+        scopeMode: boundCall.workerCapabilityScope === undefined ? "full" : "catalog_groups",
+        scopeCatalogGroupIds: diagnosticScope?.catalogGroupIds ?? Object.freeze([]),
+        knownCatalogGroupCount: 0,
+        fullCapabilityCount: 0,
+        filteredCapabilityCount: 0,
+    };
+}
+function resolveBoundExecutionFreshness(params) {
+    const executionFreshness = params.boundCall.parentCallId === null
+        ? normalizeExecutionFreshness(params.supplied)
+        : undefined;
+    const hasInvalidFreshness = params.supplied !== undefined && !executionFreshness;
+    if (!hasInvalidFreshness)
+        return executionFreshness;
+    traceWorkerCapabilityBindingRejected(params.emptyDiagnostic, "execution_freshness_invalid");
+    throw workerCapabilityBindingRejection("execution_freshness_invalid");
+}
+function readInitialLedgerHead(ledger, emptyDiagnostic) {
+    try {
+        return ledger.current();
+    }
+    catch {
+        traceWorkerCapabilityBindingRejected(emptyDiagnostic, "current_call_read_failed");
+        throw workerCapabilityBindingRejection("current_call_read_failed");
+    }
+}
+function resolveBoundDependencyResults(params) {
+    try {
+        return bindCapabilityDependencyResults(params.initialHead, params.authoritativeCall, params.supplied);
+    }
+    catch {
+        traceWorkerCapabilityBindingRejected(params.emptyDiagnostic, "dependency_results_invalid");
+        throw workerCapabilityBindingRejection("dependency_results_invalid");
+    }
+}
+function createBindingDiagnostic(params) {
+    return Object.freeze({
+        requestId: params.requestId,
+        call: params.boundCall,
+        capabilityIds: params.capabilityScope.filteredCapabilityIds,
+        scopeMode: params.capabilityScope.mode,
+        scopeCatalogGroupIds: params.capabilityScope.catalogGroupIds,
+        knownCatalogGroupCount: params.capabilityScope.knownCatalogGroupIds.length,
+        fullCapabilityCount: params.capabilityScope.fullCapabilityIds.length,
+        filteredCapabilityCount: params.capabilityScope.filteredCapabilityIds.length,
+    });
+}

package/dist/src/runtime/orchestration/worker-capabilities/binding/dependency-results.d.ts

@@ -0,0 +1,2 @@
+import { type RoleCallDependencyResult, type RoleCallFrame, type RoleCallLedgerHead } from "../../role-calls/index.js";
+export declare function bindCapabilityDependencyResults(head: RoleCallLedgerHead, call: RoleCallFrame, supplied: readonly RoleCallDependencyResult[] | undefined): readonly RoleCallDependencyResult[];

package/dist/src/runtime/orchestration/worker-capabilities/binding/dependency-results.js

@@ -0,0 +1,34 @@
+import { projectRoleCallDependencyResults, } from "../../role-calls/index.js";
+export function bindCapabilityDependencyResults(head, call, supplied) {
+    const canonical = projectRoleCallDependencyResults(head, call);
+    if (supplied === undefined)
+        return canonical;
+    if (!areCanonicalDependencyResults(supplied, canonical)) {
+        throw new Error("worker_dependency_results_invalid");
+    }
+    return Object.freeze([...supplied]);
+}
+function areCanonicalDependencyResults(supplied, canonical) {
+    if (!Array.isArray(supplied))
+        return false;
+    if (!Object.isFrozen(supplied))
+        return false;
+    if (supplied.length !== canonical.length)
+        return false;
+    return supplied.every((result, index) => matchesCanonicalDependencyResult(result, canonical[index]));
+}
+function matchesCanonicalDependencyResult(result, expected) {
+    if (!Object.isFrozen(result))
+        return false;
+    if (!expected)
+        return false;
+    if (result.resultRef !== expected.resultRef)
+        return false;
+    if (result.producerCallId !== expected.producerCallId)
+        return false;
+    if (result.roleId !== expected.roleId)
+        return false;
+    if (result.outcome !== expected.outcome)
+        return false;
+    return result.summary === expected.summary;
+}

package/dist/src/runtime/orchestration/worker-capabilities/binding/invocation-preparation.d.ts

@@ -0,0 +1,21 @@
+import { type RoleCallFrame } from "../../role-calls/index.js";
+import { type WorkerCapabilityAdapter, type WorkerCapabilityBinding, type WorkerCapabilityControls } from "../contracts.js";
+import { type WorkerCapabilityDiagnosticContext } from "../diagnostics.js";
+import type { WorkerCapabilityScopeProjection } from "../scope.js";
+export type PreparedCapabilityInvocation<TContext> = Readonly<{
+    adapter: WorkerCapabilityAdapter<TContext>;
+    intent: string;
+    authoringObjective?: string;
+    controls: WorkerCapabilityControls;
+}>;
+export declare class CapabilityInvocationPreparer<TContext> {
+    #private;
+    constructor(params: {
+        boundCall: RoleCallFrame;
+        byCapabilityId: ReadonlyMap<string, WorkerCapabilityAdapter<TContext>>;
+        capabilityScope: WorkerCapabilityScopeProjection<WorkerCapabilityAdapter<TContext>>;
+        diagnostic: WorkerCapabilityDiagnosticContext;
+    });
+    prepareSingle(input: Parameters<WorkerCapabilityBinding<TContext>["execute"]>[0]): PreparedCapabilityInvocation<TContext>;
+    prepareBatch(candidates: Parameters<WorkerCapabilityBinding<TContext>["executeBatch"]>[0]["invocations"]): readonly PreparedCapabilityInvocation<TContext>[];
+}

package/dist/src/runtime/orchestration/worker-capabilities/binding/invocation-preparation.js

@@ -0,0 +1,167 @@
+import { isRoleCapabilityId, } from "../../role-calls/index.js";
+import { WORKER_CAPABILITY_AUTHORING_OBJECTIVE_MAX_LENGTH, WORKER_CAPABILITY_INTENT_MAX_LENGTH, } from "../contracts.js";
+import { validateWorkerCapabilityControls } from "../controls.js";
+import { traceWorkerCapabilitySelectionRejected, traceWorkerCapabilitySelectionResolved, } from "../diagnostics.js";
+import { workerCapabilityBindingRejection } from "./binding-rejection.js";
+const SINGLE_CAPABILITY_LOOKUP_ISSUES = Object.freeze({
+    invalid: "capability_id_invalid",
+    outOfScope: "capability_out_of_scope",
+    unavailable: "capability_unavailable",
+});
+const BATCH_CAPABILITY_LOOKUP_ISSUES = Object.freeze({
+    invalid: "batch_capability_id_invalid",
+    outOfScope: "batch_capability_out_of_scope",
+    unavailable: "batch_capability_unavailable",
+});
+export class CapabilityInvocationPreparer {
+    #byCapabilityId;
+    #capabilityScope;
+    #diagnostic;
+    #workerPrincipal;
+    constructor(params) {
+        this.#byCapabilityId = params.byCapabilityId;
+        this.#capabilityScope = params.capabilityScope;
+        this.#diagnostic = params.diagnostic;
+        this.#workerPrincipal =
+            params.boundCall.roleId === "worker" &&
+                params.boundCall.parentCallId !== null;
+    }
+    prepareSingle(input) {
+        const adapter = this.#resolveAvailableAdapter(input.capabilityId, SINGLE_CAPABILITY_LOOKUP_ISSUES);
+        const intent = normalizeCapabilityIntent(input.intent);
+        if (!intent.ok) {
+            this.#rejectSelection(intent.issueCode, input.capabilityId);
+        }
+        const controls = validateWorkerCapabilityControls(adapter.descriptor.controls, input.controls);
+        if (!controls.ok) {
+            this.#rejectSelection(controls.issueCode, input.capabilityId);
+        }
+        const authoringObjective = normalizeAuthoringObjective({
+            input,
+            descriptor: adapter.descriptor,
+            workerPrincipal: this.#workerPrincipal,
+        });
+        if (!authoringObjective.ok) {
+            this.#rejectSelection(authoringObjective.issueCode, input.capabilityId);
+        }
+        this.#traceSelectionResolved(adapter, intent.value, controls.value);
+        return createPreparedInvocation({
+            adapter,
+            intent: intent.value,
+            authoringObjective: authoringObjective.value,
+            controls: controls.value,
+        });
+    }
+    prepareBatch(candidates) {
+        if (!hasValidCapabilityBatchCardinality(candidates)) {
+            this.#rejectSelection("batch_size_invalid");
+        }
+        const invocations = [];
+        for (const candidate of candidates) {
+            invocations.push(this.#prepareBatchCandidate(candidate));
+        }
+        return Object.freeze(invocations);
+    }
+    #prepareBatchCandidate(candidate) {
+        const adapter = this.#resolveAvailableAdapter(candidate.capabilityId, BATCH_CAPABILITY_LOOKUP_ISSUES);
+        if (adapter.descriptor.effect !== "observation") {
+            this.#rejectSelection("batch_effect_invalid", candidate.capabilityId);
+        }
+        const intent = normalizeCapabilityIntent(candidate.intent);
+        if (!intent.ok) {
+            this.#rejectSelection(`batch_${intent.issueCode}`, candidate.capabilityId);
+        }
+        const controls = validateWorkerCapabilityControls(adapter.descriptor.controls, candidate.controls);
+        if (!controls.ok) {
+            this.#rejectSelection(`batch_${controls.issueCode}`, candidate.capabilityId);
+        }
+        const authoringObjective = normalizeAuthoringObjective({
+            input: candidate,
+            descriptor: adapter.descriptor,
+            workerPrincipal: this.#workerPrincipal,
+        });
+        if (!authoringObjective.ok) {
+            this.#rejectSelection(`batch_${authoringObjective.issueCode}`, candidate.capabilityId);
+        }
+        this.#traceSelectionResolved(adapter, intent.value, controls.value);
+        return createPreparedInvocation({
+            adapter,
+            intent: intent.value,
+            authoringObjective: authoringObjective.value,
+            controls: controls.value,
+        });
+    }
+    #resolveAvailableAdapter(capabilityId, issueCodes) {
+        if (!isRoleCapabilityId(capabilityId)) {
+            this.#rejectSelection(issueCodes.invalid);
+        }
+        const adapter = this.#byCapabilityId.get(capabilityId);
+        if (adapter)
+            return adapter;
+        const isKnownButOutOfScope = this.#capabilityScope.fullCapabilityIds.includes(capabilityId);
+        const issueCode = isKnownButOutOfScope
+            ? issueCodes.outOfScope
+            : issueCodes.unavailable;
+        this.#rejectSelection(issueCode, capabilityId);
+    }
+    #traceSelectionResolved(adapter, intent, controls) {
+        traceWorkerCapabilitySelectionResolved(this.#diagnostic, adapter.descriptor, intent.length, Object.keys(controls).length);
+    }
+    #rejectSelection(issueCode, capabilityId) {
+        traceWorkerCapabilitySelectionRejected(this.#diagnostic, {
+            issueCode,
+            ...(capabilityId ? { capabilityId } : {}),
+        });
+        throw workerCapabilityBindingRejection(issueCode);
+    }
+}
+function createPreparedInvocation(params) {
+    return {
+        adapter: params.adapter,
+        intent: params.intent,
+        ...(params.authoringObjective
+            ? { authoringObjective: params.authoringObjective }
+            : {}),
+        controls: params.controls,
+    };
+}
+function normalizeCapabilityIntent(input) {
+    if (typeof input !== "string") {
+        return { ok: false, issueCode: "intent_invalid" };
+    }
+    if (input.trim().length === 0) {
+        return { ok: false, issueCode: "intent_invalid" };
+    }
+    if (input.length > WORKER_CAPABILITY_INTENT_MAX_LENGTH) {
+        return { ok: false, issueCode: "intent_invalid" };
+    }
+    return { ok: true, value: input.trim() };
+}
+function normalizeAuthoringObjective(input) {
+    const supplied = Object.hasOwn(input.input, "authoringObjective");
+    const required = input.workerPrincipal &&
+        input.descriptor.requiresPayloadAuthoringObjective === true;
+    if (!required && supplied) {
+        return { ok: false, issueCode: "authoring_objective_forbidden" };
+    }
+    if (!required)
+        return { ok: true };
+    if (!supplied) {
+        return { ok: false, issueCode: "authoring_objective_required" };
+    }
+    const value = input.input.authoringObjective;
+    if (!isValidAuthoringObjective(value)) {
+        return { ok: false, issueCode: "authoring_objective_invalid" };
+    }
+    return { ok: true, value: value.trim() };
+}
+function isValidAuthoringObjective(input) {
+    if (typeof input !== "string")
+        return false;
+    if (input.trim().length === 0)
+        return false;
+    return input.length <= WORKER_CAPABILITY_AUTHORING_OBJECTIVE_MAX_LENGTH;
+}
+function hasValidCapabilityBatchCardinality(input) {
+    return Array.isArray(input) && input.length >= 2;
+}

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

@@ -1,13 +1 @@
-import { type RoleCallDependencyResult, type RoleCallFrame, type RoleCallLedger } from "../role-calls/index.js";
-import { type WorkerCapabilityAdapter, type WorkerCapabilityBinding, type WorkerCapabilityExecutionFreshness } from "./contracts.js";
-export declare function createRoleCapabilityBinding<TContext>(params: {
-    requestId: string;
-    context: TContext;
-    call: RoleCallFrame;
-    ledger: RoleCallLedger;
-    adapters: readonly WorkerCapabilityAdapter<TContext>[];
-    dependencyResults?: readonly RoleCallDependencyResult[];
-    executionFreshness?: WorkerCapabilityExecutionFreshness;
-}): WorkerCapabilityBinding<TContext>;
-/** Compatibility name for the existing Worker contract and focused callers. */
-export declare const createWorkerCapabilityBinding: typeof createRoleCapabilityBinding;
+export { createRoleCapabilityBinding, createRoleCapabilityBinding as createWorkerCapabilityBinding, } from "./binding/create-binding.js";