@uipath/maestro-builder-sdk 6.40.1 → 6.41.1

package/dist/core/actions.d.ts

@@ -491,230 +491,6 @@ export interface IxpExtractInputs {
  * (`'in-solution'`). Shared by `rpaWorkflow`, `agenticProcess` and `agent`.
  */
 export type ProcessLocation = 'published' | 'in-solution';
-export interface RpaWorkflowInputs {
-    /**
-     * The published process's release key (a GUID). It becomes part of the node's
-     * type, `uipath.core.rpa-workflow.<key>`. Find it with
-     * `uip or processes list --all-folders --process-type Process` (the row's `Key`)
-     * or `uip maestro flow registry search "uipath.core.rpa-workflow"`.
-     *
-     * For an in-solution sibling it is `resource.key` from
-     * `resources/solution_folder/process/process/<project>.json` — the suffix of the
-     * node type `uip maestro flow registry list --local` shows.
-     */
-    key: string;
-    /** The process's name in Orchestrator — e.g. `'RPA Workflow'`. */
-    name: string;
-    /**
-     * Where the process lives. `'published'` (the default) is a process deployed
-     * to `folderPath`. `'in-solution'` is a sibling RPA project of the same
-     * solution: it needs `projectId` and no `folderPath`.
-     */
-    location?: ProcessLocation;
-    /**
-     * The Orchestrator folder holding the process — e.g.
-     * `'Shared/uipath-maestro-flow/ProjectEuler RPA'`. Required for a published
-     * process; omit it for an in-solution sibling.
-     *
-     * @enforcedBy RPA_NO_FOLDER A published process needs its folder.
-     */
-    folderPath?: string;
-    /**
-     * The sibling RPA project's `resource.projectKey`, read from
-     * `resources/solution_folder/process/process/<project>.json`. Required only
-     * when `location` is `'in-solution'`.
-     *
-     * @enforcedBy RPA_LOCAL_NO_PROJECT_ID An in-solution process needs its project id.
-     */
-    projectId?: string;
-    /**
-     * The PROCESS's own input arguments, by its own argument names (e.g.
-     * `{ problemId: 123 }`). Not a fixed schema — every process declares its own,
-     * and only the deployed process knows them.
-     */
-    inputs?: Record<string, unknown>;
-    /**
-     * The process's OUTPUT arguments — the fields it returns, and their types
-     * (e.g. `{ title: 'string' }`). Required if anything reads the step's output.
-     *
-     * Why you have to say: the process's output schema lives on the tenant, and
-     * authoring happens offline. Without it `$vars.<step>.output.<field>` reads
-     * from an object with no declared fields, and nothing could tell a real field
-     * from a typo. Declaring
-     * the fields here is the same thing the platform's own definition does when it
-     * can reach the process, and it is what lets a misspelled read be caught at
-     * `uip maestro flow check` instead of at run time.
-     *
-     * @enforcedBy RPA_READ_UNKNOWN_FIELD A read of the output must name a field declared here.
-     * @enforcedBy RPA_READ_WITHOUT_RETURNS Reading a field off the result requires declaring it here.
-     */
-    returns?: Record<string, ReturnFieldType>;
-}
-export interface ApiWorkflowInputs {
-    /**
-     * The published API workflow's key (a GUID). It becomes part of the node's
-     * type, `uipath.core.api-workflow.<key>`. Find it with
-     * `uip or processes list --all-folders --process-type Api` (an API workflow's
-     * `ProcessKey` reads `<name>.api.<name>`; the GUID you want is the row's `Key`)
-     * or `uip maestro flow registry search`.
-     */
-    key: string;
-    /** The workflow's name in Orchestrator — e.g. `'NameToAgeFixed'`. */
-    name: string;
-    /** The Orchestrator folder holding it — e.g. `'Shared'`. */
-    folderPath: string;
-    /**
-     * The WORKFLOW's own input arguments, by its own argument names (e.g.
-     * `{ name: 'tomasz' }`). Not a fixed schema — every workflow declares its own.
-     */
-    inputs?: Record<string, unknown>;
-    /**
-     * The workflow's OUTPUT arguments — the fields it returns, and their types
-     * (e.g. `{ EstimatedAge: 'integer' }`). Required if anything reads the step's
-     * output, for the same reason as `rpaWorkflow`'s: the schema lives on the
-     * tenant and authoring happens offline, so an undeclared read is rejected.
-     *
-     * `'integer'` is what makes the replay fixture a number rather than a string;
-     * see {@link ReturnFieldType} for why the vocabulary carries it.
-     *
-     * @enforcedBy APIWF_READ_WITHOUT_RETURNS Reading a field off the result requires
-     * declaring it here.
-     */
-    returns?: Record<string, ReturnFieldType>;
-}
-/**
- * A published Orchestrator **Function** — a small, single-purpose unit of code
- * deployed as its own resource and invoked as one step
- * (`Orchestrator.ExecuteFunctionAsync`). Same published-resource shape as
- * {@link ApiWorkflowInputs}; what differs is the family and the folder.
- */
-export interface PublishedFunctionInputs {
-    /**
-     * The function's key (a GUID) — it becomes part of the node's type,
-     * `uipath.core.function.<key>`. Find it with
-     * `uip maestro flow registry search "uipath.core.function"` (after
-     * `registry pull --force`) or the Orchestrator process listing.
-     */
-    key: string;
-    /** The function's name in Orchestrator, e.g. `'acme-echo'`. */
-    name: string;
-    /**
-     * The Orchestrator folder holding it. A function is usually deployed into a
-     * folder of its OWN name (e.g. `'Shared/acme-echo'`), and the binding's
-     * `resourceKey` is `<folderPath>.<name>` — copy the folder from the tenant
-     * rather than assuming `'Shared'`.
-     */
-    folderPath: string;
-    /** The function's own input arguments, by its own names. */
-    inputs?: Record<string, unknown>;
-    /**
-     * The function's OUTPUT arguments — the fields it returns, and their types.
-     * Required if anything reads the step's output: the schema lives on the
-     * tenant and authoring is offline, so an undeclared read is rejected.
-     *
-     * @enforcedBy FUNCTION_READ_WITHOUT_RETURNS Reading a field off the result
-     * requires declaring it here.
-     */
-    returns?: Record<string, ReturnFieldType>;
-}
-interface AgenticProcessInputsBase {
-    /**
-     * The published agentic process's key (a GUID). It becomes part of the node's
-     * type, `uipath.core.agentic-process.<key>`. Find it with
-     * `uip or processes list --all-folders --process-type ProcessOrchestration` (an
-     * agentic process's `ProcessKey` reads `<name>.agentic.<name>`; the GUID you want
-     * is the row's `Key`) or `uip maestro flow registry search agentic`.
-     *
-     * `--all-folders` PAGINATES at 50 rows and says so in `Pagination.HasMore` — pass
-     * `--limit`/`--offset`, or scope the call with `--folder-path`, or a process that
-     * exists will look as though it does not.
-     */
-    key: string;
-    /** The process's name in Orchestrator — e.g. `'ProcurementProcess'`. */
-    name: string;
-    /**
-     * Where the process lives. `'published'` (the default) is a process deployed
-     * to `folderPath`. `'in-solution'` is a sibling Flow of the same solution, so
-     * it needs `form: 'flow'`, `projectId` and no `folderPath`; `key` is the
-     * sibling's `resource.key` from `resources/solution_folder/process/flow/<project>.json`.
-     * Only the Flow form has been run in-solution; `'bpmn'` and `'case'` siblings
-     * are refused until they are.
-     *
-     * @enforcedBy AGENTIC_LOCAL_FORM_UNVERIFIED In-solution is supported for `form: 'flow'` only.
-     */
-    location?: ProcessLocation;
-    /**
-     * The Orchestrator folder holding it — e.g.
-     * `'Shared/uipath-agents/ProcurementProcess'`. Required for a published
-     * process; omit it for an in-solution sibling.
-     *
-     * @enforcedBy AGENTIC_NO_FOLDER A published process needs its folder.
-     */
-    folderPath?: string;
-    /**
-     * The sibling project's `resource.projectKey`, read from the same resource
-     * file as `key` (`resources/solution_folder/process/flow/<project>.json`).
-     * Required only when `location` is `'in-solution'`.
-     *
-     * @enforcedBy AGENTIC_LOCAL_NO_PROJECT_ID An in-solution process needs its project id.
-     */
-    projectId?: string;
-    /**
-     * The PROCESS's own input arguments, by its own argument names (e.g.
-     * `{ productId: 1 }`). Not a fixed schema — every agentic process declares its
-     * own, and only the deployed process knows them.
-     */
-    inputs?: Record<string, unknown>;
-    /**
-     * Which published form this Agentic Process is: the three forms
-     * share one public concept and differ only in wire identity. `'bpmn'` (the
-     * default, and what this factory always emitted) is a Maestro BPMN process
-     * orchestration; `'flow'` is a published Maestro Flow; `'case'` is a Case
-     * Management process.
-     */
-    form?: 'bpmn' | 'flow' | 'case';
-}
-/**
- * Whether an Agentic Process step waits for the process's result.
- * The discriminated union makes `returns` impossible to declare in the
- * fire-and-forget form: an async dispatch publishes no output, so nothing
- * downstream may read one.
- */
-export type AgenticProcessCompletion = {
-    /** Wait for the process and publish its outputs (the default). */
-    completion?: 'wait';
-    /**
-     * The process's OUTPUT arguments — the fields it returns, and their types (e.g.
-     * `{ status: 'boolean' }`). Required if anything reads the step's output, for the
-     * same reason as `rpaWorkflow`'s and `apiWorkflow`'s: the schema lives on the
-     * tenant and authoring happens offline, so an undeclared read is rejected.
-     *
-     * `uip maestro flow registry get uipath.core.agentic-process.<process>` shows what
-     * the platform synthesizes, under `outputDefinition.output.schema.properties`.
-     *
-     * Worth knowing before you assert on a value: a process can DECLARE a field and
-     * still leave it empty. `Shared/uipath-agents/ProcurementProcess` declares
-     * `{status: boolean}` and every job returns `{"status": null}` (measured
-     * 2026-07-29, four jobs) — the field arrives, the value does not.
-     *
-     * @enforcedBy AGENTIC_READ_WITHOUT_RETURNS Reading a field off the result requires
-     * declaring it here.
-     */
-    returns?: Record<string, ReturnFieldType>;
-} | {
-    /**
-     * Dispatch the process and continue immediately — the platform's
-     * fire-and-forget switch. The node keeps only its `error` output (dispatch
-     * failures still route), and `check` rejects any read of the step's result.
-     * A local replay treats this as dispatch-only: it never fabricates the
-     * output a real run would not publish.
-     */
-    completion: 'fire-and-forget';
-    /** Impossible by design: an async dispatch publishes no output. */
-    returns?: never;
-};
-/** What `agenticProcess()` takes: the shared fields plus the completion policy. */
-export type AgenticProcessInputs = AgenticProcessInputsBase & AgenticProcessCompletion;
 /**
  * Which KIND of agent project was published behind a `uipath.core.agent.<key>`
  * resource. Display-only — see {@link AgentInputs.flavour}.
@@ -1636,18 +1412,6 @@ export interface ContextIndexRef extends AgentResourcePlacement {
  * whole body rather than an inputs payload.
  */
 export interface FlowActionSpecs {
-    /** The spec {@link rpaWorkflow} builds. */
-    rpaWorkflow: {
-        inputs: RpaWorkflowInputs;
-    };
-    /** The spec {@link apiWorkflow} builds. */
-    apiWorkflow: {
-        inputs: ApiWorkflowInputs;
-    };
-    /** The spec {@link publishedFunction} builds. */
-    publishedFunction: {
-        inputs: PublishedFunctionInputs;
-    };
     /** The spec {@link createOutgoingCall} builds. */
     createOutgoingCall: {
         inputs: CreateOutgoingCallInputs;
@@ -1664,10 +1428,6 @@ export interface FlowActionSpecs {
     conversationalAgent: {
         inputs: ConversationalAgentInputs;
     };
-    /** The spec {@link agenticProcess} builds. */
-    agenticProcess: {
-        inputs: AgenticProcessInputs;
-    };
     /** The spec {@link agent} builds. */
     agent: {
         inputs: AgentInputs;
@@ -1794,111 +1554,6 @@ export declare function builtinTriggerSpec<S extends object>(spec: S): S;
  * @returns An action spec to pass to `.step(name, …)`.
  */
 export declare function ixpExtract(inputs: IxpExtractInputs): ActionSpec;
-/**
- * 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 declare function rpaWorkflow(inputs: RpaWorkflowInputs): ActionSpec;
-/**
- * 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 declare function apiWorkflow(inputs: ApiWorkflowInputs): ActionSpec;
-/**
- * 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 declare function publishedFunction(inputs: PublishedFunctionInputs): ActionSpec;
 /**
  * Place an outgoing phone call
  * (`uipath.conversational.voice.create-outgoing-call`) and get back the
@@ -1974,52 +1629,6 @@ export declare function voiceAgent(inputs: VoiceAgentInputs): ActionSpec;
  * @returns An action spec to pass to `.step(...)`.
  */
 export declare function conversationalAgent(inputs: ConversationalAgentInputs): ActionSpec;
-/**
- * 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 declare function agenticProcess(inputs: AgenticProcessInputs): ActionSpec;
 /**
  * Invoke an AGENT resource — either one published to Orchestrator or a sibling
  * agent project registered in the same solution. Both start through

package/dist/core/actions.js

@@ -145,117 +145,6 @@ export function builtinTriggerSpec(spec) {
 export function ixpExtract(inputs) {
     return builtinActionSpec({ kind: 'ixpExtract', inputs });
 }
-/**
- * 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 });
-}
 /**
  * Place an outgoing phone call
  * (`uipath.conversational.voice.create-outgoing-call`) and get back the
@@ -339,62 +228,6 @@ export function voiceAgent(inputs) {
 export function conversationalAgent(inputs) {
     return builtinActionSpec({ kind: 'conversationalAgent', 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 });
-}
 /**
  * Invoke an AGENT resource — either one published to Orchestrator or a sibling
  * agent project registered in the same solution. Both start through

package/dist/core/nodes/registry.d.ts

@@ -50,7 +50,12 @@ export declare class NodeTypeRegistry<Ctx extends ArtifactContexts> {
     byKind(kind: string, spec?: unknown): Registered<Ctx> | undefined;
     /** Every node type registered for a kind (several when they share it), in registration order. */
     typesOfKind(kind: string): readonly Registered<Ctx>[];
-    /** The node type for a type name in the file, or undefined when it is not registered. */
+    /**
+     * The node type for a type name in the file — the exact name, else the type
+     * whose `typeNamePrefix` it starts with — or undefined when no type owns it.
+     * The bare prefix counts: it is what an empty `key` builds, and the old lift
+     * read it as its factory, so it still does.
+     */
     byTypeName(typeName: string): Registered<Ctx> | undefined;
     /** Every registered kind, sorted. */
     kinds(): string[];

package/dist/core/nodes/registry.js

@@ -5,6 +5,8 @@ export class NodeTypeRegistry {
     families;
     #byKind = new Map();
     #byTypeName = new Map();
+    /** The types that own a family of names (`typeNamePrefix`); no two prefixes overlap. */
+    #byPrefix = [];
     /**
      * @param artifact - The artifact's name, for messages (`'flow'`).
      * @param families - Every family this artifact supports, in no significant order.
@@ -34,6 +36,23 @@ export class NodeTypeRegistry {
                 if (sharing && (!type.matches || sharing.some((other) => !other.type.matches))) {
                     problems.push(`kind "${type.kind}" is registered twice (${[...sharing, { family, type }].map((e) => `${e.family.id}/${e.type.typeName}`).join(' and ')}); node types that share a kind must each declare matches(spec)`);
                 }
+                if (type.typeNamePrefix !== undefined) {
+                    const prefix = type.typeNamePrefix;
+                    if (type.typeName !== `${prefix}*`) {
+                        problems.push(`${where}: a type that owns the names under "${prefix}" is named "${prefix}*", not "${type.typeName}"`);
+                    }
+                    const overlap = this.#byPrefix.find((p) => p.prefix.startsWith(prefix) || prefix.startsWith(p.prefix));
+                    if (overlap)
+                        problems.push(`${where}: prefix "${prefix}" overlaps "${overlap.prefix}" (${placeOf(overlap.entry)})`);
+                    const shadowed = [...this.#byTypeName.keys()].find((n) => n.startsWith(prefix));
+                    if (shadowed)
+                        problems.push(`${where}: prefix "${prefix}" would also own the registered type "${shadowed}"`);
+                }
+                else {
+                    const owner = this.#byPrefix.find((p) => type.typeName.startsWith(p.prefix));
+                    if (owner)
+                        problems.push(`${where}: type name "${type.typeName}" falls under the prefix "${owner.prefix}" (${placeOf(owner.entry)})`);
+                }
                 const typeOwner = this.#byTypeName.get(type.typeName);
                 if (typeOwner) {
                     problems.push(`type name "${type.typeName}" is registered twice (${placeOf(typeOwner)} and ${where}); one VersionedNodeType owns every version of a type`);
@@ -50,6 +69,9 @@ export class NodeTypeRegistry {
                 const entry = { family, type };
                 this.#byKind.set(type.kind, [...(sharing ?? []), entry]);
                 this.#byTypeName.set(type.typeName, entry);
+                if (type.typeNamePrefix !== undefined) {
+                    this.#byPrefix.push({ prefix: type.typeNamePrefix, entry });
+                }
             }
         }
         if (problems.length > 0) {
@@ -78,9 +100,17 @@ export class NodeTypeRegistry {
     typesOfKind(kind) {
         return this.#byKind.get(kind) ?? [];
     }
-    /** The node type for a type name in the file, or undefined when it is not registered. */
+    /**
+     * The node type for a type name in the file — the exact name, else the type
+     * whose `typeNamePrefix` it starts with — or undefined when no type owns it.
+     * The bare prefix counts: it is what an empty `key` builds, and the old lift
+     * read it as its factory, so it still does.
+     */
     byTypeName(typeName) {
-        return this.#byTypeName.get(typeName);
+        const exact = this.#byTypeName.get(typeName);
+        if (exact)
+            return exact;
+        return this.#byPrefix.find((p) => typeName.startsWith(p.prefix))?.entry;
     }
     /** Every registered kind, sorted. */
     kinds() {