@uipath/maestro-builder-sdk 6.40.1 → 6.41.1

package/dist/nodes/process/flow/factories.js

@@ -0,0 +1,173 @@
+/**
+ * The process factories — `rpaWorkflow()`, `apiWorkflow()`, `publishedFunction()`
+ * and `agenticProcess()`. Moved from core/actions.ts in Phase 4 of
+ * docs/NODE_TYPE_ARCHITECTURE_DESIGN.md; the package entry re-exports them.
+ */
+import { builtinActionSpec } from '../../../core/actions.js';
+/**
+ * Invoke a deployed RPA (robotic process automation) workflow — a classic
+ * UI-automation process, published to Orchestrator, run by a robot.
+ *
+ * @remarks
+ * Three fields identify the process and they all come from the tenant, which is
+ * why they are named exactly as the platform names them:
+ *
+ *   key         the published process's release key (a GUID). It becomes part of
+ *               the node's TYPE — `uipath.core.rpa-workflow.<key>` — so the
+ *               platform can tell one process's node from another's.
+ *   name        the process's name in Orchestrator.
+ *   folderPath  the Orchestrator folder it lives in.
+ *
+ * `name` + `folderPath` are what the robot is actually started by (the runtime
+ * re-resolves the release from them), and together they are also the process's
+ * `resourceKey`: `"<folderPath>.<name>"`. The serializer emits the two of them
+ * as the flow's process bindings and points the node at them, because a
+ * bindings entry the node does not reference is not a bound process.
+ *
+ * `inputs` are the PROCESS's own input arguments — whatever it declares, by its
+ * own argument names. They are not a fixed schema.
+ *
+ * The step publishes whatever the process returns, under `output`: read a field
+ * with `out('<step>', '<field>')`. Nothing local can check that an argument name
+ * or a returned field name matches the deployed process — only the robot knows —
+ * so a wrong name shows up as a faulted job on a live run, not at compile time.
+ *
+ * @example
+ * **Start a deployed process and read what it returns**
+ * ```ts
+ * .step('getTitle', rpaWorkflow({
+ *   key: '486edc26-0658-4ac1-92c9-1ef953927151',
+ *   name: 'RPA Workflow',
+ *   folderPath: 'Shared/uipath-maestro-flow/ProjectEuler RPA',
+ *   inputs: { problemId: 123 },
+ * }))
+ * .return({ title: out('getTitle', 'title') })
+ * ```
+ *
+ * @param inputs - The published process to start (`key`, `name`, `folderPath`),
+ * its `inputs`, and the output fields you read back via `returns`.
+ * @returns An action spec to pass to `.step(name, …)`.
+ */
+export function rpaWorkflow(inputs) {
+    return builtinActionSpec({ kind: 'rpaWorkflow', inputs });
+}
+/**
+ * Invoke a deployed API workflow — a coded workflow published to Orchestrator,
+ * run as a serverless job rather than by a robot.
+ *
+ * @remarks
+ * The same three identifiers as `rpaWorkflow`, for the same reason: `key` is
+ * the key the node's TYPE carries (`uipath.core.api-workflow.<key>`), while
+ * `name` + `folderPath` are what the runtime resolves the job by — and together
+ * they are the workflow's `resourceKey`, `"<folderPath>.<name>"`. The serializer
+ * emits those two as the flow's process bindings and points the node at them.
+ *
+ * The step publishes the job's output arguments under `output`, so
+ * `out('<step>', '<field>')` reads one of the fields `returns` declares. Whether
+ * an argument name or a returned field actually matches the deployed workflow is
+ * something only the tenant knows — a wrong one is a faulted job on a live run,
+ * not a compile error.
+ *
+ * @example
+ * **Start an API workflow and read a declared output argument**
+ * ```ts
+ * .step('getAge', apiWorkflow({
+ *   key: 'ce857908-ee1d-4392-b552-38bcea0be29c',
+ *   name: 'NameToAgeFixed',
+ *   folderPath: 'Shared',
+ *   inputs: { name: 'tomasz' },
+ *   returns: { EstimatedAge: 'integer' },
+ * }))
+ * .return({ age: out('getAge', 'EstimatedAge') })
+ * ```
+ *
+ * @param inputs - The published API workflow to start (`key`, `name`,
+ * `folderPath`), its `inputs`, and the fields you read back via `returns`.
+ * @returns An action spec to pass to `.step(name, …)`.
+ */
+export function apiWorkflow(inputs) {
+    return builtinActionSpec({ kind: 'apiWorkflow', inputs });
+}
+/**
+ * Invoke a published Orchestrator **Function** — a deployed unit of code run as
+ * one step (`uipath.core.function.<key>`, dispatched as
+ * `Orchestrator.ExecuteFunctionAsync`).
+ *
+ * ```ts
+ * .step('echo', publishedFunction({
+ *   key: '7059bdb5-fdd7-4e13-9d7b-1748aaeb129d',
+ *   name: 'acme-echo',
+ *   folderPath: 'Shared/acme-echo',
+ *   inputs: { message: 'hello' },
+ *   returns: { echoed: 'string' },
+ * }))
+ * ```
+ *
+ * The node type carries the key, so the function must already exist on the
+ * tenant — read `key`, `name` and `folderPath` from the registry rather than
+ * constructing them. Like the other published families, the resource identity
+ * is CLOSED by a binding pair (`<folderPath>.<name>`), and two steps on the
+ * same function share one pair.
+ *
+ * @param inputs - The function's identity, its arguments, and what it returns.
+ * @returns An action spec to pass to `.step(...)`.
+ */
+export function publishedFunction(inputs) {
+    return builtinActionSpec({ kind: 'publishedFunction', inputs });
+}
+/**
+ * Invoke a deployed AGENTIC PROCESS — a Maestro process orchestration published to
+ * Orchestrator: a BPMN process that coordinates agents, robots and people, started
+ * as a job the same way an RPA or API workflow is.
+ *
+ * @remarks
+ * The same three identifiers as `rpaWorkflow` and `apiWorkflow`, for the same
+ * reason: `key` is the key the node's TYPE carries
+ * (`uipath.core.agentic-process.<key>`), while `name` + `folderPath` are what
+ * the runtime resolves the job by — and together they are the process's
+ * `resourceKey`, `"<folderPath>.<name>"`. The serializer emits those two as the
+ * flow's process bindings and points the node at them.
+ *
+ * By default the step WAITS for the process and publishes its output arguments
+ * under `output`, so `out('<step>', '<field>')` reads one of the fields
+ * `returns` declares.
+ *
+ * `completion: 'fire-and-forget'` selects the designer's own async switch
+ * instead: the node's service type becomes `Orchestrator.Start…ProcessAsync`
+ * and it publishes no output but `error`. The type is a discriminated union, so
+ * `returns` is impossible in that form and nothing downstream can read one; a
+ * local run dispatches without waiting and yields `{ jobKey, started: true }`.
+ *
+ * `form` picks which published Agentic Process this is — `'bpmn'` (the default,
+ * a Maestro process orchestration), `'flow'` (a published Maestro Flow), or
+ * `'case'` (a Case Management process). They share one public concept and
+ * differ only in wire identity.
+ *
+ * @example
+ * **Start a Maestro process and wait for its result**
+ * ```ts
+ * .step('runIntake', agenticProcess({
+ *   key: '4fc450ab-89be-4462-8fc8-21ac4c1d6fb9',
+ *   name: 'ProcurementProcess',
+ *   folderPath: 'Shared/uipath-agents/ProcurementProcess',
+ *   inputs: { productId: 1 },
+ *   returns: { status: 'boolean' },
+ * }))
+ * .return({ ok: out('runIntake', 'status') })
+ * ```
+ *
+ * @param inputs - The published Maestro process to start (`key`, `name`,
+ * `folderPath`), its `inputs`, and the fields you read back via `returns`.
+ * @returns An action spec to pass to `.step(name, …)`.
+ */
+export function agenticProcess(inputs) {
+    // Types are erased at run time, so the discriminated union alone cannot stop
+    // `{ completion: 'fire-and-forget', returns: {...} }` arriving from untyped
+    // code — and silently dropping the returns would validate a read that can
+    // never be satisfied.
+    if (inputs.completion === 'fire-and-forget' && inputs.returns !== undefined) {
+        throw new Error("agenticProcess(): completion 'fire-and-forget' publishes no output — remove `returns`, "
+            + "or use completion: 'wait' to read the process result.");
+    }
+    return builtinActionSpec({ kind: 'agenticProcess', inputs });
+}

package/dist/nodes/process/flow/family.d.ts

@@ -0,0 +1,3 @@
+/** The process node family, as flow-node-registry.ts lists it: the RPA, API-workflow, function and agentic-process node types. */
+import type { FlowNodeFamily } from '../../../flow-node-type.js';
+export declare const processFlowFamily: FlowNodeFamily;

package/dist/nodes/process/flow/family.js

@@ -0,0 +1,8 @@
+import { PROCESS_DIAGNOSTICS } from './check.js';
+import { processNodeTypes } from './node-type.js';
+export const processFlowFamily = {
+    id: 'process',
+    title: 'Published process',
+    types: processNodeTypes,
+    diagnostics: PROCESS_DIAGNOSTICS,
+};

package/dist/nodes/process/flow/index.d.ts

@@ -0,0 +1,3 @@
+/** The process family's public surface, which the package entry re-exports. */
+export * from './spec.js';
+export * from './factories.js';

package/dist/nodes/process/flow/index.js

@@ -0,0 +1,3 @@
+/** The process family's public surface, which the package entry re-exports. */
+export * from './spec.js';
+export * from './factories.js';

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

@@ -0,0 +1,23 @@
+import { type ProcessResourceDef } from '../../../core/process-resource.js';
+import type { FlowVersionedNodeType } from '../../../flow-node-type.js';
+import type { AgenticProcessInputs, ApiWorkflowInputs, PublishedFunctionInputs, RpaWorkflowInputs } from './spec.js';
+type ProcessSpec = {
+    kind: 'rpaWorkflow';
+    inputs: RpaWorkflowInputs;
+} | {
+    kind: 'apiWorkflow';
+    inputs: ApiWorkflowInputs;
+} | {
+    kind: 'publishedFunction';
+    inputs: PublishedFunctionInputs;
+} | {
+    kind: 'agenticProcess';
+    inputs: AgenticProcessInputs;
+};
+/**
+ * The definition a process step's node is emitted against — what serialize
+ * supplies and what `errorPort` asks, so the two cannot disagree (#1040).
+ */
+export declare function processDefinition(spec: ProcessSpec): ProcessResourceDef;
+export declare const processNodeTypes: FlowVersionedNodeType<ProcessSpec>[];
+export {};