@uipath/maestro-builder-sdk 6.16.14 → 6.17.1

package/dist/compile-cli.js

@@ -17,18 +17,20 @@
  * product's own gates are supposed to answer. `.build()` still throws on
  * structural problems; only the diagnostic pass is skipped.
  */
-import { reportDiagnostics, reportResult } from './cli-result.js';
-import { writeFileSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync } from 'node:fs';
+import { reportDiagnostics, reportResult, thrownDiagnostic } from './cli-result.js';
+import { writeJsonFile } from './core/json-file.js';
+import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync } from 'node:fs';
 import { basename, dirname, join, resolve } from 'node:path';
 import { resolveFlowFile, loadBuiltFlow } from './load.js';
-import { serializeWithSidecars, connectorInputErrors, compileOwnsResource } from './serialize.js';
+import { serializeWithSidecars, compileOwnsResource } from './serialize.js';
 import { check } from './check.js';
-import { byoaCheckOpts, eventResolveErrorFor, openCliLibrary } from './cli-library.js';
+import { flowCheckOpts, openCliLibrary } from './cli-library.js';
 import { Bindings } from './bindings.js';
 import { flagValue, runWhenInvokedDirectly } from './cli-run.js';
-import { connectionResources, mergeBindingsV2, readBindingsV2 } from './bindings-v2.js';
+import { connectionResources, inlineAgentResources, mergeBindingsV2, mergeInlineAgentResources, readBindingsV2, readInlineAgentFiles, } from './bindings-v2.js';
 import { ensureTypeScriptRuntime } from './node-runtime.js';
 import { defaultBindingsFile } from './workdir.js';
+import { isWithin } from './path-within.js';
 import { BindingRefusal } from './core/binding-messages.js';
 import { ByoaRefusal } from './core/byoa.js';
 export async function run(argv) {
@@ -65,43 +67,17 @@ export async function run(argv) {
     const library = openCliLibrary(argv);
     const bindFile = flagValue(argv, '--bindings') ?? defaultBindingsFile();
     const bindings = new Bindings(bindFile);
+    // One list per run; every exit path reports it (reportResult overwrites keys).
+    const diagnostics = [];
     if (!noCheck) {
-        const diags = check(built, library
-            ? {
-                // The refusal serialize() would throw for an event it cannot resolve,
-                // printed as `✗ [EVENT_UNKNOWN]` before stopping instead of hiding
-                // behind "1 error(s); not emitting".
-                eventResolveError: eventResolveErrorFor(library),
-                ...byoaCheckOpts(library),
-                eventParams: (connector, event) => {
-                    try {
-                        return library.eventParameterFields(connector, event);
-                    }
-                    catch {
-                        return undefined; // unresolvable: serialize() reports it properly
-                    }
-                },
-                lookups: (connector, action, version, object) => library.lookupSpecs(connector, action, version, object),
-                resolutions: library.lookupResolutions,
-                // Same validator serialize() runs below, so the check pass names the
-                // refusal (and stops) instead of printing `0 error(s)` first.
-                connectorInputs: (spec, inputs) => {
-                    try {
-                        const rc = library.resolve(spec.key, spec.action, spec.version, spec.object);
-                        return connectorInputErrors(rc, inputs, library.lookupResolutions ?? {}, library.lookupSpecs(spec.key, spec.action, spec.version, spec.object) ?? {});
-                    }
-                    catch {
-                        return undefined;
-                    }
-                },
-                bindings,
-            }
-            : { bindings });
+        // Same options as `flow check`, so the two cannot disagree.
+        const diags = check(built, flowCheckOpts(library, bindings));
         const errors = diags.filter((d) => d.level === 'error');
         for (const d of diags)
             console.error(`  ${d.level === 'error' ? '✗' : '⚠'} [${d.code}] ${d.message}${d.suggestion ? ` (did you mean "${d.suggestion}"?)` : ''}`);
+        diagnostics.push(...diags);
         if (errors.length) {
-            reportDiagnostics(diags);
+            reportDiagnostics(diagnostics);
             console.error(`compile: ${errors.length} error(s); not emitting.`);
             return 1;
         }
@@ -121,28 +97,27 @@ export async function run(argv) {
         emitted = serializeWithSidecars(built, { library, bindings, warn: (w) => warnings.push(w) });
     }
     catch (error) {
-        if (!(error instanceof BindingRefusal || error instanceof ByoaRefusal))
-            throw error;
         for (const w of warnings)
             console.error(`  ⚠ [${w.code}] ${w.message}`);
+        diagnostics.push(...warnings.map(serializeWarningDiagnostic));
+        if (!(error instanceof BindingRefusal || error instanceof ByoaRefusal)) {
+            // Any other throw still ends the run through the caller (exit 1, `--json`
+            // `error`); the list is reported first.
+            diagnostics.push(thrownDiagnostic(error));
+            reportDiagnostics(diagnostics);
+            throw error;
+        }
         console.error(`  ✗ [${error.code}] ${error.message}`);
-        reportDiagnostics([
-            ...warnings.map((w) => ({ level: 'warning', code: w.code, message: w.message })),
-            { level: 'error', code: error.code, message: error.message },
-        ]);
+        diagnostics.push({ level: 'error', code: error.code, message: error.message });
+        reportDiagnostics(diagnostics);
         console.error('compile: 1 error(s); not emitting.');
         return 1;
     }
     const { flow: flowJson, sidecars } = emitted;
     for (const w of warnings)
         console.error(`  ⚠ [${w.code}] ${w.message}`);
+    diagnostics.push(...warnings.map(serializeWarningDiagnostic));
     const out = flagValue(argv, '-o') ?? `${built.name || basename(file).replace(/\.flow\.ts$|\.ts$/, '')}.flow`;
-    writeFileSync(out, JSON.stringify(flowJson, null, 2) + '\n');
-    console.log(`compile: wrote ${out} (${flowJson.nodes.length} nodes, ${flowJson.edges.length} edges)`);
-    const written = [];
-    reportResult({ path: resolve(out), nodes: flowJson.nodes.length, edges: flowJson.edges.length, sidecars: written });
-    // Same keys and types as a failed compile: `warnings` a count, `diagnostics` the list.
-    reportDiagnostics(warnings.map((w) => ({ level: 'warning', code: w.code, message: w.message })));
     // An inline agent is TWO artifacts: the node, and the agent's own configuration
     // at `<source>/agent.json` — which is where flow-v1's serializer points the
     // runtime (`entryPoint: "<source>/agent.json"`, resolved relative to the
@@ -151,19 +126,31 @@ export async function run(argv) {
     // Sidecar paths are relative to the emitted flow, and are confined to its
     // directory: a `..` or absolute path in one would be a bug here, not author
     // input, but it is cheap to refuse rather than write outside the project.
+    //
+    // Every sidecar is checked before anything is written; success is reported
+    // only once every file is on disk.
     const outDir = dirname(resolve(out));
-    for (const s of sidecars) {
-        const target = resolve(outDir, s.path);
-        if (target !== outDir && !target.startsWith(outDir + '/')) {
-            console.error(`compile: refusing to write a sidecar outside the flow's directory: ${s.path}`);
-            reportResult({ error: `refusing to write a sidecar outside the flow's directory: ${s.path}` });
-            return 1;
-        }
+    const targets = sidecars.map((s) => ({ sidecar: s, target: resolve(outDir, s.path) }));
+    const escaping = targets.find(({ target }) => target === outDir || !isWithin(outDir, target));
+    if (escaping) {
+        const message = `refusing to write a sidecar outside the flow's directory: ${escaping.sidecar.path}`;
+        console.error(`compile: ${message}; not emitting.`);
+        diagnostics.push({ level: 'error', code: 'SIDECAR_OUTSIDE_FLOW_DIR', message });
+        reportDiagnostics(diagnostics);
+        return 1;
+    }
+    // Reported before the first write, so a write that throws still carries it.
+    reportDiagnostics(diagnostics);
+    writeJsonFile(out, flowJson);
+    console.log(`compile: wrote ${out} (${flowJson.nodes.length} nodes, ${flowJson.edges.length} edges)`);
+    const written = [];
+    for (const { sidecar, target } of targets) {
         mkdirSync(dirname(target), { recursive: true });
-        writeFileSync(target, JSON.stringify(s.json, null, 2) + '\n');
-        console.log(`compile: wrote ${s.path}`);
+        writeJsonFile(target, sidecar.json);
+        console.log(`compile: wrote ${sidecar.path}`);
         written.push(target);
     }
+    reportResult({ path: resolve(out), nodes: flowJson.nodes.length, edges: flowJson.edges.length, sidecars: written });
     // PRUNE the agent resources this compile owns but did not write this time.
     // Compile otherwise only ever ADDS files, and an agent resource is keyed by a
     // uuid derived from the step name and the resource's identity — so dropping a
@@ -180,13 +167,14 @@ export async function run(argv) {
     // families the SDK cannot into the same directory (including `internal`
     // built-ins such as `load-attachments`), so anything else found there is
     // someone else's and is left alone.
-    const staleBindings = [];
+    const removedResources = [];
     const owned = new Set(sidecars
         .filter((s) => /\/resources\/[^/]+\/resource\.json$/.test(s.path))
         .map((s) => resolve(outDir, s.path)));
-    for (const agentDir of new Set(sidecars
-        .filter((s) => s.path.endsWith('/agent.json'))
-        .map((s) => dirname(resolve(outDir, s.path))))) {
+    const agentDirs = [...new Set(sidecars
+            .filter((s) => s.path.endsWith('/agent.json'))
+            .map((s) => dirname(resolve(outDir, s.path))))];
+    for (const agentDir of agentDirs) {
         const resourcesDir = join(agentDir, 'resources');
         if (!existsSync(resourcesDir))
             continue;
@@ -203,23 +191,7 @@ export async function run(argv) {
             }
             if (!compileOwnsResource(body))
                 continue;
-            const resourceType = body?.$resourceType;
-            // The binding `uip agent refresh` derived FROM this file has to go with it.
-            // Refresh will not retract it: with no resources left it writes nothing, and
-            // `mergeBindingsV2` preserves every non-connection entry, so the removed
-            // index would stay declared in `bindings_v2.json` and a deploy could still
-            // fail on it. Keyed the way refresh keys it — an index by its name.
-            const named = body?.indexName ?? body?.name;
-            const key = typeof named === 'string' && named !== '' ? named : undefined;
-            // A connector tool's binding is a `connection` row, and `mergeBindingsV2`
-            // re-derives every connection row from the flow below — nothing to retract.
-            // A built-in (`internal`) tool binds nothing at all: retracting a `process`
-            // row under its label could only remove a real process tool's binding.
-            if (key !== undefined && body?.type !== 'integration' && body?.type !== 'internal') {
-                // Keyed the way refresh keys it: an index by its name, a deployed-resource
-                // tool under `process` whatever its own type says.
-                staleBindings.push({ resource: resourceType === 'context' ? 'index' : 'process', key });
-            }
+            removedResources.push(body);
             rmSync(join(resourcesDir, entry), { recursive: true, force: true });
             console.log(`compile: removed stale ${join('resources', entry, 'resource.json')}`);
         }
@@ -235,20 +207,44 @@ export async function run(argv) {
         const sidecarPath = join(outDir, 'bindings_v2.json');
         const connections = connectionResources(flowJson);
         const existing = readBindingsV2(sidecarPath);
+        // Each inline agent's own rows (process, index, app, … — #962), derived from
+        // the agent directory as it now stands on disk, the way `uip agent refresh
+        // --inline-in-flow` derives them. `uip agent validate --inline-in-flow`
+        // requires every one of them, so leaving them to a refresh the SDK route
+        // never runs made every agent with a deployed-resource tool, a context index
+        // or an app escalation fail validate with `AgentValidationDrift`.
+        const agentRows = agentDirs
+            .map((dir) => readInlineAgentFiles(dir))
+            .filter((files) => files !== undefined)
+            .map((files) => inlineAgentResources(files));
+        // The rows a PRUNED resource declared go with it: refresh never retracts a
+        // row, so an index the flow dropped would stay declared and a deploy could
+        // still fail on it. Generated by the same function, so they match exactly,
+        // and kept when a resource that still exists declares the same row.
+        // Connection rows are skipped: every one is re-derived from the flow below.
+        const live = new Set(agentRows.flat().map((r) => `${r.resource}\u0000${r.key}`));
+        const stale = new Set(inlineAgentResources({ agent: {}, resources: removedResources, features: [] })
+            .filter((r) => r.resource !== 'connection' && !live.has(`${r.resource}\u0000${r.key}`))
+            .map((r) => `${r.resource}\u0000${r.key}`));
         // Nothing to declare and nothing already declared — do not create an empty
         // file for a flow that has no resources at all.
-        if (connections.length > 0 || existing !== undefined) {
+        if (connections.length > 0 || existing !== undefined || agentRows.some((rows) => rows.length > 0)) {
             const merged = mergeBindingsV2(existing, connections);
-            if (staleBindings.length > 0) {
-                const dropped = new Set(staleBindings.map((b) => `${b.resource}\u0000${b.key}`));
-                merged.resources = merged.resources.filter((r) => !dropped.has(`${r.resource}\u0000${r.key}`));
-            }
-            writeFileSync(sidecarPath, JSON.stringify(merged, null, 2) + '\n');
-            const kept = merged.resources.length - connections.length;
+            merged.resources = merged.resources.filter((r) => !stale.has(`${r.resource}\u0000${r.key}`));
+            for (const rows of agentRows)
+                merged.resources = mergeInlineAgentResources(merged.resources, rows);
+            writeJsonFile(sidecarPath, merged);
+            const derived = new Set([...connections, ...agentRows.flat()].map((r) => `${r.resource}\u0000${r.key}`));
+            const agentCount = merged.resources.filter((r) => r.resource !== 'connection' && derived.has(`${r.resource}\u0000${r.key}`)).length;
+            const kept = merged.resources.filter((r) => !derived.has(`${r.resource}\u0000${r.key}`)).length;
             console.log(`compile: wrote bindings_v2.json (${connections.length} connection resource(s)`
+                + `${agentCount > 0 ? `, ${agentCount} inline-agent resource(s)` : ''}`
                 + `${kept > 0 ? `, ${kept} other resource(s) preserved` : ''})`);
         }
     }
     return 0;
 }
+function serializeWarningDiagnostic(w) {
+    return { level: 'warning', code: w.code, message: w.message };
+}
 runWhenInvokedDirectly(import.meta.url, 'compile', run);

package/dist/core/actions.d.ts

@@ -58,7 +58,7 @@ interface HttpInputsBase {
      *   an error port only makes sense here (`check` says so: HTTP_ONERROR_V1).
      *   The handler can answer the flow (`.return`), stop the run
      *   (`.terminate`), or compensate and continue at a step the success path
-     *   also reaches (`h.rejoin('<step>')` — see `references/error-handling.md`);
+     *   also reaches (`h.stepToRef('<step>')` — see `references/error-handling.md`);
      * - both nodes expose JSON responses as parsed values in the live product;
      *   use `returns` to declare fields before reading them. The node choice does
      *   not decide whether application/json is parsed.
@@ -981,21 +981,48 @@ export type DelayInputs = {
     /** Impossible together with `until` — a delay waits one way or the other. */
     duration?: never;
 };
+/**
+ * Where a process resource lives: deployed to an Orchestrator folder
+ * (`'published'`, the default) or a sibling project of the SAME solution
+ * (`'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'`.
+     * `'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;
+    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,
@@ -1101,11 +1128,33 @@ interface AgenticProcessInputsBase {
     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'`.
+     * `'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;
+    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
@@ -1167,7 +1216,7 @@ export type AgenticProcessInputs = AgenticProcessInputsBase & AgenticProcessComp
  * resource. Display-only — see {@link AgentInputs.flavour}.
  */
 export type AgentFlavour = 'coded' | 'lowcode';
-export type AgentLocation = 'published' | 'in-solution';
+export type AgentLocation = ProcessLocation;
 export interface AgentInputs {
     /**
      * The agent resource key (a GUID). It becomes the node's TYPE,
@@ -1526,15 +1575,15 @@ export interface InlineAgentInputs {
     maxIterations?: number;
     /**
      * The harness the agent runs on — `'standard'` (the default) or
-     * `'advanced'`. Naming it selects the node's **1.3** definition (the
-     * registry's current, which adds the field); omitting it emits the 1.2
-     * definition byte-identically.
+     * `'advanced'`, written to the `agent.json`'s `settings.mode`. It does not
+     * change the node's version: every inline agent emits the bundle's newest
+     * `uipath.agent.autonomous` definition (1.4).
      */
     mode?: 'standard' | 'advanced';
     /**
      * Safety rails over the agent's inputs, outputs, LLM calls and tools — the
-     * platform's own array shape ({@link AgentGuardrail}), carried on the node
-     * (its 1.2 definition already declares the input) and in the `agent.json`.
+     * platform's own array shape ({@link AgentGuardrail}), carried in the
+     * `agent.json` (every bundled definition declares the input).
      *
      * ```ts
      * guardrails: [{
@@ -1550,8 +1599,8 @@ export interface InlineAgentInputs {
     guardrails?: AgentGuardrail[];
     /**
      * Attach an episodic memory so the agent learns from past runs — one
-     * {@link AgentMemoryRef}, wired to the agent's `memory` handle (its 1.4
-     * definition; naming one selects it).
+     * {@link AgentMemoryRef}, wired to the agent's `memory` handle (declared by
+     * the bundled 1.4 definition, which every inline agent uses).
      */
     memory?: AgentMemoryRef;
     /**
@@ -1764,9 +1813,9 @@ export interface HttpRequestToolRef {
  * An episodic memory the agent learns from across runs, wired to the agent's
  * own `memory` handle. Node type
  * `uipath.agent.resource.memory.<name-slug>.<id-slug>`, minted exactly as the
- * platform's mapper does. Naming one selects the agent's **1.4** definition
- * (which adds the handle) — transcribed from workbench source; the tenant
- * registry serves 1.3 (same availability note as do-while).
+ * platform's mapper does. The handle is LOCAL content on the bundled
+ * `uipath.agent.autonomous@1.4` (#431): the registry's own 1.4 declares no
+ * `memory` handle, so `check` refuses this today (AGENT_MEMORY_NOT_AUTHORABLE).
  */
 export interface AgentMemoryRef {
     /** The memory's display name on the tenant. */
@@ -1960,7 +2009,12 @@ export interface EscalationRef {
         key: string;
         /** The app's name, e.g. `'ContentReviewApp'`. */
         name: string;
-        /** The Orchestrator folder the app lives in. */
+        /**
+         * The Orchestrator folder the app lives in, e.g. `'Shared/Approvals'`.
+         * Omit it for an app that ships in this solution: compile then writes
+         * `'solution_folder'`, the `Folder` `uip solution resources list` reports
+         * for a solution-internal app.
+         */
         folderPath?: string;
         /** The fields the agent hands the reviewer — becomes the app's `inputSchema`. */
         inputs?: Record<string, InlineAgentFieldType>;

package/dist/core/agentic-process-forms.d.ts

@@ -0,0 +1,51 @@
+/**
+ * The three published forms under the Agentic Process umbrella (design §2.1).
+ * One public factory, three wire identities — transcribed from flow-v1's
+ * `RESOURCE_TYPE_METADATA` (ProcessOrchestration / Flow / CaseManagement):
+ * node-type segment, category, icon, resource subtype, `orchestratorType`
+ * (`resourceType.toLowerCase()`, per `createModel`), and the sync/async
+ * service-type pair. All three declare the fire-and-forget switch.
+ *
+ * `solutionFolder` is the folder under `resources/solution_folder/process/`
+ * that holds an in-solution sibling's resource file (e.g. a sibling Flow lands in
+ * `process/flow/Notifier.json`). The solution writer names it
+ * `toLowerFirstChar(resource.type)`: `@uipath/resource-builder-sdk`
+ * `MultiFileSolutionDefinitionProvider.buildResourceRelativePath`, with the
+ * process types `flow`, `processOrchestration` and `caseManagement` from that
+ * package's resource-type catalog.
+ *
+ * Shared by the serializer (which emits the node) and `check` (which names the
+ * resource file in `AGENTIC_LOCAL_NO_PROJECT_ID`), so the two can never disagree
+ * about what a form is.
+ */
+export declare const AGENTIC_PROCESS_FORMS: {
+    readonly bpmn: {
+        readonly prefix: "uipath.core.agentic-process.";
+        readonly category: "agentic-process";
+        readonly icon: "agentic-process";
+        readonly resourceSubType: "ProcessOrchestration";
+        readonly orchestratorType: "processorchestration";
+        readonly serviceType: "Orchestrator.StartAgenticProcess";
+        readonly solutionFolder: "processOrchestration";
+    };
+    readonly flow: {
+        readonly prefix: "uipath.core.flow.";
+        readonly category: "flow";
+        readonly icon: "flow-project";
+        readonly resourceSubType: "Flow";
+        readonly orchestratorType: "flow";
+        readonly serviceType: "Orchestrator.StartFlowProcess";
+        readonly solutionFolder: "flow";
+    };
+    readonly case: {
+        readonly prefix: "uipath.core.case-management.";
+        readonly category: "case-management";
+        readonly icon: "case-management";
+        readonly resourceSubType: "CaseManagement";
+        readonly orchestratorType: "casemanagement";
+        readonly serviceType: "Orchestrator.StartCaseMgmtProcess";
+        readonly solutionFolder: "caseManagement";
+    };
+};
+/** An `agenticProcess` form: `'bpmn' | 'flow' | 'case'`. */
+export type AgenticProcessForm = keyof typeof AGENTIC_PROCESS_FORMS;

package/dist/core/agentic-process-forms.js

@@ -0,0 +1,49 @@
+/**
+ * The three published forms under the Agentic Process umbrella (design §2.1).
+ * One public factory, three wire identities — transcribed from flow-v1's
+ * `RESOURCE_TYPE_METADATA` (ProcessOrchestration / Flow / CaseManagement):
+ * node-type segment, category, icon, resource subtype, `orchestratorType`
+ * (`resourceType.toLowerCase()`, per `createModel`), and the sync/async
+ * service-type pair. All three declare the fire-and-forget switch.
+ *
+ * `solutionFolder` is the folder under `resources/solution_folder/process/`
+ * that holds an in-solution sibling's resource file (e.g. a sibling Flow lands in
+ * `process/flow/Notifier.json`). The solution writer names it
+ * `toLowerFirstChar(resource.type)`: `@uipath/resource-builder-sdk`
+ * `MultiFileSolutionDefinitionProvider.buildResourceRelativePath`, with the
+ * process types `flow`, `processOrchestration` and `caseManagement` from that
+ * package's resource-type catalog.
+ *
+ * Shared by the serializer (which emits the node) and `check` (which names the
+ * resource file in `AGENTIC_LOCAL_NO_PROJECT_ID`), so the two can never disagree
+ * about what a form is.
+ */
+export const AGENTIC_PROCESS_FORMS = {
+    bpmn: {
+        prefix: 'uipath.core.agentic-process.',
+        category: 'agentic-process',
+        icon: 'agentic-process',
+        resourceSubType: 'ProcessOrchestration',
+        orchestratorType: 'processorchestration',
+        serviceType: 'Orchestrator.StartAgenticProcess',
+        solutionFolder: 'processOrchestration',
+    },
+    flow: {
+        prefix: 'uipath.core.flow.',
+        category: 'flow',
+        icon: 'flow-project',
+        resourceSubType: 'Flow',
+        orchestratorType: 'flow',
+        serviceType: 'Orchestrator.StartFlowProcess',
+        solutionFolder: 'flow',
+    },
+    case: {
+        prefix: 'uipath.core.case-management.',
+        category: 'case-management',
+        icon: 'case-management',
+        resourceSubType: 'CaseManagement',
+        orchestratorType: 'casemanagement',
+        serviceType: 'Orchestrator.StartCaseMgmtProcess',
+        solutionFolder: 'caseManagement',
+    },
+};

package/dist/core/binding-messages.d.ts

@@ -4,6 +4,11 @@ export declare const GUID_RE: RegExp;
 export type BindingRefusalCode = 'BINDING_SELF_NAME' | 'BINDING_UNDECLARED'
 /** An emitted definition's `<bindings.NAME>` placeholder has no `bindings[]` entry named NAME (#865). */
  | 'BINDING_PLACEHOLDER_UNRESOLVED'
+/**
+ * A custom node's definition references a `<bindings.NAME>` the contribution did not
+ * supply and the definition cannot close (no `resourceKey`, or no `values` row) (#942).
+ */
+ | 'CONTRIBUTION_BINDING_UNRESOLVED'
 /** Two steps on one connection disagree on which connector it belongs to (#866). */
  | 'CONNECTION_CONNECTOR_CONFLICT'
 /** A connector-bound node names no `connection` or no `folder` label (#890). */

package/dist/core/cli-library.d.ts

@@ -1,6 +1,7 @@
-import { Library } from './library.js';
+import { Library, type ResolvedConnector } from './library.js';
 import type { BindingsView } from './binding-messages.js';
 import { type ConnectorCheckOpts } from './connector-checks.js';
+import type { LookupResolutions, LookupSpec } from './lookups.js';
 import type { EventCheckOpts } from './event-checks.js';
 /**
  * The library for this invocation, or `undefined` when there is none.
@@ -15,17 +16,25 @@ export declare function openCliLibrary(argv: readonly string[]): Library | undef
  * The connector half of a family's check options, from a library the CLI already
  * opened.
  *
- * Every callback fails OPEN: an entry the library cannot resolve, or no library
- * at all, means "unknown", and an unknown fact fires no rule. That is what lets
- * `check` stay the fast inner-loop rung — a process with no connectors needs no
- * library, and one whose connector is absent from the library is `compile`'s
- * business to name, not this pass's to guess at.
+ * Every fact callback fails OPEN: no library at all, or an entry the library
+ * cannot resolve, means "unknown", and an unknown fact fires no rule. That is
+ * what lets `check` stay the fast inner-loop rung — a process with no
+ * connectors needs no library. The one exception is the resolution itself:
+ * `connectorResolveError` reports the refusal `compile` would throw for an
+ * action, the way `eventResolveError` does for an event, so `check` never
+ * passes a connector step `compile` refuses (#948).
+ *
+ * `inputErrors` is the family's field-contract validator. The default speaks
+ * the `=`-expression dialect BPMN uses; Flow passes its own, which renders its
+ * expressions (see `flowCheckOpts` in `../cli-library.ts`).
  *
  * The `resolutions` are the overlay's: without them every lookup already
  * recorded by `registry prepare --resolve` would be reported as still owed,
  * telling the author to re-run a prepare they already ran.
  */
-export declare function connectorCheckOpts(library: Library | undefined, bindings?: BindingsView): ConnectorCheckOpts & EventCheckOpts;
+export declare function connectorCheckOpts(library: Library | undefined, bindings?: BindingsView, inputErrors?: ConnectorInputValidator): ConnectorCheckOpts & EventCheckOpts;
+/** A family's field-contract validator: `compile`'s refusal for these inputs, or `undefined`. */
+export type ConnectorInputValidator = (rc: ResolvedConnector, inputs: Record<string, unknown>, resolutions: LookupResolutions, lookups: Readonly<Record<string, LookupSpec>>) => string | undefined;
 /**
  * `check`'s EVENT_UNKNOWN verdict: the message `library.resolveEvent` throws
  * for a subscription, or `undefined` when it resolves.