@uipath/maestro-builder-sdk 6.68.6 → 6.69.0

package/dist/case/subscription.d.ts

@@ -22,16 +22,18 @@ export declare class GenericEventNoObjectError extends CompileRefusal {
 /**
  * Resolve a Case event subscription: `library.resolveEvent` with the
  * subscription's own `version` and `object`, then refuse a GENERIC event the
- * author named no object for.
+ * author named no object for. Whatever `resolveEvent` throws (a connector or
+ * event the library does not carry, a version or object it does not resolve)
+ * is one condition, an event compile cannot place: EVENT_UNKNOWN, as Flow's
+ * compile says.
  *
  * @param library - The connector library.
  * @param kind - `trigger` for an event trigger, `event` for a wait-for-connector task or rule.
  * @param sub - The authored subscription.
  * @param byoa - Where the subscription is and the bindings, to refuse an
- *   unverified BYOA connection; compile passes it, `check` does not (it reports
- *   that rule from the shared event rules).
+ *   unverified BYOA connection.
  * @returns The resolved event.
- * @throws What `resolveEvent` throws, {@link GenericEventNoObjectError}, or a `ByoaRefusal`.
+ * @throws EVENT_UNKNOWN, {@link GenericEventNoObjectError}, or a `ByoaRefusal`.
  */
 export declare function resolveCaseSubscription(library: Library, kind: 'trigger' | 'event', sub: EventSubscription, byoa?: {
     where: string;

package/dist/case/subscription.js

@@ -16,19 +16,29 @@ function caseObjectOption(object) {
 /**
  * Resolve a Case event subscription: `library.resolveEvent` with the
  * subscription's own `version` and `object`, then refuse a GENERIC event the
- * author named no object for.
+ * author named no object for. Whatever `resolveEvent` throws (a connector or
+ * event the library does not carry, a version or object it does not resolve)
+ * is one condition, an event compile cannot place: EVENT_UNKNOWN, as Flow's
+ * compile says.
  *
  * @param library - The connector library.
  * @param kind - `trigger` for an event trigger, `event` for a wait-for-connector task or rule.
  * @param sub - The authored subscription.
  * @param byoa - Where the subscription is and the bindings, to refuse an
- *   unverified BYOA connection; compile passes it, `check` does not (it reports
- *   that rule from the shared event rules).
+ *   unverified BYOA connection.
  * @returns The resolved event.
- * @throws What `resolveEvent` throws, {@link GenericEventNoObjectError}, or a `ByoaRefusal`.
+ * @throws EVENT_UNKNOWN, {@link GenericEventNoObjectError}, or a `ByoaRefusal`.
  */
 export function resolveCaseSubscription(library, kind, sub, byoa) {
-    const rc = library.resolveEvent(kind, sub.connector, sub.event, sub.version, sub.object);
+    let rc;
+    try {
+        rc = library.resolveEvent(kind, sub.connector, sub.event, sub.version, sub.object);
+    }
+    catch (error) {
+        if (error instanceof Error && error.message.startsWith('internal SDK error:'))
+            throw error;
+        throw new CompileRefusal('EVENT_UNKNOWN', error instanceof Error ? error.message : String(error));
+    }
     const noObject = genericEventObjectRefusal(rc, sub, caseObjectOption);
     if (noObject)
         throw new GenericEventNoObjectError(noObject);

package/dist/core/refusals.d.ts

@@ -278,6 +278,7 @@ export declare const REFUSALS: {
     readonly EXTERNAL_TASK_EVENT: "lowering";
     readonly EXTERNAL_TASK_FOLDER: "lowering";
     readonly EXTERNAL_TASK_MODE: "lowering";
+    readonly EXTERNAL_TASK_MODE_MISMATCH: "lowering";
     readonly EXTRACT_SCHEMA_SHAPE: "lint";
     readonly FAKE_JOIN: "lint";
     readonly FILE_NOT_FOUND: "lowering";

package/dist/core/refusals.js

@@ -6,8 +6,9 @@
  *     stops `compile` from writing. A serializer warning (`CONNECTION_STUB`) is
  *     `lint` too: it never blocks.
  *   - `lowering`: `compile` cannot write a correct `.flow` (or caseplan, or `.bpmn`). It always
- *     stops `compile`; for a Flow, `check` reports it too, from the serializer it runs in
- *     collect mode (`SerializeOpts.collect`), so the rule lives in one place.
+ *     stops `compile`; for a Flow or a Case, `check` reports it too, from the serializer it
+ *     runs in collect mode (`SerializeOpts.collect`, `CaseSerializeOpts.collect`), so the rule
+ *     lives in one place.
  *   - `draft`: an unfinished canvas node (no connection yet, a required input
  *     left empty, a generic operation with no object). These are the codes a
  *     draft-tolerant compile collects instead of throwing (`DraftCode` in
@@ -329,6 +330,7 @@ export const REFUSALS = {
     EXTERNAL_TASK_EVENT: 'lowering',
     EXTERNAL_TASK_FOLDER: 'lowering',
     EXTERNAL_TASK_MODE: 'lowering',
+    EXTERNAL_TASK_MODE_MISMATCH: 'lowering',
     EXTRACT_SCHEMA_SHAPE: 'lint',
     FAKE_JOIN: 'lint',
     FILE_NOT_FOUND: 'lowering',

package/dist/registry/library-build/enrich.d.ts

@@ -1,5 +1,6 @@
 import type { LibraryEntry } from "../model/library.js";
 import { type BuildContext } from "./context.js";
+import { type Dict } from "./py.js";
 /**
  * Registry `httpMethod` (e.g. `GETBYID`) → a guess at the `is resources`
  * operation name, for an entry whose canonical `operation.name` is empty.
@@ -18,6 +19,25 @@ export declare function discoverOperationName(ctx: BuildContext, entry: LibraryE
  * payload; `objectDisplayName` and `display.operationLabel` fill gaps only.
  */
 export declare function applyDescribe(entry: LibraryEntry, data: unknown): LibraryEntry;
+/**
+ * Record an external agent's or automation's execution facts on its operation,
+ * from the describe payload (#1369, #1387).
+ *
+ * Integration Service keeps them on the object's metadata, not in the registry
+ * node: `executionType` (`sync`, `async` or `hybrid`) and, for an `async` or
+ * `hybrid` object, the event it answers with. `uip is resources describe`
+ * reports them as `ExecutionType`, `EventType` and `EventMode` (uip#5702,
+ * read with the same `externalExecutionOf` as `case spec`). They become
+ * `operation.executionType` and `operation.executionEvent` (`{ operation, mode }`),
+ * which Case and BPMN derive the task's `mode` and `event` from. The event is
+ * kept apart from `eventOperation` / `eventMode`, which mark a connector EVENT
+ * entry (a trigger) and which `identifyEvent` matches on.
+ *
+ * Only an `AgentExecution` / `ProcessExecution` operation gets them, and only
+ * what the payload states (an execution type outside the three is not stored): a describe from a CLI that does not report them
+ * leaves the entry as it was, so an older build stays byte-identical.
+ */
+export declare function applyExternalExecution(operation: Dict, data: unknown): void;
 /**
  * `enrich_entry`: augment a canonical entry with `is resources describe` data.
  * On any failure the entry is returned as it was, so the pipeline degrades

package/dist/registry/library-build/enrich.js

@@ -78,6 +78,7 @@ export function applyDescribe(entry, data) {
     const opCurated = pick(opData, "Curated", "curated");
     if (pyTruthy(opCurated) && !pyTruthy(get(display, "operationLabel")))
         display.operationLabel = opCurated;
+    applyExternalExecution(operation, data);
     // Parameters (path / query) — raw shape, camelCase keys.
     const params = pyOr(pick(data, "Parameters", "parameters"), []);
     if (pyTruthy(params))
@@ -92,6 +93,45 @@ export function applyDescribe(entry, data) {
         e.outputSchema = { fields: normalizeFieldKeys(responseFields) };
     return entry;
 }
+/** The operation subtypes Case's and BPMN's external agent / workflow tasks run. */
+const EXTERNAL_SUBTYPES = new Set(["AgentExecution", "ProcessExecution"]);
+/** The execution types Integration Service reports, as Case and BPMN read them. */
+const EXECUTION_TYPES = new Set(["sync", "async", "hybrid"]);
+/**
+ * Record an external agent's or automation's execution facts on its operation,
+ * from the describe payload (#1369, #1387).
+ *
+ * Integration Service keeps them on the object's metadata, not in the registry
+ * node: `executionType` (`sync`, `async` or `hybrid`) and, for an `async` or
+ * `hybrid` object, the event it answers with. `uip is resources describe`
+ * reports them as `ExecutionType`, `EventType` and `EventMode` (uip#5702,
+ * read with the same `externalExecutionOf` as `case spec`). They become
+ * `operation.executionType` and `operation.executionEvent` (`{ operation, mode }`),
+ * which Case and BPMN derive the task's `mode` and `event` from. The event is
+ * kept apart from `eventOperation` / `eventMode`, which mark a connector EVENT
+ * entry (a trigger) and which `identifyEvent` matches on.
+ *
+ * Only an `AgentExecution` / `ProcessExecution` operation gets them, and only
+ * what the payload states (an execution type outside the three is not stored): a describe from a CLI that does not report them
+ * leaves the entry as it was, so an older build stays byte-identical.
+ */
+export function applyExternalExecution(operation, data) {
+    if (!EXTERNAL_SUBTYPES.has(String(get(operation, "subType") ?? "")))
+        return;
+    // Stored only as one of the three values Case and BPMN read, lowercased: a
+    // `Hybrid` kept verbatim would be ignored downstream and read as "no record".
+    const reported = pick(data, "ExecutionType", "executionType");
+    const executionType = typeof reported === "string" ? reported.trim().toLowerCase() : "";
+    if (!EXECUTION_TYPES.has(executionType))
+        return;
+    operation.executionType = executionType;
+    if (executionType === "sync")
+        return;
+    const eventType = pick(data, "EventType", "eventType");
+    const eventMode = pick(data, "EventMode", "eventMode");
+    if (typeof eventType === "string" && eventType && typeof eventMode === "string" && eventMode)
+        operation.executionEvent = { operation: eventType, mode: eventMode };
+}
 /**
  * `enrich_entry`: augment a canonical entry with `is resources describe` data.
  * On any failure the entry is returned as it was, so the pipeline degrades

package/dist/registry/model/library.d.ts

@@ -85,6 +85,16 @@ export interface EntryOperation {
     objectFromDiscovery?: boolean;
     eventOperation?: string;
     eventMode?: string;
+    /**
+     * An external agent's or automation's `executionType` (`sync`, `async`,
+     * `hybrid`), on an `AgentExecution` / `ProcessExecution` operation only.
+     */
+    executionType?: string;
+    /** The event an `async` / `hybrid` external object answers with. */
+    executionEvent?: {
+        operation: string;
+        mode: string;
+    };
     schemaAction?: SchemaAction | null;
     dispatchStyle?: string;
     paramGrammars?: unknown;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/maestro-builder-sdk",
-  "version": "6.68.6",
+  "version": "6.69.0",
   "description": "Build UiPath Flow, Case, and BPMN artifacts by writing TypeScript.",
   "license": "MIT",
   "homepage": "https://docs.uipath.com/maestro",
@@ -100,5 +100,5 @@
     "@types/node": "^22.7.0",
     "esbuild": "^0.28.1"
   },
-  "gitref": "7e50034dc8a8317fe205d355859bc80f047174b3"
+  "gitref": "f1c4fc99c993d7cc8defcda32496be344f018a23"
 }