@uipath/maestro-builder-sdk 6.8.1 → 6.8.2

package/dist/decompile.js

@@ -1247,7 +1247,11 @@ function emitAgentCluster(node, imp, inputNames, graph) {
     if (node.type === T.conversationalAgent) {
         const st = (i.conversationalAgentSettings ?? {});
         const settingExpr = (k) => {
-            const raw = typeof st[k] === 'string' ? st[k] : undefined;
+            // `unwrapSource` rather than a string test: since the envelope reaches
+            // these five keys (migrate's `NESTED_BINDING_INPUTS`), a bare string is
+            // only what a pre-1.6 file carries. Reading strings alone made every
+            // modern file decompile to a conversational agent with no turn wiring.
+            const raw = unwrapSource(st[k]);
             if (raw === undefined || raw === '')
                 return undefined;
             const js = raw.startsWith('=js:') ? raw.slice(4) : raw;

package/dist/migrate.js

@@ -48,6 +48,82 @@ function isUnwrappedInput(nodeType, key) {
         return false;
     return UNWRAPPED_INPUTS.some((r) => nodeType.startsWith(r.typePrefix) && r.keys.has(key));
 }
+/**
+ * Inputs whose value is an OBJECT of bindings, wrapped one level down.
+ *
+ * `wrapNodes` walks `n.inputs` one level and skips anything that is not a
+ * string, so a sub-object of bindings is never reached. For almost every input
+ * that is correct — a connector's `entityConfig` is a payload, not a binding
+ * table, and wrapping its leaves would corrupt it. `conversationalAgentSettings`
+ * is the exception: its five keys are per-turn BINDINGS, and the platform's own
+ * writer envelopes each one.
+ *
+ * **`uipath.agent.conversational` → `conversationalAgentSettings`** (measured
+ * 2026-09-23 against the same-ground A/B run):
+ *
+ *   - Every binding written by the PRODUCT carries the envelope: 5 of 5 across
+ *     the v1 arm's `conversationalAgentSettings`, each a
+ *     `{ type: 'jsExpression', expression, fieldType }`. Every binding written
+ *     by this SDK is a bare `=js:` string: 5 of 5 in the v2 arm. No mixed case
+ *     anywhere in the corpus.
+ *   - The bare string is the pre-1.3 spelling, and Studio Web renders it as
+ *     literal text rather than evaluating it — so the flow deploys, validates
+ *     `Valid`, and shows the author the text `$vars.listen.output…` where the
+ *     transcript should be.
+ *   - `uip maestro flow validate` accepts both, which is why this survived: the
+ *     SDK's own `check`, `compile` and the product's static validator all passed
+ *     on the broken shape. `skill-flow-conversational-chat-loop` scored 0.61
+ *     with a green ladder.
+ *
+ * The `fieldType`s are a table rather than a schema read because the node's own
+ * manifest declares `conversationalAgentSettings` as an untyped `object`
+ * (`uipath.agent.conversational@1.6` and `@1.7`, `inputDefinition.properties`),
+ * so there is nothing underneath it to read. They are the types the product
+ * writes, from the same measurement.
+ *
+ * `mode` is deliberately absent: it is an editor-state enum (`'simple'` /
+ * `'custom'`), not a binding, and the product leaves it a plain string.
+ */
+const NESTED_BINDING_INPUTS = [
+    {
+        typePrefix: 'uipath.agent.conversational',
+        key: 'conversationalAgentSettings',
+        fieldTypes: {
+            context: 'object',
+            conversationId: 'string',
+            exchangeId: 'string',
+            messages: 'array',
+            userSettings: 'object',
+        },
+    },
+];
+/**
+ * Wrap the binding leaves of an object-valued input, in place.
+ *
+ * Only the keys the table names are touched. An unknown key is left exactly as
+ * it is: the table is evidence about specific fields, and a key nobody measured
+ * is not covered by it.
+ */
+function wrapNestedBindings(node) {
+    if (typeof node.type !== 'string')
+        return;
+    for (const rule of NESTED_BINDING_INPUTS) {
+        if (!node.type.startsWith(rule.typePrefix))
+            continue;
+        const settings = node.inputs?.[rule.key];
+        if (!settings || typeof settings !== 'object' || Array.isArray(settings))
+            continue;
+        for (const [key, fieldType] of Object.entries(rule.fieldTypes)) {
+            const v = settings[key];
+            if (typeof v !== 'string' || isWrappedSource(v))
+                continue;
+            // The same rule the top-level loop applies: an expression always, and a
+            // literal whenever the field is not string-typed.
+            if (v.startsWith('=') || fieldType !== 'string')
+                settings[key] = wrap(v, fieldType);
+        }
+    }
+}
 /**
  * The only `fieldType` values `@uipath/flow-schema`'s `expressionValueSchema`
  * accepts (it is `.strict()`, so anything else fails the file's schema and with
@@ -155,6 +231,7 @@ function wrapNodes(nodes, schemaByType, globalTypeByName, subflows = {}) {
                 if (v.startsWith('=') || declared !== 'string')
                     n.inputs[k] = wrap(v, declared);
             }
+            wrapNestedBindings(n);
         }
         if (n.outputs) {
             for (const [k, vobj] of Object.entries(n.outputs)) {

package/dist/serialize.js

@@ -1628,7 +1628,17 @@ function conversationalAgentJson(spec) {
             // agent's — a debug run without both is refused before it starts.
             maxTokens: spec.maxTokenPerResponse ?? 16384,
             temperature: spec.temperature ?? 0,
-            engine: 'basic-v2',
+            // `basic-v2` is the NON-conversational inline agent's engine (the other
+            // `agent.json` writer in this file, 100 lines down), and it was copied in
+            // with the rest of that shape. Every instance of THIS node is
+            // conversational — `metadata.isConversational` below says so
+            // unconditionally — and `voiceAgentJson`, the sibling conversational
+            // family, already spells it the other way. Measured across the 2026-09-23
+            // A/B run: every product-written `agent.json` with `isConversational: true`
+            // carries `conversational-v1` (3 of 3) and every one with `false` carries
+            // `basic-v2` (6 of 6). The SDK's own voice path agreed (2 of 2); only this
+            // path disagreed, and its task graded the sidecar as not conversational.
+            engine: 'conversational-v1',
             ...(spec.maxIterations === undefined ? {} : { maxIterations: spec.maxIterations }),
             mode: 'standard',
         },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/maestro-builder-sdk",
-  "version": "6.8.1",
+  "version": "6.8.2",
   "description": "Build UiPath Flow, Case, and BPMN artifacts by writing TypeScript.",
   "license": "MIT",
   "homepage": "https://docs.uipath.com/maestro",
@@ -87,5 +87,5 @@
     "@types/node": "^22.7.0",
     "esbuild": "^0.28.1"
   },
-  "gitref": "5ec4e9cb4aeac6a5297078cfd071d7c38784fed3"
+  "gitref": "34be5c196660ad049240339a969f508f67898e19"
 }