@uipath/maestro-builder-sdk 6.63.0 → 6.65.0

package/dist/nodes/agent/flow/check.js

@@ -340,15 +340,15 @@ export function checkInlineAgent(inputs, ctx) {
     //
     // An artifact that compiles and can never validate is the worst of the two
     // failures, so this is said here — before the emit — rather than left to a rung.
-    // It is an ERROR because there is no spelling that works today, and `--no-check`
-    // remains the escape for a tenant whose manifest does declare the handle.
+    // It is an ERROR because there is no spelling that works today. `compile` does
+    // not run check, so a tenant whose manifest does declare the handle still compiles it.
     if (inputs?.memory !== undefined) {
         at('AGENT_MEMORY_NOT_AUTHORABLE', `Inline agent step "${step}" attaches \`memory\`, which the platform cannot resolve: the tenant's `
             + `\`uipath.agent.autonomous\` manifest declares no \`memory\` handle (only escalation, context, tool, `
             + `success, error) and the registry serves no \`uipath.agent.resource.memory.*\` node type. The flow `
             + `compiles and then fails \`uip maestro flow validate\` as RetryWillNotFix. Drop \`memory\`; for `
             + `retrieval over a knowledge source use a context index instead (\`tools\`/context grounding). `
-            + `Pass --no-check only on a tenant whose manifest does declare the handle.`);
+            + `On a tenant whose manifest does declare the handle, ignore this finding: \`compile\` does not run check.`);
     }
     // A context `query` is what the RUNTIME searches with, and it is not an
     // expression slot. A plain string is the model-invoked `dynamic` variant: the
@@ -468,7 +468,7 @@ export function checkInlineAgent(inputs, ctx) {
                 + `of the prompt) with one line per field, in the platform's own wording: "${rewrite}" Declare a field \`'object'\` or `
                 + `\`'array'\` if it should carry structure. \`uip maestro flow validate\` accepts this prompt, so `
                 + `nothing later catches it. If this is a false positive (the prompt only mentions JSON as data), `
-                + `compile with --no-check.`);
+                + `ignore this finding: \`compile\` does not run check.`);
         }
     }
     // The prompts-vs-variables agreement, in both directions. Both prompts are

package/dist/nodes/connector/flow/node-type.js

@@ -270,6 +270,40 @@ function liftConnector(node, ctx) {
         missing,
     };
 }
+/**
+ * Whether a connector operation node is a draft the canvas saved, by what the
+ * file itself shows: no connection or folder (`BINDING_MISSING`), or a field its
+ * own definition marks `required` that the node gives no value
+ * (`CONNECTOR_INPUT_MISSING`). For instance a Slack send saved before a
+ * connection was picked has `detail.connectionId: null`. An operation with no
+ * object picked is not one: `compile` can only stand in for it, so it is never
+ * written either way.
+ */
+function isConnectorDraft(node, definition) {
+    const detail = (node.inputs?.detail ?? {});
+    const label = (v) => (typeof v === 'string' ? v : undefined);
+    if (missingBindingLabels({ connection: label(detail.connectionId), folder: label(detail.connectionFolderKey) }).length > 0)
+        return true;
+    const fields = definition?.inputDefinition?.fields;
+    if (!Array.isArray(fields))
+        return false;
+    const slots = ['bodyParameters', 'queryParameters', 'pathParameters']
+        .map((slot) => detail[slot])
+        .filter((m) => !!m && typeof m === 'object' && !Array.isArray(m));
+    const parts = Array.isArray(detail.multipartParameters) ? detail.multipartParameters : [];
+    const given = (name) => parts.some((p) => p?.name === name) || slots.some((m) => {
+        if (Object.prototype.hasOwnProperty.call(m, name))
+            return true;
+        let at = m;
+        for (const seg of name.split('.')) {
+            if (!at || typeof at !== 'object' || !Object.prototype.hasOwnProperty.call(at, seg))
+                return false;
+            at = at[seg];
+        }
+        return true;
+    });
+    return fields.some((f) => f?.required === true && typeof f.name === 'string' && !given(f.name));
+}
 function printConnector(l, ctx) {
     // A present input whose value is `undefined` (the inputs check accepts one, and
     // serialize keeps it in memory) prints as `undefined`, as it did before the port.
@@ -284,7 +318,7 @@ function printConnector(l, ctx) {
             ['object', optional(l.object)],
         ],
         ...(l.missing.length > 0
-            ? { comment: `TODO: bind ${l.missing.join(' and ')}; compile refuses this node until it has both labels (BINDING_MISSING)` }
+            ? { comment: `TODO: bind ${l.missing.join(' and ')}; check refuses this node until it has both labels (BINDING_MISSING)` }
             : {}),
     };
 }
@@ -302,6 +336,7 @@ const connector10 = {
     },
     serialize: (spec, ctx) => serializeConnector(spec, ctx),
     deserialize: (node, ctx) => liftConnector(node, ctx),
+    isDraft: (node, definition) => isConnectorDraft(node, definition),
     print: (spec, ctx) => printConnector(spec, ctx),
     check: (spec, ctx) => ctx.connector(spec),
     // Every Expr in the inputs, nested ones included, resolves against the flow's names.

package/dist/serialize.d.ts

@@ -29,6 +29,8 @@ export type DraftCode = BindingRefusalCode | typeof CONNECTOR_INPUT_MISSING | 'C
 export interface DraftFinding {
     /** The emitted node's id. */
     nodeId: string;
+    /** The step whose node it is. Set by a carried-drafts compile ({@link SerializeOpts.carriedDrafts}). */
+    step?: string;
     /** A {@link DraftCode}, or a node-type package's own code reported through `ctx.draft`. */
     code: DraftCode | string;
     /** The sentence the strict compile refuses with. */
@@ -71,6 +73,28 @@ export interface SerializeOpts {
      * ordinary compile), behaviour is unchanged.
      */
     draft?: (finding: DraftFinding) => void;
+    /**
+     * Carried drafts, for `compile` (docs/CHECK_COMPILE_CONTRACT_DESIGN.md D2).
+     *
+     * A step marked `{ draft: true }` ({@link StepOptions.draft}) that the
+     * ordinary compile refuses only for draft findings ({@link DraftCode}: a
+     * connector with no connection, an empty required input) is written anyway
+     * when the flow CARRIES the definition of the node it emits
+     * (`.definitions([...])`). Decompile sets both for a canvas draft node. The
+     * node is written with that definition and the inputs it has, and each
+     * finding is reported here. A draft with no flag, or no carried definition,
+     * or one the node type can only stand in for (a generic operation with no
+     * object), is refused exactly as without this option. So is any other
+     * refusal. A flow with no draft compiles byte for byte as without it.
+     *
+     * For instance, a decompiled canvas flow whose Slack send has no `messageToSend`
+     * compiles with a `CONNECTOR_INPUT_MISSING` finding here, and a second Slack
+     * send written by hand with no `messageToSend` (no flag) is refused, though
+     * the flow carries the definition of that operation.
+     *
+     * Ignored when {@link draft} is given (merge's compile tolerates every draft).
+     */
+    carriedDrafts?: (finding: DraftFinding) => void;
     /**
      * Collect mode, for `check` (docs/CHECK_COMPILE_CONTRACT_DESIGN.md §3.5).
      *

package/dist/serialize.js

@@ -2542,6 +2542,76 @@ function serializeFlow(built, opts) {
         }
         return [{ node: id, port }];
     }
+    /**
+     * Run a node type's `serialize`, and in a carried-drafts compile
+     * ({@link SerializeOpts.carriedDrafts}) try a refused `{ draft: true }` step
+     * once more as a draft. The ordinary emission runs first, so a flow with no draft compiles
+     * exactly as it would without the option. When it throws a refusal and the flow
+     * carries any definition, what that emission bound is undone and the node is
+     * emitted again with `drafting` on. That second contribution is returned with
+     * the first refusal as `strict` when it reported a draft finding; the caller
+     * writes it only with a carried definition, and throws `strict` otherwise. A
+     * second emission that throws, or reports no finding, ends in `strict` too, so
+     * a refusal that is not a draft reads as it always has.
+     */
+    function serializeCarriedDraft(impl, spec, ctx, scope, id, bound, stepOptions, findings, enableDrafting, warnings) {
+        if (!opts.carriedDrafts || opts.draft || opts.collect || carriedDefs.size === 0 || stepOptions?.draft !== true) {
+            return { contribution: impl.serialize(spec, ctx) };
+        }
+        const mark = {
+            resources: new Set(resourceBindings.keys()), sidecars: sidecars.length,
+            agentSchemas: scope.agentSchemas.length, unbound: unboundDrafts.has(id),
+        };
+        // Each emission's warnings are held, so a node emitted twice reports only
+        // the warnings of the emission that is kept (or of the refused one).
+        const flush = (held) => { for (const w of held)
+            opts.warn?.(w); };
+        const first = [];
+        warnings.held = first;
+        try {
+            const contribution = impl.serialize(spec, ctx);
+            warnings.held = undefined;
+            flush(first);
+            return { contribution };
+        }
+        catch (error) {
+            warnings.held = undefined;
+            if (!(error instanceof CompileRefusal)) {
+                flush(first);
+                throw error;
+            }
+            for (const key of [...resourceBindings.keys()])
+                if (!mark.resources.has(key))
+                    resourceBindings.delete(key);
+            for (const f of sidecars.splice(mark.sidecars)) {
+                if (!sidecars.some((kept) => kept.path === f.path))
+                    explicitSidecars.delete(f.path);
+            }
+            scope.agentSchemas.length = mark.agentSchemas;
+            if (!mark.unbound)
+                unboundDrafts.delete(id);
+            bound.length = 0;
+            enableDrafting();
+            const second = [];
+            warnings.held = second;
+            let contribution;
+            try {
+                contribution = impl.serialize(spec, ctx);
+            }
+            catch {
+                flush(first);
+                throw error;
+            }
+            finally {
+                warnings.held = undefined;
+            }
+            if (findings.length === 0) {
+                flush(first);
+                throw error;
+            }
+            return { contribution, strict: error, strictWarnings: first, draftWarnings: second };
+        }
+    }
     /**
      * Lower a step whose kind is a registered node type (flow-node-registry.ts):
      * the node type serializes its spec through a context, and this owns the rest —
@@ -2572,6 +2642,19 @@ function serializeFlow(built, opts) {
                 rendered.add(copy);
             return copy;
         };
+        // Merge's compile drafts every node; `compile` (carriedDrafts) drafts a node
+        // only on a second try, after the ordinary emission refused it.
+        let drafting = opts.draft !== undefined;
+        const carriedFindings = [];
+        // Where this step's warnings go: `opts.warn`, or held while a carried-drafts
+        // compile does not yet know which emission it keeps (serializeCarriedDraft).
+        const warnings = {};
+        const bindingOpts = opts.warn
+            ? { ...opts, warn: (w) => { if (warnings.held)
+                    warnings.held.push(w);
+                else
+                    opts.warn(w); } }
+            : opts;
         const ctx = {
             step: step.name,
             nodeId: id,
@@ -2598,7 +2681,7 @@ function serializeFlow(built, opts) {
                 ? resolved.carried
                 : bundledDefinition(typeName, v) ?? carriedFor(typeName, v)),
             bindings: resourceBindings,
-            resolveBinding: ((name, attribute, at, target) => resolveBinding(opts, name, attribute, at, target)),
+            resolveBinding: ((name, attribute, at, target) => resolveBinding(bindingOpts, name, attribute, at, target)),
             bindConnection: (c) => {
                 const { entries } = connectionResourceBindings({
                     def: { model: c.model },
@@ -2625,15 +2708,26 @@ function serializeFlow(built, opts) {
                 const out = renderDeep(value, scope.rename, rendered);
                 return out !== null && typeof out === 'object' ? fileCopy(out) : out;
             },
-            drafting: opts.draft !== undefined,
+            get drafting() { return drafting; },
             draft: (code, message) => {
                 if (code === 'BINDING_MISSING')
                     unboundDrafts.add(id);
-                opts.draft?.({ nodeId: id, code: code, message });
+                if (opts.draft)
+                    opts.draft({ nodeId: id, code: code, message });
+                else
+                    carriedFindings.push({ nodeId: id, step: step.name, code: code, message });
             },
         };
         const bound = [];
-        const contribution = impl.serialize(spec, ctx);
+        const { contribution, strict, strictWarnings, draftWarnings } = serializeCarriedDraft(impl, spec, ctx, scope, id, bound, step.options, carriedFindings, () => { drafting = true; }, warnings);
+        // A carried draft refused after all reports the warnings of the refused emission.
+        const refuse = () => {
+            for (const w of strictWarnings ?? [])
+                opts.warn?.(w);
+            throw strict;
+        };
+        if (strict !== undefined && contribution.standIn !== undefined)
+            refuse();
         if (contribution.standIn !== undefined) {
             // A draft stand-in: the node as the draft has it, with no definition to
             // place it against (see FlowNodeContribution.standIn).
@@ -2677,6 +2771,22 @@ function serializeFlow(built, opts) {
             const origin = entry.family.package;
             def = { ...def, source: { package: origin.name, ...(origin.version !== undefined ? { version: origin.version } : {}) } };
         }
+        // A draft `compile` writes: only a step marked `{ draft: true }` (checked in
+        // serializeCarriedDraft) with the definition the flow carries for the node it
+        // emits (decompile's copy of the canvas file's entry), else refused as the
+        // ordinary emission refused it (SerializeOpts.carriedDrafts).
+        if (strict !== undefined) {
+            const carried = typeof def?.nodeType === 'string' && typeof def?.version === 'string'
+                ? carriedFor(def.nodeType, def.version)
+                : undefined;
+            if (carried === undefined)
+                refuse();
+            def = carried;
+            for (const w of draftWarnings ?? [])
+                opts.warn?.(w);
+            for (const f of carriedFindings)
+                opts.carriedDrafts?.(f);
+        }
         // A type that owns a family of names (`typeNamePrefix`) is placed under the
         // name its definition carries — `uipath.core.function.<key>`, not the prefix.
         // The bare prefix is allowed: an empty `key` builds it, check refuses that

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/maestro-builder-sdk",
-  "version": "6.63.0",
+  "version": "6.65.0",
   "description": "Build UiPath Flow, Case, and BPMN artifacts by writing TypeScript.",
   "license": "MIT",
   "homepage": "https://docs.uipath.com/maestro",
@@ -100,5 +100,5 @@
     "@types/node": "^22.7.0",
     "esbuild": "^0.28.1"
   },
-  "gitref": "a4d62ecfe71de0865a81621edbf878ae84d0152b"
+  "gitref": "cef5c166db15d92f544e04c9817e280551ecc9dd"
 }