@uipath/maestro-builder-sdk 6.68.6 → 6.68.7

package/dist/bpmn/intsvc.js

@@ -191,6 +191,16 @@ export function createExternalTask(ctx, n) {
             `${n.key}/${n.action} is "${String(op.subType ?? 'untyped')}". ` +
             `The shipped library has very few of these — ${wanted === 'AgentExecution' ? '2' : '1'} operation(s).`);
     }
+    // The object's execution type, when the library records it (#1369): a `mode`
+    // that contradicts it compiles the other contract, which validate accepts and
+    // the run gets wrong. Studio Web runs `hybrid` as `async`.
+    const recorded = op.executionType;
+    if (recorded === 'sync' || recorded === 'async' || recorded === 'hybrid') {
+        const runs = recorded === 'sync' ? 'sync' : 'async';
+        if (n.mode !== runs)
+            throw new CompileRefusal('EXTERNAL_TASK_MODE_MISMATCH', `external ${n.family} "${n.id}" has mode "${n.mode}", but the connector library records ${n.key}/${n.action}'s ` +
+                `executionType as "${recorded}", which runs ${runs}; the node would run the wrong contract. Use mode: "${runs}".`);
+    }
     const conn = connectorBindingRef(ctx, n.connection, 'Connection', 'ConnectionId', `${rc.connectorKey} connection`);
     const folder = connectorBindingRef(ctx, n.folder, 'Connection', 'folderKey', 'FolderKey', conn?.resourceKey);
     if (!conn || !folder) {

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

@@ -430,9 +430,12 @@ export type ConnectorSpecData = Extract<ActionSpec, {
  * reports it for the connector object.
  *
  * @remarks
- * This is a property of the connector object, not a choice about the case: copy
- * it from the activity's `case spec` result
- * (`Data.EssentialConfiguration.essentialConfiguration.executionType`). The Case
+ * This is a property of the connector object, not a choice about the case. The
+ * connector library records it for the object when it was built or prepared
+ * from Integration Service metadata that reports it, and compile then takes it
+ * from there: leave `mode` out. Otherwise copy it from the activity's `case spec`
+ * result (`Data.EssentialConfiguration.essentialConfiguration.executionType`).
+ * A `mode` the library contradicts is refused (EXTERNAL_TASK_MODE_MISMATCH). The Case
  * Designer saves `sync` as the `Sync…Execution` service type and both `async`
  * and `hybrid` as `Async…Execution`, and writes the value itself into the task's
  * `executionType` context.
@@ -457,10 +460,10 @@ export type ExternalExecutionMode = 'sync' | 'async' | 'hybrid';
  * the Case Designer reads it from the object's metadata (its first event mode
  * and that mode's first event type) and saves it as the task's `operation` and
  * `eventMode` context rows, and as `eventType` / `eventMode` in the metadata's
- * `activityPropertyConfiguration`. Copy it from the same two rows of the
- * activity's `case spec` result (`caseShape.context`). `decompile` lifts it from
- * a saved task. For
- * example, the Power Automate "Invoke a Flow" object (`hybrid`) answers with
+ * `activityPropertyConfiguration`. Like `mode`, compile takes it from the
+ * connector library when the library records it; otherwise copy it from the same
+ * two rows of the activity's `case spec` result (`caseShape.context`).
+ * `decompile` lifts it from a saved task. For example, the Power Automate "Invoke a Flow" object (`hybrid`) answers with
  * `{ operation: 'TRIGGER_CREATED', mode: 'polling' }`.
  */
 export interface ExternalEventPair {
@@ -476,16 +479,18 @@ export interface ExternalTaskOptions<I extends Record<string, unknown>> {
     /** Symbolic Orchestrator folder binding name declared in `bindings.json`. */
     folder: string;
     /**
-     * The connector object's `executionType` from its `case spec` result. Required:
-     * the connector library does not carry it yet (#1369), and a wrong value passes
-     * `validate` but runs the wrong contract. Not whether the stage waits: that is
+     * The connector object's `executionType`. Leave it out when the connector
+     * library records it (compile reads it from there); otherwise copy it from the
+     * `case spec` result. Compile refuses a task with no mode from either
+     * (EXTERNAL_TASK_MODE), and one the library contradicts
+     * (EXTERNAL_TASK_MODE_MISMATCH). Not whether the stage waits: that is
      * `.required(false)`. See {@link ExternalExecutionMode}.
      */
-    mode: ExternalExecutionMode;
+    mode?: ExternalExecutionMode;
     /**
-     * The event an `async` or `hybrid` object answers with. Required for `hybrid`;
-     * optional for `async`; refused for `sync`, which answers inline. See
-     * {@link ExternalEventPair}.
+     * The event an `async` or `hybrid` object answers with. Leave it out when the
+     * connector library records it. A `hybrid` task needs one from either place;
+     * a `sync` one refuses it, since it answers inline. See {@link ExternalEventPair}.
      */
     event?: ExternalEventPair;
     /** Inputs statically checked by the generated connector descriptor. */
@@ -493,9 +498,9 @@ export interface ExternalTaskOptions<I extends Record<string, unknown>> {
 }
 /** Normalized descriptor and execution mode stored on a built external task. */
 export interface ExternalTaskSpecData {
-    /** The connector object's `executionType`. */
-    mode: ExternalExecutionMode;
-    /** The event an `async` or `hybrid` object answers with, when given. */
+    /** The connector object's `executionType`, when authored (else the library's). */
+    mode?: ExternalExecutionMode;
+    /** The event an `async` or `hybrid` object answers with, when authored (else the library's). */
     event?: ExternalEventPair;
     /** Shared connector action identity, inputs, and symbolic bindings. */
     connector: ConnectorSpecData;

package/dist/case/case-sdk.js

@@ -333,7 +333,7 @@ class TaskBuilder {
     external(kind, descriptor, opts) {
         this.setKind(kind);
         this._external = {
-            mode: opts.mode,
+            ...(opts.mode !== undefined ? { mode: opts.mode } : {}),
             ...(opts.event !== undefined ? { event: { ...opts.event } } : {}),
             connector: makeConnector(descriptor, opts.inputs, {
                 connection: opts.connection,

package/dist/case/check.d.ts

@@ -52,6 +52,25 @@ export type CaseCheckOpts = Pick<ConnectorCheckOpts, 'connectorResolveError' | '
         version?: string;
         object?: string;
     }) => string | undefined;
+    /**
+     * What Case `compile` would refuse an External Agent / External Workflow
+     * task's mode and event with, judged against what the library records for
+     * the object (`externalExecution`): EXTERNAL_TASK_MODE (no mode from the
+     * author or the library), EXTERNAL_TASK_MODE_MISMATCH, EXTERNAL_TASK_EVENT.
+     * `undefined` when they are fine, or the descriptor does not resolve.
+     */
+    externalExecutionError?: (owner: string, descriptor: {
+        key: string;
+        action: string;
+        version?: string;
+        object?: string;
+    }, authored: {
+        mode?: unknown;
+        event?: unknown;
+    }) => {
+        code: string;
+        message: string;
+    } | undefined;
     subscriptionError?: (kind: 'trigger' | 'event', subscription: EventSubscription) => {
         code: string;
         message: string;

package/dist/case/check.js

@@ -7,7 +7,7 @@ import { schemaVersionRefusal } from '../schema-version.js';
 import { caseJsonPreservation, caseJsonPreservationErrors, preservedBindings } from './preserve.js';
 import { EQUALS_EXPR_DIALECT, checkBindingLabels, checkConnectorContract, checkConnectorLookups, checkConnectorSchema, } from '../core/connector-checks.js';
 import { checkEventResolution } from '../core/event-checks.js';
-import { EXTERNAL_TASK_DESCRIPTOR_CONTRACT, EXTERNAL_TASK_EVENT, externalEventRefusal, isExternalExecutionMode } from './external.js';
+import { EXTERNAL_TASK_DESCRIPTOR_CONTRACT, externalExecution } from './external.js';
 import { isResourceLabelRefusal, resolveResourceRef } from './resource-identity.js';
 import { taskShapeProblems } from './task-shape.js';
 import { isConnectorPlaceholder } from './connector-placeholder.js';
@@ -303,7 +303,7 @@ export function check(built, opts = {}) {
     // positive that blocks emit (this gate runs before serialization), so it must be
     // re-derived from the serializer rather than from remembered probe results.
     for (const stage of built.stages) {
-        checkStage(stage, diags, refStage, refPlacement, opts.bindings);
+        checkStage(stage, diags, refStage, refPlacement, opts.bindings, opts.externalExecutionError !== undefined);
         stage.slaRules.forEach((s, i) => checkSla(s, `stage "${stage.label}" SLA #${i + 1}`, diags));
     }
     built.slaRules.forEach((s, i) => checkSla(s, `case SLA #${i + 1}`, diags));
@@ -325,7 +325,9 @@ export function check(built, opts = {}) {
  *   CONNECTOR_OBJECT_REQUIRED, CONNECTOR_OBJECT_NOT_GENERIC; then their inputs
  *   (`buildConnectorInputs`): CONNECTOR_INPUT, LOOKUP_UNRESOLVED;
  * - an external task's resolved descriptor (`externalDescriptorRefusal`):
- *   EXTERNAL_TASK_DESCRIPTOR_CONTRACT;
+ *   EXTERNAL_TASK_DESCRIPTOR_CONTRACT; and its mode and event against what the
+ *   library records for the object (`externalExecution`): EXTERNAL_TASK_MODE,
+ *   EXTERNAL_TASK_MODE_MISMATCH, EXTERNAL_TASK_EVENT;
  * - an event trigger, a wait-for-connector task and a wait-for-connector rule
  *   resolve their subscription (`resolveCaseSubscription`): EVENT_UNKNOWN,
  *   EVENT_GENERIC_NO_OBJECT.
@@ -391,6 +393,9 @@ function checkLibraryConnectors(built, opts, diags) {
                 const refused = opts.externalDescriptorError?.(t.kind, spec);
                 if (refused !== undefined)
                     diags.push({ level: 'error', code: EXTERNAL_TASK_DESCRIPTOR_CONTRACT, message: `${where}: ${refused}`, where: t.name });
+                const execution = opts.externalExecutionError?.(where, spec, t.external);
+                if (execution !== undefined)
+                    diags.push({ level: 'error', code: execution.code, message: execution.message, where: t.name });
             }
             if (t.kind === 'wait-for-connector' && isSubscription(t.waitConnector))
                 subscription('event', t.waitConnector, `Wait-for-connector task "${t.name}"`, t.name);
@@ -441,7 +446,9 @@ function isNilOrEmpty(value) {
         return Object.keys(value).length === 0;
     return false;
 }
-function checkStage(stage, diags, refStage, refPlacement, bindings) {
+function checkStage(stage, diags, refStage, refPlacement, bindings, 
+/** A library judges external tasks' mode and event (`externalExecutionError`). */
+externalJudge) {
     const where = `stage "${stage.label}"`;
     if (stage.exception && stage.required !== false)
         diags.push({
@@ -622,17 +629,15 @@ function checkStage(stage, diags, refStage, refPlacement, bindings) {
                     where: t.name,
                 });
             else {
-                if (!isExternalExecutionMode(t.external.mode))
-                    diags.push({
-                        level: 'error',
-                        code: 'EXTERNAL_TASK_MODE',
-                        message: `${family} task "${t.name}" mode must be the connector object's executionType: "sync", "async" or "hybrid".`,
-                        where: t.name,
-                    });
-                else {
-                    const refused = externalEventRefusal(`${family} task "${t.name}"`, t.external.mode, t.external.event);
-                    if (refused)
-                        diags.push({ level: 'error', code: EXTERNAL_TASK_EVENT, message: refused, where: t.name });
+                // The authored mode and event alone. With a library at hand, the
+                // library pass judges them against the object instead (and reports a
+                // missing mode), so they are judged here only without one.
+                const libraryJudges = externalJudge
+                    && !!t.external.connector?.key?.trim() && !!t.external.connector?.action?.trim();
+                if (!libraryJudges) {
+                    const judged = externalExecution(`${family} task "${t.name}"`, t.external, undefined);
+                    if (judged?.code !== undefined)
+                        diags.push({ level: 'error', code: judged.code, message: judged.message, where: t.name });
                 }
                 if (!t.external.connector?.key?.trim() || !t.external.connector?.action?.trim())
                     diags.push({

package/dist/case/cli-library.js

@@ -8,7 +8,7 @@
  * both `case check` and `case compile`'s check pass call.
  */
 import { connectorCheckOpts } from '../core/cli-library.js';
-import { externalDescriptorRefusal } from './external.js';
+import { externalDescriptorRefusal, externalExecution } from './external.js';
 import { EVENT_GENERIC_NO_OBJECT, GenericEventNoObjectError, resolveCaseSubscription } from './subscription.js';
 /**
  * Case's check options from a library the CLI already opened, or `{}` without one.
@@ -48,6 +48,17 @@ export function caseCheckOpts(library, bindings) {
             }
             return externalDescriptorRefusal(kind, rc);
         },
+        externalExecutionError: (owner, d, authored) => {
+            let rc;
+            try {
+                rc = library.resolve(d.key, d.action, d.version, d.object);
+            }
+            catch {
+                return undefined; // connectorResolveError's to report
+            }
+            const judged = externalExecution(owner, authored, rc.entry?.operation ?? {});
+            return judged?.code !== undefined ? { code: judged.code, message: judged.message } : undefined;
+        },
         subscriptionError: (kind, sub) => {
             try {
                 resolveCaseSubscription(library, kind, sub);

package/dist/case/decompile.js

@@ -2,7 +2,7 @@ import { commentText } from '../core/comment-text.js';
 import { implicitInArgTrigger } from './in-arg-binding.js';
 import { tsLiteral, tsNumber } from '../core/ts-literal.js';
 import { CASE_FORMAT_PROFILE, CASE_SCHEMA_VERSIONS } from './format-profile.js';
-import { EXTERNAL_TASK_CONTEXT, EXTERNAL_TASK_EVENT_CONTEXT, externalDescriptorRefusal, externalEventRefusal, externalServiceType, isExternalExecutionMode } from './external.js';
+import { EXTERNAL_TASK_CONTEXT, EXTERNAL_TASK_EVENT_CONTEXT, externalDescriptorRefusal, externalEventRefusal, externalServiceType, isExternalExecutionMode, libraryExecution } from './external.js';
 import { preserveSchemaVersion } from '../schema-version.js';
 import { ownEntry } from '../core/own-entry.js';
 import { isUnrestorableSlotId, taskFingerprint } from './preserve.js';
@@ -676,8 +676,8 @@ function externalCall(task, refs, library) {
     const serviceType = externalServiceType(kind, mode);
     if (data.serviceType !== serviceType)
         throw new Error(`${owner} has serviceType "${String(data.serviceType ?? '')}", but its executionType "${mode}" saves as "${serviceType}".`);
-    // The event the object answers with, as saved: the same rule compile applies,
-    // so a lifted task always compiles back (a hybrid task without one does not).
+    // The event the object answers with, as saved, judged by compile's event rule
+    // here, and against the library's record below (`externalExecution` in compile).
     const event = eventRows.length ? { operation: stringValue('operation'), mode: stringValue('eventMode') } : undefined;
     // A saved plan has no `event` option to drop, so a sync task with event rows
     // gets its own text naming the rows; every other case is compile's rule.
@@ -699,6 +699,19 @@ function externalCall(task, refs, library) {
     const refused = externalDescriptorRefusal(kind, resolved);
     if (refused)
         throw new Error(`${owner}: ${refused}`);
+    // Compile refuses a mode or event the library contradicts (#1369), so a task
+    // saved against a different record would lift to source that does not compile
+    // back: refuse it here, by name, before the author edits anything.
+    const recorded = libraryExecution(resolved.entry?.operation);
+    if (recorded.mode !== undefined && recorded.mode !== mode)
+        throw new Error(`${owner} is saved with executionType "${mode}", but the connector library records the object's ` +
+            `executionType as "${recorded.mode}", so the lifted source would not compile back. Re-save the task in Studio Web, ` +
+            `or rebuild the library (registry prepare) if the object changed.`);
+    if (event !== undefined && recorded.event !== undefined
+        && (event.operation !== recorded.event.operation || event.mode !== recorded.event.mode))
+        throw new Error(`${owner} is saved with event ${JSON.stringify(event)}, but the connector library records the object's ` +
+            `event as ${JSON.stringify(recorded.event)}, so the lifted source would not compile back. Re-save the task in Studio Web, ` +
+            `or rebuild the library (registry prepare) if the object changed.`);
     if (!Array.isArray(data.inputs))
         throw new Error(`${owner} inputs must be an array.`);
     const inputs = connectorInputs(data.inputs, resolved, owner);

package/dist/case/external.d.ts

@@ -58,6 +58,52 @@ export declare function isExternalExecutionMode(value: unknown): value is Extern
  * @returns The service type.
  */
 export declare function externalServiceType(kind: 'external-agent' | 'external-workflow', mode: ExternalExecutionMode): string;
+/** Check's and compile's code when an authored `mode` disagrees with the library. */
+export declare const EXTERNAL_TASK_MODE_MISMATCH = "EXTERNAL_TASK_MODE_MISMATCH";
+/** A judged execution: the task's mode and event, or why it cannot be written. */
+export type ExternalExecution = {
+    mode: ExternalExecutionMode;
+    event?: ExternalEventPair;
+    code?: undefined;
+} | {
+    code: string;
+    message: string;
+};
+/**
+ * The execution facts the connector library records for the object
+ * (`operation.executionType` and `operation.executionEvent`, from
+ * `registry build-library` / `registry prepare`, #1369). A value the SDK does
+ * not know is ignored, as if it were absent.
+ */
+export declare function libraryExecution(operation: unknown): {
+    mode?: ExternalExecutionMode;
+    event?: ExternalEventPair;
+};
+/**
+ * The mode and event an external task is written with: what the author passed,
+ * else what the connector library records for the object. `check` and
+ * `serialize` both call this, so they refuse the same tasks with the same text.
+ *
+ * - `mode` comes from the author or the library. With neither, the task is
+ *   refused (EXTERNAL_TASK_MODE): a guessed default would compile an `async`
+ *   object to the sync contract without a word (#1370 was closed for that).
+ * - An authored `mode` the library contradicts is refused
+ *   (EXTERNAL_TASK_MODE_MISMATCH): the plan would run the wrong contract.
+ * - `event` comes from the author or, for an `async` / `hybrid` object, the
+ *   library; an authored one the library contradicts is refused
+ *   (EXTERNAL_TASK_EVENT), and so is any pair {@link externalEventRefusal} refuses.
+ *
+ * @param owner - The task as the message names it, e.g. `External Workflow task "Run"`.
+ * @param authored - The task's authored `mode` and `event`.
+ * @param operation - The resolved library entry's `operation`, or `undefined`
+ *   when no library is at hand (model-only `check`, which then judges only what
+ *   was authored and reports no missing mode).
+ * @returns The mode and event, or the refusal.
+ */
+export declare function externalExecution(owner: string, authored: {
+    mode?: unknown;
+    event?: unknown;
+}, operation: unknown): ExternalExecution | undefined;
 /** Check's code for {@link externalDescriptorRefusal}. */
 export declare const EXTERNAL_TASK_DESCRIPTOR_CONTRACT = "EXTERNAL_TASK_DESCRIPTOR_CONTRACT";
 /**

package/dist/case/external.js

@@ -45,7 +45,8 @@ export function externalEventRefusal(owner, mode, event) {
             return undefined;
         return (`${owner} is on a "hybrid" object, which answers through an event: pass the event the object reports as ` +
             `event: { operation, mode } (for example { operation: "TRIGGER_CREATED", mode: "polling" }, ` +
-            `the "operation" and "eventMode" rows of the case spec result's caseShape.context). Without it the task has nothing to wait on.`);
+            `the "operation" and "eventMode" rows of the case spec result's caseShape.context), or prepare the connector so the ` +
+            `library records it. Without it the task has nothing to wait on.`);
     }
     if (mode === 'sync')
         return `${owner} is on a "sync" object, which answers inline and has no event; drop event, or fix mode.`;
@@ -79,6 +80,83 @@ export function externalServiceType(kind, mode) {
         return sync ? CASE_FORMAT_PROFILE.externalAgentSyncServiceType : CASE_FORMAT_PROFILE.externalAgentAsyncServiceType;
     return sync ? CASE_FORMAT_PROFILE.externalWorkflowSyncServiceType : CASE_FORMAT_PROFILE.externalWorkflowAsyncServiceType;
 }
+/** Check's and compile's code when an authored `mode` disagrees with the library. */
+export const EXTERNAL_TASK_MODE_MISMATCH = 'EXTERNAL_TASK_MODE_MISMATCH';
+/**
+ * The execution facts the connector library records for the object
+ * (`operation.executionType` and `operation.executionEvent`, from
+ * `registry build-library` / `registry prepare`, #1369). A value the SDK does
+ * not know is ignored, as if it were absent.
+ */
+export function libraryExecution(operation) {
+    const op = (operation ?? {});
+    const mode = isExternalExecutionMode(op.executionType) ? op.executionType : undefined;
+    const raw = op.executionEvent;
+    const event = mode !== undefined && mode !== 'sync' && typeof raw?.operation === 'string' && raw.operation
+        && isExternalEventMode(raw.mode)
+        ? { operation: raw.operation, mode: raw.mode }
+        : undefined;
+    return { ...(mode ? { mode } : {}), ...(event ? { event } : {}) };
+}
+/**
+ * The mode and event an external task is written with: what the author passed,
+ * else what the connector library records for the object. `check` and
+ * `serialize` both call this, so they refuse the same tasks with the same text.
+ *
+ * - `mode` comes from the author or the library. With neither, the task is
+ *   refused (EXTERNAL_TASK_MODE): a guessed default would compile an `async`
+ *   object to the sync contract without a word (#1370 was closed for that).
+ * - An authored `mode` the library contradicts is refused
+ *   (EXTERNAL_TASK_MODE_MISMATCH): the plan would run the wrong contract.
+ * - `event` comes from the author or, for an `async` / `hybrid` object, the
+ *   library; an authored one the library contradicts is refused
+ *   (EXTERNAL_TASK_EVENT), and so is any pair {@link externalEventRefusal} refuses.
+ *
+ * @param owner - The task as the message names it, e.g. `External Workflow task "Run"`.
+ * @param authored - The task's authored `mode` and `event`.
+ * @param operation - The resolved library entry's `operation`, or `undefined`
+ *   when no library is at hand (model-only `check`, which then judges only what
+ *   was authored and reports no missing mode).
+ * @returns The mode and event, or the refusal.
+ */
+export function externalExecution(owner, authored, operation) {
+    if (authored.mode !== undefined && !isExternalExecutionMode(authored.mode))
+        return {
+            code: 'EXTERNAL_TASK_MODE',
+            message: `${owner} mode must be the connector object's executionType: "sync", "async" or "hybrid".`,
+        };
+    const library = operation === undefined ? {} : libraryExecution(operation);
+    if (authored.mode !== undefined && library.mode !== undefined && authored.mode !== library.mode)
+        return {
+            code: EXTERNAL_TASK_MODE_MISMATCH,
+            message: `${owner} has mode "${authored.mode}", but the connector library records the object's executionType as ` +
+                `"${library.mode}"; the plan would run the wrong contract. Drop mode to use the library's, or fix it.`,
+        };
+    const mode = authored.mode ?? library.mode;
+    if (mode === undefined) {
+        if (operation === undefined)
+            return undefined; // model-only check: the library decides
+        return {
+            code: 'EXTERNAL_TASK_MODE',
+            message: `${owner} has no mode, and the connector library records no executionType for the object. ` +
+                `Pass mode: the object's executionType from its case spec result ` +
+                `(Data.EssentialConfiguration.essentialConfiguration.executionType), or rebuild the library with registry prepare.`,
+        };
+    }
+    const authoredEvent = authored.event;
+    if (authoredEvent !== undefined && library.event !== undefined
+        && (authoredEvent?.operation !== library.event.operation || authoredEvent?.mode !== library.event.mode))
+        return {
+            code: EXTERNAL_TASK_EVENT,
+            message: `${owner} has event ${JSON.stringify(authoredEvent)}, but the connector library records the object's event as ` +
+                `${JSON.stringify(library.event)}. Drop event to use the library's, or fix it.`,
+        };
+    const event = authoredEvent ?? (mode !== 'sync' ? library.event : undefined);
+    const refused = externalEventRefusal(owner, mode, event);
+    if (refused)
+        return { code: EXTERNAL_TASK_EVENT, message: refused };
+    return { mode, ...(event !== undefined ? { event } : {}) };
+}
 /** Check's code for {@link externalDescriptorRefusal}. */
 export const EXTERNAL_TASK_DESCRIPTOR_CONTRACT = 'EXTERNAL_TASK_DESCRIPTOR_CONTRACT';
 /**

package/dist/case/serialize.js

@@ -19,7 +19,7 @@ import { bindingLabelRefusal } from '../core/binding-messages.js';
 import { resolveEventWhere } from '../core/lookups.js';
 import { resolveCaseSubscription } from './subscription.js';
 import { dedupeConditionNames } from './rule-names.js';
-import { EXTERNAL_TASK_DESCRIPTOR_CONTRACT, EXTERNAL_TASK_EVENT, externalDescriptorRefusal, externalEventRefusal, externalServiceType, isExternalExecutionMode, } from './external.js';
+import { EXTERNAL_TASK_DESCRIPTOR_CONTRACT, externalDescriptorRefusal, externalExecution, externalServiceType, } from './external.js';
 import { CASE_FORMAT_PROFILE, CASE_SCHEMA_VERSIONS, caseVersionMismatch } from './format-profile.js';
 import { isResourceLabelRefusal, resolveResourceRef, resourceIdentity } from './resource-identity.js';
 import { ownEntry } from '../core/own-entry.js';
@@ -1828,24 +1828,26 @@ function externalTaskData(kind, spec, resolver, elementId, where) {
     const refused = externalDescriptorRefusal(kind, rc);
     if (refused)
         throw new CompileRefusal(EXTERNAL_TASK_DESCRIPTOR_CONTRACT, refused);
-    if (!isExternalExecutionMode(spec.mode))
-        throw new CompileRefusal('EXTERNAL_TASK_MODE', `${kind} task mode must be the connector object's executionType: "sync", "async" or "hybrid".`);
-    const eventRefused = externalEventRefusal(where, spec.mode, spec.event);
-    if (eventRefused)
-        throw new CompileRefusal(EXTERNAL_TASK_EVENT, eventRefused);
+    // The authored mode and event, else the library's (#1369): the same call check makes.
+    const execution = externalExecution(where, spec, rc.entry?.operation ?? {});
+    if (!execution)
+        throw new Error(`internal SDK error: ${where} was judged without its library operation.`);
+    if (execution.code !== undefined)
+        throw new CompileRefusal(execution.code, execution.message);
+    const { mode, event } = execution;
     if (!spec.connector.connection || !spec.connector.folder)
         throw new CompileRefusal(spec.connector.connection ? 'EXTERNAL_TASK_FOLDER' : 'EXTERNAL_TASK_CONNECTION', `${kind} task requires non-empty connection and folder binding names.`);
-    const data = connectorTaskData(spec.connector, resolver, elementId, where, spec.mode, spec.event);
+    const data = connectorTaskData(spec.connector, resolver, elementId, where, mode, event);
     const context = data.context;
     const metadataAt = context.findIndex((row) => row.name === 'metadata');
     // The Designer's order: the event pair (when the object answers through one),
     // then the execution type, just before `metadata`.
-    context.splice(metadataAt, 0, ...(spec.event ? [
-        io('operation', 'string', { value: spec.event.operation }),
-        io('eventMode', 'string', { value: spec.event.mode }),
-    ] : []), io('executionType', 'string', { value: spec.mode }));
+    context.splice(metadataAt, 0, ...(event ? [
+        io('operation', 'string', { value: event.operation }),
+        io('eventMode', 'string', { value: event.mode }),
+    ] : []), io('executionType', 'string', { value: mode }));
     context.push(io('activityConfigurationVersion', 'string', { value: 'v2' }));
-    return { ...data, serviceType: externalServiceType(kind, spec.mode) };
+    return { ...data, serviceType: externalServiceType(kind, mode) };
 }
 /** A context/output name/value entry (the caseplan `InputOutput` shape). */
 function io(name, type, extra) {

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

@@ -329,6 +329,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.68.7",
   "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": "436dbc08c3130fcde3197adec572df61116f4ede"
 }