@uipath/maestro-builder-sdk 6.21.1 → 6.22.0

package/dist/serialize.js

@@ -19,6 +19,7 @@ import { rawNodeInputProblem, registeredRawType } from './raw-node-advice.js';
 import { planContributionBindings } from './core/contribution-bindings.js';
 import { declaredErrorPortRefusal, definitionHasErrorPort, errorPortRefusal } from './core/error-port.js';
 import { FLOW_NODE_TYPES } from './flow-node-registry.js';
+import { stepExits } from './flow-step-exits.js';
 import { resolveVersion } from './core/nodes/versioned.js';
 import { isAnswerField } from './core/hitl-answers.js';
 import { connectionConnectors } from './bindings-v2.js';
@@ -28,7 +29,7 @@ import { genericEventObjectRefusal } from './core/event-checks.js';
 import { OUTCOME_HANDLE_NODE_TYPES, assertHitlExitInvariant, hitlExitModel, hitlExitViolation, outcomeIdOf, outcomeSlug } from './core/hitl-routing.js';
 import { STICKY_NOTE_TYPE, STICKY_NOTE_TYPE_VERSION } from './core/definitionless-node-types.js';
 import { placeholderPosition } from './node-placement.js';
-import { declaredExits, hasExits } from './core/step-ports.js';
+import { hasExits } from './core/step-ports.js';
 import { stopsAtEnd } from './flow-step-tree.js';
 import { assertNodeEnvelope } from './core/node-envelope.js';
 import { buildConfiguration } from './config.js';
@@ -97,8 +98,6 @@ const NODE_TYPE = {
     conversationalAgent: 'uipath.agent.conversational',
     createOutgoingCall: 'uipath.conversational.voice.create-outgoing-call',
     endCall: 'uipath.conversational.voice.end-call',
-    http: 'core.action.http',
-    httpV2: 'core.action.http.v2',
     hitl: 'uipath.human-in-the-loop',
     // The two other spellings of the SAME human task, both resolvable on this
     // tenant. `hitl()` emits the base type unless `variant` names one of these;
@@ -3336,27 +3335,6 @@ function subNodeId(obj, nodeId) {
     return JSON.parse(JSON.stringify(obj).split('{nodeId}').join(nodeId));
 }
 const NO_RENAME = { nodeIds: new Map(), errorEnvelopes: new Map() };
-/**
- * Which runtime variable holds a failed node's envelope, by node type.
- *
- * Measured on the product, one debug run per family (2026-09-10). Six of the
- * seven families probed publish it as `<step>.error`, which is what the
- * definitions declare (`outputDefinition.error.var`) and what `err()` writes, so
- * only the exceptions are listed here:
- *
- * - `core.action.http.v2` — `<step>.error` is the boolean `true` and the
- *   envelope is in `<step>.output` (instance 430d43ad-4583-40c0-8f74-b49d2c4904e4).
- *
- * `core.action.http` (plain, 1.0.0 and the 1.3 `flow migrate` produces) is NOT
- * an entry: it publishes no envelope anywhere, so there is no variable to name.
- * `check` refuses an error handler on it instead (HTTP_ONERROR_V1).
- *
- * Read with `ownEntry`: the envelope variable for a node type, or undefined when
- * it is the default `error`.
- */
-const ERROR_ENVELOPE_VAR = {
-    [NODE_TYPE.httpV2]: 'output',
-};
 /**
  * Append the flow's `.stickyNotes()` as real `stickyNote` nodes.
  *
@@ -3654,12 +3632,11 @@ function describeDeclared(bindings) {
  * 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.
+ * A registered kind (flow-node-registry.ts) is not listed: its type is the
+ * registry's.
  */
 export function bundledActionNodeType(spec) {
     switch (spec?.kind) {
-        case 'http': return spec.inputs?.managed ? NODE_TYPE.httpV2 : NODE_TYPE.http;
         case 'hitl': return hitlNodeType(spec.inputs);
         case 'inlineAgent': return INLINE_AGENT_TYPE;
         case 'subflow':
@@ -5006,8 +4983,6 @@ export function serialize(built, opts = {}) {
     if (!customTrigger)
         root.nodes.push(trigger);
     function successPort(type) {
-        if (type === NODE_TYPE.http || type === NODE_TYPE.httpV2)
-            return 'default';
         if (type === NODE_TYPE.loop)
             return 'success';
         // Every human-task definition declares one static source handle, `completed`.
@@ -5119,9 +5094,8 @@ export function serialize(built, opts = {}) {
         const id = stepUid(scope, step.name);
         // As for every typed family: record the failure-envelope boundary before any
         // expression renders, so a handler reading this step resolves correctly.
-        const envelope = ownEntry(ERROR_ENVELOPE_VAR, impl.typeName);
-        if (envelope)
-            scope.rename.errorEnvelopes.set(step.name, envelope);
+        if (impl.errorEnvelope)
+            scope.rename.errorEnvelopes.set(step.name, impl.errorEnvelope);
         const ctx = {
             step: step.name,
             version: impl.version,
@@ -5132,6 +5106,17 @@ export function serialize(built, opts = {}) {
             bind: (b) => { bound.push(b); },
             definition: (typeName, version) => bundledDefinition(typeName, version),
             bindings: resourceBindings,
+            resolveBinding: (name, attribute, at) => resolveBinding(opts, name, attribute, at),
+            bindConnection: (c) => {
+                const { entries } = connectionResourceBindings({
+                    def: { model: c.model },
+                    connectorKey: c.connectorKey,
+                    connectionId: c.connectionId,
+                    ...(c.folderKey !== undefined ? { folderKey: c.folderKey } : {}),
+                    ...(c.resourceKey !== undefined ? { resourceKey: c.resourceKey } : {}),
+                }, resourceBindings);
+                bound.push(...entries);
+            },
         };
         const bound = [];
         const contribution = impl.serialize(spec, ctx);
@@ -6247,43 +6232,7 @@ export function serialize(built, opts = {}) {
             }
             throw new Error(`step "${step.name}": not an action spec — pass a factory result, subflow(), or a FlowAction subclass instance.`);
         }
-        if (spec.kind !== 'http') {
-            throw new Error(`step "${step.name}": unknown action kind "${spec.kind}".`);
-        }
-        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
-        // a handler that reads this step resolves against the right variable. The
-        // handler is emitted after the step it guards, so recording it here is early
-        // enough.
-        const envelope = ownEntry(ERROR_ENVELOPE_VAR, type);
-        if (envelope)
-            scope.rename.errorEnvelopes.set(step.name, envelope);
-        // The guard above leaves http; registered kinds returned at the top.
-        node.inputs = actionInputs(spec, scope.rename, opts, step.name);
-        if (spec.kind === 'http') {
-            node.outputs = httpOutputs(node.outputs, spec.inputs.returns, spec.inputs.managed);
-            if (spec.inputs.managed) {
-                const binding = resolveManagedHttpBinding(spec.inputs, opts, `managed http "${step.name}"`);
-                const { entries } = connectionResourceBindings({
-                    def: { model: node.model },
-                    connectorKey: 'uipath-uipath-http',
-                    connectionId: binding?.connectionId ?? 'ImplicitConnection',
-                    folderKey: binding?.folderKey,
-                    // ImplicitConnection is the binding's default, not a remote
-                    // resource key. Keeping the key empty matches product-authored
-                    // manual HTTP nodes and lets the runtime supply the debug folder.
-                    ...(binding ? {} : { resourceKey: '' }),
-                }, resourceBindings);
-                for (const entry of entries)
-                    resourceBindings.set(entry.id, entry);
-            }
-        }
-        scope.nodes.push(node);
-        for (const t of tails)
-            addEdge(scope, t, id);
-        return [{ node: id, port: successPort(type) }];
+        throw new Error(`step "${step.name}": unknown action kind "${spec.kind}".`);
     }
     /**
      * Wire a step's `.onError(...)` handler — the edge out of the node's `error`
@@ -6472,8 +6421,8 @@ export function serialize(built, opts = {}) {
                 // The exits are resolved BEFORE the node is emitted, because a spec with
                 // no routable fan-out (a human task pinned to 1.0, a variant, an http
                 // with no branches) must refuse rather than emit a node and then
-                // discover it has one port. `declaredExits` carries the reason.
-                const exits = declaredExits(step.spec, step.options?.version);
+                // discover it has one port. `stepExits` carries the reason.
+                const exits = stepExits(step.spec, step.options?.version);
                 if (!hasExits(exits)) {
                     throw new Error(`.stepSwitch("${step.name}"): ${exits.reason}, so there are no exits to route.`
                         + (exits.suggestion ? ` ${exits.suggestion}` : ''));
@@ -7174,208 +7123,3 @@ export function assertBindingPlaceholdersResolve(flow) {
         + `"invalid GUID <bindings.…>") and refuses to publish. This is a serializer defect, not an authoring `
         + `error; report it with the flow source.`);
 }
-function actionInputs(spec, rename = NO_RENAME, opts = {}, stepName = '') {
-    if (spec.kind === 'http') {
-        const i = spec.inputs;
-        if (i.managed)
-            return managedHttpInputs(i, rename, opts, stepName);
-        if (i.connection !== undefined
-            || i.folder !== undefined
-            || i.targetConnector !== undefined) {
-            throw new Error('standalone http cannot use Integration Service connection settings; set managed: true');
-        }
-        const defaults = jsonClone(defByType.get(NODE_TYPE.http)?.inputDefaults ?? {});
-        return {
-            ...defaults,
-            method: i.method ?? 'GET',
-            url: renderValue(i.url, rename),
-            headers: renderMap(i.headers, rename),
-            queryParams: renderMap(i.query, rename),
-            body: i.body !== undefined ? renderValue(i.body, rename) : '',
-            contentType: i.contentType ?? 'application/json',
-            ...httpRequestSettings(i),
-            ...httpBranchRows(i, rename),
-        };
-    }
-    throw new Error(`internal SDK error: no inputs for action kind "${spec.kind}".`);
-}
-/**
- * `timeout` / `retryCount` — the two request settings BOTH http node types carry.
- *
- * **These fields were never MISSING from the emitted node.** Both definitions
- * declare them in `inputDefaults` (`timeout: 'PT15M'`, `retryCount: 0`) and the
- * `...defaults` spread has always carried them through, so every http node this
- * SDK ever emitted already said fifteen minutes and no retries. What the author
- * had no way to do was say anything ELSE — which is the actual gap, and why this
- * spreads AFTER the defaults rather than instead of them.
- *
- * Emitting only-when-set therefore does two things at once: an author's value
- * overrides the definition's, and an author who says nothing gets byte-for-byte
- * what they got before. (~99% of the 808 deployed http nodes are on the
- * defaults, so that is also the faithful shape.)
- *
- * `check` has already validated the FORM of both (`HTTP_TIMEOUT_NOT_DURATION`,
- * `HTTP_RETRY_COUNT_INVALID`), so this writes them through verbatim.
- */
-function httpRequestSettings(i) {
-    return {
-        ...(i.timeout !== undefined ? { timeout: i.timeout } : {}),
-        ...(i.retryCount !== undefined ? { retryCount: i.retryCount } : {}),
-    };
-}
-/**
- * The MANAGED HTTP node's inputs (`core.action.http.v2`).
- *
- * The platform routes this one through Integration Service's own HTTP connector,
- * so the request rides inside a connector `detail` envelope instead of sitting at
- * the top level. Every constant below is read off the deployed corpus (384
- * instances, 2026-05-11 → 07-29), not invented:
- *
- *   - `uiPathActivityTypeId` — ONE value across all 331 instances that carry it;
- *   - `detail.method: 'POST'` + `endpoint: '/http-request'` — 352 of 352. That is
- *     how the flow calls the CONNECTOR; the HTTP verb the connector performs
- *     lives in `bodyParameters.method` (GET on 309). Two `method`s, one value
- *     each, and swapping them silently turns every GET into a POST;
- *   - `connectionId: 'ImplicitConnection'` — 290 of 352 (the rest bind an
- *     explicit Integration Service connection);
- *   - the `configuration` blob, whose `=jsonString:` envelope the platform reads
- *     back as the activity's instance parameters.
- */
-/** The `branches` rows both HTTP definitions declare: id/name from the author's name, conditions rendered like a decision's. */
-function httpBranchRows(i, rename) {
-    if (!i.branches?.length)
-        return {};
-    return {
-        branches: i.branches.map((b) => ({
-            id: b.name,
-            name: b.name,
-            conditionExpression: renameRefs(b.condition.js, rename),
-        })),
-    };
-}
-function resolveManagedHttpBinding(i, opts, where) {
-    const configured = i.connection !== undefined || i.folder !== undefined;
-    if (!configured)
-        return undefined;
-    if (typeof i.connection !== 'string' || i.connection.trim() === ''
-        || typeof i.folder !== 'string' || i.folder.trim() === '') {
-        throw new Error('managed http connection mode requires both a non-empty connection and folder');
-    }
-    // The same resolution a connector step gets: a self-referential binding is an
-    // error, a stub is a warning. This used to be the one call site left on the
-    // silent `resolve(name) ?? name` spelling.
-    return {
-        connectionId: resolveBinding(opts, i.connection, 'connection', where),
-        folderKey: resolveBinding(opts, i.folder, 'folder', where),
-    };
-}
-function managedHttpInputs(i, rename, opts, stepName) {
-    const defaults = jsonClone(defByType.get(NODE_TYPE.httpV2)?.inputDefaults ?? {});
-    // Resolution is repeated by the caller that hoists the binding pair; only that
-    // one carries the `warn` sink, so a stub is reported once, not twice.
-    const binding = resolveManagedHttpBinding(i, { bindings: opts.bindings }, `managed http "${stepName}"`);
-    if (i.targetConnector !== undefined && !binding) {
-        throw new Error('managed http targetConnector requires both a non-empty connection and folder');
-    }
-    if (i.targetConnector !== undefined
-        && (typeof i.targetConnector !== 'string' || i.targetConnector.trim() === '')) {
-        throw new Error('managed http targetConnector must be a non-empty connector key');
-    }
-    const url = renderValue(i.url, rename);
-    const bodyParameters = {
-        authentication: binding ? 'connector' : 'manual',
-        method: i.method ?? 'GET',
-        ...(binding ? {
-            targetConnector: i.targetConnector ?? 'uipath-uipath-http',
-            connection: binding.connectionId,
-            path: url,
-        } : {}),
-        url,
-    };
-    const headers = renderMap(i.headers, rename);
-    if (Object.keys(headers).length > 0)
-        bodyParameters.headers = headers;
-    const query = renderMap(i.query, rename);
-    if (Object.keys(query).length > 0)
-        bodyParameters.query = query;
-    if (i.body !== undefined)
-        bodyParameters.body = renderValue(i.body, rename);
-    return {
-        ...defaults,
-        ...httpBranchRows(i, rename),
-        // TOP-LEVEL on the managed node too, NOT inside `detail` — the platform reads
-        // the request settings off the node, while `detail` is the connector call it
-        // wraps.
-        ...httpRequestSettings(i),
-        detail: {
-            connector: 'uipath-uipath-http',
-            connectionId: binding?.connectionId ?? 'ImplicitConnection',
-            connectionResourceId: binding?.connectionId ?? null,
-            connectionFolderKey: binding?.folderKey ?? null,
-            method: 'POST',
-            endpoint: '/http-request',
-            bodyParameters,
-            configuration: '=jsonString:' + JSON.stringify({
-                essentialConfiguration: {
-                    instanceParameters: {
-                        connectorKey: 'uipath-uipath-http',
-                        objectName: 'http-request',
-                        httpMethod: 'POST',
-                        activityType: 'Curated',
-                        version: '1.0.0',
-                    },
-                    objectName: 'http-request',
-                    operation: 'create',
-                    packageVersion: '1.0.0',
-                    httpMethod: 'POST',
-                    path: '/http-request',
-                    unifiedTypesCompatible: true,
-                    savedJitInputFieldId: 'in_http-request',
-                },
-            }),
-            uiPathActivityTypeId: '5c4cc855-b42a-37e6-b910-de8588998fce',
-            errorState: { issues: [] },
-            telemetryData: {
-                connectorKey: 'uipath-uipath-http',
-                connectorName: 'HTTP',
-                operationType: 'create',
-                objectName: 'http-request',
-                objectDisplayName: 'HTTP Request',
-                primaryKeyName: '',
-            },
-        },
-    };
-}
-/**
- * An HTTP node's declared parsed-JSON response shape, from the author's `returns`.
- *
- * The platform's own definition declares `output` as a bare object — only the API
- * being called knows its body — so a `body.<field>` read is unresolvable until the
- * author says what is in there. Same rule, same word, as `rpaWorkflow.returns`.
- */
-function httpOutputs(base, returns, managed) {
-    if (!returns || Object.keys(returns).length === 0)
-        return base;
-    const out = jsonClone(base);
-    if (!out.output)
-        return out;
-    // The whole `output` shape lives on the INSTANCE, not in the bundled
-    // definition — deliberately. An instance schema may refine a GENERIC definition
-    // object but never override one that already declares a
-    // shape, so declaring `body`/`statusCode` in the def would lock the author's
-    // `returns` out of the very read it exists to license. The definition stays
-    // byte-faithful to the platform's (a bare object, because only the API being
-    // called knows its body) and the author's declaration is the only source of
-    // shape — which is also what makes refusing a read with no `returns` correct.
-    out.output.properties = {
-        body: {
-            type: 'object',
-            description: managed
-                ? 'Response body, deserialized by Integration Service'
-                : 'JSON response body, deserialized by the standalone HTTP runtime',
-            properties: Object.fromEntries(Object.entries(returns).map(([name, type]) => [name, { type }])),
-        },
-        statusCode: { type: 'number', description: 'HTTP status code of the response' },
-    };
-    return out;
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/maestro-builder-sdk",
-  "version": "6.21.1",
+  "version": "6.22.0",
   "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": "fb7b702cde7f69674dfc8ed9e4eb171472e8d8e7"
+  "gitref": "b090b1119c411ed2ffdefab1d258d629ff624a1f"
 }