@uipath/maestro-builder-sdk 6.17.3 → 6.17.5

package/dist/check.js

@@ -9,7 +9,7 @@ import { Expr, SCHEDULE_PRESETS, DELAY_PRESETS, VARIANT_OPERATION, parseIxpProje
 import { FlowNode } from './core/node-classes.js';
 import { planContributionBindings } from './core/contribution-bindings.js';
 import { definitionHasErrorPort, errorPortRefusal } from './core/error-port.js';
-import { resolveContributionDefinition } from './serialize.js';
+import { bundledActionNodeType, bundledDefinition, resolveContributionDefinition } from './serialize.js';
 import { QUEUE_ITEM_RECORD_SCHEMA } from './core/queue-record.js';
 import { AGENTIC_PROCESS_FORMS } from './core/agentic-process-forms.js';
 import { checkEventResolution, checkEventSubscription, eventParamsFor, } from './core/event-checks.js';
@@ -5341,29 +5341,24 @@ function collectActionExprs(s, out, errorSource) {
     }
 }
 /**
- * The node types that HAVE an error port — the definitions that carry
- * `supportsErrorHandling: true`, plus the families whose def is per-tenant and
- * declares it too (rpa / api-workflow / agentic-process / agent / connector).
+ * The families whose definition is built per tenant or per call, so there is no
+ * bundled definition to ask, and whose definitions all have
+ * an error port (the SDK's own `rpaWorkflowDef` / `apiWorkflowDef` /
+ * `agenticProcessDef` / `agentDef` / `ixpExtractDef` set
+ * `supportsErrorHandling: true`; Integration Service connector activities
+ * declare the `error` handle).
  *
- * Read as a list rather than off the bundled defs because three of these have no
- * bundled def at all: their definitions are synthesized per call from the tenant.
+ * Every family with a bundled definition is NOT listed: its answer comes from
+ * that definition (`bundledActionNodeType` + `definitionHasErrorPort`), so a
+ * family cannot drift from its definition again (#1011: `documentClassify` was
+ * missing here although `uipath.document.classify@1.0` sets the flag).
+ *
+ * Not listed, deliberately: `publishedFunction` (its synthesized definition sets
+ * the flag, but no run has measured a function failure routing; it stays
+ * refused until one does) and `waitEvent` (an event wait resumes or does not).
  */
-const ERROR_PORT_SPEC_KINDS = new Set([
-    'http', 'script', 'transform', 'subflow', 'connector',
-    'queueItem', 'rpaWorkflow', 'apiWorkflow', 'agenticProcess', 'agent', 'inlineAgent',
-    // The two AI patterns. Both definitions have always carried
-    // `supportsErrorHandling: true` — the bundled copies just did not declare the
-    // `error` HANDLE to go with it, so nothing here could have been read off them
-    // (fixed in the same card). Their failures are the ones most worth routing: the
-    // service refuses a file it cannot read, and the reason arrives in
-    // `err('<step>', 'detail')` verbatim — e.g. "No valid files to use for
-    // Summarization."
-    'summarize', 'batchTransform',
-    // Document extraction. Every extractor's definition declares
-    // `supportsErrorHandling: true` and an `error` handle gated on
-    // `errorHandlingEnabled` — and its failures are the ones most worth routing
-    // (an unreadable document, or a classification with no match).
-    'ixpExtract',
+const PER_TENANT_ERROR_PORT_KINDS = new Set([
+    'connector', 'rpaWorkflow', 'apiWorkflow', 'agenticProcess', 'agent', 'ixpExtract',
 ]);
 /** The five fields the platform's error envelope declares — no more, no less. */
 // The five the definitions declare, plus the two every probed runtime envelope
@@ -5428,11 +5423,23 @@ function checkOnError(_handler, step, diags) {
         return;
     }
     const spec = step.spec;
-    if (!ERROR_PORT_SPEC_KINDS.has(spec.kind)) {
+    // A typed family with a bundled definition: ask the definition serialize will
+    // emit, at the version it will emit (#1011). For instance `voiceAgent()`
+    // defaults to uipath.agent.voice@1.0 (no error port) and `{ version: '1.1' }`
+    // selects @1.1 (which has one).
+    // A version the SDK does not bundle (an inline agent's registry version) has
+    // no definition here to ask; version resolution reports that, not this check.
+    const bundledType = bundledActionNodeType(spec);
+    const bundledDef = bundledType ? bundledDefinition(bundledType, step.options?.version) : undefined;
+    const noPort = bundledType
+        ? bundledDef !== undefined && !definitionHasErrorPort(bundledDef)
+        : !PER_TENANT_ERROR_PORT_KINDS.has(spec.kind);
+    if (noPort) {
+        const nodeType = bundledDef ? ` (${bundledDef.nodeType}@${bundledDef.version})` : '';
         diags.push({
             level: 'error',
             code: 'ONERROR_NO_ERROR_PORT',
-            message: `Step "${step.name}" is a ${spec.kind} step, and that node type has no error port — its definition does not `
+            message: `Step "${step.name}" is a ${spec.kind} step${nodeType}, and that node type has no error port — its definition does not `
                 + `set supportsErrorHandling, so the edge would leave a handle the node does not have. Handle the failure `
                 + `downstream instead (a delay cannot fail; a wait resumes or does not).`,
             step: step.name,

package/dist/core/cli-library.js

@@ -96,7 +96,8 @@ export function connectorCheckOpts(library, bindings, inputErrors = (rc, inputs,
         },
         // The refusal compile throws for an operation it cannot resolve, with its
         // code and text: CONNECTOR_NOT_IN_LIBRARY, CONNECTOR_OBJECT_REQUIRED,
-        // CONNECTOR_OBJECT_NOT_GENERIC.
+        // CONNECTOR_OBJECT_NOT_GENERIC, CONNECTOR_LIBRARY_ENTRY_UNREADABLE, or
+        // CONNECTOR_RESOLVE_FAILED for any other throw.
         connectorResolveError: (spec) => {
             const r = resolve(spec);
             return 'error' in r ? r.error : undefined;
@@ -114,11 +115,19 @@ export function connectorCheckOpts(library, bindings, inputErrors = (rc, inputs,
         ...(bindings ? { bindings } : {}),
     };
 }
+/** `check`'s code for an untyped throw from `library.resolve`; see {@link connectorResolver}. */
+const CONNECTOR_RESOLVE_FAILED = 'CONNECTOR_RESOLVE_FAILED';
 /**
  * `library.resolve` for one connector step, memoized per step for the life of
- * one check's options. A {@link ConnectorResolveError} is the refusal compile
- * throws and becomes `error`; anything else thrown is not a verdict about the
- * author's source and stays "unknown", as before.
+ * one check's options.
+ *
+ * This is the exact call `serialize` makes, so ANY throw here is a throw compile
+ * makes too, and becomes `error`. A {@link ConnectorResolveError} keeps its own
+ * code (CONNECTOR_NOT_IN_LIBRARY, CONNECTOR_LIBRARY_ENTRY_UNREADABLE, …).
+ * Anything else, which `library.resolve` does not throw on purpose, is reported
+ * as CONNECTOR_RESOLVE_FAILED with its message. Treating an untyped throw as
+ * "unknown" used to let `check` pass a step `compile` then died on (#1015); the
+ * event twin, `eventResolveErrorFor`, already reported every throw.
  */
 function connectorResolver(library) {
     const memo = new Map();
@@ -132,7 +141,7 @@ function connectorResolver(library) {
             catch (error) {
                 r = error instanceof ConnectorResolveError
                     ? { error: { code: error.code, message: error.message } }
-                    : { unknown: true };
+                    : { error: { code: CONNECTOR_RESOLVE_FAILED, message: error instanceof Error ? error.message : String(error) } };
             }
             memo.set(id, r);
         }

package/dist/core/error-port.d.ts

@@ -22,4 +22,6 @@ export declare function definitionHasErrorPort(def: any): boolean;
  * The ONERROR_NO_ERROR_PORT sentence for a definition-backed node, naming its
  * node type. Shared with serialize, which throws it for the same node.
  */
-export declare function errorPortRefusal(stepName: string, def: any): string;
+export declare function errorPortRefusal(stepName: string, def: any, o?: {
+    bundled?: boolean;
+}): string;

package/dist/core/error-port.js

@@ -28,9 +28,9 @@ export function definitionHasErrorPort(def) {
  * The ONERROR_NO_ERROR_PORT sentence for a definition-backed node, naming its
  * node type. Shared with serialize, which throws it for the same node.
  */
-export function errorPortRefusal(stepName, def) {
+export function errorPortRefusal(stepName, def, o = {}) {
     return `Step "${stepName}" is a ${def?.nodeType}@${def?.version} node, and its definition has no error port: `
         + `it does not set supportsErrorHandling: true and declares no "error" source handle, so the edge would leave a `
-        + `handle the node does not have. Handle the failure downstream instead, or pass the definition exactly as `
-        + `\`uip maestro flow registry get\` returns it.`;
+        + `handle the node does not have. Handle the failure downstream instead`
+        + (o.bundled ? '.' : `, or pass the definition exactly as \`uip maestro flow registry get\` returns it.`);
 }

package/dist/core/library.d.ts

@@ -225,7 +225,12 @@ export type ConnectorResolveCode =
 /** A GENERIC operation (one entry per object) named without an `object`. */
  | 'CONNECTOR_OBJECT_REQUIRED'
 /** An `object` on a single, non-generic operation. */
- | 'CONNECTOR_OBJECT_NOT_GENERIC';
+ | 'CONNECTOR_OBJECT_NOT_GENERIC'
+/**
+ * The index lists the operation, but its entry file or `.v1def.json` sidecar is
+ * missing or not valid JSON: the library on disk is incomplete (#1015).
+ */
+ | 'CONNECTOR_LIBRARY_ENTRY_UNREADABLE';
 /**
  * The refusal {@link Library.resolve} throws, with a `code` for each reason.
  *

package/dist/core/library.js

@@ -827,8 +827,13 @@ export class Library {
     }
     build(dir, e, nodeType, opts = {}) {
         const entryPath = join(dir, e.path);
-        const entry = JSON.parse(readFileSync(entryPath, 'utf8'));
-        const v1def = readV1def(entryPath);
+        // The two files the index row promises. A missing or corrupt one is a fault in
+        // the library on disk, not in the author's source, but compile cannot go on
+        // without it, so it is a typed refusal like the others: `check` reports it with
+        // the same code and text instead of passing a step compile then dies on with a
+        // bare ENOENT (#1015).
+        const entry = readLibraryFile(nodeType, entryPath, () => JSON.parse(readFileSync(entryPath, 'utf8')));
+        const v1def = readLibraryFile(nodeType, v1defPathOf(entryPath), () => readV1def(entryPath));
         // A stamped object (case 4) reaches here with the index entry's `objectName`
         // replaced but the sibling's FILE on disk — so restate the object and derive
         // the endpoint from the sibling's own template, rather than shipping a node
@@ -944,6 +949,33 @@ function deriveObjectPath(operation, objectName) {
     }
     return out;
 }
+/** The `.v1def.json` sidecar path beside a library entry file. */
+function v1defPathOf(entryPath) {
+    return entryPath.replace(/\.json$/, '.v1def.json');
+}
+/**
+ * Read one file an index row points at, turning a missing or unparsable file
+ * into {@link ConnectorResolveError} `CONNECTOR_LIBRARY_ENTRY_UNREADABLE`.
+ *
+ * The library build refuses to write an entry without its sidecar
+ * (`registry/library-build/plan.ts`), so this only fires for a library that was
+ * damaged after it was built: an interrupted pull, a hand-edited overlay. The
+ * remedy is the same either way: rebuild the layer the file belongs to.
+ */
+function readLibraryFile(nodeType, path, read) {
+    try {
+        return read();
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        // ENOENT already names the path; a JSON SyntaxError does not.
+        const reason = message.includes(path) ? message : `${path}: ${message}`;
+        throw new ConnectorResolveError('CONNECTOR_LIBRARY_ENTRY_UNREADABLE', `connector library entry for ${nodeType} is unreadable: ${reason}. The library index lists `
+            + `this operation, but the file is missing or not valid JSON, so the library on disk is incomplete. `
+            + `Refresh it with \`${PULL_COMMAND}\`; if the file is in the \`connectors-local\` overlay, `
+            + `re-run the \`${prepareCommand()}\` that wrote it.`);
+    }
+}
 /**
  * Read the `.v1def.json` sidecar beside a library entry file, with a connection
  * definition's `model.bindings.resource` in the designer's canonical casing.
@@ -961,7 +993,7 @@ function deriveObjectPath(operation, objectName) {
  * validate and debug — which fold the case — passed.
  */
 function readV1def(entryPath) {
-    const raw = JSON.parse(readFileSync(entryPath.replace(/\.json$/, '.v1def.json'), 'utf8'));
+    const raw = JSON.parse(readFileSync(v1defPathOf(entryPath), 'utf8'));
     const v1def = Array.isArray(raw) ? raw[0] : raw;
     const bindings = v1def?.model?.bindings;
     if (typeof bindings?.resource === 'string' && bindings.resource.toLowerCase() === 'connection') {

package/dist/serialize.d.ts

@@ -88,6 +88,30 @@ export declare function serializeWithSidecars(built: BuiltFlow, opts?: Serialize
         json: unknown;
     }>;
 };
+/**
+ * The node type a typed action compiles to, when that type's definition is
+ * bundled in `core-definitions.json`. `undefined` for a family whose definition
+ * is built per tenant or per call (connector, rpaWorkflow, apiWorkflow,
+ * agenticProcess, publishedFunction, agent, ixpExtract) and for a spec this SDK
+ * does not lower by kind.
+ *
+ * The http / transform / delay / script emit path reads its type from here too,
+ * so the answer `check` gets is the type `serialize` writes.
+ */
+export declare function bundledActionNodeType(spec: {
+    kind?: string;
+    inputs?: any;
+} | undefined): string | undefined;
+/**
+ * The bundled definition of `nodeType` that `makeNode` resolves: the author's
+ * exact `{ version }` when given, otherwise the pinned default (the first
+ * bundled entry). `undefined` when the SDK does not ship that type or version.
+ *
+ * For instance, `uipath.agent.voice` resolves to `@1.0` by default (no
+ * `supportsErrorHandling`) and to `@1.1` with `{ version: '1.1' }` (which sets
+ * it), so the error-port answer depends on the version.
+ */
+export declare function bundledDefinition(nodeType: string, requestedVersion?: string): any | undefined;
 /**
  * Resolve a contribution's {@link DefinitionReference} to a concrete manifest —
  * exactly (design §2.6/§4.2): the named version resolves or compilation fails,

package/dist/serialize.js

@@ -651,8 +651,12 @@ const INLINE_AGENT_TYPE = 'uipath.agent.autonomous';
  *  - **61 deployed, debug-green agent instances** across 61 dated
  *    `skill-flow-{coded,lowcode}-agent` artifacts (05-18 → 07-29): `sortOrder: 505`
  *    in 61/61, the `<folderPath>.<name>` resourceKey in 58/61 (the 3 exceptions are
- *    the in-solution shape — a bare project GUID and an EMPTY folderPath — which
- *    404s at job start, so they are not a second convention), and the descriptor
+ *    the in-solution shape — a bare key and an EMPTY folderPath — which 404'd at
+ *    job start in those runs; that is the shape of `location: 'in-solution'`,
+ *    built by `processResourceLocation`, and it starts the job when the sibling is
+ *    in the solution: 54 v1 `skill-flow-coded-agent` runs, 09-01 → 10-08, carry
+ *    `isInSolution: true`, 45 score 1.0 and none of the other 9 fails on a
+ *    job-start 404, #1012), and the descriptor
  *    ARRAY `bindings.values` in 59/61 (2 early runs used the object form);
  *  - flow-v1's own generator, which is where those come from:
  *    `node-manifest-builder.ts::createModel` hard-codes `bpmn:ServiceTask` for every
@@ -676,9 +680,11 @@ const INLINE_AGENT_TYPE = 'uipath.agent.autonomous';
  * `display.icon` — which is why one factory serves both.
  */
 function agentDef(spec) {
-    const inSolution = spec.location === 'in-solution';
-    const folderPath = inSolution ? '' : (spec.folderPath ?? '');
-    const resourceKey = inSolution ? spec.key : `${folderPath}.${spec.name}`;
+    // One location slot with the other process resources: the in-solution
+    // model carries `projectId`, `projectName` AND `isInSolution: true`, as
+    // flow-core's `createModel` writes for every sibling-project resource.
+    const loc = processResourceLocation(spec);
+    const { inSolution, resourceKey } = loc;
     const properties = {};
     for (const [k, v] of Object.entries(spec.inputs)) {
         properties[k] = { type: typeof v === 'number' ? 'number' : typeof v === 'boolean' ? 'boolean' : 'string' };
@@ -688,8 +694,8 @@ function agentDef(spec) {
         version: '1.0.0',
         category: 'agent',
         runtimeConstraints: { exclude: ['api-function'] },
-        description: inSolution ? `(In-solution) ${spec.name}` : `(${folderPath})`,
-        tags: inSolution ? ['in-solution', 'local'] : [],
+        description: loc.description,
+        tags: loc.tags,
         sortOrder: 505,
         supportsErrorHandling: true,
         display: {
@@ -700,19 +706,12 @@ function agentDef(spec) {
             { position: 'left', handles: [{ id: 'input', type: 'target', handleType: 'input' }] },
             { position: 'right', handles: [{ id: 'output', type: 'source', handleType: 'output' }] },
         ],
-        ...(inSolution
-            ? {
-                toolbarExtensions: {
-                    design: { actions: [{ id: 'open-workflow', icon: 'external-link', label: 'Open' }] },
-                },
-                projectId: spec.projectId,
-            }
-            : {}),
+        ...loc.definitionExtras,
         model: {
             type: 'bpmn:ServiceTask',
             serviceType: 'Orchestrator.StartAgentJob',
             version: 'v2',
-            ...(!inSolution ? { section: 'Published' } : {}),
+            ...(inSolution ? {} : { section: 'Published' }),
             bindings: {
                 resource: 'process',
                 resourceSubType: 'Agent',
@@ -720,10 +719,10 @@ function agentDef(spec) {
                 orchestratorType: 'agent',
                 values: [
                     { name: 'name', propertyAttribute: 'name', default: spec.name },
-                    { name: 'folderPath', propertyAttribute: 'folderPath', default: folderPath },
+                    { name: 'folderPath', propertyAttribute: 'folderPath', default: loc.folderPath },
                 ],
             },
-            ...(inSolution ? { projectId: spec.projectId, projectName: spec.name } : {}),
+            ...loc.modelExtras,
             context: [
                 { name: 'name', type: 'string', value: '<bindings.name>' },
                 { name: 'folderPath', type: 'string', value: '<bindings.folderPath>' },
@@ -3924,6 +3923,58 @@ function describeDeclared(bindings) {
         return ' (no bindings.json was loaded)';
     return names.length ? ` (bindings.json declares: ${names.join(', ')})` : ' (bindings.json declares no entries)';
 }
+/**
+ * The node type a typed action compiles to, when that type's definition is
+ * bundled in `core-definitions.json`. `undefined` for a family whose definition
+ * is built per tenant or per call (connector, rpaWorkflow, apiWorkflow,
+ * agenticProcess, publishedFunction, agent, ixpExtract) and for a spec this SDK
+ * does not lower by kind.
+ *
+ * The http / transform / delay / script emit path reads its type from here too,
+ * so the answer `check` gets is the type `serialize` writes.
+ */
+export function bundledActionNodeType(spec) {
+    switch (spec?.kind) {
+        case 'http': return spec.inputs?.managed ? NODE_TYPE.httpV2 : NODE_TYPE.http;
+        case 'transform': return transformNodeType(spec.inputs);
+        case 'hitl': return hitlNodeType(spec.inputs);
+        case 'queueItem': return spec.inputs?.wait ? NODE_TYPE.queueCreateAndWait : NODE_TYPE.queueCreate;
+        case 'inlineAgent': return INLINE_AGENT_TYPE;
+        case 'delay':
+        case 'script':
+        case 'mock':
+        case 'subflow':
+        case 'summarize':
+        case 'batchTransform':
+        case 'documentClassify':
+        case 'dynamicExtract':
+        case 'dataFabricRead':
+        case 'dataFabricCreate':
+        case 'dataFabricUpdate':
+        case 'dataFabricDelete':
+        case 'sendMessage':
+        case 'waitForMessage':
+        case 'conversationContext':
+        case 'createOutgoingCall':
+        case 'endCall':
+        case 'voiceAgent':
+        case 'conversationalAgent':
+            return NODE_TYPE[spec.kind];
+        default: return undefined;
+    }
+}
+/**
+ * The bundled definition of `nodeType` that `makeNode` resolves: the author's
+ * exact `{ version }` when given, otherwise the pinned default (the first
+ * bundled entry). `undefined` when the SDK does not ship that type or version.
+ *
+ * For instance, `uipath.agent.voice` resolves to `@1.0` by default (no
+ * `supportsErrorHandling`) and to `@1.1` with `{ version: '1.1' }` (which sets
+ * it), so the error-port answer depends on the version.
+ */
+export function bundledDefinition(nodeType, requestedVersion) {
+    return requestedVersion !== undefined ? DEFS[`${nodeType}@${requestedVersion}`] : defByType.get(nodeType);
+}
 /**
  * Resolve a contribution's {@link DefinitionReference} to a concrete manifest —
  * exactly (design §2.6/§4.2): the named version resolves or compilation fails,
@@ -4687,11 +4738,24 @@ export function serialize(built, opts = {}) {
      * families are not recorded: their definitions are the SDK's own.
      */
     const contributionDefs = new Map();
-    /** Refuse an `error` edge from a contribution-lowered node whose definition has no error port. */
+    /**
+     * The bundled definition of every node `makeNode` resolved from
+     * `core-definitions.json` (no definition passed in), by node id (#1011). A
+     * definition built per tenant or per call (connector, rpa, queue, ixp) is not
+     * recorded: `check` answers for those from its per-tenant kind list.
+     */
+    const bundledNodeDefs = new Map();
+    /**
+     * Refuse an `error` edge from a node whose definition has no error port: a
+     * contribution-lowered node (#943) or a typed node with a bundled definition
+     * (#1011). Same predicate as `check`, so `compile --no-check` agrees with it.
+     */
     function refuseErrorEdgeWithoutPort(nodeId, stepName) {
-        const def = contributionDefs.get(nodeId);
-        if (def !== undefined && !definitionHasErrorPort(def))
-            throw new Error(errorPortRefusal(stepName, def));
+        const contributed = contributionDefs.get(nodeId);
+        const def = contributed ?? bundledNodeDefs.get(nodeId);
+        if (def !== undefined && !definitionHasErrorPort(def)) {
+            throw new Error(errorPortRefusal(stepName, def, { bundled: contributed === undefined }));
+        }
     }
     /**
      * Hoist a contribution's own bindings, then close every `<bindings.NAME>` its
@@ -4859,6 +4923,8 @@ export function serialize(built, opts = {}) {
         }
         if (def)
             emittedDefs.set(`${type}@${def.version}`, def);
+        if (def && !o.def)
+            bundledNodeDefs.set(id, def);
         const node = {
             id,
             type,
@@ -5265,17 +5331,14 @@ export function serialize(built, opts = {}) {
             // `AgentInputs.inputs`) and because the emitted binding subtype is `Agent`.
             const s = spec.inputs;
             const inSolution = s.location === 'in-solution';
-            const folderPath = inSolution ? '' : (s.folderPath ?? '');
             const def = agentDef({
-                key: s.key, name: s.name, folderPath, location: s.location, projectId: s.projectId,
+                key: s.key, name: s.name, folderPath: s.folderPath, location: s.location, projectId: s.projectId,
                 inputs: s.inputs, returns: s.returns, flavour: s.flavour,
             });
-            const { entries } = processResourceBindings({
-                name: s.name,
-                folderPath,
-                resourceSubType: 'Agent',
-                ...(inSolution ? { resourceKey: s.key } : {}),
-            }, resourceBindings);
+            // The pair's key and folder come off the definition, as for rpa / agentic
+            // steps: one place decides the in-solution shape.
+            const pairFolder = def.model.bindings.values.find((v) => v.name === 'folderPath').default;
+            const { entries } = processResourceBindings({ name: s.name, folderPath: pairFolder, resourceSubType: 'Agent', resourceKey: def.model.bindings.resourceKey }, resourceBindings);
             for (const b of entries)
                 resourceBindings.set(b.id, b);
             const id = stepUid(scope, step.name);
@@ -6428,10 +6491,7 @@ export function serialize(built, opts = {}) {
         if (!['http', 'transform', 'delay', 'script'].includes(spec.kind)) {
             throw new Error(`step "${step.name}": unknown action kind "${spec.kind}".`);
         }
-        const type = spec.kind === 'http' ? (spec.inputs.managed ? NODE_TYPE.httpV2 : NODE_TYPE.http)
-            : spec.kind === 'transform' ? transformNodeType(spec.inputs)
-                : spec.kind === 'delay' ? NODE_TYPE.delay
-                    : NODE_TYPE.script;
+        const type = bundledActionNodeType(spec);
         const id = stepUid(scope, step.name);
         const node = makeNode(type, id, step.name, { parentId, requestedVersion: step.options?.version });
         // Record the failure-envelope boundary BEFORE any expression is rendered, so

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/maestro-builder-sdk",
-  "version": "6.17.3",
+  "version": "6.17.5",
   "description": "Build UiPath Flow, Case, and BPMN artifacts by writing TypeScript.",
   "license": "MIT",
   "homepage": "https://docs.uipath.com/maestro",
@@ -92,5 +92,5 @@
     "@types/node": "^22.7.0",
     "esbuild": "^0.28.1"
   },
-  "gitref": "8da4aeeb1592a342b2ac705939e646cd77baa891"
+  "gitref": "5c050c27fe72360970e28b811ad581442140544f"
 }