@uipath/maestro-builder-sdk 6.20.1 → 6.20.3

package/dist/api-index.md

@@ -219,8 +219,8 @@ could hand you spans for a version you do not have.
 | `SchedulePreset` | type | `dist/flow-sdk.d.ts:131` | Supporting types |  |
 | `script` | function | `dist/nodes/script/flow/factories.d.ts:7-14` | Actions | Declare an inline script action. |
 | `ScriptInputs` | interface | `dist/nodes/script/flow/spec.d.ts:7-44` | Option shapes | 2 field(s) |
-| `ScriptReturns` | type | `dist/core/script-return.d.ts:33-38` | Supporting types | What an author may write for `script({ returns })`: the type outright, or — for an object return — the FIELDS, which is… |
-| `ScriptReturnType` | type | `dist/core/script-return.d.ts:31-32` | Supporting types | The vocabulary a script's output can be declared as. |
+| `ScriptReturns` | type | `dist/core/script-return.d.ts:42-48` | Supporting types | What an author may write for `script({ returns })`: the type outright, or — for an object return — the FIELDS, which is… |
+| `ScriptReturnType` | type | `dist/core/script-return.d.ts:31-41` | Supporting types | The vocabulary a script's output can be declared as. |
 | `sendMessage` | function | `dist/core/actions.d.ts:2438-2456` | Actions | Post an assistant message into a live conversation (`uipath.conversational.send-message`). |
 | `SendMessageInputs` | interface | `dist/core/actions.d.ts:492-511` | Option shapes | 4 field(s) |
 | `ShownField` | interface | `dist/core/actions.d.ts:198-213` | Supporting types | A value the reviewer READS: shown on the form, filled in from the flow. |

package/dist/check.js

@@ -9,7 +9,7 @@ import { Expr, SCHEDULE_PRESETS, parseIxpProjectType, flatNameOf, flatNameSegmen
 import { FlowNode } from './core/node-classes.js';
 import { planContributionBindings } from './core/contribution-bindings.js';
 import { definitionHasErrorPort, errorPortRefusal } from './core/error-port.js';
-import { bundledActionNodeType, bundledDefinition, resolveContributionDefinition } from './serialize.js';
+import { bundledActionNodeType, bundledDefinition, perCallDefinition, resolveContributionDefinition } from './serialize.js';
 import { sdkFormFieldType } from './core/form-field-type.js';
 import { QUEUE_ITEM_RECORD_SCHEMA } from './core/queue-record.js';
 import { AGENTIC_PROCESS_FORMS } from './core/agentic-process-forms.js';
@@ -4814,6 +4814,7 @@ function checkRegisteredStep(entry, s, exprs, errorSource, opts, diags, typeOf,
         const ctx = {
             step: s.name,
             version: impl.version,
+            definition: () => bundledDefinition(impl.typeName, impl.version),
             report: (code, message, suggestion) => diags.push(catalogued(entry, s.name, code, message, suggestion)),
             declaredRef: (js) => {
                 const name = declaredRefName(js, triggerId);
@@ -4951,25 +4952,31 @@ function collectActionExprs(s, out, errorSource) {
     }
 }
 /**
- * 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).
+ * The families with no definition this SDK can ask, and an error port anyway:
+ * an Integration Service connector activity's definition comes from the
+ * connector library, and every connector activity declares the `error` handle.
  *
- * 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).
+ * Every other family is decided by a definition, never by a list:
  *
- * 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).
+ *  - a bundled family by its bundled definition (`bundledActionNodeType` +
+ *    `bundledDefinition`, #1011: `documentClassify` was missing from the old
+ *    list although `uipath.document.classify@1.0` sets the flag);
+ *  - a per-tenant family (`rpaWorkflow`, `apiWorkflow`, `agenticProcess`,
+ *    `publishedFunction`, `agent`, `ixpExtract`) by the definition serialize
+ *    synthesizes for it (`perCallDefinition`, #1040: `publishedFunction` was
+ *    refused here although `publishedFunctionDef` sets the flag).
+ *
+ * `publishedFunction`'s flag is measured, not assumed: on 2026-10-08 four
+ * `flow debug` jobs on alpha/codereval called `acme-echo` with a non-string
+ * `message` (null, object, number, array). In each, the function job failed
+ * (`Python.FUNCTION_EXECUTION_ERROR`, category User, status 502), the node's
+ * error boundary fired, and the handler's `err('message')` read
+ * "Failure in the Orchestrator Job".
+ *
+ * A kind in none of these (`waitEvent`) has no error port: an event wait
+ * resumes or does not.
  */
-const PER_TENANT_ERROR_PORT_KINDS = new Set([
-    'connector', 'rpaWorkflow', 'apiWorkflow', 'agenticProcess', 'agent', 'ixpExtract',
-]);
+const NO_DEFINITION_ERROR_PORT_KINDS = new Set(['connector']);
 /**
  * The ONERROR_NO_ERROR_PORT sentence for a typed step — a built-in family or a
  * registered node type — whose node type has no error port. One spelling for
@@ -5083,9 +5090,30 @@ placed) {
     // 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);
+    // A per-tenant family: ask the definition serialize synthesizes for it (#1040).
+    let perCallDef;
+    if (!bundledType) {
+        try {
+            perCallDef = perCallDefinition(spec);
+        }
+        catch {
+            // The family's own checks report a spec its builder cannot lower.
+            return;
+        }
+    }
+    const def = bundledType ? bundledDef : perCallDef;
+    const noPort = def !== undefined
+        ? !definitionHasErrorPort(def)
+        : !bundledType && !NO_DEFINITION_ERROR_PORT_KINDS.has(spec.kind);
+    if (noPort && perCallDef !== undefined) {
+        diags.push({
+            level: 'error',
+            code: 'ONERROR_NO_ERROR_PORT',
+            message: errorPortRefusal(step.name, perCallDef, { bundled: true }),
+            step: step.name,
+        });
+        return;
+    }
     if (noPort) {
         diags.push({
             level: 'error',

package/dist/core/script-return.d.ts

@@ -28,14 +28,24 @@
  * into a designer error — the exact defect this file exists to remove, pointed
  * the other way.
  */
-/** The vocabulary a script's output can be declared as. */
-export type ScriptReturnType = 'string' | 'number' | 'boolean' | 'object' | 'array';
+/**
+ * The vocabulary a script's output can be declared as.
+ *
+ * `'any'` is the platform's own declaration on `core.action.script@1.1` (the
+ * 1.0.0 definition says `'object'`), so it is valid only as the top-level
+ * `returns` of a 1.1 step; `check` refuses it on 1.0.0 and as a field type.
+ * Declaring it keeps the output open even when the body plainly returns one
+ * type; it is also how decompile writes back a 1.1 node whose output a designer
+ * left at that default.
+ */
+export type ScriptReturnType = 'string' | 'number' | 'boolean' | 'object' | 'array' | 'any';
 /**
  * What an author may write for `script({ returns })`: the type outright, or —
  * for an object return — the FIELDS, which is the spelling every other action's
- * `returns` uses (`http`, `rpaWorkflow`, `agent`).
+ * `returns` uses (`http`, `rpaWorkflow`, `agent`). A field's type is never
+ * `'any'`.
  */
-export type ScriptReturns = ScriptReturnType | Record<string, ScriptReturnType>;
+export type ScriptReturns = ScriptReturnType | Record<string, Exclude<ScriptReturnType, 'any'>>;
 /** A resolved output declaration: a type, and for objects the fields we know. */
 export interface ScriptOutputShape {
     type: ScriptReturnType;

package/dist/decompile.js

@@ -563,7 +563,9 @@ function emitRegisteredSpec(node, imp, inputNames) {
         sourceText: unwrapSource,
         plainValue: unwrapPlain,
         stepName: (nodeId) => nodeId,
-        definition: () => runDefs.get(`${node.type}@${version}`) ?? runDefs.get(node.type),
+        // The file's carried definition first; the bundled one at the node's version
+        // when the file carries none (a hand-trimmed or SDK-written file).
+        definition: () => runDefs.get(`${node.type}@${version}`) ?? BUNDLED_DEFINITIONS[`${node.type}@${version}`] ?? runDefs.get(node.type),
         warn: warnOnce,
     };
     const spec = impl.deserialize(node, ctx);

package/dist/flow-node-type.d.ts

@@ -92,7 +92,10 @@ export interface FlowDeserializeContext {
     plainValue(raw: unknown): unknown;
     /** The step name a node id was emitted for. */
     stepName(nodeId: string): string;
-    /** The file's own `definitions[]` entry for this node, if it carries one. */
+    /**
+     * The node's definition: the file's own `definitions[]` entry for it, else the
+     * SDK's bundled definition at the node's version; undefined when neither exists.
+     */
     definition(): unknown;
     /** Report something the lift could not keep. Decompile prints it once. */
     warn(message: string): void;
@@ -119,6 +122,11 @@ export interface FlowCheckContext {
     readonly step: string;
     /** The version the node will be emitted at. */
     readonly version: string;
+    /**
+     * The SDK's bundled definition of this step's node type at `version` (the one
+     * serialize emits from), or undefined when the SDK does not ship it.
+     */
+    definition(): unknown;
     /** Report a diagnostic on this step. Its severity is the family catalog's for `code`. */
     report(code: string, message: string, suggestion?: string): void;
     /**

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

@@ -2,8 +2,22 @@ export const SCRIPT_DIAGNOSTICS = {
     SCRIPT_RETURNS_UNKNOWN_TYPE: { severity: 'error', summary: '`returns` names a type the wire format does not know' },
     SCRIPT_EMPTY_RETURNS: { severity: 'warning', summary: '`returns: {}` names no fields' },
 };
-/** The type vocabulary a script's `returns` may name — what the wire format accepts. */
-const SCRIPT_RETURN_TYPES = new Set(['string', 'number', 'boolean', 'object', 'array']);
+/**
+ * The types a script's `returns` may name for a FIELD, and at the top level on
+ * every version. `any` is not one: no definition declares a field as `any`.
+ */
+const SCRIPT_FIELD_TYPES = new Set(['string', 'number', 'boolean', 'object', 'array']);
+/**
+ * The types a top-level `returns` may name at this step's version: the field
+ * types, plus the output type the node's own definition declares at that version
+ * (`any` on `core.action.script@1.1`, `object` on 1.0.0).
+ */
+function topLevelTypes(ctx) {
+    const declared = ctx.definition()
+        ?.outputDefinition?.output?.type;
+    return typeof declared === 'string' ? new Set([...SCRIPT_FIELD_TYPES, declared]) : SCRIPT_FIELD_TYPES;
+}
+const quoted = (types) => [...types].map((t) => `"${t}"`).join(', ');
 /**
  * A script step's `returns` — the author overriding what the body looks like.
  *
@@ -19,9 +33,10 @@ export function checkScript(inputs, ctx) {
     if (returns === undefined)
         return;
     if (typeof returns === 'string') {
-        if (!SCRIPT_RETURN_TYPES.has(returns)) {
+        const allowed = topLevelTypes(ctx);
+        if (!allowed.has(returns)) {
             ctx.report('SCRIPT_RETURNS_UNKNOWN_TYPE', `Script step "${step}" declares \`returns: ${JSON.stringify(returns)}\`, which is not a type the `
-                + `wire format knows. Use one of ${[...SCRIPT_RETURN_TYPES].map((t) => `"${t}"`).join(', ')}, or a `
+                + `wire format knows at ${ctx.version}. Use one of ${quoted(allowed)}, or a `
                 + `field map like \`{ total: "number" }\` to name an object's fields.`);
         }
         return;
@@ -41,9 +56,9 @@ export function checkScript(inputs, ctx) {
         return;
     }
     for (const [name, type] of Object.entries(fields)) {
-        if (typeof type !== 'string' || !SCRIPT_RETURN_TYPES.has(type)) {
+        if (typeof type !== 'string' || !SCRIPT_FIELD_TYPES.has(type)) {
             ctx.report('SCRIPT_RETURNS_UNKNOWN_TYPE', `Script step "${step}" declares field "${name}" as ${JSON.stringify(type)}, which is not a type the `
-                + `wire format knows. Use one of ${[...SCRIPT_RETURN_TYPES].map((t) => `"${t}"`).join(', ')}.`);
+                + `wire format knows for a field. Use one of ${quoted(SCRIPT_FIELD_TYPES)}.`);
         }
     }
 }

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

@@ -23,9 +23,13 @@ import { checkScript } from './check.js';
  */
 function scriptOutputs(base, returns, code) {
     const shape = returns !== undefined ? declaredScriptShape(returns) : inferScriptShape(code);
-    // Nothing knowable, or knowably the open object the definition already
-    // declares — leave the node exactly as it was.
-    if (!shape || (shape.type === 'object' && !shape.properties))
+    // Nothing knowable — leave the node exactly as it was. An INFERRED bare object
+    // is nothing knowable either: the inference never enumerates fields, so it
+    // only says "some object", and the definition's own declaration stands. A
+    // DECLARED type always lands, even `object`: the definition's default is
+    // version-dependent (`object` on script 1.0.0, `any` on 1.1), so "the same as
+    // the default" is not a property of the word `object`.
+    if (!shape || (returns === undefined && shape.type === 'object' && !shape.properties))
         return base;
     if (!base || typeof base !== 'object')
         return base;
@@ -46,7 +50,7 @@ function scriptOutputs(base, returns, code) {
  * the same way — a property map the body does not produce is one the author gave
  * as `returns: {…}`.
  */
-function liftReturns(node, code) {
+function liftReturns(node, code, definitionType) {
     const out = node.outputs?.output;
     const declared = typeof out?.type === 'string' ? out.type : undefined;
     if (!declared)
@@ -54,11 +58,14 @@ function liftReturns(node, code) {
     const props = out?.properties;
     // What re-compiling this body with NO `returns` would declare. Mirror
     // `scriptOutputs` exactly: an inference of a bare `object` (or none at all)
-    // leaves the definition's own `{type:'object'}` standing, untouched.
+    // leaves the definition's own output type standing, untouched. That type is
+    // the node's definition AT ITS VERSION (`definitionType`): `object` on script
+    // 1.0.0 but `any` on 1.1, so a 1.1 node's untouched `any` is the default, not
+    // an author override.
     const inferred = inferScriptShape(code);
     const effective = inferred && !(inferred.type === 'object' && !inferred.properties)
         ? inferred
-        : { type: 'object', properties: undefined };
+        : { type: definitionType, properties: undefined };
     const same = effective.type === declared
         && JSON.stringify(sortKeys(effective.properties ?? {})) === JSON.stringify(sortKeys(props ?? {}));
     if (same)
@@ -95,14 +102,16 @@ function scriptAt(version) {
                 ...(typed !== base ? { outputs: typed } : {}),
             };
         },
-        deserialize: (node) => {
+        deserialize: (node, ctx) => {
             const raw = node.inputs?.script;
             const code = typeof raw === 'string' ? raw : '';
             // `returns` is recovered only when the node's declared output is something
             // re-compiling the body would NOT produce on its own: serialize infers from
             // the body first, so a script whose type is already plain in its code
             // round-trips without it.
-            const returns = liftReturns(node, code);
+            const defType = ctx.definition()
+                ?.outputDefinition?.output?.type;
+            const returns = liftReturns(node, code, typeof defType === 'string' ? defType : 'object');
             return { kind: 'script', inputs: { code, ...(returns !== undefined ? { returns } : {}) } };
         },
         print: ({ inputs }, ctx) => {

package/dist/serialize.d.ts

@@ -102,6 +102,26 @@ export declare function bundledActionNodeType(spec: {
     kind?: string;
     inputs?: any;
 } | undefined): string | undefined;
+/**
+ * The definition serialize synthesizes for a family that has no bundled one:
+ * a published process resource (`rpaWorkflow`, `apiWorkflow`,
+ * `agenticProcess`, `publishedFunction`, `agent`) or an `ixpExtract` step.
+ * Their node type carries a tenant's key, so the SDK builds the definition
+ * per call, transcribed from what `registry get` returns. `undefined` for
+ * every other kind (a bundled family, a connector, a container).
+ *
+ * The emit path builds its definition here, and `check` asks this same
+ * definition whether the node has an error port (#1040), so the two cannot
+ * disagree. For instance `publishedFunction(...)` yields
+ * `uipath.core.function.<key>@1.0.0` with `supportsErrorHandling: true`.
+ *
+ * Throws what the family's builder throws for an unusable spec (an
+ * `ixpExtract` project that is not a node type).
+ */
+export declare function perCallDefinition(spec: {
+    kind?: string;
+    inputs?: any;
+} | undefined): any | undefined;
 /**
  * The bundled definition of `nodeType` that `makeNode` resolves: the author's
  * exact `{ version }` when given, otherwise the pinned default (the first

package/dist/serialize.js

@@ -3793,6 +3793,48 @@ export function bundledActionNodeType(spec) {
         default: return undefined;
     }
 }
+/**
+ * The definition serialize synthesizes for a family that has no bundled one:
+ * a published process resource (`rpaWorkflow`, `apiWorkflow`,
+ * `agenticProcess`, `publishedFunction`, `agent`) or an `ixpExtract` step.
+ * Their node type carries a tenant's key, so the SDK builds the definition
+ * per call, transcribed from what `registry get` returns. `undefined` for
+ * every other kind (a bundled family, a connector, a container).
+ *
+ * The emit path builds its definition here, and `check` asks this same
+ * definition whether the node has an error port (#1040), so the two cannot
+ * disagree. For instance `publishedFunction(...)` yields
+ * `uipath.core.function.<key>@1.0.0` with `supportsErrorHandling: true`.
+ *
+ * Throws what the family's builder throws for an unusable spec (an
+ * `ixpExtract` project that is not a node type).
+ */
+export function perCallDefinition(spec) {
+    const s = spec?.inputs ?? {};
+    switch (spec?.kind) {
+        case 'publishedFunction':
+            return publishedFunctionDef({ key: s.key, name: s.name, folderPath: s.folderPath, inputs: s.inputs ?? {}, returns: s.returns });
+        case 'apiWorkflow':
+            return apiWorkflowDef({ key: s.key, name: s.name, folderPath: s.folderPath, inputs: s.inputs ?? {}, returns: s.returns });
+        case 'agenticProcess':
+            return agenticProcessDef({
+                key: s.key, name: s.name, folderPath: s.folderPath, location: s.location, projectId: s.projectId,
+                inputs: s.inputs ?? {}, returns: s.returns, form: s.form,
+            });
+        case 'rpaWorkflow':
+            return rpaWorkflowDef({
+                key: s.key, name: s.name, folderPath: s.folderPath, location: s.location, projectId: s.projectId,
+                inputs: s.inputs ?? {}, returns: s.returns,
+            });
+        case 'agent':
+            return agentDef({
+                key: s.key, name: s.name, folderPath: s.folderPath, location: s.location, projectId: s.projectId,
+                inputs: s.inputs ?? {}, returns: s.returns, flavour: s.flavour,
+            });
+        case 'ixpExtract': return ixpExtractDef(s);
+        default: return undefined;
+    }
+}
 /**
  * The bundled definition of `nodeType` that `makeNode` resolves: the author's
  * exact `{ version }` when given, otherwise the pinned default (the first
@@ -5267,10 +5309,7 @@ export function serialize(built, opts = {}) {
             // because `inputs` is required here (the empty-input floor — see
             // `AgentInputs.inputs`) and because the emitted binding subtype is `Agent`.
             const s = spec.inputs;
-            const def = agentDef({
-                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 def = perCallDefinition(spec);
             // 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;
@@ -5842,19 +5881,8 @@ export function serialize(built, opts = {}) {
             const s = spec.inputs;
             const nodeInputs = s.inputs ?? {};
             const fireAndForget = spec.kind === 'agenticProcess' && spec.inputs.completion === 'fire-and-forget';
-            const def = spec.kind === 'publishedFunction'
-                ? publishedFunctionDef({ key: spec.inputs.key, name: s.name, folderPath: spec.inputs.folderPath, inputs: nodeInputs, returns: spec.inputs.returns })
-                : spec.kind === 'apiWorkflow'
-                    ? apiWorkflowDef({ key: spec.inputs.key, name: s.name, folderPath: spec.inputs.folderPath, inputs: nodeInputs, returns: spec.inputs.returns })
-                    : spec.kind === 'agenticProcess'
-                        ? agenticProcessDef({
-                            key: spec.inputs.key, name: s.name, folderPath: s.folderPath, location: spec.inputs.location,
-                            projectId: spec.inputs.projectId, inputs: nodeInputs, returns: spec.inputs.returns, form: spec.inputs.form,
-                        })
-                        : rpaWorkflowDef({
-                            key: spec.inputs.key, name: s.name, folderPath: s.folderPath, location: spec.inputs.location,
-                            projectId: spec.inputs.projectId, inputs: nodeInputs, returns: spec.inputs.returns,
-                        });
+            // The same definition `check` asks about the error port.
+            const def = perCallDefinition(spec);
             // The bindings first: two steps on the same process share ONE pair, and the
             // definition's `model.context` names ids that have to exist.
             // Read off the definition: one kind carries several subtypes (agenticProcess by `form`).
@@ -6155,7 +6183,7 @@ export function serialize(built, opts = {}) {
         }
         if (spec.kind === 'ixpExtract') {
             const s = spec.inputs;
-            const def = ixpExtractDef(s);
+            const def = perCallDefinition(spec); // ixpExtractDef: 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/maestro-builder-sdk",
-  "version": "6.20.1",
+  "version": "6.20.3",
   "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": "5440c25e8e833aced459eb5a0ae9109ac3c973ae"
+  "gitref": "15fa01717ebe49d6cf51c9ec11cca4a7ebbf9bb7"
 }