@k2b/cloud 0.6.0-rc.0

package/src/workflows/ai/types.ts

@@ -0,0 +1,111 @@
+import { z } from "zod";
+import type { WorkflowJsonValue } from "../contracts";
+
+const prompt = z.string().trim().min(1).max(20_000);
+const modelProfileId = z.string().trim().min(1).max(120).optional();
+const choice = z.string().trim().min(1).max(200);
+const choices = z
+  .array(choice)
+  .min(2)
+  .max(50)
+  .refine((values) => new Set(values).size === values.length, "Choices must be unique.");
+
+const structuredField = z
+  .object({
+    name: z
+      .string()
+      .trim()
+      .regex(/^[A-Za-z][A-Za-z0-9_]{0,79}$/),
+    type: z.enum(["text", "number", "boolean", "date_time", "enum"]),
+    description: z.string().trim().min(1).max(500),
+    required: z.boolean().default(true),
+    choices: z.array(choice).min(1).max(50).optional(),
+    maxLength: z.number().int().min(1).max(20_000).optional(),
+  })
+  .strict()
+  .superRefine((field, ctx) => {
+    if (field.type === "enum" && !field.choices)
+      ctx.addIssue({ code: "custom", path: ["choices"], message: "Enum fields require choices." });
+    if (field.type !== "enum" && field.choices)
+      ctx.addIssue({ code: "custom", path: ["choices"], message: "Choices are only valid for enum fields." });
+    if (field.type !== "text" && field.maxLength)
+      ctx.addIssue({ code: "custom", path: ["maxLength"], message: "maxLength is only valid for text fields." });
+  });
+
+const structuredFields = z
+  .array(structuredField)
+  .min(1)
+  .max(40)
+  .refine((fields) => new Set(fields.map((field) => field.name)).size === fields.length, "Structured field names must be unique.");
+
+export const workflowAiRequestSchema = z.discriminatedUnion("kind", [
+  z.object({
+    kind: z.literal("generate_text"),
+    prompt,
+    input: z.unknown().optional(),
+    modelProfileId,
+    maxOutputChars: z.number().int().min(1).max(20_000).default(4_000),
+  }),
+  z.object({
+    kind: z.literal("classify"),
+    prompt,
+    input: z.unknown(),
+    choices,
+    modelProfileId,
+  }),
+  z
+    .object({
+      kind: z.literal("classify_many"),
+      prompt,
+      input: z.unknown(),
+      choices,
+      minChoices: z.number().int().min(0).max(50).default(0),
+      maxChoices: z.number().int().min(0).max(50).optional(),
+      modelProfileId,
+    })
+    .superRefine((value, ctx) => {
+      const maximum = value.maxChoices ?? value.choices.length;
+      if (maximum > value.choices.length) {
+        ctx.addIssue({ code: "custom", path: ["maxChoices"], message: "maxChoices cannot exceed the number of choices." });
+      }
+      if (value.minChoices > maximum) {
+        ctx.addIssue({ code: "custom", path: ["minChoices"], message: "minChoices cannot exceed maxChoices." });
+      }
+    }),
+  z.object({
+    kind: z.literal("extract_data"),
+    prompt,
+    input: z.unknown(),
+    fields: structuredFields,
+    modelProfileId,
+  }),
+]);
+
+export type WorkflowAiRequest = z.infer<typeof workflowAiRequestSchema>;
+export type WorkflowAiRequestInput = z.input<typeof workflowAiRequestSchema>;
+export type WorkflowAiTaskStatus = "queued" | "running" | "succeeded" | "failed" | "canceled";
+
+export type WorkflowAiTask = {
+  /** Existing user in the run authorization snapshot, when this is user-owned work. */
+  usageUserId?: string;
+  id: string;
+  appId: string;
+  runId: string;
+  stepKey: string;
+  effectKey: string;
+  kind: WorkflowAiRequest["kind"];
+  request: WorkflowAiRequest;
+  inputHash: string;
+  modelProfileId: string;
+  status: WorkflowAiTaskStatus;
+  output: WorkflowJsonValue | null;
+  usage: WorkflowJsonValue | null;
+  attempts: number;
+  errorCode: string | null;
+  errorMessage: string | null;
+  cancelRequestedAt: string | null;
+  createdAt: string;
+  startedAt: string | null;
+  completedAt: string | null;
+  updatedAt: string;
+};

package/src/workflows/ai-actions.ts

@@ -0,0 +1,269 @@
+import type { AiResolvedModel } from "../ai/types";
+import type { WorkflowAiRequestInput, WorkflowAiTask } from "./ai/types";
+import type { WorkflowFieldSchema, WorkflowJsonValue } from "./contracts";
+import type { WorkflowActionContext, WorkflowActionResult, WorkflowPlannedEffect } from "./definition";
+import { workflowAction } from "./definition";
+
+const text = (description: string, optional = false, maxLength = 20_000) =>
+  ({ kind: "string", minLength: 1, maxLength, optional, description }) as const;
+const identifier = (description: string) => ({ kind: "string", format: "identifier", minLength: 1, maxLength: 120, description }) as const;
+const model = text("Optional enabled AI model profile ID.", true, 120);
+const prompt = text("Instructions for the AI task.");
+const choices = {
+  kind: "array",
+  items: text("One allowed classification value.", false, 200),
+  minItems: 2,
+  maxItems: 50,
+  description: "Allowed classification values.",
+} as const;
+const structuredFieldTypes: Array<"text" | "number" | "boolean" | "date_time" | "enum"> = [
+  "text",
+  "number",
+  "boolean",
+  "date_time",
+  "enum",
+];
+const structuredFields = {
+  kind: "array",
+  minItems: 1,
+  maxItems: 40,
+  description: "Declared fields in the returned object.",
+  items: {
+    kind: "object",
+    properties: {
+      name: identifier("Stable output field name."),
+      type: { kind: "string", enum: structuredFieldTypes, description: "Field value type." },
+      description: text("What the field means and how to extract it.", false, 500),
+      required: { kind: "boolean", optional: true, description: "Whether the field must be present. Defaults to true." },
+      choices: { kind: "array", optional: true, minItems: 1, maxItems: 50, items: text("One enum value.", false, 200) },
+      maxLength: { kind: "number", integer: true, minimum: 1, maximum: 20_000, optional: true, description: "Maximum text length." },
+    },
+  },
+} as const satisfies WorkflowFieldSchema;
+const extractDataConfig = {
+  kind: "object",
+  properties: {
+    input: { kind: "value", description: "Bounded JSON input from which fields are extracted." },
+    prompt,
+    fields: structuredFields,
+    model,
+    saveAs: identifier("Variable name for the extracted object."),
+  },
+} as const;
+
+type WorkflowAiActionDependencies = {
+  getByEffectKey(effectKey: string): Promise<WorkflowAiTask | null>;
+  create(input: {
+    runId: string;
+    stepKey: string;
+    effectKey: string;
+    request: WorkflowAiRequestInput;
+    modelProfileId: string;
+  }): Promise<{ task: WorkflowAiTask; created: boolean }>;
+  exists(effectKey: string): Promise<boolean>;
+  resolveModel(requestedModelId?: string): Promise<AiResolvedModel>;
+  submit(taskId: string): Promise<void>;
+};
+
+const dependencies = async (): Promise<WorkflowAiActionDependencies> => {
+  const [{ resolveAiWorkflowModel }, store, runtime] = await Promise.all([
+    import("../ai/structured"),
+    import("./ai/store"),
+    import("./ai/runtime"),
+  ]);
+  return {
+    getByEffectKey: store.getWorkflowAiTaskByEffectKey,
+    create: store.createWorkflowAiTask,
+    exists: store.workflowAiTaskExists,
+    resolveModel: resolveAiWorkflowModel,
+    submit: runtime.submitWorkflowAiTask,
+  };
+};
+
+const failureCode = (error: unknown): string => {
+  const code =
+    (error as { aiError?: { code?: unknown }; code?: unknown } | null)?.aiError?.code ?? (error as { code?: unknown } | null)?.code;
+  return typeof code === "string" ? `WORKFLOW_AI_${code.toUpperCase()}` : "WORKFLOW_AI_UNAVAILABLE";
+};
+
+const taskResult = (task: WorkflowAiTask): WorkflowActionResult<WorkflowJsonValue> | null => {
+  if (task.status === "succeeded") return { state: "succeeded", output: task.output };
+  if (task.status === "failed") {
+    return {
+      state: "failed",
+      code: task.errorCode ?? "WORKFLOW_AI_FAILED",
+      message: task.errorMessage ?? "Workflow AI task failed.",
+    };
+  }
+  if (task.status === "canceled") {
+    return { state: "failed", code: "WORKFLOW_AI_CANCELED", message: "Workflow AI task was canceled." };
+  }
+  return null;
+};
+
+export const runWorkflowAiAction = async (
+  ctx: Pick<WorkflowActionContext, "runId" | "stepKey" | "effectKey">,
+  request: WorkflowAiRequestInput,
+  injected?: WorkflowAiActionDependencies,
+): Promise<WorkflowActionResult<WorkflowJsonValue>> => {
+  const deps = injected ?? (await dependencies());
+  try {
+    let task = await deps.getByEffectKey(ctx.effectKey);
+    const terminal = task ? taskResult(task) : null;
+    if (terminal) return terminal;
+
+    if (!task) {
+      const resolved = await deps.resolveModel(request.modelProfileId?.trim() || undefined);
+      task = (
+        await deps.create({
+          runId: ctx.runId,
+          stepKey: ctx.stepKey,
+          effectKey: ctx.effectKey,
+          request,
+          modelProfileId: resolved.profile.id,
+        })
+      ).task;
+      const racedTerminal = taskResult(task);
+      if (racedTerminal) return racedTerminal;
+    }
+
+    await deps.submit(task.id);
+    return { state: "waiting", dependency: { kind: "ai.workflow-task", key: task.id } };
+  } catch (error) {
+    return {
+      state: "failed",
+      code: failureCode(error),
+      message: error instanceof Error ? error.message : "Workflow AI task is unavailable.",
+      retryable: failureCode(error) === "WORKFLOW_AI_UNAVAILABLE",
+    };
+  }
+};
+
+export const planWorkflowAiAction = async (
+  ctx: Pick<WorkflowActionContext, "effectKey">,
+  summary: string,
+  injected?: Pick<WorkflowAiActionDependencies, "exists">,
+): Promise<WorkflowPlannedEffect> => {
+  const deps = injected ?? (await dependencies());
+  const exists = await deps.exists(ctx.effectKey);
+  return {
+    summary,
+    ...(exists ? {} : { consumes: { maxAiCalls: 1 } }),
+    issues: ["AI output is not available during a dry run."],
+  };
+};
+
+export const AI_WORKFLOW_ACTIONS = {
+  aiExtractData: workflowAction.idempotent<typeof extractDataConfig, WorkflowJsonValue>({
+    label: "AI extract structured data",
+    description: "Extracts one bounded, validated object from supplied input.",
+    outputType: "core.value",
+    config: extractDataConfig,
+    plan: (ctx) => planWorkflowAiAction(ctx, "Extract structured data with AI."),
+    run: (ctx, values) =>
+      runWorkflowAiAction(ctx, {
+        kind: "extract_data",
+        input: values.input,
+        prompt: values.prompt,
+        fields: values.fields,
+        ...(values.model ? { modelProfileId: values.model } : {}),
+      }),
+  }),
+  aiGenerateText: workflowAction.idempotent({
+    label: "AI generate text",
+    description: "Generates one bounded text value without performing a domain action.",
+    outputType: "core.text",
+    config: {
+      kind: "object",
+      properties: {
+        prompt,
+        input: { kind: "value", optional: true, description: "Optional JSON input supplied separately from the prompt." },
+        model,
+        maxOutputChars: {
+          kind: "number",
+          integer: true,
+          minimum: 1,
+          maximum: 20_000,
+          optional: true,
+          description: "Maximum generated text length. Defaults to 4000 characters.",
+        },
+        saveAs: identifier("Variable name for the generated text."),
+      },
+    },
+    plan: (ctx) => planWorkflowAiAction(ctx, "Generate text with AI."),
+    run: (ctx, values) =>
+      runWorkflowAiAction(ctx, {
+        kind: "generate_text",
+        prompt: values.prompt,
+        ...(values.input === undefined ? {} : { input: values.input }),
+        ...(values.model ? { modelProfileId: values.model } : {}),
+        ...(values.maxOutputChars === undefined ? {} : { maxOutputChars: values.maxOutputChars }),
+      }),
+  }),
+  aiClassify: workflowAction.idempotent({
+    label: "AI classify",
+    description: "Returns exactly one value from the declared choices.",
+    outputType: "core.text",
+    config: {
+      kind: "object",
+      properties: {
+        input: { kind: "value", description: "Bounded JSON value to classify." },
+        prompt,
+        choices,
+        model,
+        saveAs: identifier("Variable name for the selected choice."),
+      },
+    },
+    plan: (ctx) => planWorkflowAiAction(ctx, "Classify one value with AI."),
+    run: (ctx, values) =>
+      runWorkflowAiAction(ctx, {
+        kind: "classify",
+        input: values.input,
+        prompt: values.prompt,
+        choices: values.choices,
+        ...(values.model ? { modelProfileId: values.model } : {}),
+      }),
+  }),
+  aiClassifyMany: workflowAction.idempotent({
+    label: "AI classify many",
+    description: "Returns a unique subset of the declared choices in their declared order.",
+    outputType: "core.textArray",
+    config: {
+      kind: "object",
+      properties: {
+        input: { kind: "value", description: "Bounded JSON value to classify." },
+        prompt,
+        choices,
+        minChoices: {
+          kind: "number",
+          integer: true,
+          minimum: 0,
+          maximum: 50,
+          optional: true,
+          description: "Minimum number of choices. Defaults to zero.",
+        },
+        maxChoices: {
+          kind: "number",
+          integer: true,
+          minimum: 0,
+          maximum: 50,
+          optional: true,
+          description: "Maximum number of choices. Defaults to all declared choices.",
+        },
+        model,
+        saveAs: identifier("Variable name for the selected choices."),
+      },
+    },
+    plan: (ctx) => planWorkflowAiAction(ctx, "Classify multiple values with AI."),
+    run: (ctx, values) =>
+      runWorkflowAiAction(ctx, {
+        kind: "classify_many",
+        input: values.input,
+        prompt: values.prompt,
+        choices: values.choices,
+        ...(values.minChoices === undefined ? {} : { minChoices: values.minChoices }),
+        ...(values.maxChoices === undefined ? {} : { maxChoices: values.maxChoices }),
+        ...(values.model ? { modelProfileId: values.model } : {}),
+      }),
+  }),
+} as const;

package/src/workflows/authoring.ts

@@ -0,0 +1,88 @@
+import type { DefinedWorkflowModule } from "./module";
+
+export type WorkflowCompletionKind = "keyword" | "source" | "field" | "literal";
+
+export type WorkflowCompletionItem = {
+  label: string;
+  kind: WorkflowCompletionKind;
+  detail?: string;
+  insertText: string;
+  textEdit: { start: number; end: number; text: string };
+  commitCharacters?: string[];
+};
+
+export type WorkflowCompletionContext = {
+  caret: number;
+  line: string;
+  key: string | undefined;
+  range: { start: number; end: number };
+};
+
+export const workflowCompletionContext = (source: string, caret: number): WorkflowCompletionContext => {
+  const clampedCaret = Math.min(Math.max(caret, 0), source.length);
+  const lineStart = source.lastIndexOf("\n", Math.max(0, clampedCaret - 1)) + 1;
+  const lineEnd = source.indexOf("\n", clampedCaret);
+  const end = lineEnd === -1 ? source.length : lineEnd;
+  const line = source.slice(lineStart, clampedCaret);
+  const colon = line.indexOf(":");
+  const range =
+    colon >= 0
+      ? {
+          start: lineStart + colon + 1 + (line.slice(colon + 1).match(/^\s*/)?.[0].length ?? 0),
+          end,
+        }
+      : {
+          start: clampedCaret - (/[A-Za-z0-9_-]*$/.exec(line)?.[0].length ?? 0),
+          end: clampedCaret,
+        };
+  return {
+    caret: clampedCaret,
+    line,
+    key: /^\s*(?:-\s*)?([A-Za-z][A-Za-z0-9]*)\s*:/.exec(line)?.[1],
+    range,
+  };
+};
+
+export const workflowCompletionItem = (
+  context: Pick<WorkflowCompletionContext, "range">,
+  kind: WorkflowCompletionKind,
+  label: string,
+  insertText: string,
+  detail?: string,
+): WorkflowCompletionItem => ({
+  label,
+  kind,
+  insertText,
+  textEdit: { ...context.range, text: insertText },
+  ...(detail ? { detail } : {}),
+});
+
+export const buildWorkflowManifestCompletions = (
+  source: string,
+  caret: number,
+  workflows: DefinedWorkflowModule,
+): WorkflowCompletionItem[] => {
+  const manifest = workflows.manifest;
+  const context = workflowCompletionContext(source, caret);
+  if (context.key === "type") {
+    return manifest.inputs.map((input) => workflowCompletionItem(context, "literal", input.kind, input.kind, input.description));
+  }
+  if (/^\s*-\s*[A-Za-z0-9_]*$/.test(context.line)) {
+    return manifest.actions.map((action) =>
+      workflowCompletionItem(context, "keyword", action.kind, `${action.kind}:\n    `, action.description),
+    );
+  }
+  const lineStart = context.caret - context.line.length;
+  const prefix = source.slice(0, lineStart);
+  const triggerBlock = source.slice(prefix.lastIndexOf("triggers:"), lineStart).replace("triggers:", "");
+  if (/^triggers:\s*$/m.test(prefix) && !/^\S/m.test(triggerBlock)) {
+    return manifest.triggers.map((trigger) =>
+      workflowCompletionItem(context, "keyword", trigger.kind, trigger.snippet ?? `${trigger.kind}:\n  `, trigger.description),
+    );
+  }
+  return [
+    workflowCompletionItem(context, "keyword", "inputs", "inputs:\n  ", "Declare typed inputs"),
+    workflowCompletionItem(context, "keyword", "triggers", "triggers:\n  ", "Declare automatic triggers"),
+    workflowCompletionItem(context, "keyword", "steps", "steps:\n  - ", "Declare workflow steps"),
+  ];
+};

package/src/workflows/builtins.ts

@@ -0,0 +1,193 @@
+import type {
+  WorkflowActionDescriptor,
+  WorkflowExecutionError,
+  WorkflowFieldSchema,
+  WorkflowJsonValue,
+  WorkflowPlanningOutcome,
+  WorkflowStepOutcome,
+} from "./contracts";
+import { workflowMessageExpressions } from "./language/expressions";
+import type {
+  WorkflowActionStep,
+  WorkflowDryRunActionContext,
+  WorkflowDryRunActionPort,
+  WorkflowExecuteActionContext,
+  WorkflowExecuteActionPort,
+} from "./runtime/ports";
+
+const identifier = (description: string): WorkflowFieldSchema => ({
+  kind: "string",
+  format: "identifier",
+  maxLength: 120,
+  description,
+});
+
+const text = (description: string): WorkflowFieldSchema => ({
+  kind: "string",
+  minLength: 1,
+  maxLength: 1_000,
+  description,
+});
+
+const object = (properties: Record<string, WorkflowFieldSchema>): WorkflowFieldSchema & { kind: "object" } => ({
+  kind: "object",
+  properties,
+});
+
+export const workflowBuiltinActionDescriptors = [
+  {
+    kind: "setVariable",
+    label: "Set variable",
+    description: "Stores a value for later steps in the current scope.",
+    effect: "pure",
+    dryRun: "full",
+    outputType: "core.value",
+    config: object({ name: identifier("Variable name."), value: { kind: "value", description: "Value to store." } }),
+  },
+  {
+    kind: "succeed",
+    label: "Succeed workflow",
+    description: "Stops the workflow successfully with an operator-facing message.",
+    effect: "pure",
+    dryRun: "full",
+    config: object({ message: text("Operator-facing success message.") }),
+  },
+  {
+    kind: "fail",
+    label: "Fail workflow",
+    description: "Stops the workflow with an operator-facing error message.",
+    effect: "pure",
+    dryRun: "full",
+    config: object({ message: text("Operator-facing failure message.") }),
+  },
+] satisfies WorkflowActionDescriptor[];
+
+type WorkflowBuiltinActionContext = WorkflowExecuteActionContext | WorkflowDryRunActionContext;
+
+export type WorkflowBuiltinActionAuthorize = (
+  context: WorkflowBuiltinActionContext,
+  step: WorkflowActionStep,
+) => Promise<WorkflowExecutionError | undefined>;
+
+export type WorkflowBuiltinActionPorts = {
+  execute: WorkflowExecuteActionPort;
+  dryRun: WorkflowDryRunActionPort;
+};
+
+export type WorkflowBuiltinTextRenderer = (params: {
+  context: WorkflowBuiltinActionContext;
+  step: WorkflowActionStep;
+  field: string;
+  value: string;
+  label: string;
+}) => Promise<string> | string;
+
+const actionPath = (step: WorkflowActionStep): Array<string | number> => [...step.sourcePath, step.action];
+
+const requiredString = (value: WorkflowJsonValue | undefined, label: string): string => {
+  if (typeof value !== "string" || value.length === 0) throw new TypeError(`${label} must be non-empty text`);
+  return value;
+};
+
+const requiredValue = (value: WorkflowJsonValue | undefined, label: string): WorkflowJsonValue => {
+  if (value === undefined) throw new TypeError(`${label} is required`);
+  return value;
+};
+
+export const renderWorkflowTextTemplate = async (params: {
+  context: WorkflowExecuteActionContext | WorkflowDryRunActionContext;
+  step: WorkflowActionStep;
+  field: string;
+  value: WorkflowJsonValue | undefined;
+  label: string;
+}): Promise<string> => {
+  const message = requiredString(params.value, params.label);
+  let rendered = "";
+  let offset = 0;
+  for (const [index, expression] of workflowMessageExpressions(message).entries()) {
+    rendered += message.slice(offset, expression.index);
+    if (!expression.expression) throw new TypeError(`${params.label} contains an invalid expression`);
+    const path = [...actionPath(params.step), params.field, "expression", index];
+    const value =
+      expression.expression.kind === "now"
+        ? await params.context.evaluate("${{ now() }}", path)
+        : await params.context.resolveReference(expression.expression.reference, path);
+    rendered += value === undefined || value === null ? "" : typeof value === "string" ? value : JSON.stringify(value);
+    offset = expression.index + expression.raw.length;
+  }
+  return `${rendered}${message.slice(offset)}`;
+};
+
+export const createWorkflowBuiltinActionPorts = (options: {
+  authorize: WorkflowBuiltinActionAuthorize;
+  renderText?: WorkflowBuiltinTextRenderer;
+}): WorkflowBuiltinActionPorts => {
+  const authorize = async (context: WorkflowBuiltinActionContext, step: WorkflowActionStep): Promise<WorkflowExecutionError | undefined> =>
+    options.authorize(context, step);
+
+  const execute = async (context: WorkflowExecuteActionContext, step: WorkflowActionStep): Promise<WorkflowStepOutcome> => {
+    const authorizationError = await authorize(context, step);
+    if (authorizationError) return { state: "failed", error: authorizationError };
+    if (step.action === "setVariable") {
+      const name = requiredString(step.config.name, "setVariable.name");
+      const output = await context.evaluate(requiredValue(step.config.value, "setVariable.value"), [...actionPath(step), "value"]);
+      context.variables.set(name, output);
+      return { state: "completed", output };
+    }
+    const label = `${step.action}.message`;
+    const value = requiredString(step.config.message, label);
+    const message = options.renderText
+      ? await options.renderText({ context, step, field: "message", value, label })
+      : await renderWorkflowTextTemplate({ context, step, field: "message", value, label });
+    return step.action === "succeed"
+      ? { state: "terminal", status: "succeeded", message }
+      : { state: "failed", error: { code: "WORKFLOW_FAILED", message, retryable: false } };
+  };
+
+  const plan = async (context: WorkflowDryRunActionContext, step: WorkflowActionStep): Promise<WorkflowPlanningOutcome> => {
+    const authorizationError = await authorize(context, step);
+    if (authorizationError) return { state: "indeterminate", reason: authorizationError.message };
+    if (step.action === "setVariable") {
+      const name = requiredString(step.config.name, "setVariable.name");
+      const output = await context.evaluate(requiredValue(step.config.value, "setVariable.value"), [...actionPath(step), "value"]);
+      context.variables.set(name, output);
+      return { state: "planned", output, effects: [] };
+    }
+    return {
+      state: "terminal",
+      status: step.action === "succeed" ? "succeeded" : "failed",
+      message: options.renderText
+        ? await options.renderText({
+            context,
+            step,
+            field: "message",
+            value: requiredString(step.config.message, `${step.action}.message`),
+            label: `${step.action}.message`,
+          })
+        : await renderWorkflowTextTemplate({
+            context,
+            step,
+            field: "message",
+            value: step.config.message,
+            label: `${step.action}.message`,
+          }),
+      effects: [],
+    };
+  };
+
+  const restoreCompleted = (
+    context: WorkflowBuiltinActionContext,
+    step: WorkflowActionStep,
+    outcome: { output?: WorkflowJsonValue },
+  ): void => {
+    if (step.action === "setVariable" && typeof step.config.name === "string" && outcome.output !== undefined) {
+      context.variables.set(step.config.name, outcome.output);
+    }
+  };
+
+  const actions = new Set(workflowBuiltinActionDescriptors.map(({ kind }) => kind));
+  return {
+    execute: { get: (action) => (actions.has(action) ? { execute, restoreCompleted } : undefined) },
+    dryRun: { get: (action) => (actions.has(action) ? { plan, restoreCompleted } : undefined) },
+  };
+};