Add full field support to tryTask form generation

.changeset/tryTask-form.md

@@ -0,0 +1,5 @@
+---
+"@openworkflowspec/diagram-editor": minor
+---
+
+Add full field support to tryTask form generation.

packages/open-workflow-diagram-editor/playwright.config.ts

@@ -18,6 +18,7 @@ import { defineConfig } from "@playwright/test";
 
 export default defineConfig({
   testDir: "tests-e2e",
+  timeout: 60000,
 
   expect: {
     timeout: 30000,

packages/open-workflow-diagram-editor/src/core/schemaToFormFields.ts

@@ -17,6 +17,7 @@
 import type { DereferencedSchema } from "./schemaFilter";
 import { isPlainObject } from "./utils";
 import type { ContentFormat } from "./workflowSdk";
+export type { ContentFormat } from "./workflowSdk";
 
 /**
  * A single form field descriptor produced by walking a task's JSON Schema.
@@ -88,6 +89,8 @@ export interface EnumField extends FieldBase {
   options: string[];
   /** Schema default = what the runtime assumes when the key is absent */
   defaultValue?: string;
+  valueMap?: Record<string, unknown>;
+  innerObjectFormat?: ContentFormat;
 }
 
 /**
@@ -285,6 +288,53 @@ function isMapSchema(schema: Record<string, unknown>): boolean {
   return false;
 }
 
+/**
+ * Returns the ordered variant keys if every oneOf candidate has exactly one
+ * property whose value schema is an empty-object marker.
+ */
+function isBackoffSchema(
+  schema: Record<string, unknown>,
+  defs: Record<string, unknown> | undefined,
+): string[] | undefined {
+  if (!Array.isArray(schema.oneOf) || schema.properties) return undefined;
+  const candidates = schema.oneOf as unknown[];
+  if (candidates.length < 2) return undefined;
+
+  const keys: string[] = [];
+  for (const candidate of candidates) {
+    if (!isPlainObject(candidate)) return undefined;
+    const c = candidate as Record<string, unknown>;
+
+    const props = c.properties as Record<string, unknown> | undefined;
+    if (!props || !isPlainObject(props)) return undefined;
+    const propKeys = Object.keys(props);
+    if (propKeys.length !== 1) return undefined;
+    const key = propKeys[0]!;
+
+    let valueProp = props[key] as unknown;
+    if (
+      isPlainObject(valueProp) &&
+      typeof (valueProp as Record<string, unknown>).$ref === "string"
+    ) {
+      const ref = resolveRef((valueProp as Record<string, unknown>).$ref as string, defs);
+      if (ref) valueProp = ref;
+    }
+    if (!isPlainObject(valueProp)) return undefined;
+    const valueObj = valueProp as Record<string, unknown>;
+    // Reject if the value schema has any structural constraints.
+    const hasStructure =
+      valueObj.properties !== undefined ||
+      valueObj.oneOf !== undefined ||
+      valueObj.anyOf !== undefined ||
+      valueObj.allOf !== undefined ||
+      (valueObj.additionalProperties !== undefined && valueObj.additionalProperties !== false);
+    if (hasStructure) return undefined;
+
+    keys.push(key);
+  }
+  return keys;
+}
+
 /**
  * Returns the items schema for an array, following one $ref if present.
  * Used by both task lists and ordered maps to get the array's item structure.
@@ -616,6 +666,28 @@ export function schemaToFormFields(
       }
     }
 
+    // ── Backoff type selector ───────────────────────────────────────────────
+    // Emits an EnumField with valueMap so EnumControl and sets innerObjectFormat
+    // so EnumControl renders a textarea for the inner object payload beneath the combobox.
+    const backoffOptions = isBackoffSchema(resolved, localDefs);
+    if (backoffOptions) {
+      const valueMap: Record<string, unknown> = {};
+      for (const opt of backoffOptions) {
+        valueMap[opt] = { [opt]: {} };
+      }
+      fields.push({
+        kind: "enum",
+        path: fieldPath,
+        label: deriveLabel(prop, key),
+        ...withDesc(description),
+        required: isRequired,
+        options: backoffOptions,
+        valueMap,
+        innerObjectFormat: format,
+      });
+      continue;
+    }
+
     // ── oneOf / anyOf at property level ────────────────────────────────────
     const candidates = (resolved.oneOf ?? resolved.anyOf) as unknown[] | undefined;
     if (Array.isArray(candidates)) {

packages/open-workflow-diagram-editor/src/i18n/locales/en.ts

@@ -69,6 +69,7 @@ export const en = {
   "sidebar.form.applied": "Applied",
   "sidebar.form.selectOption": "Select an option…",
   "sidebar.form.default": "(default)",
+  "sidebar.form.innerObject.parseError": "Must be a valid YAML/JSON object",
   "aria.form.taskProperties": "Task properties",
   "sidebar.map.addProperty": "+ Add property",
   "sidebar.map.keyPlaceholder": "key",

packages/open-workflow-diagram-editor/src/react-flow/hooks/useWorkflowHistory.ts

@@ -125,7 +125,9 @@ export function useWorkflowHistory(isReadOnly: boolean): UseWorkflowHistoryRetur
       }
 
       // No-op if model content is unchanged.
-      if (structuralEqual(present.model, newModel)) return;
+      if (structuralEqual(present.model, newModel)) {
+        return;
+      }
 
       // Content changed externally (e.g. props.content updated by host or addon panel).
       // Preserve the current viewport so undo restores to where the user was looking,
@@ -203,16 +205,12 @@ export function useWorkflowHistory(isReadOnly: boolean): UseWorkflowHistoryRetur
     setPendingViewportRestore(null);
   }, []);
 
-  const resetHistory = React.useCallback(() => {
-    reset();
-  }, [reset]);
-
   return {
     model: getPresent(state)?.model ?? null,
     selectedNodeId: getPresent(state)?.selectedNodeId ?? null,
     seedModel,
     submitModel,
-    resetHistory,
+    resetHistory: reset,
     undo,
     redo,
     canUndo,

packages/open-workflow-diagram-editor/src/side-panel/EditFormFooter.tsx

@@ -16,14 +16,15 @@
 
 import * as React from "react";
 import type * as RF from "@xyflow/react";
+import { GraphNodeType } from "@openworkflowspec/sdk";
 import type { BaseNodeData } from "@/react-flow/nodes/Nodes";
 import { useI18n } from "@openworkflowspec/i18n";
 import { SidebarFooter } from "@/components/ui/sidebar";
 import { Button } from "@/components/ui/button";
 import { useFormState } from "react-hook-form";
 import { updateTask } from "@/core/workflowEditing";
 import { applyDirtyValues } from "@/core/taskDraft";
-import { flattenTask, padRemovedPaths } from "@/side-panel/forms/TaskForm";
+import { flattenTask, padRemovedPaths, setNestedPath } from "@/side-panel/forms/TaskForm";
 import {
   computeSentinelDefaults,
   SENTINEL_KEY,
@@ -32,11 +33,17 @@ import {
 } from "@/side-panel/forms/FormField";
 import { getFormFieldsForNodeType } from "@/core";
 import type { FormFieldDescriptor, OneOfField, OneOfVariant } from "@/core/schemaToFormFields";
+import { getInnerObjectForPath } from "@/side-panel/forms/customFields/EnumControl";
 import { useDiagramEditorContext } from "@/store/DiagramEditorContext";
 import { useEditSession } from "./EditSession";
 import { Check } from "lucide-react";
 import type { Specification } from "@openworkflowspec/sdk";
-import { collectFormListPaths, collectWholeValuePaths } from "./forms/taskFormContext";
+import {
+  collectFormListPaths,
+  collectValueMapFields,
+  collectWholeValuePaths,
+  getNestedValue,
+} from "./forms/taskFormContext";
 
 /* How long the applied message stays in footer */
 const APPLIED_MESSAGE_MS = 2400;
@@ -137,6 +144,21 @@ function DraftStatus({ changedCount, isDirty, showApplied }: DraftStatusProps) {
   );
 }
 
+/**
+ * Returns the task id used to locate and update the task in the workflow model.
+ */
+function resolveTaskId(node: RF.Node<BaseNodeData>): string {
+  if (
+    (node.type === GraphNodeType.Try ||
+      node.type === GraphNodeType.Catch ||
+      node.type === "catch-container") &&
+    node.parentId !== undefined
+  ) {
+    return node.parentId;
+  }
+  return node.id;
+}
+
 export function EditFormFooter({ node }: { node: RF.Node<BaseNodeData> }) {
   const { t } = useI18n();
   const { form } = useEditSession();
@@ -156,10 +178,11 @@ export function EditFormFooter({ node }: { node: RF.Node<BaseNodeData> }) {
 
   const { dirtyFields, isDirty, defaultValues } = useFormState({ control: form.control });
   const task = node.data.task;
+  const taskId = resolveTaskId(node);
   const showApplied = appliedNodeId === node.id;
 
   // Guard conditions that permanently prevent display
-  if (isReadOnly || task === undefined || node.data.taskReference === undefined || model === null) {
+  if (isReadOnly || task === undefined || model === null) {
     return null;
   }
 
@@ -203,6 +226,31 @@ export function EditFormFooter({ node }: { node: RF.Node<BaseNodeData> }) {
     // that are exclusive to the non-selected variants so they can be removed.
     const nodeType = node.type ?? "";
     const allFields = nodeType ? getFormFieldsForNodeType(nodeType) : [];
+    const flatTask = flattenTask(task as Record<string, unknown>);
+    for (const enumField of collectValueMapFields(allFields)) {
+      // Read via getValues(path) — reads _formValues directly, bypassing the
+      // defaultValues fallback that getValues() (no args) applies for absent keys.
+      const live = form.getValues(enumField.path as never) as unknown;
+      const raw =
+        typeof live === "string" || live === undefined ? live : flatValues[enumField.path];
+      if (typeof raw === "string") {
+        const key = raw;
+        if (key && enumField.innerObjectFormat !== undefined) {
+          // Read the inner object content from the module-level store populated by EnumControl.
+          const innerObj = getInnerObjectForPath(enumField.path, enumField.innerObjectFormat);
+          // Keep the draft and inline parse error intact; do not partially commit the form.
+          if (innerObj === null) return;
+          flatValues[enumField.path] = { [key]: innerObj };
+        } else {
+          flatValues[enumField.path] = key ? enumField.valueMap![key] : undefined;
+        }
+        flatDirty.add(enumField.path);
+      } else if (raw === undefined && flatTask[enumField.path] !== undefined) {
+        flatValues[enumField.path] = undefined;
+        flatDirty.add(enumField.path);
+      }
+    }
+
     const selectedVariants = collectSelectedVariants(allFields, flatValues);
     const liveSentinelPaths = new Set([...sentinelPaths].filter((p) => selectedVariants.has(p)));
     const sentinelConstWrites = new Map<string, Record<string, unknown>>();
@@ -240,7 +288,7 @@ export function EditFormFooter({ node }: { node: RF.Node<BaseNodeData> }) {
       collectFormListPaths(allFields),
       sentinelPresenceKeys,
     ) as Specification.Task;
-    const updatedModel = updateTask(model, node.id, updated);
+    const updatedModel = updateTask(model, taskId, updated);
     commitWorkflow(updatedModel);
     // Reset to committed state; pass current sentinel labels so variant
     // selections are preserved even when the cleared field has no data match.
@@ -259,16 +307,21 @@ export function EditFormFooter({ node }: { node: RF.Node<BaseNodeData> }) {
       updated as Record<string, unknown>,
       currentSentinels,
     );
-    const resetVals: Record<string, unknown> = {
+    const resetVals: Record<string, unknown> = structuredClone({
       ...(updated as Record<string, unknown>),
       ...(Object.keys(sentinelDefaults).length > 0 ? { [SENTINEL_KEY]: sentinelDefaults } : {}),
-    };
+    });
     padRemovedPaths(
       resetVals,
       task as Record<string, unknown>,
       updated as Record<string, unknown>,
       collectWholeValuePaths(allFields, updated as Record<string, unknown>),
     );
+    for (const enumField of collectValueMapFields(allFields)) {
+      if (getNestedValue(updated as Record<string, unknown>, enumField.path) === undefined) {
+        setNestedPath(resetVals, enumField.path, "");
+      }
+    }
     form.reset(resetVals);
     setAppliedNodeId(node.id);
 

packages/open-workflow-diagram-editor/src/side-panel/forms/TaskForm.tsx

@@ -22,7 +22,13 @@ import { getFormFieldsForNodeType, structuralEqual } from "@/core";
 import { FormField, SENTINEL_KEY, SENTINEL_PREFIX, computeSentinelDefaults } from "./FormField";
 import { useSiblingTaskNames } from "./useSiblingTaskNames";
 import { useDiagramEditorContext } from "@/store/DiagramEditorContext";
-import { TaskFormContext, collectWholeValuePaths, filterReadOnlyFields } from "./taskFormContext";
+import {
+  TaskFormContext,
+  collectWholeValuePaths,
+  filterReadOnlyFields,
+  getNestedValue,
+  collectValueMapFields,
+} from "./taskFormContext";
 import { useWorkflowErrorsForForm } from "./validation";
 import { useEditSession } from "@/side-panel/EditSession";
 
@@ -52,7 +58,15 @@ export function flattenTask(
       if (Array.isArray(v) || wholeValuePaths.has(fullKey)) {
         result[fullKey] = v;
       } else if (typeof v === "object" && v !== null) {
-        result = { ...result, ...flattenTask(v, fullKey, wholeValuePaths) };
+        const nested = flattenTask(v, fullKey, wholeValuePaths);
+        // If recursing into the object produced no entries but the object itself
+        // is non-empty, keep it as a leaf so it is not silently discarded.
+        // Truly empty objects ({}) are dropped as before.
+        if (Object.keys(nested).length === 0 && Object.keys(v as object).length > 0) {
+          result[fullKey] = v;
+        } else {
+          result = { ...result, ...nested };
+        }
       } else {
         result[fullKey] = v;
       }
@@ -62,7 +76,7 @@ export function flattenTask(
   return prefix ? { [prefix]: value } : {};
 }
 
-function setNestedPath(obj: Record<string, unknown>, dotPath: string, value: unknown): void {
+export function setNestedPath(obj: Record<string, unknown>, dotPath: string, value: unknown): void {
   const parts = dotPath.split(".");
   if (
     parts.some((part) => part === "__proto__" || part === "prototype" || part === "constructor")
@@ -187,16 +201,21 @@ export function TaskForm({ nodeType, task, nodeId, taskReference }: TaskFormProp
       liveSentinels,
     );
     const taskClone = structuredClone(task as Record<string, unknown>);
-    const resetVals: Record<string, unknown> = {
+    const resetVals: Record<string, unknown> = structuredClone({
       ...taskClone,
       ...(Object.keys(sentinelDefaults).length > 0 ? { [SENTINEL_KEY]: sentinelDefaults } : {}),
-    };
+    });
     padRemovedPaths(
       resetVals,
       prevTask as Record<string, unknown>,
       taskClone,
       collectWholeValuePaths(allFields, taskClone),
     );
+    for (const enumField of collectValueMapFields(allFields)) {
+      if (getNestedValue(task as Record<string, unknown>, enumField.path) === undefined) {
+        setNestedPath(resetVals, enumField.path, "");
+      }
+    }
     form.reset(resetVals);
   }, [task, nodeId, form, allFields]);