newo 3.7.0 → 3.7.2

package/src/api.ts

@@ -23,8 +23,11 @@ import type {
   CreateSkillResponse,
   CreateFlowEventRequest,
   CreateFlowEventResponse,
+  UpdateFlowEventRequest,
   CreateFlowStateRequest,
   CreateFlowStateResponse,
+  UpdateFlowStateRequest,
+  UpdateFlowRequest,
   CreateSkillParameterRequest,
   CreateSkillParameterResponse,
   CreateCustomerAttributeRequest,
@@ -151,6 +154,30 @@ export async function listFlowSkills(client: AxiosInstance, flowId: string): Pro
   return response.data;
 }
 
+/**
+ * Fetch a single flow's top-level descriptor.
+ *
+ * Used by push to detect whether local metadata.yaml title/description
+ * differ from the platform before patching.
+ */
+export interface FlowDescriptor {
+  id: string;
+  idn: string;
+  title: string;
+  description: string | null;
+  agent_id: string;
+  default_runner_type: string;
+  default_model: { provider_idn: string; model_idn: string };
+  publication_datetime?: string;
+  last_change_datetime?: string;
+  creation_datetime?: string;
+}
+
+export async function getFlow(client: AxiosInstance, flowId: string): Promise<FlowDescriptor> {
+  const response = await client.get<FlowDescriptor>(`/api/v1/designer/flows/${flowId}`);
+  return response.data;
+}
+
 export async function getSkill(client: AxiosInstance, skillId: string): Promise<Skill> {
   const response = await client.get<Skill>(`/api/v1/designer/skills/${skillId}`);
   return response.data;
@@ -345,6 +372,14 @@ export async function createFlowEvent(client: AxiosInstance, flowId: string, eve
   return response.data;
 }
 
+export async function updateFlowEvent(
+  client: AxiosInstance,
+  eventId: string,
+  eventData: UpdateFlowEventRequest
+): Promise<void> {
+  await client.patch(`/api/v1/designer/flows/events/${eventId}`, eventData);
+}
+
 export async function deleteFlowEvent(client: AxiosInstance, eventId: string): Promise<void> {
   await client.delete(`/api/v1/designer/flows/events/${eventId}`);
 }
@@ -354,6 +389,32 @@ export async function createFlowState(client: AxiosInstance, flowId: string, sta
   return response.data;
 }
 
+export async function updateFlowState(
+  client: AxiosInstance,
+  stateId: string,
+  stateData: UpdateFlowStateRequest
+): Promise<void> {
+  await client.put(`/api/v1/designer/flows/states/${stateId}`, stateData);
+}
+
+export async function deleteFlowState(client: AxiosInstance, stateId: string): Promise<void> {
+  await client.delete(`/api/v1/designer/flows/states/${stateId}`);
+}
+
+/**
+ * Update flow metadata (title, description, runner type, default model).
+ *
+ * Uses PATCH /api/v1/designer/flows/{flowId}. The platform requires the
+ * full flow descriptor; sending a partial body returns 500.
+ */
+export async function updateFlow(
+  client: AxiosInstance,
+  flowId: string,
+  flowData: UpdateFlowRequest
+): Promise<void> {
+  await client.patch(`/api/v1/designer/flows/${flowId}`, flowData);
+}
+
 export async function createSkillParameter(client: AxiosInstance, skillId: string, paramData: CreateSkillParameterRequest): Promise<CreateSkillParameterResponse> {
   // Debug the parameter creation request
   console.log('Creating parameter for skill:', skillId);

package/src/domain/strategies/sync/AttributeSyncStrategy.ts

@@ -39,6 +39,11 @@ import {
   customerAttributesMapPath
 } from '../../../fsutil.js';
 import { patchYamlToPyyaml } from '../../../format/yaml-patch.js';
+import {
+  isJsonValueType,
+  normalizeJsonValueForStorage,
+  jsonValuesEqual
+} from '../../../sync/json-attr-utils.js';
 import { sha256, saveHashes, loadHashes } from '../../../hash.js';
 
 /**
@@ -220,8 +225,14 @@ export class AttributeSyncStrategy implements ISyncStrategy<CustomerAttributesRe
   private cleanAttribute(attr: CustomerAttribute): CustomerAttribute {
     let processedValue = attr.value;
 
-    // Handle JSON string values
-    if (typeof attr.value === 'string' && attr.value.startsWith('[{') && attr.value.endsWith('}]')) {
+    // Coerce JSON-typed values to a STRING. The API may return parsed
+    // objects for `value_type: json`; if we let yaml.dump turn them into
+    // YAML structures, the next push sends an object and the Workflow
+    // Builder canvas blanks out. See src/sync/json-attr-utils.ts.
+    if (isJsonValueType(attr.value_type)) {
+      processedValue = normalizeJsonValueForStorage(attr.value);
+    } else if (typeof attr.value === 'string' && attr.value.startsWith('[{') && attr.value.endsWith('}]')) {
+      // Legacy: reformat array-of-objects JSON strings for readability
       try {
         const parsed = JSON.parse(attr.value);
         processedValue = JSON.stringify(parsed, null, 0);
@@ -342,10 +353,24 @@ export class AttributeSyncStrategy implements ISyncStrategy<CustomerAttributesRe
       const remoteAttr = remoteMap.get(localAttr.idn);
       if (!remoteAttr) continue;
 
-      if (String(localAttr.value) !== String(remoteAttr.value)) {
+      // For JSON-typed attrs, compare canonical JSON (handles
+      // pretty/compact and string/object differences). Always send the
+      // value as a STRING so the platform stores the canvas the way the
+      // Workflow Builder expects to read it back.
+      const isJson = isJsonValueType(localAttr.value_type);
+      const valuesAreEqual = isJson
+        ? jsonValuesEqual(localAttr.value, remoteAttr.value)
+        : String(localAttr.value) === String(remoteAttr.value);
+
+      if (!valuesAreEqual) {
+        const valueToSend = isJson
+          ? normalizeJsonValueForStorage(localAttr.value)
+          : localAttr.value;
+
         await updateCustomerAttribute(client, {
-          id: attributeId,
-          ...localAttr
+          ...localAttr,
+          value: valueToSend,
+          id: attributeId
         });
         updatedCount++;
         this.logger.info(`  ✓ Updated customer attribute: ${localAttr.idn}`);
@@ -399,10 +424,22 @@ export class AttributeSyncStrategy implements ISyncStrategy<CustomerAttributesRe
       const remoteAttr = remoteMap.get(localAttr.idn);
       if (!remoteAttr) continue;
 
-      if (String(localAttr.value) !== String(remoteAttr.value)) {
+      // Same canonical-JSON / always-string-on-push policy as customer
+      // attributes (see pushCustomerAttributes for rationale).
+      const isJson = isJsonValueType(localAttr.value_type);
+      const valuesAreEqual = isJson
+        ? jsonValuesEqual(localAttr.value, remoteAttr.value)
+        : String(localAttr.value) === String(remoteAttr.value);
+
+      if (!valuesAreEqual) {
+        const valueToSend = isJson
+          ? normalizeJsonValueForStorage(localAttr.value)
+          : localAttr.value;
+
         await updateProjectAttribute(client, project.id, {
-          id: attributeId,
-          ...localAttr
+          ...localAttr,
+          value: valueToSend,
+          id: attributeId
         });
         updatedCount++;
         this.logger.info(`  ✓ Updated project attribute: ${projectIdn}/${localAttr.idn}`);

package/src/domain/strategies/sync/ProjectSyncStrategy.ts

@@ -49,7 +49,14 @@ import {
   publishFlow,
   listLibraries,
   updateLibrarySkill,
+  getFlow,
 } from '../../../api.js';
+import {
+  syncFlowMetadata,
+  emptyFlowSyncCounts,
+  totalFlowSyncOps,
+  describeFlowSyncCounts
+} from '../../../sync/flow-metadata.js';
 import {
   ensureState,
   writeFileSafe,
@@ -540,6 +547,24 @@ export class ProjectSyncStrategy implements ISyncStrategy<ProjectMeta, LocalProj
     for (const change of changes) {
       try {
         if (change.operation === 'modified') {
+          // Flow-level metadata.yaml needs different handling than a skill
+          // script: we sync title/events/state_fields rather than uploading a
+          // file. Detected by filename. (GH issue #3)
+          if (change.path.endsWith('/metadata.yaml') && !change.path.includes('/libraries/')) {
+            const pathParts = change.path.split('/');
+            // {customer}/projects/{project}/{agent}/{flow}/metadata.yaml
+            // Last 5 segments end with metadata.yaml; skip if it's a skill
+            // metadata file (one extra segment) - skill metadata is handled
+            // by V1 legacy push, not by this strategy yet.
+            const tail = pathParts.slice(-5);
+            const isFlowMeta = tail[0] === 'projects' || tail[2] && tail[4] === 'metadata.yaml';
+            if (isFlowMeta && tail.length === 5) {
+              const updateResult = await this.pushFlowMetadataUpdate(client, change, mapData, newHashes);
+              result.updated += updateResult;
+              continue;
+            }
+          }
+
           const isLibrary = change.path.includes('/libraries/');
           if (isLibrary) {
             const updateResult = await this.pushLibrarySkillUpdate(client, change, mapData, newHashes);
@@ -568,6 +593,64 @@ export class ProjectSyncStrategy implements ISyncStrategy<ProjectMeta, LocalProj
     return result;
   }
 
+  /**
+   * Push a flow metadata.yaml change — syncs title, events, and state_fields
+   * to the platform. Closes GH issue #3 (events/title silently un-synced).
+   *
+   * Path shape: newo_customers/{customer}/projects/{project}/{agent}/{flow}/metadata.yaml
+   */
+  private async pushFlowMetadataUpdate(
+    client: AxiosInstance,
+    change: ChangeItem<LocalProjectData>,
+    mapData: ProjectMap,
+    newHashes: HashStore
+  ): Promise<number> {
+    const pathParts = change.path.split('/');
+    // Tail: projects/{project}/{agent}/{flow}/metadata.yaml
+    const flowIdn = pathParts[pathParts.length - 2] || '';
+    const agentIdn = pathParts[pathParts.length - 3] || '';
+    const projectIdn = pathParts[pathParts.length - 4] || '';
+
+    const projectData = mapData.projects[projectIdn];
+    const agentData = projectData?.agents[agentIdn];
+    const flowData = agentData?.flows[flowIdn];
+
+    if (!flowData?.id) {
+      this.logger.warn(`Flow metadata change but flow not in project map: ${projectIdn}/${agentIdn}/${flowIdn}`);
+      return 0;
+    }
+
+    const content = await fs.readFile(change.path, 'utf8');
+    let localFlow: FlowMetadata;
+    try {
+      localFlow = yaml.load(content) as FlowMetadata;
+    } catch (error) {
+      throw new Error(`Failed to parse ${change.path}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+
+    let remoteFlow = null;
+    try {
+      remoteFlow = await getFlow(client, flowData.id);
+    } catch (error: any) {
+      this.logger.verbose(`Could not GET flow ${flowIdn}: ${error.response?.status ?? error.message}`);
+    }
+
+    const counts = emptyFlowSyncCounts();
+    await syncFlowMetadata(client, flowData.id, localFlow, remoteFlow, false, counts);
+
+    const total = totalFlowSyncOps(counts);
+    if (total > 0) {
+      this.logger.info(`↑ Flow ${flowIdn}: ${describeFlowSyncCounts(counts)}`);
+    }
+    for (const err of counts.errors) {
+      this.logger.warn(err);
+    }
+
+    // Stamp the hash so the next push skips this file unless it changes again.
+    newHashes[change.path] = sha256(content);
+    return total;
+  }
+
   /**
    * Push a skill update
    */
@@ -709,6 +792,23 @@ export class ProjectSyncStrategy implements ISyncStrategy<ProjectMeta, LocalProj
     for (const [projectIdn, projectData] of Object.entries(mapData.projects)) {
       for (const [agentIdn, agentData] of Object.entries(projectData.agents)) {
         for (const [flowIdn, flowData] of Object.entries(agentData.flows)) {
+          // Flow metadata change detection (title/events/state_fields).
+          // Surfaced as a change so push() picks it up alongside skill edits.
+          const flowMetaPath = flowMetadataPath(customer.idn, projectIdn, agentIdn, flowIdn);
+          if (await fs.pathExists(flowMetaPath)) {
+            const content = await fs.readFile(flowMetaPath, 'utf8');
+            const currentHash = sha256(content);
+            const storedHash = hashes[flowMetaPath];
+
+            if (storedHash !== currentHash) {
+              changes.push({
+                item: {} as LocalProjectData,
+                operation: 'modified',
+                path: flowMetaPath
+              });
+            }
+          }
+
           for (const [skillIdn, _skillData] of Object.entries(flowData.skills)) {
             const skillFile = await getSingleSkillFile(customer.idn, projectIdn, agentIdn, flowIdn, skillIdn);
 

package/src/domain/strategies/sync/V2ProjectSyncStrategy.ts

@@ -33,6 +33,7 @@ import type {
   Skill,
   FlowEvent,
   FlowState,
+  FlowMetadata,
   ProjectData,
   ProjectMap,
   SkillMetadata
@@ -51,7 +52,14 @@ import {
   getCustomerAttributes,
   listLibraries,
   updateLibrarySkill,
+  getFlow,
 } from '../../../api.js';
+import {
+  syncFlowMetadata,
+  emptyFlowSyncCounts,
+  totalFlowSyncOps,
+  describeFlowSyncCounts
+} from '../../../sync/flow-metadata.js';
 import type { LibraryResponse } from '../../../api.js';
 import {
   ensureStateOnly,
@@ -84,7 +92,10 @@ import {
   buildV2InlineSkill,
   buildV2FlowEvent,
   buildV2StateField,
+  parseV2FlowYaml,
   type V2InlineSkill,
+  type V2FlowEvent,
+  type V2StateField,
 } from '../../../format/v2-yaml.js';
 import { isContentDifferent } from '../../../sync/skill-files.js';
 import yaml from 'js-yaml';
@@ -648,6 +659,15 @@ export class V2ProjectSyncStrategy implements ISyncStrategy<ProjectMeta, LocalPr
     for (const change of changes) {
       try {
         if (change.operation === 'modified') {
+          // V2 flow YAML: newo_customers/{cust}/{proj}/agents/{agent}/flows/{flow}/{flow}.yaml
+          // The flow YAML carries title, events, and state_fields inline, so
+          // changes there must sync to the platform like V1 metadata.yaml.
+          if (this.isV2FlowYamlPath(change.path)) {
+            const count = await this.pushV2FlowYamlUpdate(client, change, mapData, newHashes);
+            result.updated += count;
+            continue;
+          }
+
           // Detect if this is a library skill or flow skill by path
           const isLibrary = change.path.includes('/libraries/');
           const count = isLibrary
@@ -671,6 +691,115 @@ export class V2ProjectSyncStrategy implements ISyncStrategy<ProjectMeta, LocalPr
     return result;
   }
 
+  /**
+   * Recognize the V2 flow YAML location: .../agents/{agent}/flows/{flow}/{flow}.yaml
+   * Distinguishes it from skill scripts, library YAMLs, and attribute files.
+   */
+  private isV2FlowYamlPath(p: string): boolean {
+    const parts = p.split('/');
+    const file = parts[parts.length - 1];
+    if (!file || !file.endsWith('.yaml')) return false;
+    // .../agents/{agent}/flows/{flow}/{flow}.yaml → last 5 parts:
+    //   agents, {agent}, flows, {flow}, {flow}.yaml
+    if (parts.length < 5) return false;
+    const flowsKeyword = parts[parts.length - 3];
+    const agentsKeyword = parts[parts.length - 5];
+    const flowFolder = parts[parts.length - 2] || '';
+    const stem = file.slice(0, -'.yaml'.length);
+    return flowsKeyword === 'flows' && agentsKeyword === 'agents' && stem === flowFolder;
+  }
+
+  /**
+   * Push V2 flow YAML changes. Closes GH issue #3 for newo_v2 layout.
+   * Parses the V2 YAML, converts to V1-shaped FlowMetadata, and reuses the
+   * shared syncFlowMetadata routine that calls PATCH/POST/DELETE per child.
+   */
+  private async pushV2FlowYamlUpdate(
+    client: AxiosInstance,
+    change: ChangeItem<LocalProjectData>,
+    mapData: ProjectMap,
+    newHashes: HashStore
+  ): Promise<number> {
+    const parts = change.path.split('/');
+    const flowIdn = parts[parts.length - 2] || '';
+    const agentIdn = parts[parts.length - 4] || '';
+    const projectIdn = parts[parts.length - 6] || '';
+
+    const projectData = mapData.projects[projectIdn];
+    const agentData = projectData?.agents[agentIdn];
+    const flowData = agentData?.flows[flowIdn];
+
+    if (!flowData?.id) {
+      this.logger.warn(`[newo_v2] Flow YAML change but flow not in project map: ${projectIdn}/${agentIdn}/${flowIdn}`);
+      return 0;
+    }
+
+    const v2Flow = await parseV2FlowYaml(change.path);
+
+    // Convert V2 → V1-shaped FlowMetadata for the shared sync routine.
+    // V2 events lack `id` and `description`; we fill defaults so the shape
+    // matches FlowEvent[] / FlowState[] expected by syncFlowMetadata.
+    // Optional fields are omitted (not set to undefined) to satisfy
+    // exactOptionalPropertyTypes.
+    const localMeta: FlowMetadata = {
+      id: flowData.id,
+      idn: v2Flow.idn,
+      title: v2Flow.title,
+      description: v2Flow.description ?? '',
+      default_runner_type: (v2Flow.default_runner_type as 'guidance' | 'nsl') || 'guidance',
+      default_model: {
+        provider_idn: v2Flow.default_provider_idn,
+        model_idn: v2Flow.default_model_idn,
+      },
+      events: (v2Flow.events || []).map((e: V2FlowEvent) => {
+        const out: FlowEvent = {
+          id: '',
+          idn: e.idn,
+          description: '',
+          skill_selector: e.skill_selector as 'first' | 'last' | 'random' | 'all',
+          interrupt_mode: (e.interrupt_mode || 'queue') as 'allow' | 'deny' | 'queue',
+          ...(e.skill_idn != null ? { skill_idn: e.skill_idn } : {}),
+          ...(e.state_idn != null ? { state_idn: e.state_idn } : {}),
+          ...(e.integration_idn != null ? { integration_idn: e.integration_idn } : {}),
+          ...(e.connector_idn != null ? { connector_idn: e.connector_idn } : {}),
+        };
+        return out;
+      }),
+      state_fields: (v2Flow.state_fields || []).map((s: V2StateField) => {
+        const out: FlowState = {
+          id: '',
+          idn: s.idn,
+          title: s.title || s.idn,
+          scope: (s.scope || 'flow') as 'flow' | 'agent' | 'project' | 'global',
+          ...(s.default_value != null ? { default_value: s.default_value } : {}),
+        };
+        return out;
+      }),
+    };
+
+    let remoteFlow = null;
+    try {
+      remoteFlow = await getFlow(client, flowData.id);
+    } catch (error: any) {
+      this.logger.verbose(`[newo_v2] Could not GET flow ${flowIdn}: ${error.response?.status ?? error.message}`);
+    }
+
+    const counts = emptyFlowSyncCounts();
+    await syncFlowMetadata(client, flowData.id, localMeta, remoteFlow, false, counts);
+
+    const total = totalFlowSyncOps(counts);
+    if (total > 0) {
+      this.logger.info(`[newo_v2] ↑ Flow ${flowIdn}: ${describeFlowSyncCounts(counts)}`);
+    }
+    for (const err of counts.errors) {
+      this.logger.warn(err);
+    }
+
+    const content = await fs.readFile(change.path, 'utf8');
+    newHashes[change.path] = sha256(content);
+    return total;
+  }
+
   /**
    * Push a V2 skill update
    *
@@ -801,6 +930,24 @@ export class V2ProjectSyncStrategy implements ISyncStrategy<ProjectMeta, LocalPr
     for (const [projectIdn, projectData] of Object.entries(mapData.projects)) {
       // Flow skills
       for (const [agentIdn, agentData] of Object.entries(projectData.agents)) {
+        for (const [flowIdn, _flowData] of Object.entries(agentData.flows)) {
+          // V2 stores flow events / state_fields / title inline in the flow
+          // YAML. Detect changes here so push() can sync them (GH issue #3).
+          const flowYamlPath = v2FlowYamlPath(customer.idn, projectIdn, agentIdn, flowIdn);
+          if (await fs.pathExists(flowYamlPath)) {
+            const content = await fs.readFile(flowYamlPath, 'utf8');
+            const currentHash = sha256(content);
+            const storedHash = hashes[flowYamlPath];
+            if (storedHash !== currentHash) {
+              changes.push({
+                item: {} as LocalProjectData,
+                operation: 'modified',
+                path: flowYamlPath
+              });
+            }
+          }
+        }
+
         for (const [flowIdn, flowData] of Object.entries(agentData.flows)) {
           for (const [skillIdn, skillMeta] of Object.entries(flowData.skills)) {
             const scriptPath = v2SkillScriptPath(

package/src/sync/attributes.ts

@@ -12,6 +12,11 @@ import path from 'path';
 import fs from 'fs-extra';
 import yaml from 'js-yaml';
 import { patchYamlToPyyaml } from '../format/yaml-patch.js';
+import {
+  isJsonValueType,
+  normalizeJsonValueForStorage,
+  jsonValuesEqual
+} from './json-attr-utils.js';
 import type { AxiosInstance } from 'axios';
 import type { CustomerConfig } from '../types.js';
 
@@ -43,15 +48,21 @@ export async function saveCustomerAttributes(
         idMapping[attr.idn] = attr.id;
       }
 
-      // Special handling for complex JSON string values
+      // Coerce JSON-typed values to a STRING. The API can return the value
+      // as a parsed object for `value_type: json` attributes; if we let
+      // yaml.dump serialize that as a YAML structure the next push sends
+      // `{"value": {...}}` instead of `{"value": "..."}` and the Workflow
+      // Builder canvas breaks. See src/sync/json-attr-utils.ts for the
+      // full rationale.
       let processedValue = attr.value;
-      if (typeof attr.value === 'string' && attr.value.startsWith('[{') && attr.value.endsWith('}]')) {
+      if (isJsonValueType(attr.value_type)) {
+        processedValue = normalizeJsonValueForStorage(attr.value);
+      } else if (typeof attr.value === 'string' && attr.value.startsWith('[{') && attr.value.endsWith('}]')) {
+        // Legacy: reformat array-of-objects JSON strings for readability
         try {
-          // Parse and reformat JSON for better readability
           const parsed = JSON.parse(attr.value);
-          processedValue = JSON.stringify(parsed, null, 0); // No extra spacing, but valid JSON
+          processedValue = JSON.stringify(parsed, null, 0); // compact, valid JSON
         } catch (e) {
-          // Keep original if parsing fails
           processedValue = attr.value;
         }
       }
@@ -145,9 +156,12 @@ export async function saveProjectAttributes(
         idMapping[attr.idn] = attr.id;
       }
 
-      // Special handling for complex JSON string values
+      // Coerce JSON-typed values to a STRING. See json-attr-utils.ts for
+      // why this matters (Workflow Builder canvas blank-screen bug).
       let processedValue = attr.value;
-      if (typeof attr.value === 'string' && attr.value.startsWith('[{') && attr.value.endsWith('}]')) {
+      if (isJsonValueType(attr.value_type)) {
+        processedValue = normalizeJsonValueForStorage(attr.value);
+      } else if (typeof attr.value === 'string' && attr.value.startsWith('[{') && attr.value.endsWith('}]')) {
         try {
           const parsed = JSON.parse(attr.value);
           processedValue = JSON.stringify(parsed, null, 0);
@@ -297,19 +311,34 @@ export async function pushProjectAttributes(
 
     // Value type is already parsed (we removed !enum tags above)
     const valueType = localAttr.value_type;
-
-    // Check if value changed (use ?? to preserve 0, false, empty string)
-    const localValue = String(localAttr.value ?? '');
-    const remoteValue = String(remoteAttr.value ?? '');
-
-    if (localValue !== remoteValue) {
+    const isJson = isJsonValueType(valueType);
+
+    // Check if value changed.
+    // For JSON-typed values, compare canonical (compact) JSON so that
+    // pretty- vs compact-printed forms don't register as changes and
+    // string vs object representations compare equal. For everything
+    // else, fall back to the existing String() comparison (which still
+    // preserves 0, false, "" via ??).
+    const valuesAreEqual = isJson
+      ? jsonValuesEqual(localAttr.value, remoteAttr.value)
+      : String(localAttr.value ?? '') === String(remoteAttr.value ?? '');
+
+    if (!valuesAreEqual) {
       if (verbose) console.log(`   🔄 Updating project attribute: ${localAttr.idn}`);
 
       try {
+        // Always send JSON-typed values as a STRING. If the API or our
+        // YAML loader handed us an object, the platform stores it
+        // differently from the original string and the Workflow Builder
+        // canvas blanks out.
+        const valueToSend = isJson
+          ? normalizeJsonValueForStorage(localAttr.value)
+          : localAttr.value;
+
         const attributeToUpdate = {
           id: attributeId,
           idn: localAttr.idn,
-          value: localAttr.value,
+          value: valueToSend,
           title: localAttr.title,
           description: localAttr.description,
           group: localAttr.group,