@uipath/maestro-builder-sdk 6.60.0 → 6.61.0

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

@@ -1,5 +1,4 @@
 import { Expr } from '../../../core/expr.js';
-import { derivedResourceNodeId } from '../../../core/agent-resource-identity.js';
 import { GUID_RE } from '../../../core/binding-messages.js';
 import { prepareCommand } from '../../../core/cli-spelling.js';
 import { nearestName } from '../../../core/edit-distance.js';
@@ -372,24 +371,7 @@ export function checkInlineAgent(inputs, ctx) {
                 + `run-dependent search needs.`);
         }
     }
-    // The index id is half of the resource node's TYPE
-    // (`…context.index.<slug>.<id>`), and the platform resolves the index by it.
-    // A blank, padded or non-GUID id builds a type no tenant serves, and nothing
-    // downstream says so: the flow compiles, merges and validates, and the agent
-    // runs ungrounded. So it is an error, not a warning. The id is tested as
-    // written, not trimmed, because serialize emits it as written.
-    for (const cx of contexts) {
-        const id = typeof cx?.id === 'string' ? cx.id : '';
-        if (!GUID_RE.test(id)) {
-            at('AGENT_CONTEXT_NO_ID', `Inline agent step "${step}" grounds on context index "${cx?.name ?? ''}" with `
-                + (id.trim() === '' ? 'no `id`'
-                    : GUID_RE.test(id.trim()) ? `\`id\` ${JSON.stringify(cx?.id)}, which has whitespace around the GUID`
-                        : `\`id\` ${JSON.stringify(cx?.id)}, which is not a GUID`) + '. '
-                + `The id is the index's key: it is the tail of the resource node's type and how the runtime finds `
-                + `the index, so without a real one the agent runs ungrounded and \`validate\` does not notice. `
-                + `\`uip solution resources list --kind Index --source remote --search "<name>"\` returns it as \`Key\`.`);
-        }
-    }
+    // A context index whose `id` is not a GUID is the serializer's AGENT_CONTEXT_NO_ID.
     // An index outside the deployment folder needs its folder named. The resource
     // file carries no `indexId`, so `indexName` + `folderPath` is the whole locator,
     // and `@uipath/tool-agent`'s `createIndexBinding` leaves the folder off the
@@ -425,67 +407,23 @@ export function checkInlineAgent(inputs, ctx) {
     }
     // Where each resource node sits (`nodeId`, `source`): decompile writes them
     // for a node the canvas placed, and compile writes them as given. A blank or
-    // repeated id would make compile refuse the flow or overwrite another node,
-    // and a `source` that is not a uuid names a directory the platform does not
-    // expect (the agent's own `source` has the same rule).
+    // taken `nodeId` and a `source` two of them share are the serializer's
+    // INLINE_AGENT_RESOURCE_NODE_ID / INLINE_AGENT_RESOURCE_SOURCE_DUP; a `source`
+    // that is not a uuid names a directory the platform does not expect (the
+    // agent's own `source` has the same rule).
     const asList = (v) => (v === undefined ? [] : Array.isArray(v) ? v : [v]);
     const placed = [
-        ...asList(inputs?.context).map((r) => ({ what: `context index "${r?.name ?? ''}"`, kind: 'Context', nodeId: r?.nodeId, source: r?.source })),
-        ...asList(inputs?.tools).map((r) => ({ what: `${r?.kind ?? ''} tool`, kind: 'Tool', nodeId: r?.nodeId, source: r?.source })),
-        ...asList(inputs?.escalation).map((r) => ({ what: `escalation "${r?.name ?? ''}"`, kind: 'Escalation', nodeId: r?.nodeId, source: r?.source })),
+        ...asList(inputs?.context).map((r) => ({ what: `context index "${r?.name ?? ''}"`, source: r?.source })),
+        ...asList(inputs?.tools).map((r) => ({ what: `${r?.kind ?? ''} tool`, source: r?.source })),
+        ...asList(inputs?.escalation).map((r) => ({ what: `escalation "${r?.name ?? ''}"`, source: r?.source })),
     ];
-    // The ids compile derives for the resources with no `nodeId`: the n-th one of
-    // a kind gets `<step><Kind>`, then `<step><Kind>2`, ... An explicit id equal to
-    // one of them makes compile refuse the flow, or rename the derived node.
-    for (const kind of ['Context', 'Tool', 'Escalation']) {
-        const derived = placed.filter((r) => r.kind === kind && r.nodeId === undefined);
-        derived.forEach((r, n) => {
-            const id = derivedResourceNodeId(step, kind, n);
-            ctx.resources.derivedNodeId(id, `the id compile derives for the ${r.what} of inline agent step "${step}"`);
-        });
-    }
-    /** Explicit `source` -> the resource on THIS agent that has it: two would write one resource.json. */
-    const sources = new Map();
     for (const r of placed) {
-        if (r.nodeId !== undefined) {
-            const id = typeof r.nodeId === 'string' ? r.nodeId : '';
-            let other;
-            if (id.trim() === '') {
-                at('INLINE_AGENT_RESOURCE_NODE_ID', `Inline agent step "${step}" gives its ${r.what} the \`nodeId\` ${JSON.stringify(r.nodeId)}, which is `
-                    + `not a node id. Omit \`nodeId\` to derive one, or give the id the node has in the flow.`);
-            }
-            else if ((other = ctx.resources.claimNodeId(id, r.what)) !== undefined) {
-                at('INLINE_AGENT_RESOURCE_NODE_ID', `Inline agent step "${step}" gives its ${r.what} the \`nodeId\` "${id}", which the ${other.what} `
-                    + `(on step "${other.step}") already has. Node ids are unique in a flow.`);
-            }
-        }
-        if (r.source === undefined)
-            continue;
         // Not trimmed: compile writes `source` as given, into `inputs.source` and the directory name.
-        if (!GUID_RE.test(String(r.source))) {
+        if (r.source !== undefined && !GUID_RE.test(String(r.source))) {
             at('INLINE_AGENT_RESOURCE_SOURCE_NOT_GUID', `Inline agent step "${step}" gives its ${r.what} the \`source\` ${JSON.stringify(r.source)}, which is not `
                 + `a uuid${/^\s|\s$/.test(String(r.source)) ? ' (it has spaces around it)' : ''}. \`source\` is the resource's `
                 + `directory under the agent's own (\`resources/<source>/resource.json\`) and the node's \`inputs.source\`. `
                 + 'Omit it and one is derived from the flow id, the step and the resource.');
-            continue;
-        }
-        const key = String(r.source).toLowerCase();
-        const first = sources.get(key);
-        if (first !== undefined) {
-            at('INLINE_AGENT_RESOURCE_SOURCE_DUP', `Inline agent step "${step}" gives its ${first} and its ${r.what} the same \`source\` "${String(r.source)}". `
-                + 'Both would write `resources/<source>/resource.json` under this agent, and the second file would replace '
-                + 'the first. Give each resource its own `source`, or omit `source` to derive one.');
-        }
-        else {
-            sources.set(key, r.what);
-        }
-    }
-    if (typeof inputs?.source === 'string' && GUID_RE.test(inputs.source.trim())) {
-        const other = ctx.resources.claimFolder(inputs.source.trim());
-        if (other !== undefined) {
-            at('INLINE_AGENT_RESOURCE_SOURCE_DUP', `Inline agent steps "${other}" and "${step}" have the same \`source\` "${inputs.source}". Both would write `
-                + '`<source>/agent.json`, and the second file would replace the first. Give each agent its own `source`, '
-                + 'or omit it to derive one.');
         }
     }
     if (inputs?.source !== undefined && !GUID_RE.test(String(inputs.source).trim())) {
@@ -665,17 +603,11 @@ export function checkInlineAgent(inputs, ctx) {
     // tools happens at compile (where the library is), not here.
     const toolRefs = inputs?.tools === undefined ? []
         : Array.isArray(inputs.tools) ? inputs.tools : [inputs.tools];
-    const BUILTIN_TOOLS = ['analyzefiles', 'summarize', 'batchtransform'];
     for (const t of toolRefs) {
         const kind = t?.kind;
-        if (kind === 'builtin') {
-            if (!BUILTIN_TOOLS.includes(String(t.tool))) {
-                at('INLINE_AGENT_TOOL_UNKNOWN_BUILTIN', `Inline agent step "${step}" declares a builtin tool ${JSON.stringify(t.tool)}. `
-                    + `The platform ships exactly three: ${BUILTIN_TOOLS.map((b) => `'${b}'`).join(', ')} — the node type is a `
-                    + `fixed string, so any other name is a node the tenant has never heard of.`, `{ kind: 'builtin', tool: 'summarize' }`);
-            }
-        }
-        else if (kind === 'connector') {
+        // A builtin tool other than the three, and a kind no tool has, are the
+        // serializer's INLINE_AGENT_TOOL_UNKNOWN_BUILTIN / INLINE_AGENT_TOOL_UNKNOWN_KIND.
+        if (kind === 'connector') {
             const c = t;
             if (blank(c.connector) || blank(c.operation)) {
                 at('INLINE_AGENT_TOOL_NO_OPERATION', `Inline agent step "${step}" declares a connector tool without ${blank(c.connector) ? 'a `connector`' : 'an `operation`'}. `
@@ -696,9 +628,7 @@ export function checkInlineAgent(inputs, ctx) {
                     + `Name the bindings.json labels the same way \`connector()\` takes them — \`${prepareCommand(key, op)}\` `
                     + `finds the connection and writes both entries.`, `{ kind: 'connector', connector: '${key}', operation: '${op}', connection: '<connection label>', folder: '<folder label>' }`);
             }
-            else {
-                ctx.bindingLabels(`Inline agent step "${step}"'s connector tool`, labels, undefined, blank(c.connector) ? undefined : { key: String(c.connector), ...(blank(c.operation) ? {} : { action: String(c.operation) }) });
-            }
+            // Labels it has are the serializer's to judge against bindings.json (BINDING_*).
         }
         else if (kind === 'ixp') {
             const x = t;
@@ -756,11 +686,6 @@ export function checkInlineAgent(inputs, ctx) {
                     + `tool's contract allows GET, POST, PUT, PATCH, DELETE — anything else the runtime refuses at call time.`);
             }
         }
-        else {
-            at('INLINE_AGENT_TOOL_UNKNOWN_KIND', `Inline agent step "${step}" declares a tool with kind ${JSON.stringify(kind)}. Valid kinds: 'builtin', `
-                + `'connector', 'process', 'agent', 'api', 'flow', 'maestro', 'function', 'ixp', 'mcp', 'a2a', `
-                + `'clientside', 'httpRequest'.`);
-        }
     }
     const escalations = inputs?.escalation === undefined ? []
         : Array.isArray(inputs.escalation) ? inputs.escalation : [inputs.escalation];

package/dist/nodes/agent/flow/inline-agent.js

@@ -118,7 +118,7 @@ export function serializeInlineAgent(s, ctx) {
         source,
         name: step,
     });
-    ctx.sidecar({ path: `${source}/agent.json`, json: agentJson });
+    ctx.sidecar({ path: `${source}/agent.json`, json: agentJson }, s.source !== undefined ? `inline agent step "${step}"` : undefined);
     // The schema's property TYPES need this scope's finished variables, which do
     // not exist yet: the `properties` object is filled in place when the scope
     // closes.
@@ -131,12 +131,21 @@ export function serializeInlineAgent(s, ctx) {
     // is the direction both definitions declare.
     const contexts = s.context === undefined ? [] : Array.isArray(s.context) ? s.context : [s.context];
     for (const cx of contexts) {
-        // `check`'s AGENT_CONTEXT_NO_ID, again for `--no-check`: a blank id builds
-        // the type `…context.index.<slug>.`, which no tenant serves, and nothing
-        // after this point would say so.
+        // The index id is half of the resource node's TYPE
+        // (`…context.index.<slug>.<id>`), and the platform resolves the index by it.
+        // A blank, padded or non-GUID id builds a type no tenant serves, and nothing
+        // downstream says so: the flow compiles, merges and validates, and the agent
+        // runs ungrounded. The id is tested as written, not trimmed, because it is
+        // emitted as written.
         if (typeof cx?.id !== 'string' || !GUID_RE.test(cx.id)) {
-            throw new CompileRefusal('AGENT_CONTEXT_NO_ID', `inline agent "${step}": context index "${cx?.name ?? ''}" needs its index id (a GUID) as \`id\`; `
-                + `got ${JSON.stringify(cx?.id)}. \`uip solution resources list --kind Index --source remote --search "<name>"\` returns it as \`Key\`.`);
+            const id = typeof cx?.id === 'string' ? cx.id : '';
+            throw new CompileRefusal('AGENT_CONTEXT_NO_ID', `Inline agent step "${step}" grounds on context index "${cx?.name ?? ''}" with `
+                + (id.trim() === '' ? 'no `id`'
+                    : GUID_RE.test(id.trim()) ? `\`id\` ${JSON.stringify(cx?.id)}, which has whitespace around the GUID`
+                        : `\`id\` ${JSON.stringify(cx?.id)}, which is not a GUID`) + '. '
+                + `The id is the index's key: it is the tail of the resource node's type and how the runtime finds `
+                + `the index, so without a real one the agent runs ungrounded and \`validate\` does not notice. `
+                + `\`uip solution resources list --kind Index --source remote --search "<name>"\` returns it as \`Key\`.`);
         }
         const cdef = contextIndexDef({ name: cx.name, id: cx.id });
         // `<step>Context`, deduped for a second index on the same agent, unless the
@@ -188,7 +197,7 @@ export function serializeInlineAgent(s, ctx) {
         ctx.sidecar({
             path: `${source}/resources/${contextResourceId}/resource.json`,
             json: contextResourceJson(cx, { id: contextResourceId, query: contextQuery }),
-        }, cx.source !== undefined);
+        }, cx.source !== undefined ? `inline agent step "${step}"'s context index "${cx.name ?? ''}"` : undefined);
     }
     // TOOLS — one resource node per tool, joined to the agent's `tool` handle; the
     // same artifact shape as context (no incoming control flow, no output, never
@@ -200,6 +209,9 @@ export function serializeInlineAgent(s, ctx) {
     // — derived, so a recompile is not a diff.
     const toolRefs = s.tools === undefined ? [] : Array.isArray(s.tools) ? s.tools : [s.tools];
     for (const tr of toolRefs) {
+        // An entry that is no object (null, a hole, a string) has no kind at all.
+        if (tr === null || typeof tr !== 'object')
+            throw unknownToolKind(step, undefined);
         let tdef;
         let label;
         let extraInputs = {};
@@ -207,8 +219,11 @@ export function serializeInlineAgent(s, ctx) {
         if (tr.kind === 'builtin') {
             const bdef = ownEntry(BUILTIN_TOOL_DEFS, tr.tool);
             tdef = bdef === undefined ? undefined : jsonClone(bdef);
-            if (!tdef)
-                throw new CompileRefusal('INLINE_AGENT_TOOL_UNKNOWN_BUILTIN', `inline agent "${step}": unknown builtin tool "${tr.tool}" (analyzefiles | summarize | batchtransform).`);
+            if (!tdef) {
+                throw new CompileRefusal('INLINE_AGENT_TOOL_UNKNOWN_BUILTIN', `Inline agent step "${step}" declares a builtin tool ${JSON.stringify(tr.tool)}. `
+                    + `The platform ships exactly three: ${Object.keys(BUILTIN_TOOL_DEFS).map((b) => `'${b}'`).join(', ')} — the node `
+                    + `type is a fixed string, so any other name is a node the tenant has never heard of.`, `{ kind: 'builtin', tool: 'summarize' }`);
+            }
             label = tdef.display.label;
             // The designer-placed node carries the def's `inputDefaults` with the
             // author's values over them — the context rule, kept per builtin (each def
@@ -242,8 +257,14 @@ export function serializeInlineAgent(s, ctx) {
             extraInputs = jsonClone(tdef.inputDefaults);
         }
         else if (tr.kind === 'connector') {
-            if (!ctx.library)
+            if (!ctx.library) {
+                // Its labels are bindings.json's to judge, as a connector step's are:
+                // refused ahead of the library, so a run without one still hears about them.
+                const where = `inline agent "${step}"'s connector tool "${tr.connector}/${tr.operation}"`;
+                ctx.resolveBinding(tr.connection, 'connection', where, { key: tr.connector, action: tr.operation });
+                ctx.resolveBinding(tr.folder, 'folder', where, { key: tr.connector, action: tr.operation });
                 throw new CompileRefusal('LIBRARY_REQUIRED', `inline agent "${step}"'s connector tool needs a library (pass --library / set $FLOW_SDK_LIBRARY_JSON).`);
+            }
             const rc = ctx.library.resolve(tr.connector, tr.operation, tr.version, tr.object);
             // An entry `prepare` synthesized from Integration Service compiles in BPMN
             // only — for a tool as for a step: `connectorToolDef` reads the same
@@ -338,7 +359,7 @@ export function serializeInlineAgent(s, ctx) {
         else {
             const meta = ownEntry(PROCESS_TOOL_META, tr.kind);
             if (!meta)
-                throw new CompileRefusal('INLINE_AGENT_TOOL_UNKNOWN_KIND', `inline agent "${step}": unknown tool kind "${tr.kind}".`);
+                throw unknownToolKind(step, tr.kind);
             tdef = processToolDef(tr.kind, tr);
             label = tr.name;
             // The definition's `model.context` names `<bindings.name>` /
@@ -377,7 +398,7 @@ export function serializeInlineAgent(s, ctx) {
                     ? httpRequestToolResourceJson(label, toolInputs, { id: toolResourceId, canvasNodeId: tid })
                     : toolResourceJson(tr, { id: toolResourceId });
         if (toolResource !== undefined) {
-            ctx.sidecar({ path: `${source}/resources/${toolResourceId}/resource.json`, json: toolResource }, tr.source !== undefined);
+            ctx.sidecar({ path: `${source}/resources/${toolResourceId}/resource.json`, json: toolResource }, tr.source !== undefined ? `inline agent step "${step}"'s ${tr.kind} tool` : undefined);
         }
     }
     // ESCALATION — the agent's TOP handle; an Action Center app task a human
@@ -443,7 +464,7 @@ export function serializeInlineAgent(s, ctx) {
             ctx.sidecar({
                 path: `${source}/resources/${qsource}/resource.json`,
                 json: escalationResourceJson(esc, { id: qsource, channelId, quickFormSchema: schema }),
-            }, esc.source !== undefined);
+            }, esc.source !== undefined ? `inline agent step "${step}"'s escalation "${esc.name ?? ''}"` : undefined);
             continue;
         }
         const app = esc.app;
@@ -486,7 +507,7 @@ export function serializeInlineAgent(s, ctx) {
         ctx.sidecar({
             path: `${source}/resources/${esource}/resource.json`,
             json: escalationResourceJson(esc, { id: esource, channelId }),
-        }, esc.source !== undefined);
+        }, esc.source !== undefined ? `inline agent step "${step}"'s escalation "${esc.name ?? ''}"` : undefined);
     }
     // MEMORY — one episodic-memory resource on the agent's `memory` handle (the
     // 1.4 definition selected above). Same artifact shape as context.
@@ -525,3 +546,9 @@ export function serializeInlineAgent(s, ctx) {
         attach,
     };
 }
+/** INLINE_AGENT_TOOL_UNKNOWN_KIND: a tool whose `kind` names no tool the platform has. */
+function unknownToolKind(step, kind) {
+    return new CompileRefusal('INLINE_AGENT_TOOL_UNKNOWN_KIND', `Inline agent step "${step}" declares a tool with kind ${JSON.stringify(kind)}. Valid `
+        + "kinds: 'builtin', 'connector', 'process', 'agent', 'api', 'flow', 'maestro', 'function', 'ixp', 'mcp', 'a2a', "
+        + "'clientside', 'httpRequest'.");
+}

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

@@ -65,15 +65,36 @@ function listOutputs(rc, nodeId) {
 }
 function serializeConnector(spec, ctx) {
     const step = ctx.step;
-    if (!ctx.library)
+    if (!ctx.library) {
+        // The labels are bindings.json's to judge, not the library's: refused ahead
+        // of the library, so a run without one (`check`'s inner loop) still hears
+        // about them. With a library they are judged below, as they always were.
+        const where = `connector "${step}"`;
+        const target = { key: spec.key, action: spec.action };
+        const missing = missingBindingLabels(spec);
+        if (missing.length > 0 && !ctx.drafting)
+            throw new BindingRefusal('BINDING_MISSING', bindingMissingMessage(where, missing, target));
+        ctx.resolveBinding(spec.connection, 'connection', where, target);
+        ctx.resolveBinding(spec.folder, 'folder', where, target);
         throw new CompileRefusal('LIBRARY_REQUIRED', `connector "${step}" needs a library (pass --library / set $FLOW_SDK_LIBRARY_JSON).`);
+    }
+    // The library's refusals (the operation, its fields) name the connector, not
+    // the step: they say which step as `check` always has.
+    const onStep = (refusal) => new CompileRefusal(refusal.code, `Connector step "${step}": ${refusal.message}`, refusal.suggestion);
     let rc;
     try {
         rc = ctx.library.resolve(spec.key, spec.action, spec.version, spec.object);
     }
     catch (error) {
-        if (!ctx.drafting || !(error instanceof ConnectorResolveError) || error.code !== 'CONNECTOR_OBJECT_REQUIRED')
+        if (error instanceof Error && error.message.startsWith('internal SDK error:'))
             throw error;
+        // A throw `library.resolve` makes on no purpose is still this step's refusal,
+        // under the code `check` has always given it (#1015).
+        if (!(error instanceof ConnectorResolveError)) {
+            throw onStep(new CompileRefusal('CONNECTOR_RESOLVE_FAILED', error instanceof Error ? error.message : String(error)));
+        }
+        if (!ctx.drafting || error.code !== 'CONNECTOR_OBJECT_REQUIRED')
+            throw onStep(error);
         // A generic operation saved before its object was picked has no definition
         // to emit against. Draft tolerance emits a stable stand-in under the node's
         // id; merge restores the original when it is untouched and refuses it
@@ -100,11 +121,10 @@ function serializeConnector(spec, ctx) {
     // An entry `prepare` synthesized from Integration Service compiles in BPMN only.
     const noDefinition = synthesizedDefinitionRefusal(rc);
     if (noDefinition)
-        throw noDefinition;
+        throw onStep(noDefinition);
     const where = `connector "${step}"`;
     const target = { key: spec.key, action: spec.action };
-    // A connector-bound node needs both labels (#890); check says so first
-    // (BINDING_MISSING). A draft that names no connection gets no binding rows
+    // A connector-bound node needs both labels (#890: BINDING_MISSING). A draft that names no connection gets no binding rows
     // either: there is nothing to bind, and rows with an empty resourceKey would
     // leak into the merged file through merge's bindings union.
     let unbound = false;
@@ -129,19 +149,26 @@ function serializeConnector(spec, ctx) {
         });
     }
     const library = ctx.library;
-    const connectorInputs = buildConnectorInputs(rc, spec.inputs, {
-        ...(ctx.drafting
-            ? { onMissingRequired: (m) => ctx.draft(CONNECTOR_INPUT_MISSING, `connector ${rc.nodeType}: ${m}`) }
-            : {}),
-        dialect: FLOW_EXPR_DIALECT,
-        render: (value) => ctx.renderDeep(value),
-        resolutions: library.lookupResolutions ?? {},
-        // Only for the missing-required hint; a test double that is not a full
-        // Library simply gets the plain message.
-        lookups: typeof library.lookupSpecs === 'function'
-            ? library.lookupSpecs(spec.key, spec.action, spec.version, spec.object)
-            : {},
-    });
+    const connectorInputs = (() => {
+        try {
+            return buildConnectorInputs(rc, spec.inputs, {
+                ...(ctx.drafting
+                    ? { onMissingRequired: (m) => ctx.draft(CONNECTOR_INPUT_MISSING, `connector ${rc.nodeType}: ${m}`) }
+                    : {}),
+                dialect: FLOW_EXPR_DIALECT,
+                render: (value) => ctx.renderDeep(value),
+                resolutions: library.lookupResolutions ?? {},
+                // Only for the missing-required hint; a test double that is not a full
+                // Library simply gets the plain message.
+                lookups: typeof library.lookupSpecs === 'function'
+                    ? library.lookupSpecs(spec.key, spec.action, spec.version, spec.object)
+                    : {},
+            });
+        }
+        catch (error) {
+            throw error instanceof CompileRefusal ? onStep(error) : error;
+        }
+    })();
     const replayInputs = replayInputsOf(connectorInputs);
     const detail = {
         connector: rc.connectorKey,

package/dist/nodes/document/flow/ixp.d.ts

@@ -30,5 +30,5 @@ export declare function ixpExtractDef(spec: {
     folderPath?: string;
     versionTag?: string;
     description?: string;
-}): any;
+}, step?: string): any;
 export declare const ixpExtractNodeType: FlowVersionedNodeType<IxpExtractSpec>;

package/dist/nodes/document/flow/ixp.js

@@ -63,15 +63,25 @@ const IXP_DEF = ixpDefinition;
  * validate` and Studio Web's property panel refuse that). So the emitter writes
  * the defaults and the node reads them back, rather than the two drifting.
  */
-export function ixpExtractDef(spec) {
-    const parts = parseIxpProjectType(spec.project);
+export function ixpExtractDef(spec, step = 'ixpExtract') {
+    const parts = typeof spec.project === 'string' ? parseIxpProjectType(spec.project) : undefined;
     if (!parts) {
-        // The three conditions check tells apart, under check's three codes.
-        const code = typeof spec.project !== 'string' || spec.project.trim() === '' ? 'IXP_NO_PROJECT'
-            : !spec.project.startsWith('uipath.ixp.') ? 'IXP_PROJECT_NOT_NODE_TYPE' : 'IXP_PROJECT_TAIL_UNPARSEABLE';
-        throw new CompileRefusal(code, `ixpExtract: "${spec.project}" is not a resolvable extractor node type. It must be `
-            + `uipath.ixp.<slug>.<projectVersionId>-<folderKey> — copy it from `
-            + `\`uip maestro flow registry pull --force && uip maestro flow registry search -f "type:startsWith=uipath.ixp"\`.`);
+        // Three conditions, three codes, each with its remedy.
+        const project = typeof spec.project === 'string' ? spec.project.trim() : '';
+        if (project === '') {
+            throw new CompileRefusal('IXP_NO_PROJECT', `IxP step "${step}" has no \`project\`. That is the extractor's whole node type, and it carries the `
+                + `project version id and folder key the platform resolves the deployment by. Copy it from the registry `
+                + `— never construct it: three different spellings of its tail exist in deployed flows.`, `project: 'uipath.ixp.<slug>.<projectVersionId>-<folderKey>'  // uip maestro flow registry pull --force && uip maestro flow registry search -f "type:startsWith=uipath.ixp"`);
+        }
+        if (!project.startsWith('uipath.ixp.')) {
+            throw new CompileRefusal('IXP_PROJECT_NOT_NODE_TYPE', `IxP step "${step}"'s \`project\` is ${JSON.stringify(spec.project)}, which is not a \`uipath.ixp.*\` node `
+                + `type. This field takes the type verbatim from \`registry search\`, not the project's name or id — the `
+                + `name goes in \`name\` and the slug in \`modelName\`.`);
+        }
+        throw new CompileRefusal('IXP_PROJECT_TAIL_UNPARSEABLE', `IxP step "${step}"'s \`project\` ends in ${JSON.stringify(project.slice(project.lastIndexOf('.') + 1))}, which is `
+            + `not the \`<projectVersionId>-<folderKey>\` pair of uuids the current registry serves. Two older spellings `
+            + `exist in the corpus — a sanitized folder path, and the literal string "undefined" — and neither resolves `
+            + `today. Re-read the type from \`registry search\` after \`registry pull --force\`.`);
     }
     const { versionId, folderKey } = parts;
     const model = {
@@ -223,23 +233,9 @@ function checkIxpExtract(inputs, ctx) {
     const step = ctx.step;
     const at = (code, message, suggestion) => ctx.report(code, message, suggestion);
     const blank = (v) => v === undefined || v === null || (typeof v === 'string' && v.trim() === '');
-    const project = String(inputs?.project ?? '').trim();
-    if (blank(project)) {
-        at('IXP_NO_PROJECT', `IxP step "${step}" has no \`project\`. That is the extractor's whole node type, and it carries the `
-            + `project version id and folder key the platform resolves the deployment by. Copy it from the registry `
-            + `— never construct it: three different spellings of its tail exist in deployed flows.`, `project: 'uipath.ixp.<slug>.<projectVersionId>-<folderKey>'  // uip maestro flow registry pull --force && uip maestro flow registry search -f "type:startsWith=uipath.ixp"`);
-    }
-    else if (!project.startsWith('uipath.ixp.')) {
-        at('IXP_PROJECT_NOT_NODE_TYPE', `IxP step "${step}"'s \`project\` is ${JSON.stringify(inputs.project)}, which is not a \`uipath.ixp.*\` node `
-            + `type. This field takes the type verbatim from \`registry search\`, not the project's name or id — the `
-            + `name goes in \`name\` and the slug in \`modelName\`.`);
-    }
-    else if (parseIxpProjectType(project) === undefined) {
-        at('IXP_PROJECT_TAIL_UNPARSEABLE', `IxP step "${step}"'s \`project\` ends in ${JSON.stringify(project.slice(project.lastIndexOf('.') + 1))}, which is `
-            + `not the \`<projectVersionId>-<folderKey>\` pair of uuids the current registry serves. Two older spellings `
-            + `exist in the corpus — a sanitized folder path, and the literal string "undefined" — and neither resolves `
-            + `today. Re-read the type from \`registry search\` after \`registry pull --force\`.`);
-    }
+    // A `project` that is missing, not a `uipath.ixp.*` type, or whose tail does
+    // not parse is the serializer's IXP_NO_PROJECT / IXP_PROJECT_NOT_NODE_TYPE /
+    // IXP_PROJECT_TAIL_UNPARSEABLE.
     if (blank(inputs?.modelName)) {
         at('IXP_NO_MODEL_NAME', `IxP step "${step}" has no \`modelName\`. The definition marks it required (\`minLength: 1\`) and the `
             + `platform's \`ixp-node\` validator refuses an empty one — it is the project's own name as the tenant `
@@ -273,7 +269,7 @@ function checkIxpExtract(inputs, ctx) {
  * author named, and the fixed output pair.
  */
 function serializeIxpExtract(s, ctx) {
-    const def = ixpExtractDef(s); // throws on an unparseable project
+    const def = ixpExtractDef(s, ctx.step); // throws on an unparseable project
     const { versionId } = parseIxpProjectType(s.project); // ixpExtractDef threw if it could not parse
     // The bindings first: two steps on the same project share ONE pair, and the
     // definition's `model.bindings.resourceKey` names the key they hang off.

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

@@ -88,15 +88,10 @@ export function checkHitl(inputs, ctx) {
     // Per-outcome exits are not a version question: quick-form draws one handle
     // per outcome like the base node, so it may ask for them; the two app-backed
     // variants read their outcomes from the app and leave on `completed`.
+    // Asking a variant for either is the serializer's HITL_OUTCOME_PORTS_VARIANT;
+    // the rules below assume a task that can have what it asks for.
     if (variant !== undefined
         && (inputs?.exposeError === true || (inputs?.outcomePorts === true && !hitlDerivesOutcomeHandles(variant)))) {
-        at('HITL_OUTCOME_PORTS_VARIANT', inputs?.exposeError === true
-            ? `Human task "${step}" asks for exposeError, but its variant is "${variant}" — the error output `
-                + `exists only on the base node type's 1.2 definition.`
-            : `Human task "${step}" asks for outcomePorts, but its variant is "${variant}", which reads its `
-                + `outcomes from its app and leaves on its single 'completed' exit.`, inputs?.exposeError === true
-            ? 'Omit `variant`, or drop exposeError.'
-            : `Route on out('${step}', 'Action') downstream.`);
         return;
     }
     // `legacyCompleted: true` keeps a pre-#3512 file's `completed` edge (#1197).
@@ -104,11 +99,9 @@ export function checkHitl(inputs, ctx) {
     // rarely what the author wants, and `flow validate` says nothing about it.
     if (inputs?.legacyCompleted === true) {
         const outcomes = Array.isArray(inputs?.outcomes) ? inputs.outcomes : [];
-        if (inputs?.outcomePorts !== undefined || inputs?.exposeError === true) {
-            at('HITL_LEGACY_COMPLETED_CONFLICT', `Human task "${step}" sets legacyCompleted: true, which leaves it on its single 'completed' handle, and also `
-                + `${inputs?.exposeError === true ? 'exposeError' : 'outcomePorts'}, which asks for per-outcome exits.`, 'Drop `legacyCompleted`.');
+        // With outcomePorts or exposeError too it is the serializer's HITL_LEGACY_COMPLETED_CONFLICT.
+        if (inputs?.outcomePorts !== undefined || inputs?.exposeError === true)
             return;
-        }
         if (!hitlDerivesOutcomeHandles(variant) || outcomes.length === 0) {
             // Its own code: this flow compiles, so the code is check's alone.
             at('HITL_LEGACY_COMPLETED_NO_EFFECT', `Human task "${step}" sets legacyCompleted: true, but ${outcomes.length === 0 ? 'it has no outcomes'

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

@@ -579,16 +579,16 @@ function hitlAt(typeName, version, factory) {
             const pinned = ctx.pinnedVersion;
             const exitModel = hitlExitModel(inputs, pinned);
             if (typeName !== BASE && inputs?.exposeError === true) {
-                throw new CompileRefusal('HITL_OUTCOME_PORTS_VARIANT', `"${ctx.step}": exposeError needs the base human task's 1.2 definition, which adds the `
-                    + `error output — the '${inputs?.variant}' variant has no such version. Drop the variant or exposeError.`);
+                throw new CompileRefusal('HITL_OUTCOME_PORTS_VARIANT', `Human task "${ctx.step}" asks for exposeError, but its variant is "${inputs?.variant}" — the error output `
+                    + `exists only on the base node type's 1.2 definition.`, 'Omit `variant`, or drop exposeError.');
             }
             if (inputs?.outcomePorts === true && !OUTCOME_HANDLE_NODE_TYPES.has(typeName)) {
-                throw new CompileRefusal('HITL_OUTCOME_PORTS_VARIANT', `"${ctx.step}": outcomePorts: true, but the '${inputs?.variant}' variant reads its outcomes `
-                    + `from its app and leaves on its single 'completed' exit. Route on out('${ctx.step}', 'Action') downstream.`);
+                throw new CompileRefusal('HITL_OUTCOME_PORTS_VARIANT', `Human task "${ctx.step}" asks for outcomePorts, but its variant is "${inputs?.variant}", which reads its `
+                    + `outcomes from its app and leaves on its single 'completed' exit.`, `Route on out('${ctx.step}', 'Action') downstream.`);
             }
             if (inputs?.legacyCompleted === true && (inputs?.outcomePorts !== undefined || inputs?.exposeError === true)) {
-                throw new CompileRefusal('HITL_LEGACY_COMPLETED_CONFLICT', `"${ctx.step}": legacyCompleted: true leaves the task on its single 'completed' handle, so it cannot also `
-                    + `${inputs?.exposeError === true ? 'expose the error output (exposeError)' : 'set outcomePorts'}. Drop one.`);
+                throw new CompileRefusal('HITL_LEGACY_COMPLETED_CONFLICT', `Human task "${ctx.step}" sets legacyCompleted: true, which leaves it on its single 'completed' handle, and also `
+                    + `${inputs?.exposeError === true ? 'exposeError' : 'outcomePorts'}, which asks for per-outcome exits.`, 'Drop `legacyCompleted`.');
             }
             if (inputs?.legacyCompleted === true && typeName === BASE && (pinned === '1.1' || pinned === '1.2')) {
                 throw new CompileRefusal('HITL_LEGACY_COMPLETED_VERSION', `"${ctx.step}": legacyCompleted: true, but { version: '${pinned}' } pins the task's per-outcome definition, `
@@ -615,7 +615,16 @@ function hitlAt(typeName, version, factory) {
             // Every human-task definition declares one static source handle,
             // `completed`: the real exit on an app-backed task and on one with no
             // outcomes, and the author's explicit choice with `legacyCompleted: true`.
-            return { ...contribution, port: 'completed', ...(exitModel.legacyCompleted ? { legacyCompleted: true } : {}) };
+            const outcomes = Array.isArray(inputs?.outcomes) ? inputs.outcomes : [];
+            const noOutcomePorts = {
+                why: outcomes.length === 0 ? 'it declares no outcomes'
+                    : exitModel.legacyCompleted ? 'it sets legacyCompleted: true'
+                        : `the '${String(inputs?.variant)}' variant reads its outcomes from its app`,
+                suggestion: exitModel.legacyCompleted
+                    ? 'drop `legacyCompleted` (and set outcomePorts: true to route each outcome)'
+                    : `route on out('${ctx.step}', 'Action') downstream`,
+            };
+            return { ...contribution, port: 'completed', noOutcomePorts, ...(exitModel.legacyCompleted ? { legacyCompleted: true } : {}) };
         },
         deserialize: (node, ctx) => liftHitl(node, typeName, ctx),
         print: printHitl,

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

@@ -88,27 +88,9 @@ export function checkHttp(inputs, ctx) {
                 + `Integration Service connection or an .onError() handler.`);
         }
     }
-    const connection = inputs?.connection;
-    const folder = inputs?.folder;
-    const targetConnector = inputs?.targetConnector;
-    const bindingConfigured = connection !== undefined || folder !== undefined;
-    const targetConfigured = targetConnector !== undefined;
-    const nonEmpty = (value) => typeof value === 'string' && value.trim().length > 0;
-    if (!inputs?.managed && (bindingConfigured || targetConfigured)) {
-        ctx.report('HTTP_BINDING_REQUIRES_MANAGED', `Step "${step}" supplies Integration Service connection settings to the standalone HTTP node. `
-            + `Only the managed node can use connection, folder, or targetConnector.`, `managed: true`);
-    }
-    else if (inputs?.managed && bindingConfigured && (!nonEmpty(connection) || !nonEmpty(folder))) {
-        ctx.report('HTTP_MANAGED_BINDING_INCOMPLETE', `Managed HTTP step "${step}" must name both a non-empty \`connection\` and \`folder\`. The platform `
-            + `needs the pair to resolve the Integration Service connection at runtime.`, `connection: 'http', folder: 'shared'`);
-    }
-    if (inputs?.managed && targetConfigured && !nonEmpty(targetConnector)) {
-        ctx.report('HTTP_TARGET_CONNECTOR_EMPTY', `Managed HTTP step "${step}" sets an empty \`targetConnector\`; name its Integration Service connector key.`, `targetConnector: 'uipath-salesforce-slack'`);
-    }
-    else if (inputs?.managed && targetConfigured && !bindingConfigured) {
-        ctx.report('HTTP_TARGET_CONNECTOR_REQUIRES_BINDING', `Managed HTTP step "${step}" sets \`targetConnector\` without a connection and folder. `
-            + `A connector-specific fallback needs the binding pair whose authentication it reuses.`, `connection: 'slack', folder: 'shared'`);
-    }
+    // Connection settings on the standalone node, an incomplete pair, and an
+    // empty or unbound `targetConnector` are the serializer's HTTP_BINDING_* /
+    // HTTP_MANAGED_BINDING_INCOMPLETE / HTTP_TARGET_CONNECTOR_*.
     const timeout = inputs?.timeout;
     if (timeout !== undefined) {
         if (typeof timeout !== 'string' || !ISO8601_DURATION.test(timeout.trim())) {
@@ -138,16 +120,8 @@ export function checkHttp(inputs, ctx) {
 export function checkHttpStep(inputs, ctx) {
     const step = ctx.step;
     checkHttp(inputs, ctx);
-    // Only a complete pair: an empty half is HTTP_MANAGED_BINDING_INCOMPLETE, which
-    // serialize refuses before it resolves either name.
-    const pair = inputs;
-    const filled = (v) => typeof v === 'string' && v.trim() !== '';
-    if (pair?.managed && filled(pair.connection) && filled(pair.folder)) {
-        const target = pair.targetConnector;
-        ctx.bindingLabels(`managed http "${step}"`, pair, 
-        // The connector its CONNECTION belongs to: the target, not the wrapper.
-        { id: step, connector: typeof target === 'string' && target !== '' ? target : 'uipath-uipath-http' });
-    }
+    // A managed step's binding labels are the serializer's (BINDING_*), as a
+    // connector step's are.
     const seen = new Set();
     for (const b of inputs?.branches ?? []) {
         if (!/^[A-Za-z0-9_-]+$/.test(b.name)) {