cloving 1.1.0 → 1.3.0

package/dist/src/repository-identity.js

@@ -0,0 +1,4 @@
+export function repositoryFileName(identity) {
+    const name = identity.name.replace(/[^A-Za-z0-9_-]/g, "").slice(0, 24);
+    return `${name}-${identity.sha256.slice(0, 8)}`;
+}

package/dist/src/review-subject.d.ts

@@ -0,0 +1,41 @@
+export interface CommitReviewSubject {
+    readonly commit: string;
+    readonly target: string;
+    readonly number?: number;
+}
+export interface DraftReviewSubject {
+    readonly draft: string;
+    readonly commit?: string;
+}
+export type ReviewSubject = CommitReviewSubject | DraftReviewSubject;
+export type Reviewer = {
+    readonly kind: "greptile";
+} | {
+    readonly kind: "turn";
+    readonly profile: string;
+};
+export interface ReviewResult {
+    readonly accepted: boolean;
+    readonly feedback: string;
+    readonly commit: string | null;
+    readonly subjectDigest: string;
+}
+export declare function reviewSubjectText(subject: ReviewSubject): string;
+export declare function commitId(value: unknown): value is string;
+export interface ReviewSnapshot {
+    readonly commit: string | null;
+    readonly subjectDigest: string;
+    readonly prompt: string;
+}
+export type ReviewVerdict = "accept" | "change";
+export declare function reviewReport(text: string): {
+    readonly reviewVerdict: ReviewVerdict | null;
+    readonly feedback: string;
+};
+export declare function reviewReportStream(limit: number): {
+    write: (chunk: string) => void;
+    result: () => {
+        reviewVerdict: ReviewVerdict | null;
+        feedback: string;
+    };
+};

package/dist/src/review-subject.js

@@ -0,0 +1,91 @@
+import { record } from "./protocol.js";
+export function reviewSubjectText(subject) {
+    if (record(subject) === undefined)
+        throw new Error("invalid-review-subject");
+    if ("draft" in subject)
+        return draftReviewText(subject);
+    if (!commitId(subject.commit) ||
+        typeof subject.target !== "string" ||
+        subject.target.trim() === "")
+        throw new Error("invalid-review-subject");
+    const identity = [
+        "cloving-review-subject",
+        1,
+        "commit",
+        subject.target,
+        subject.commit,
+    ];
+    if (subject.number !== undefined)
+        identity.push(subject.number);
+    return JSON.stringify(identity);
+}
+function draftReviewText(subject) {
+    if (typeof subject.draft !== "string" ||
+        subject.draft.trim() === "" ||
+        (subject.commit !== undefined && !commitId(subject.commit)))
+        throw new Error("invalid-review-subject");
+    return JSON.stringify([
+        "cloving-review-subject",
+        1,
+        "draft",
+        subject.commit ?? null,
+        subject.draft,
+    ]);
+}
+export function commitId(value) {
+    return (typeof value === "string" && /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/.test(value));
+}
+export function reviewReport(text) {
+    const trimmed = text.trimEnd();
+    const start = trimmed.lastIndexOf("\n") + 1;
+    const line = trimmed.slice(start);
+    const verdict = line.slice("Review verdict: ".length);
+    if (!line.startsWith("Review verdict: ") ||
+        (verdict !== "accept" && verdict !== "change"))
+        return { reviewVerdict: null, feedback: text };
+    return {
+        reviewVerdict: verdict,
+        feedback: trimmed.slice(0, start).trimEnd(),
+    };
+}
+export function reviewReportStream(limit) {
+    let text = "";
+    let trailing = "";
+    let prefix = "";
+    let length = 0;
+    let contentLength = 0;
+    let verdict = null;
+    const finish = () => {
+        if (contentLength > 0)
+            verdict =
+                contentLength > 24
+                    ? null
+                    : reviewReport(prefix.slice(0, contentLength)).reviewVerdict;
+        prefix = "";
+        length = 0;
+        contentLength = 0;
+    };
+    return {
+        write: (chunk) => {
+            const trimmed = chunk.trimEnd();
+            if (trimmed === "")
+                trailing = (trailing + chunk).slice(-limit);
+            if (trimmed !== "") {
+                text = (text + trailing + trimmed).slice(-limit);
+                trailing = chunk.slice(trimmed.length).slice(-limit);
+            }
+            for (const [index, part] of chunk.split("\n").entries()) {
+                if (index > 0)
+                    finish();
+                if (part.trimEnd() !== "")
+                    contentLength = Math.min(25, length + part.trimEnd().length);
+                prefix = (prefix + part).slice(0, 24);
+                length = Math.min(25, length + part.length);
+            }
+        },
+        result: () => {
+            finish();
+            return { reviewVerdict: verdict, feedback: reviewReport(text).feedback };
+        },
+    };
+}

package/dist/src/run-wait.d.ts

@@ -0,0 +1,23 @@
+import type { RunWaitOutcome, RunWaitRequest } from "./step-bridge.ts";
+export interface RunWaitTarget {
+    readonly parentRunId: string | null;
+    readonly status: string;
+    readonly endedAt: number | null;
+    readonly outcome: RunWaitOutcome | null;
+}
+export type RunWaitResult = {
+    readonly kind: "waiting";
+    readonly deadline: number;
+} | {
+    readonly kind: "completed";
+    readonly outcome: RunWaitOutcome;
+} | {
+    readonly kind: "refused";
+    readonly reason: string;
+};
+export declare function runWaitResult(request: RunWaitRequest, context: {
+    readonly callerRunId: string;
+    readonly startedAt: number;
+    readonly now: number;
+    readonly target: RunWaitTarget | undefined;
+}): RunWaitResult;

package/dist/src/run-wait.js

@@ -0,0 +1,20 @@
+function validSeconds(seconds) {
+    return Number.isInteger(seconds) && seconds >= 1 && seconds <= 86400;
+}
+export function runWaitResult(request, context) {
+    const { target, callerRunId, startedAt, now } = context;
+    const seconds = request.maximumWaitSeconds;
+    if (!validSeconds(seconds) ||
+        target?.parentRunId !== callerRunId ||
+        request.runId === callerRunId)
+        return { kind: "refused", reason: "run-wait-refused" };
+    const deadline = startedAt + seconds * 1000;
+    if (["completed", "failed", "cancelled"].includes(target.status) &&
+        target.outcome !== null &&
+        target.endedAt !== null &&
+        target.endedAt <= deadline)
+        return { kind: "completed", outcome: target.outcome };
+    if (now >= deadline)
+        return { kind: "refused", reason: "run-wait-timeout" };
+    return { kind: "waiting", deadline };
+}

package/dist/src/service/active-tickets.d.ts

@@ -0,0 +1,4 @@
+import { type Fields } from "../protocol.ts";
+import type { ServiceContext } from "./replies.ts";
+export declare function activeWorkflow(context: ServiceContext, workflowId: string): Promise<Fields[]>;
+export declare function queueOverview(context: ServiceContext): Promise<Fields>;

package/dist/src/service/active-tickets.js

@@ -0,0 +1,49 @@
+import { record } from "../protocol.js";
+export async function activeWorkflow(context, workflowId) {
+    const workflows = await context.authority.queries.workflowIds();
+    const state = await context.authority.state();
+    const queueRun = async (runId) => workflows[runId] === "develop-issue" ||
+        (await context.authority.queries.manifest(runId))?.queue === true;
+    const runs = Object.values(state.runs).filter((run) => !["completed", "failed", "cancelled"].includes(run.status));
+    const own = runs.filter((run) => workflows[run.runId] === workflowId);
+    const queued = workflowId === "develop-issue" ||
+        context.registry.byId(workflowId)?.queue === true ||
+        (await Promise.all(own.map((run) => queueRun(run.runId)))).includes(true);
+    const active = await Promise.all(runs.map(async (run) => {
+        if (workflows[run.runId] !== workflowId &&
+            !(queued && (await queueRun(run.runId))))
+            return undefined;
+        return storedTicket(context, state.details[run.runId]?.input);
+    }));
+    return active.filter((input) => input !== undefined);
+}
+export async function queueOverview(context) {
+    const workflow = context.registry.workflowIds
+        .map((id) => context.registry.byId(id))
+        .find((workflow) => workflow?.admission !== undefined);
+    if (workflow?.admission === undefined)
+        return {};
+    const active = await activeWorkflow(context, workflow.workflowId);
+    return {
+        queue: {
+            lanes: workflow.admission === "when-idle" ? 1 : workflow.admission,
+            busy: active.length,
+            skipped: [
+                ...active.flatMap((input) => typeof input["ticketId"] === "string"
+                    ? [{ ticketId: input["ticketId"], reason: "ticket-active" }]
+                    : []),
+                ...(workflow.resolver.skippedTickets?.() ?? []),
+            ],
+        },
+    };
+}
+async function storedTicket(context, digest) {
+    const text = digest
+        ? await context.authority.queries.document(digest)
+        : undefined;
+    const input = record(JSON.parse(text ?? "null")) ?? {};
+    const ticket = record(record(input["input"])?.["ticket"]);
+    return ticket === undefined
+        ? input
+        : { ...input, ticketId: ticket["id"], ticket: ticket["text"] };
+}

package/dist/src/service/command-effects.d.ts

@@ -0,0 +1,4 @@
+import type { ServiceContext } from "./replies.ts";
+import type { Fields } from "../protocol.ts";
+import type { OperationView } from "../broker/actor/authority.ts";
+export declare function commandFields(context: ServiceContext, operations: readonly OperationView[]): Promise<Fields>;

package/dist/src/service/command-effects.js

@@ -0,0 +1,16 @@
+export async function commandFields(context, operations) {
+    const effects = operations
+        .filter((operation) => operation.capability === "command")
+        .map((operation) => ({
+        operationId: operation.operationId,
+        name: operation.method.slice(4),
+        state: operation.status,
+        exitCode: null,
+        durationMilliseconds: null,
+    }));
+    if (effects.length === 0)
+        return {};
+    return {
+        commandEffects: (await context.commandEffects?.(effects)) ?? effects,
+    };
+}

package/dist/src/service/decision-handler.d.ts

@@ -5,5 +5,9 @@ export declare function feedbackOf(context: ServiceContext, scope: {
     readonly state: StoredState;
     readonly runId: string;
 }): Promise<readonly Fields[]>;
+export declare function decidedOf(context: ServiceContext, scope: {
+    readonly state: StoredState;
+    readonly runId: string;
+}): Promise<readonly Fields[]>;
 export declare function questions(context: ServiceContext, parameters: Fields): Promise<Reply>;
 export declare function decision(context: ServiceContext, parameters: Fields): Promise<Reply>;

package/dist/src/service/decision-handler.js

@@ -1,5 +1,6 @@
-import { continues, gateKey } from "../authority/gates.js";
-import { gateContinuation } from "../authority/reduction.js";
+import { delivers, gateKey } from "../authority/gates.js";
+import { isDeviceActor } from "../authority/commands.js";
+import { gateDelivery } from "../authority/reduction.js";
 import { documentDigest } from "../broker/decision-restore.js";
 import { committed, failed, invalidRequest, isIdentifier, publicReceipt, rejection, result, wholeNumber, } from "./replies.js";
 const decisions = {
@@ -43,6 +44,25 @@ export async function feedbackOf(context, scope) {
     }
     return shown;
 }
+export async function decidedOf(context, scope) {
+    const decided = typed(scope.state).filter((gate) => gate.runId === scope.runId &&
+        gate.outcome !== null &&
+        gate.outcome.decision !== null);
+    const shown = [];
+    for (const gate of decided) {
+        const page = await context.authority.queries.eventsAfter({
+            after: (gate.outcome?.sequence ?? 1) - 1,
+            limit: 1,
+        });
+        const actor = page.events[0]?.payload["actor"];
+        shown.push({
+            decisionId: decisionId(gate),
+            decision: gate.outcome?.decision ?? null,
+            actor: typeof actor === "string" ? actor : "local",
+        });
+    }
+    return shown;
+}
 async function described(context, shown) {
     const { state, gate } = shown;
     const { queries } = context.authority;
@@ -120,7 +140,20 @@ function textLimit(context, command) {
         ? { bytes: feedbackBytes, name: "A feedback text" }
         : { bytes: context.textBytes, name: "An answer" };
 }
+function actorOf(parameters) {
+    const actor = parameters["actor"] ?? null;
+    if (actor === null)
+        return null;
+    return isDeviceActor(actor) ? actor : undefined;
+}
 function decisionRequest(parameters) {
+    const actor = actorOf(parameters);
+    const fields = decisionFields(parameters);
+    if (actor === undefined || fields === undefined)
+        return undefined;
+    return { ...fields, actor };
+}
+function decisionFields(parameters) {
     const { command, reference, expectedRevision, generation } = parameters;
     const { subjectDigest, commandId } = parameters;
     const text = parameters["text"] ?? null;
@@ -183,6 +216,7 @@ export async function decision(context, parameters) {
             generation: request.generation,
             subject: request.subjectDigest,
             ...(text === null ? {} : { answer: documentDigest(text) }),
+            ...(request.actor === null ? {} : { actor: request.actor }),
         },
         documents: text === null ? [] : [text],
     });
@@ -203,9 +237,9 @@ export async function decision(context, parameters) {
 }
 async function continuationState(context, decided) {
     const { gate, run } = decided;
-    if (!continues(gate))
+    if (!delivers(gate))
         return "held";
-    const { operationId } = gateContinuation(gate);
+    const { operationId } = gateDelivery(gate);
     const operation = (await context.authority.operations()).find((item) => item.operationId === operationId);
     if (operation?.deliveries.some((delivery) => delivery.outcome === "sent"))
         return "admitted";
@@ -224,6 +258,7 @@ async function recorded(context, outcome) {
         decisionId: decisionId(gate),
         runId,
         decision: gate.outcome?.decision ?? null,
+        actor: stored.command.actor ?? null,
         commandId,
         replayed: outcome.replayed,
         receipt: publicReceipt(stored),

package/dist/src/service/gateway.js

@@ -1,5 +1,6 @@
 import { invalidCommand, serializable, textList, unserializable, } from "../broker/actor/authority-receipts.js";
 import { record } from "../protocol.js";
+import { commandLimits } from "../command-settings.js";
 export const workerCommandBound = 1_000;
 const permitted = {
     operator: [
@@ -10,6 +11,7 @@ const permitted = {
         "cancel-run",
     ],
     worker: [
+        "record-schedule-skip",
         "mark-started",
         "open-gate",
         "register-wait",
@@ -64,8 +66,17 @@ function refusal(submission, textBytes) {
         };
     return undefined;
 }
+async function reportLimit(parts, submission) {
+    if (submission.command["kind"] !== "report-effect" ||
+        !submission.documents.some((text) => Buffer.byteLength(text) > parts.textBytes))
+        return parts.textBytes;
+    const operation = await parts.authority.effects.operation(String(submission.command["operationId"]));
+    return operation?.capability === "command"
+        ? commandLimits.resultBytes
+        : parts.textBytes;
+}
 export function commandGateway(parts) {
-    const { authority, registry, clock, textBytes } = parts;
+    const { authority, registry, clock } = parts;
     const bound = parts.pendingWorkerCommands ?? workerCommandBound;
     let pending = 0;
     async function manifest(command) {
@@ -74,7 +85,11 @@ export function commandGateway(parts) {
             return registry.byPin(String(command["workflow"]))?.manifest;
         if (!pinned.includes(kind))
             return undefined;
-        const run = (await authority.state()).runs[String(command["runId"])];
+        const runId = String(command["runId"]);
+        const stored = await authority.queries.manifest(runId);
+        if (stored?.bundleDigest !== undefined)
+            return stored;
+        const run = (await authority.state()).runs[runId];
         return registry.byPin(run?.workflow ?? "")?.manifest;
     }
     async function forwarded(submission) {
@@ -109,7 +124,7 @@ export function commandGateway(parts) {
             const submission = checked(given.principal, copy);
             if (submission === undefined)
                 return invalidCommand;
-            const refused = refusal(submission, textBytes);
+            const refused = refusal(submission, await reportLimit(parts, submission));
             if (refused !== undefined)
                 return refused;
             return submission.principal === "worker"

package/dist/src/service/queue-runs.d.ts

@@ -0,0 +1,3 @@
+import type { Reply } from "../protocol.ts";
+import { type ServiceContext } from "./replies.ts";
+export declare function queueRunStatuses(context: ServiceContext, runIds: unknown): Promise<Reply>;

package/dist/src/service/queue-runs.js

@@ -0,0 +1,39 @@
+import { failed, invalidRequest, isIdentifier, result, } from "./replies.js";
+export async function queueRunStatuses(context, runIds) {
+    if (!Array.isArray(runIds) ||
+        runIds.length === 0 ||
+        runIds.length > 4 ||
+        !runIds.every(isIdentifier))
+        return invalidRequest("A queue status batch needs one to four run IDs.");
+    const state = await context.authority.state();
+    const runs = [];
+    for (const runId of runIds) {
+        const run = state.runs[runId];
+        if (run === undefined)
+            return failed("unknown-run", { detail: `No run has the ID ${runId}.` });
+        runs.push(await queuedRun(context, {
+            runId,
+            status: run.status,
+            sequence: state.sequence,
+        }));
+    }
+    return result("queue-run-statuses", { runs });
+}
+async function queuedRun(context, run) {
+    const event = await context.authority.queries.latestCompletion({
+        runId: run.runId,
+        atOrBefore: run.sequence,
+        terminal: true,
+    });
+    return {
+        runId: run.runId,
+        state: run.status,
+        terminalSequence: event?.sequence ?? null,
+        outcome: event?.type === "run.completed"
+            ? {
+                kind: event.payload["outcome"],
+                issueUpdate: event.payload["issueUpdate"],
+            }
+            : null,
+    };
+}

package/dist/src/service/registry.d.ts

@@ -1,5 +1,11 @@
+import type { CommandWaits, WorkflowStage, WorkflowStages } from "../workflow-declaration.ts";
 import type { SubmissionContract } from "../submission.ts";
 import type { ExecutionManifest } from "../workflow-admission.ts";
+import type { AvailableManifest } from "../broker/actor/delivery-intents.ts";
+export interface WorkflowBundleStore {
+    readonly directory: string;
+    readonly repository: string;
+}
 export type Resolution = {
     readonly kind: "resolved";
     readonly input: unknown;
@@ -13,28 +19,41 @@ export interface ResolutionRequest {
     readonly submission: Readonly<Record<string, unknown>>;
     readonly commandId: string;
     readonly signal: AbortSignal;
+    readonly activeTickets?: readonly Readonly<Record<string, unknown>>[];
 }
 export interface Resolver {
     readonly id: string;
     readonly version: string;
     readonly resolve: (request: ResolutionRequest) => Promise<Resolution>;
+    readonly skippedTickets?: () => readonly Readonly<Record<string, unknown>>[];
 }
 export interface WorkflowRegistration {
+    readonly queue?: boolean;
     readonly workflowId: string;
     readonly manifest: ExecutionManifest;
     readonly availability: "available" | "unavailable";
     readonly submission: SubmissionContract;
     readonly resolver: Resolver;
     readonly effectLimit?: number;
-    readonly admission?: "when-idle";
+    readonly stages?: readonly WorkflowStage[];
+    readonly handoffs?: readonly string[];
+    readonly commands?: readonly string[];
+    readonly commandWaits?: CommandWaits;
+    readonly admission?: "when-idle" | number;
 }
 export interface Registered extends WorkflowRegistration {
     readonly pin: string;
 }
 export interface Registry {
     readonly workflowIds: readonly string[];
+    readonly workflowStages: WorkflowStages;
     readonly byId: (workflowId: string) => Registered | undefined;
     readonly byPin: (pin: string) => Registered | undefined;
-    readonly available: (pinned: ExecutionManifest) => ExecutionManifest | undefined;
+    readonly bundle: (pinned: ExecutionManifest) => Promise<string | undefined>;
+    readonly available: AvailableManifest;
 }
-export declare function workflowRegistry(workflows: readonly WorkflowRegistration[]): Registry;
+export declare function workflowRegistry(workflows: readonly WorkflowRegistration[], options?: {
+    readonly retainedWorkflows?: readonly WorkflowRegistration[];
+    readonly workflowBundles?: WorkflowBundleStore;
+    readonly retainedWorkflow?: AvailableManifest;
+}): Registry;

package/dist/src/service/registry.js

@@ -1,13 +1,56 @@
 import { workflowPin } from "../broker/workflow-pin.js";
-export function workflowRegistry(workflows) {
-    const registered = workflows.map((workflow) => ({
+import { declaredManifest } from "../execution-pin.js";
+import { readRetainedWorkflowBundle } from "../../tools/workflow-bundles.js";
+function registered(workflow) {
+    const manifest = declaredManifest(workflow.manifest, workflow);
+    return {
         ...workflow,
-        pin: workflowPin(workflow.manifest),
-    }));
+        ...(manifest.handoffs === undefined ? {} : { handoffs: manifest.handoffs }),
+        manifest,
+        pin: workflowPin(manifest),
+    };
+}
+function availableVersions(workflow) {
+    if (workflow.availability !== "available")
+        return [];
+    if (workflow.manifest.bundleDigest === undefined)
+        return [workflow];
+    const manifest = { ...workflow.manifest };
+    delete manifest.bundleDigest;
+    return [workflow, { ...workflow, manifest, pin: workflowPin(manifest) }];
+}
+export function workflowRegistry(workflows, options = {}) {
+    const current = workflows.map(registered);
+    const available = [
+        ...current,
+        ...(options.retainedWorkflows ?? []).map(registered),
+    ].flatMap(availableVersions);
+    const byPin = (pin) => available.find((workflow) => workflow.pin === pin);
+    const bundle = async (pinned) => {
+        if (pinned.bundleDigest === undefined ||
+            options.workflowBundles === undefined)
+            return undefined;
+        const retained = await readRetainedWorkflowBundle({
+            ...options.workflowBundles,
+            id: pinned.bundleDigest,
+        });
+        return retained.kind === "available" ? retained.directory : undefined;
+    };
     return {
-        workflowIds: registered.map((workflow) => workflow.workflowId),
-        byId: (workflowId) => registered.find((workflow) => workflow.workflowId === workflowId),
-        byPin: (pin) => registered.find((workflow) => workflow.pin === pin),
-        available: (pinned) => registered.find((workflow) => workflow.manifest.workflowId === pinned.workflowId)?.manifest,
+        workflowIds: current.map((workflow) => workflow.workflowId),
+        workflowStages: Object.fromEntries(current.flatMap((workflow) => workflow.stages === undefined
+            ? []
+            : [[workflow.workflowId, workflow.stages]])),
+        byId: (workflowId) => current.find((workflow) => workflow.workflowId === workflowId),
+        byPin,
+        bundle,
+        available: (pinned) => {
+            const manifest = byPin(workflowPin(pinned))?.manifest;
+            if (pinned.bundleDigest === undefined)
+                return manifest;
+            return bundle(pinned).then((directory) => directory !== undefined
+                ? (manifest ?? options.retainedWorkflow?.(pinned))
+                : undefined);
+        },
     };
 }

package/dist/src/service/replies.d.ts

@@ -3,9 +3,14 @@ import type { Fields, Reply } from "../protocol.ts";
 import type { ChangeSignal } from "./changes.ts";
 import type { Gateway } from "./gateway.ts";
 import type { Registry } from "./registry.ts";
+import { type WorkflowRefusal } from "../workflow-refusals.ts";
+import type { CommandEffects } from "../command-settings.ts";
 export interface ServiceContext {
+    readonly workerHarness?: (operationId: string) => Promise<string | undefined>;
+    readonly commandEffects?: CommandEffects;
     readonly authority: Authority;
     readonly registry: Registry;
+    readonly workflowRefusals?: readonly WorkflowRefusal[];
     readonly gateway: Gateway;
     readonly clock: () => string;
     readonly livenessMilliseconds: number;
@@ -16,6 +21,11 @@ export interface ServiceContext {
     readonly worldReports?: () => readonly unknown[];
     readonly changed?: ChangeSignal["next"];
 }
+export declare function queryMetadata(options: {
+    readonly workerHarness?: ServiceContext["workerHarness"];
+    readonly commandEffects?: CommandEffects;
+    readonly workflowRefusals?: readonly WorkflowRefusal[];
+}): Pick<ServiceContext, "workerHarness" | "commandEffects" | "workflowRefusals">;
 export declare function result(kind: string, fields: Fields): Reply;
 export declare function failed(code: string, extra: Fields): Reply;
 export declare function invalidRequest(detail: string): Reply;

package/dist/src/service/replies.js

@@ -1,4 +1,16 @@
 import { isRecordKey } from "../authority/commands.js";
+import { workflowRefusals, } from "../workflow-refusals.js";
+export function queryMetadata(options) {
+    return {
+        ...(options.workerHarness === undefined
+            ? {}
+            : { workerHarness: options.workerHarness }),
+        ...(options.commandEffects === undefined
+            ? {}
+            : { commandEffects: options.commandEffects }),
+        workflowRefusals: workflowRefusals(options.workflowRefusals),
+    };
+}
 const codes = {
     "invalid-command": "invalid-request",
     "request-too-large": "input-too-large",