@uipath/maestro-builder-sdk 6.33.2 → 6.35.0

package/dist/case/case-sdk.d.ts

@@ -372,7 +372,7 @@ export interface BuiltCaseExitCondition {
     marksCaseComplete?: boolean;
     rules: CaseRule[][];
 }
-export type TaskKind = 'process' | 'agent' | 'rpa' | 'api-workflow' | 'case-management' | 'flow-process' | 'external-agent' | 'external-workflow' | 'action' | 'connector' | 'wait-for-timer' | 'wait-for-connector';
+export type TaskKind = 'process' | 'agent' | 'rpa' | 'api-workflow' | 'case-management' | 'flow-process' | 'business-rule' | 'external-agent' | 'external-workflow' | 'action' | 'connector' | 'wait-for-timer' | 'wait-for-connector';
 /** Published-resource task kinds that the Case schema permits as unresolved skeletons. */
 export type UnresolvedReferenceTaskKind = 'process' | 'agent' | 'rpa' | 'api-workflow' | 'case-management';
 /**
@@ -428,6 +428,25 @@ export interface TaskRef {
     name: string;
     folderPath: string;
 }
+/**
+ * Options for {@link TaskBuilder.businessRule}.
+ */
+export interface BusinessRuleOptions {
+    /** The Orchestrator folder the rule is deployed in, e.g. `Shared`. */
+    folder: string;
+    /**
+     * The rule's whole result schema, as `uip maestro case tasks describe --type
+     * business-rule` returns it on the `output` row (`_jsonSchema`): one object
+     * keyed by decision name, each holding that decision's columns. Optional; it
+     * is copied onto the `output` row so the designer can show the columns.
+     */
+    resultSchema?: unknown;
+}
+/** Normalized business-rule configuration stored on a built task. */
+export interface BusinessRuleSpecData {
+    /** The rule's decision-keyed result schema, when the author supplied it. */
+    resultSchema?: unknown;
+}
 /**
  * Action-task recipient type. `2` = a single user by email — the only value the
  * platform corpus exercises for case action tasks; `0`/`1`/`3` are reserved for
@@ -520,6 +539,8 @@ export interface BuiltTask {
     name: string;
     kind: TaskKind;
     ref?: TaskRef;
+    /** business-rule task: the rule's decision-keyed result schema, when known. */
+    businessRule?: BusinessRuleSpecData;
     action?: ActionSpecData;
     connector?: ConnectorSpecData;
     /** Descriptor-resolved external agent/workflow configuration. */
@@ -718,6 +739,7 @@ declare class TaskBuilder {
     private readonly _name;
     private _kind?;
     private _ref?;
+    private _businessRule?;
     private _action?;
     private _connector?;
     private _external?;
@@ -808,6 +830,35 @@ declare class TaskBuilder {
     flowProcess(name: string, opts?: {
         folder?: string;
     }): this;
+    /**
+     * Evaluate a deployed **business rule** (a DMN decision package) and read its
+     * decisions back.
+     *
+     * @remarks
+     * Emits a `business-rule` task at `version: 'v3'` (below v3 the engine cannot
+     * run the `.uirule` package a BusinessRules project deploys). The rule is named
+     * through a `name` + `folderPath` pair of root bindings with
+     * `resource: 'BusinessRule'` and `resourceKey: '<folder>.<name>'`, the shape
+     * Studio Web and `uip maestro case bindings sync` write.
+     *
+     * The task always carries the two outputs every business-rule task has: `output`
+     * (`source: '=result'`, the whole decision-keyed result) and `Error`. To store
+     * one decision column in a case variable, add an extract with `.outputs()`
+     * whose source names the decision and column directly — `=<Decision>.<column>`,
+     * never `=result.…` or `=output.…`:
+     *
+     * ```ts
+     * .task('Score Credit Risk', t => t
+     *   .businessRule('CreditRisk', { folder: 'Shared' })
+     *   .inputs({ creditScore: { value: '=vars.creditScore', type: 'number' } })
+     *   .outputs({ riskBand: { source: '=RiskDecision.riskBand', type: 'string' } }))
+     * ```
+     *
+     * @param name - The deployed rule's name.
+     * @param opts - `folder` (required) and the optional `resultSchema`.
+     * @returns This builder, so calls chain.
+     */
+    businessRule(name: string, opts: BusinessRuleOptions): this;
     private external;
     /**
      * Invoke an external agent through its generated Integration Service descriptor.

package/dist/case/case-sdk.js

@@ -160,6 +160,7 @@ class TaskBuilder {
     _name;
     _kind;
     _ref;
+    _businessRule;
     _action;
     _connector;
     _external;
@@ -263,6 +264,39 @@ class TaskBuilder {
     flowProcess(name, opts) {
         return this.reference('flow-process', name, opts);
     }
+    /**
+     * Evaluate a deployed **business rule** (a DMN decision package) and read its
+     * decisions back.
+     *
+     * @remarks
+     * Emits a `business-rule` task at `version: 'v3'` (below v3 the engine cannot
+     * run the `.uirule` package a BusinessRules project deploys). The rule is named
+     * through a `name` + `folderPath` pair of root bindings with
+     * `resource: 'BusinessRule'` and `resourceKey: '<folder>.<name>'`, the shape
+     * Studio Web and `uip maestro case bindings sync` write.
+     *
+     * The task always carries the two outputs every business-rule task has: `output`
+     * (`source: '=result'`, the whole decision-keyed result) and `Error`. To store
+     * one decision column in a case variable, add an extract with `.outputs()`
+     * whose source names the decision and column directly — `=<Decision>.<column>`,
+     * never `=result.…` or `=output.…`:
+     *
+     * ```ts
+     * .task('Score Credit Risk', t => t
+     *   .businessRule('CreditRisk', { folder: 'Shared' })
+     *   .inputs({ creditScore: { value: '=vars.creditScore', type: 'number' } })
+     *   .outputs({ riskBand: { source: '=RiskDecision.riskBand', type: 'string' } }))
+     * ```
+     *
+     * @param name - The deployed rule's name.
+     * @param opts - `folder` (required) and the optional `resultSchema`.
+     * @returns This builder, so calls chain.
+     */
+    businessRule(name, opts) {
+        this.reference('business-rule', name, { folder: opts.folder });
+        this._businessRule = opts.resultSchema === undefined ? {} : { resultSchema: opts.resultSchema };
+        return this;
+    }
     external(kind, descriptor, opts) {
         this.setKind(kind);
         this._external = {
@@ -448,15 +482,16 @@ class TaskBuilder {
         // Task I/O binding is reference-mode only — process/agent/rpa/api-workflow,
         // case-management, and flow-process. Connector tasks derive their own
         // inputs/outputs from the operation schema.
-        const REF_IO = new Set(['process', 'agent', 'rpa', 'api-workflow', 'case-management', 'flow-process']);
+        const REF_IO = new Set(['process', 'agent', 'rpa', 'api-workflow', 'case-management', 'flow-process', 'business-rule']);
         if ((this._inputs || this._outputs) && !REF_IO.has(this._kind))
-            throw new Error(`task "${this._name}": .inputs()/.outputs() are only supported on reference-mode tasks (process/agent/rpa/api-workflow/case-management/flow-process), not "${this._kind}".`);
+            throw new Error(`task "${this._name}": .inputs()/.outputs() are only supported on reference-mode tasks (process/agent/rpa/api-workflow/case-management/flow-process/business-rule), not "${this._kind}".`);
         if (!this._ref && (this._inputs || this._outputs))
             throw new Error(`task "${this._name}": an unresolved reference task cannot declare inputs or outputs.`);
         return {
             name: this._name,
             kind: this._kind,
             ref: this._ref,
+            businessRule: this._businessRule,
             action: this._action,
             connector: this._connector,
             external: this._external,

package/dist/case/check.js

@@ -483,6 +483,36 @@ function checkStage(stage, diags, refStage, refPlacement) {
                 message: `Task "${t.name}" binding "${'var' in invalidBinding ? invalidBinding.var : invalidBinding.name}" has unsupported type ${JSON.stringify(invalidBinding.type)}. Use a type name such as "string" or "jsonSchema"; jsonSchema(...) is only for declaring a structured case variable.`,
                 where: t.name,
             });
+        if (t.kind === 'business-rule') {
+            if (!t.ref || !t.ref.name.trim() || !t.ref.folderPath.trim())
+                diags.push({
+                    level: 'error',
+                    code: 'BUSINESS_RULE_EMPTY_DATA',
+                    message: `Business-rule task "${t.name}" must name its deployed rule and the Orchestrator folder it is deployed in: .businessRule('<rule>', { folder: '<folder>' }).`,
+                    where: t.name,
+                });
+            for (const o of t.outputs ?? []) {
+                const wrapped = /^=\s*(result|output)\./.exec(o.source);
+                if (wrapped)
+                    diags.push({
+                        level: 'error',
+                        code: 'BUSINESS_RULE_OUTPUT_SOURCE',
+                        message: `Business-rule task "${t.name}" output "${o.var}" reads "${o.source}". An extract reads a field of the rule's result directly — write "=${o.source.replace(/^=\s*(result|output)\./, '')}" (\`=<Decision>.<column>\`). The whole result is already the task's own \`output\` row (\`=result\`); \`=${wrapped[1]}.…\` names a field the result does not have.`,
+                        where: t.name,
+                    });
+                // An extract row is NAMED after its source's last segment (`emitTaskOutput`),
+                // so `=Decision.output` writes a second row named `output` beside the
+                // task's own. The case variable it stores into collides with nothing.
+                const rowName = o.source.replace(/^=/, '').split('.').pop();
+                if (rowName === 'output' || rowName === 'Error')
+                    diags.push({
+                        level: 'error',
+                        code: 'BUSINESS_RULE_OUTPUT_NAME',
+                        message: `Business-rule task "${t.name}" output "${o.var}" reads "${o.source}", which writes an output row named "${rowName}" — the name of the task's own ${rowName === 'output' ? '`output` row (the whole result, `=result`)' : '`Error` row (`=Error`)'}. Two rows with one name are ambiguous to the designer; rename the decision column.`,
+                        where: t.name,
+                    });
+            }
+        }
         if (t.kind === 'flow-process' && (!t.ref || !t.ref.name.trim()))
             diags.push({
                 level: 'error',

package/dist/case/compile-cli.js

@@ -364,7 +364,12 @@ function syncBindingsV2(caseplan, outPath) {
             resource: group.resource,
             key: group.key,
             value: group.value,
-            metadata: group.subType ? { subType: group.subType } : {},
+            // A BusinessRule entry carries the bindings version deploy needs to
+            // override its folder — the metadata `uip maestro case bindings sync`
+            // writes for it (no subType).
+            metadata: group.subType
+                ? { subType: group.subType }
+                : group.resource === 'BusinessRule' ? { BindingsVersion: '2.2' } : {},
         });
     }
     resources.push(...connectionResources);

package/dist/case/decompile.js

@@ -579,6 +579,8 @@ function emitTaskKind(task, refs, library) {
         const folder = folderPath ? `, ${opts([['folder', tsLiteral(folderPath)]])}` : '';
         return `.${method}(${tsLiteral(name ?? '')}${folder})`;
     }
+    if (isAuthorableBusinessRule(task))
+        return businessRuleCall(task, refs);
     if (kind === 'action') {
         let recipient;
         if (data.recipient) {
@@ -616,7 +618,12 @@ function emitTaskKind(task, refs, library) {
         const spec = waitConnectorSpec(data, `wait-for-connector task "${task.displayName ?? task.id ?? '?'}"`, refs);
         return spec === undefined ? '.waitForConnector()' : `.waitForConnector(${spec})`;
     }
-    const message = `unsupported task kind "${kind}" for task "${task.displayName ?? task.id ?? '?'}".`;
+    const message = kind === 'business-rule'
+        // The converter reads a missing version as v2, whose result shape differs
+        // from v3's decision-keyed one; recompiling it as v3 would change what its
+        // extracts read. Keep the task as data instead.
+        ? `business-rule task "${task.displayName ?? task.id ?? '?'}" has ${data.version === undefined ? 'no version (the converter reads it as v2)' : `version "${String(data.version)}"`}; only v3 business-rule tasks are authorable.`
+        : `unsupported task kind "${kind}" for task "${task.displayName ?? task.id ?? '?'}".`;
     diagnose(refs, {
         code: 'UNSUPPORTED_TASK_KIND',
         message,
@@ -624,6 +631,29 @@ function emitTaskKind(task, refs, library) {
     });
     return `.__UNRESOLVED_TASK_KIND__(${tsLiteral(kind)}, ${tsLiteral(data)})`;
 }
+/** A business-rule task `.businessRule()` can rebuild: v3 only. */
+function isAuthorableBusinessRule(task) {
+    return task.type === 'business-rule' && task.data?.version === 'v3';
+}
+/** The two outputs every business-rule task carries, which `.businessRule()` re-emits itself. */
+function isBusinessRuleOwnOutput(row) {
+    return (row.name === 'output' && row.source === '=result') || (row.name === 'Error' && row.source === '=Error');
+}
+function businessRuleCall(task, refs) {
+    const data = task.data ?? {};
+    const owner = `business-rule task "${task.displayName ?? task.id ?? '?'}"`;
+    const name = bindingDefault(data.name, refs);
+    const folderPath = bindingDefault(data.folderPath, refs);
+    if (typeof name !== 'string' || !name || typeof folderPath !== 'string')
+        throw new Error(`${owner} must name its rule and folder (data.name / data.folderPath).`);
+    const outputRow = (Array.isArray(data.outputs) ? data.outputs : [])
+        .find((row) => row.name === 'output' && row.source === '=result');
+    const resultSchema = outputRow?._jsonSchema;
+    return `.businessRule(${tsLiteral(name)}, ${opts([
+        ['folder', tsLiteral(folderPath)],
+        ['resultSchema', resultSchema !== undefined ? tsLiteral(resultSchema) : undefined],
+    ])})`;
+}
 function ioArg(rows, kind) {
     const valueField = kind === 'inputs' ? 'value' : 'source';
     const entries = rows.map((row) => {
@@ -647,6 +677,14 @@ function emitTask(out, depth, task, lane, refs, library) {
         if (Array.isArray(data.outputs) && data.outputs.length)
             out.line(inner, `.outputs(${ioArg(data.outputs, 'outputs')})`);
     }
+    if (isAuthorableBusinessRule(task)) {
+        const data = task.data ?? {};
+        const extracts = (Array.isArray(data.outputs) ? data.outputs : []).filter((row) => !isBusinessRuleOwnOutput(row));
+        if (Array.isArray(data.inputs) && data.inputs.length)
+            out.line(inner, `.inputs(${ioArg(data.inputs, 'inputs')})`);
+        if (extracts.length)
+            out.line(inner, `.outputs(${ioArg(extracts, 'outputs')})`);
+    }
     if (task.isRequired !== undefined)
         out.line(inner, task.isRequired ? '.required()' : '.required(false)');
     if (task.shouldRunOnlyOnce !== undefined)
@@ -749,11 +787,20 @@ function producedVariableNames(plan) {
         if (!isStage(node))
             continue;
         for (const lane of node.data?.tasks ?? [])
-            for (const task of lane)
-                if (ownEntry(TASK_KIND_METHOD, task.type))
+            for (const task of lane) {
+                if (ownEntry(TASK_KIND_METHOD, task.type)) {
                     for (const row of task.data?.outputs ?? [])
                         if (row.var)
                             produced.add(row.var);
+                }
+                else if (isAuthorableBusinessRule(task)) {
+                    // A business-rule extract registers its case variable on recompile, as
+                    // a reference-task output does; the task's own rows do not.
+                    for (const row of task.data?.outputs ?? [])
+                        if (row.var && !isBusinessRuleOwnOutput(row))
+                            produced.add(row.var);
+                }
+            }
     }
     return produced;
 }

package/dist/case/format-profile.d.ts

@@ -40,7 +40,7 @@ export declare const CASE_FORMAT_PROFILE: Readonly<CaseFormatProfile>;
  * Which Case JSON schema versions `.schemaVersion()` may declare.
  *
  * ONE, and that is the honest answer rather than a placeholder. Case is a
- * closed, whole-document schema: `@uipath/case-schema` ships a chain of 31
+ * closed, whole-document schema: `@uipath/case-schema` ships a chain of
  * grammars (`case-schema-census.json`'s `versionChain`), each with its own
  * forward migration, and a version is a claim that the entire document matches
  * that grammar. This SDK emits the V30 grammar natively — the V30 rule schemas

package/dist/case/format-profile.js

@@ -28,16 +28,20 @@ export const CASE_FORMAT_PROFILE = {
         { featureFlag: 'canvas-useExplicitEntryExitConditions', fromVersion: '12.0.0' },
         { featureFlag: 'canvas-caseUnifiedSchema', fromVersion: '20.0.0' },
     ],
+    // The validation pin (the `@uipath/case-schema` devDependency in
+    // typescript/package.json; the census records it as `generatedFrom.version`)
+    // and the newest Case JSON version that package reads. The writer stays at V30 (`writeVersion`): V31+ is read
+    // and migrated by the platform, not emitted here.
     validationCeiling: {
-        caseSchemaVersion: '0.1016.2',
-        formatVersion: '30.0.0',
+        caseSchemaVersion: '0.1173.0',
+        formatVersion: '32.0.4',
     },
 };
 /**
  * Which Case JSON schema versions `.schemaVersion()` may declare.
  *
  * ONE, and that is the honest answer rather than a placeholder. Case is a
- * closed, whole-document schema: `@uipath/case-schema` ships a chain of 31
+ * closed, whole-document schema: `@uipath/case-schema` ships a chain of
  * grammars (`case-schema-census.json`'s `versionChain`), each with its own
  * forward migration, and a version is a claim that the entire document matches
  * that grammar. This SDK emits the V30 grammar natively — the V30 rule schemas

package/dist/case/serialize.js

@@ -491,8 +491,18 @@ function applyPreservedIdentities(result, preservation) {
             take(task, taskIdentity.id);
             takeConditions(task?.entryConditions, taskIdentity.entryConditions);
             (taskIdentity.inputs ?? []).forEach((row, index) => take(task?.data?.inputs?.[index], row.id));
-            (taskIdentity.outputs ?? []).forEach((row, index) => {
-                const target = task?.data?.outputs?.[index];
+            const outputRows = task?.data?.outputs ?? [];
+            const wantedRows = taskIdentity.outputs ?? [];
+            // Match by name when unique on both sides, else by position.
+            const unique = (names, name) => names.filter((n) => n === name).length === 1;
+            const currentNames = outputRows.map((r) => r?.name);
+            const wantedNames = wantedRows.map((r) => r.name);
+            const named = new Set(wantedRows.filter((r) => unique(wantedNames, r.name) && unique(currentNames, r.name)).map((r) => r.name));
+            wantedRows.forEach((row, index) => {
+                const target = named.has(row.name)
+                    ? outputRows.find((r) => r?.name === row.name)
+                    // A positional match never takes a row a name match owns.
+                    : named.has(outputRows[index]?.name) ? undefined : outputRows[index];
                 const currentId = target?.id;
                 take(target, row.id);
                 if (typeof currentId === 'string' && typeof row.id === 'string' && target?.value === currentId) {
@@ -839,6 +849,8 @@ function taskData(task, resolver, taskId, stageId, ids) {
                 data.outputs = task.outputs.map((o, i) => emitTaskOutput(o, elementId, ids, `${elementId}:out:${i}:${o.var}`, resolver));
             return data;
         }
+        case 'business-rule':
+            return businessRuleTaskData(task, resolver, `${stageId}-${taskId}`, ids);
         case 'action': {
             const a = task.action ?? {};
             const data = {};
@@ -1094,6 +1106,76 @@ function emitTaskOutput(o, elementId, ids, seed, resolver) {
         elementId,
     };
 }
+// ─── Business-rule task ───────────────────────────────────────────────────────
+/** The version a business-rule task carries: below v3 the engine cannot run the
+ * `.uirule` package a BusinessRules project deploys (the case converter falls
+ * back to v2 when the field is missing). Same constant as the CLI's
+ * `BUSINESS_RULE_TASK_VERSION`. */
+const BUSINESS_RULE_TASK_VERSION = 'v3';
+/** The binding `resource` a business rule is bound by — the CLI's and Studio
+ * Web's spelling. `businessRule` (the registry cache category / BPMN binding
+ * pattern) is a different namespace, and a binding that uses it is not a
+ * BusinessRule resource to the bindings_v2 reader. */
+const BUSINESS_RULE_RESOURCE = 'BusinessRule';
+/** Mint (once per resourceKey + attribute) one root `BusinessRule` binding. */
+function businessRuleBinding(resolver, ids, resourceKey, propertyAttribute, value) {
+    for (const entry of resolver.bindingSink.values()) {
+        if (entry.resource === BUSINESS_RULE_RESOURCE && entry.resourceKey === resourceKey
+            && entry.propertyAttribute === propertyAttribute)
+            return entry.id;
+    }
+    const id = ids.make('b', 8, `binding:${BUSINESS_RULE_RESOURCE}:${resourceKey}:${propertyAttribute}`);
+    resolver.bindingSink.set(id, {
+        id,
+        name: propertyAttribute,
+        type: 'string',
+        resource: BUSINESS_RULE_RESOURCE,
+        resourceKey,
+        default: value,
+        propertyAttribute,
+    });
+    return id;
+}
+/**
+ * The `data` of a `business-rule` task, as Studio Web writes it and as the
+ * CLI's `tasks describe --type business-rule` + splice produce it:
+ *
+ * - `name` / `folderPath` are `=bindings.<id>` references to a `BusinessRule`
+ *   binding pair keyed `<folder>.<name>` (the runtime resolves the rule through
+ *   them; `validate --strict` refuses literals);
+ * - `version: 'v3'`;
+ * - `outputs` always starts with `output` (`source: '=result'`, the whole
+ *   decision-keyed result) and `Error` (`source: '=Error'`), followed by the
+ *   author's extract rows, whose sources read a field of the result
+ *   (`=<Decision>.<column>`).
+ */
+function businessRuleTaskData(task, resolver, elementId, ids) {
+    const ref = task.ref;
+    const resourceKey = `${ref.folderPath}.${ref.name}`;
+    const nameId = businessRuleBinding(resolver, ids, resourceKey, 'name', ref.name);
+    const folderId = businessRuleBinding(resolver, ids, resourceKey, 'folderPath', ref.folderPath);
+    const ownRow = (name, source, seed, extra = {}) => {
+        const slot = ids.make('v', 8, `${elementId}:${seed}`);
+        return { name, type: 'jsonSchema', id: slot, var: slot, value: slot, source, target: `=${slot}`, elementId, ...extra };
+    };
+    const resultSchema = task.businessRule?.resultSchema;
+    const outputs = [
+        ownRow('output', '=result', 'br:output', resultSchema === undefined ? {} : { _jsonSchema: resultSchema }),
+        // The CLI's `buildErrorOutput()` row after `addVarIdsToInputsOutputs`:
+        // `displayName`, and the error schema as both `_jsonSchema` and `body`.
+        ownRow('Error', '=Error', 'br:error', {
+            displayName: 'Error', _jsonSchema: structuredClone(ERROR_OUTPUT_SCHEMA), body: structuredClone(ERROR_OUTPUT_SCHEMA),
+        }),
+        ...(task.outputs ?? []).map((o, i) => emitTaskOutput(o, elementId, ids, `${elementId}:out:${i}:${o.var}`, resolver)),
+    ];
+    return {
+        name: `=bindings.${nameId}`,
+        folderPath: `=bindings.${folderId}`,
+        version: BUSINESS_RULE_TASK_VERSION,
+        inputs: (task.inputs ?? []).map((inp, i) => emitTaskInput(inp, elementId, ids, `${elementId}:in:${i}:${inp.name}`)),
+        outputs,
+    };
+}
 // ─── Connector task (execute-connector-activity) ──────────────────────────────
 /**
  * Build the `execute-connector-activity` `data` payload for an IS connector task,
@@ -1353,6 +1435,14 @@ function connectorOutputVar(resolver, base) {
     resolver.connectorOutputCounts.set(base, occurrence);
     return occurrence === 1 ? base : `${base}${occurrence}`;
 }
+/** The `Error` output's schema: the designer's (and the CLI's) `ERROR_OUTPUT_SCHEMA`. */
+const ERROR_OUTPUT_SCHEMA = {
+    type: 'object',
+    properties: {
+        code: { type: 'string' }, message: { type: 'string' }, detail: { type: 'string' },
+        category: { type: 'string' }, status: { type: 'number' }, element: { type: 'string' },
+    },
+};
 function connectorOutputs(rc, elementId, resolver) {
     const responseSchema = rc.entry.outputSchema
         ? schemaFromFields(rc.entry.outputSchema.fields ?? [])
@@ -1367,13 +1457,7 @@ function connectorOutputs(rc, elementId, resolver) {
         },
         {
             name: 'Error', displayName: 'Error', type: 'jsonSchema', source: '=Error',
-            body: {
-                type: 'object',
-                properties: {
-                    code: { type: 'string' }, message: { type: 'string' }, detail: { type: 'string' },
-                    category: { type: 'string' }, status: { type: 'number' }, element: { type: 'string' },
-                },
-            },
+            body: structuredClone(ERROR_OUTPUT_SCHEMA),
             var: errorVar, id: errorVar, value: errorVar, target: `=${errorVar}`, elementId,
         },
     ];

package/dist/check.js

@@ -10,7 +10,7 @@ import { FlowNode } from './core/node-classes.js';
 import { planContributionBindings } from './core/contribution-bindings.js';
 import { definitionHasErrorPort, errorPortRefusal } from './core/error-port.js';
 import { actionVersion, bundledActionNodeType, bundledContainerDefinition, bundledDefinition, perCallDefinition, resolveContributionDefinition } from './serialize.js';
-import { FORM_FIELD_TYPES, formFieldOptionsProblem, formFieldOptionsWhy, formFieldTypeHint, formFieldTypeWhy, validFormFieldTypesText } from './core/form-field-type.js';
+import { FORM_FIELD_TYPES, formFieldOptionsProblem, formFieldOptionsWhy, formFieldSettingProblems, formFieldTypeHint, formFieldTypeWhy, validFormFieldTypesText, } from './core/form-field-type.js';
 import { AGENTIC_PROCESS_FORMS } from './core/agentic-process-forms.js';
 import { checkEventResolution, checkEventSubscription, eventParamsFor, } from './core/event-checks.js';
 import { checkCookedEscapes } from './flow-expr-check.js';
@@ -3573,7 +3573,7 @@ function checkInlineAgent(step, inputs, diags, opts = {}, ledger = newResourceId
                         + `${JSON.stringify(f?.type)}, ${formFieldTypeWhy(f?.type, `which the form does not recognize — it would `
                             + `be published as a plain string`)}. Valid: ${validFormFieldTypesText()}.`, formFieldTypeHint(f?.type));
                 }
-                const optionsProblem = formFieldOptionsProblem(f?.type, f?.options);
+                const optionsProblem = formFieldOptionsProblem(f);
                 if (optionsProblem !== undefined) {
                     const message = `Inline agent step "${step}"'s quick-form escalation field "${String(f?.id ?? '?')}" `
                         + `${formFieldOptionsWhy(optionsProblem, f?.type)}.`;
@@ -3583,6 +3583,10 @@ function checkInlineAgent(step, inputs, diags, opts = {}, ledger = newResourceId
                         at('INLINE_AGENT_ESCALATION_FIELD_OPTIONS', message, `options: [{ id: 'opt-1', value: 'high', label: 'High' }, { id: 'opt-2', value: 'low', label: 'Low' }]`);
                     }
                 }
+                for (const problem of formFieldSettingProblems(f)) {
+                    at('INLINE_AGENT_ESCALATION_FIELD_SETTING_INVALID', `Inline agent step "${step}"'s quick-form escalation gives the field "${String(f?.id ?? '?')}" `
+                        + `${problem}. The platform refuses the form.`);
+                }
             }
             continue;
         }

package/dist/core/actions.d.ts

@@ -102,19 +102,114 @@ export interface FormFieldOption {
     /** What the reviewer sees, e.g. `'High'`. */
     label: string;
 }
+/**
+ * How a form field renders (`@uipath/hitl-schema-types` `controlType`). It is a
+ * separate vocabulary from the data `type`: a single choice is `type: 'string'`
+ * with `controlType: 'dropdown'`. When it is absent, the form uses the data
+ * type's default control (or the one a choice spelling such as `singleSelect`
+ * implies).
+ */
+export type FormFieldControlType = 'text' | 'textarea' | 'numberInput' | 'datePicker' | 'dateAndTimePicker' | 'checkbox' | 'dropdown' | 'radioGroup' | 'multiSelect' | 'checkboxGroup' | 'fileUpload';
+/**
+ * One condition of a form-field rule (`@uipath/hitl-schema-types`
+ * `fieldConditionSchema`): `when` names the field it reads, and the other keys
+ * say what that field's value must be.
+ */
+export interface FormFieldCondition {
+    /** The id of the field the condition reads, e.g. `'priority'`. */
+    when: string;
+    /** The value must equal this. */
+    is?: unknown;
+    /** The value must not equal this. */
+    isNot?: unknown;
+    /** The value must be one of these. */
+    in?: unknown[];
+    /** The value must be none of these. */
+    notIn?: unknown[];
+    /** The value must match this regular expression. */
+    matches?: string;
+    /** A custom condition expression, kept as written. */
+    custom?: string;
+}
+/**
+ * A form-field rule (`@uipath/hitl-schema-types` `fieldRuleSchema`): when its
+ * conditions hold, its `effects` apply to the field, for example
+ * `{ visible: true }` or `{ required: true }`.
+ *
+ * @example
+ * hitl({
+ *   fields: [
+ *     { id: 'priority', type: 'singleSelect', direction: 'output', options: [{ id: 'o1', value: 'high', label: 'High' }] },
+ *     {
+ *       id: 'reason', type: 'string', direction: 'output',
+ *       // Required only when the priority is high.
+ *       rules: [{ id: 'rule-1', conditions: [{ when: 'priority', is: 'high' }], effects: { required: true } }],
+ *     },
+ *   ],
+ *   outcomes: ['Done'],
+ * })
+ */
+export interface FormFieldRule {
+    /** The rule's own stable id, e.g. `'rule-1'`. */
+    id: string;
+    /** What must hold for the effects to apply. */
+    conditions: FormFieldCondition[];
+    /** How the conditions combine. The platform's default is `'AND'`. */
+    operator?: 'AND' | 'OR';
+    /** What applies while the conditions hold, keyed by effect (`visible`, `required`, `disabled`). */
+    effects: Record<string, unknown>;
+}
+/**
+ * The form-field keys that say how a field looks and behaves, with the
+ * platform's own names and shapes (`@uipath/hitl-schema-types` `fieldSchemaFor`).
+ * Every one is optional and written to the form row as given, so a field the
+ * canvas saved keeps them through decompile, an edit and compile.
+ *
+ * @example
+ * hitl({
+ *   fields: [{
+ *     id: 'priority', label: 'Priority', type: 'string', direction: 'output', required: true,
+ *     controlType: 'dropdown',
+ *     options: [{ id: 'o1', value: 'high', label: 'High' }, { id: 'o2', value: 'low', label: 'Low' }],
+ *     defaultValue: 'high', colSpan: 6, requiredMessage: 'Pick one',
+ *     description: 'How urgent the invoice is.',
+ *   }],
+ *   outcomes: ['Done'],
+ * })
+ */
+export interface FormFieldSettings {
+    /** Conditions that show, require or disable the field. */
+    rules?: FormFieldRule[];
+    /** The message the form shows when a required field is left empty. */
+    requiredMessage?: string;
+    /** The field's width on the form's 12-column grid: an integer from 1 to 12. Absent means the full width. */
+    colSpan?: number;
+    /**
+     * How the field renders, e.g. `'dropdown'` or `'textarea'`. Absent means the
+     * data type's default control.
+     */
+    controlType?: FormFieldControlType;
+    /**
+     * The choices of a picker field — a `dropdown` / `singleSelect` / `enum`, or a
+     * `multiSelect`. Written to the form verbatim, in order.
+     */
+    options?: FormFieldOption[];
+    /**
+     * The value the form starts with: one `options` value for a single-choice
+     * field, a list of them for a multi-select, or the starting text.
+     */
+    defaultValue?: string | string[];
+    /** Guidance for an agent that pre-fills the field. */
+    description?: string;
+}
 /** A value the reviewer READS: shown on the form, filled in from the flow. */
-export interface ShownField {
+export interface ShownField extends FormFieldSettings {
     /** Field id — the key the answer object uses. Must be unique on the form. */
     id: string;
     /** Label the reviewer sees. Defaults to `id`. */
     label?: string;
     type: FormFieldType;
     direction: 'input';
-    /**
-     * The choices of a picker field — a `singleSelect` / `enum` dropdown or a
-     * `multiSelect`. Written to the form verbatim, in order.
-     */
-    options?: FormFieldOption[];
     /**
      * What to show — a reference, e.g. `input('amount')` or
      * `out('fetchInvoice', 'body.total')`. Required: a shown field with nothing
@@ -124,18 +219,13 @@ export interface ShownField {
     value: Expr;
 }
 /** A value the reviewer FILLS IN: read downstream with `out('<step>', '<id>')`. */
-export interface AskedField {
+export interface AskedField extends FormFieldSettings {
     /** Field id — the key the answer object uses. Must be unique on the form. */
     id: string;
     /** Label the reviewer sees. Defaults to `id`. */
     label?: string;
     type: FormFieldType;
     direction: 'output';
-    /**
-     * The choices of a picker field — a `singleSelect` / `enum` dropdown or a
-     * `multiSelect`. Written to the form verbatim, in order.
-     */
-    options?: FormFieldOption[];
     /** Reviewer must fill it in before the task can be completed. */
     required?: boolean;
 }
@@ -145,18 +235,13 @@ export interface AskedField {
  * answer. Read it downstream with `out('<step>', '<id>')` — the write target is
  * the field's own id, deliberately decoupled from where the pre-fill came from.
  */
-export interface InOutField {
+export interface InOutField extends FormFieldSettings {
     /** Field id — the key the answer object uses. Must be unique on the form. */
     id: string;
     /** Label the reviewer sees. Defaults to `id`. */
     label?: string;
     type: FormFieldType;
     direction: 'inOut';
-    /**
-     * The choices of a picker field — a `singleSelect` / `enum` dropdown or a
-     * `multiSelect`. Written to the form verbatim, in order.
-     */
-    options?: FormFieldOption[];
     /** What to pre-fill — a reference, e.g. `out('fetchInvoice', 'body.total')`. */
     value: Expr;
     /** Reviewer must confirm/fill it before the task can be completed. */