@uipath/maestro-builder-sdk 6.68.4 → 6.68.5

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

@@ -437,9 +437,10 @@ export type ConnectorSpecData = Extract<ActionSpec, {
  * and `hybrid` as `Async…Execution`, and writes the value itself into the task's
  * `executionType` context.
  *
- * `hybrid` is refused for now (EXTERNAL_TASK_HYBRID_UNSUPPORTED): the Designer
- * also writes an event pair for it (`operation`, `eventMode`) that the connector
- * library does not carry (#1387). Add a task on a hybrid object in Studio Web.
+ * An `async` or `hybrid` object also answers through an event, which the
+ * Designer saves next to it; pass that pair as {@link ExternalTaskOptions.event}.
+ * A `hybrid` task without it is refused (EXTERNAL_TASK_EVENT), since the task
+ * would have nothing to wait on.
  *
  * It does not decide whether the stage waits for the task. A task the stage must
  * not wait on is `.required(false)`, whatever its execution type. For example, a
@@ -447,6 +448,27 @@ export type ConnectorSpecData = Extract<ActionSpec, {
  * it.
  */
 export type ExternalExecutionMode = 'sync' | 'async' | 'hybrid';
+/**
+ * The event an `async` or `hybrid` external object answers with, as Integration
+ * Service reports it for the connector object.
+ *
+ * @remarks
+ * Like the execution type, a property of the connector object, not a choice:
+ * 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
+ * `{ operation: 'TRIGGER_CREATED', mode: 'polling' }`.
+ */
+export interface ExternalEventPair {
+    /** The event operation, e.g. `TRIGGER_CREATED`: the task's `operation` context row. */
+    operation: string;
+    /** How the event is received: the task's `eventMode` context row. */
+    mode: 'polling' | 'webhooks';
+}
 /** Required wiring and typed inputs for an external agent/workflow invocation. */
 export interface ExternalTaskOptions<I extends Record<string, unknown>> {
     /** Symbolic Integration Service connection name declared in `bindings.json`. */
@@ -460,6 +482,12 @@ export interface ExternalTaskOptions<I extends Record<string, unknown>> {
      * `.required(false)`. See {@link 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}.
+     */
+    event?: ExternalEventPair;
     /** Inputs statically checked by the generated connector descriptor. */
     inputs: I;
 }
@@ -467,6 +495,8 @@ export interface ExternalTaskOptions<I extends Record<string, unknown>> {
 export interface ExternalTaskSpecData {
     /** The connector object's `executionType`. */
     mode: ExternalExecutionMode;
+    /** The event an `async` or `hybrid` object answers with, when given. */
+    event?: ExternalEventPair;
     /** Shared connector action identity, inputs, and symbolic bindings. */
     connector: ConnectorSpecData;
 }

package/dist/case/case-sdk.js

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

package/dist/case/check.js

@@ -6,7 +6,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_HYBRID_UNSUPPORTED, externalHybridRefusal, isExternalExecutionMode } from './external.js';
+import { EXTERNAL_TASK_DESCRIPTOR_CONTRACT, EXTERNAL_TASK_EVENT, externalEventRefusal, isExternalExecutionMode } from './external.js';
 import { isResourceLabelRefusal, resolveResourceRef } from './resource-identity.js';
 import { taskShapeProblems } from './task-shape.js';
 import { isConnectorPlaceholder } from './connector-placeholder.js';
@@ -623,13 +623,11 @@ function checkStage(stage, diags, refStage, refPlacement, bindings) {
                         message: `${family} task "${t.name}" mode must be the connector object's executionType: "sync", "async" or "hybrid".`,
                         where: t.name,
                     });
-                else if (t.external.mode === 'hybrid')
-                    diags.push({
-                        level: 'error',
-                        code: EXTERNAL_TASK_HYBRID_UNSUPPORTED,
-                        message: externalHybridRefusal(`${family} task "${t.name}"`),
-                        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 });
+                }
                 if (!t.external.connector?.key?.trim() || !t.external.connector?.action?.trim())
                     diags.push({
                         level: 'error',

package/dist/case/decompile.js

@@ -1,7 +1,7 @@
 import { commentText } from '../core/comment-text.js';
 import { tsLiteral, tsNumber } from '../core/ts-literal.js';
 import { CASE_FORMAT_PROFILE, CASE_SCHEMA_VERSIONS } from './format-profile.js';
-import { EXTERNAL_TASK_CONTEXT, externalDescriptorRefusal, externalHybridRefusal, externalServiceType, isExternalExecutionMode } from './external.js';
+import { EXTERNAL_TASK_CONTEXT, EXTERNAL_TASK_EVENT_CONTEXT, externalDescriptorRefusal, externalEventRefusal, externalServiceType, isExternalExecutionMode } from './external.js';
 import { preserveSchemaVersion } from '../schema-version.js';
 import { ownEntry } from '../core/own-entry.js';
 import { isUnrestorableSlotId, taskFingerprint } from './preserve.js';
@@ -618,7 +618,9 @@ function connectorCall(task, refs, library) {
 /**
  * Lift an External Agent / External Workflow task saved in the Case Designer's
  * shape (the one `serialize` emits): a connector activity's context and input
- * containers plus the object's `executionType`, which becomes `mode`. The
+ * containers plus the object's `executionType`, which becomes `mode`, and the
+ * event pair an async / hybrid object answers with (`operation` and `eventMode`
+ * rows), which becomes `event`. The
  * service type must be the one that execution type gives, so a plan whose two
  * disagree is refused rather than lifted to a source that would compile to
  * something else.
@@ -637,19 +639,20 @@ function externalCall(task, refs, library) {
         throw new Error(`${owner} data.bindings must be an empty array; bindings live at case root.`);
     if (!Array.isArray(data.context))
         throw new Error(`${owner} requires a resolved context array.`);
-    // A hybrid task carries an event pair the SDK cannot write back (#1387): refuse
-    // it by name, before its extra context rows are reported as unknown.
-    if (data.context.some((row) => row?.name === 'executionType' && row.value === 'hybrid'))
-        throw new Error(externalHybridRefusal(owner));
-    // Exactly the context rows serialize writes (the Designer's set): an unknown
-    // or repeated row would be dropped by the lift and lost on recompile.
+    // Exactly the context rows serialize writes (the Designer's set, plus the
+    // event pair an async / hybrid object answers with): an unknown or repeated
+    // row would be dropped by the lift and lost on recompile.
     const contextNames = data.context.map((row) => String(row?.name ?? ''));
-    const unknownContext = contextNames.find((name, at) => !EXTERNAL_TASK_CONTEXT.includes(name) || contextNames.indexOf(name) !== at);
+    const unknownContext = contextNames.find((name, at) => !(EXTERNAL_TASK_CONTEXT.includes(name) || EXTERNAL_TASK_EVENT_CONTEXT.includes(name)) || contextNames.indexOf(name) !== at);
     if (unknownContext !== undefined)
         throw new Error(`${owner} has unsupported or repeated context row "${unknownContext}".`);
     const absentContext = EXTERNAL_TASK_CONTEXT.find((name) => !contextNames.includes(name));
     if (absentContext)
         throw new Error(`${owner} is missing context row "${absentContext}".`);
+    // The pair is written whole or not at all, so half of one cannot be lifted.
+    const eventRows = EXTERNAL_TASK_EVENT_CONTEXT.filter((name) => contextNames.includes(name));
+    if (eventRows.length === 1)
+        throw new Error(`${owner} carries context row "${eventRows[0]}" without "${EXTERNAL_TASK_EVENT_CONTEXT.find((name) => name !== eventRows[0])}"; the event pair is saved whole.`);
     const context = contextMap(data);
     const stringValue = (name) => {
         const row = context.get(name);
@@ -672,6 +675,18 @@ 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).
+    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.
+    if (mode === 'sync' && event)
+        throw new Error(`${owner} has context rows "operation" (${JSON.stringify(event.operation)}) and "eventMode" ` +
+            `(${JSON.stringify(event.mode)}) on executionType "sync"; a sync object answers inline and has no event. ` +
+            `Remove the two rows, or fix executionType and serviceType if the object is async or hybrid.`);
+    const eventRefused = externalEventRefusal(owner, mode, event);
+    if (eventRefused)
+        throw new Error(eventRefused);
     const identity = library.identifyAction({
         connectorKey: stringValue('connectorKey'),
         httpMethod: stringValue('method'),
@@ -691,6 +706,7 @@ function externalCall(task, refs, library) {
         ['connection', tsLiteral(binding('connection'))],
         ['folder', tsLiteral(binding('folderKey'))],
         ['mode', tsLiteral(mode)],
+        ['event', event ? opts([['operation', tsLiteral(event.operation)], ['mode', tsLiteral(event.mode)]]) : undefined],
         ['inputs', tsLiteral(inputs)],
     ]);
     const method = kind === 'external-agent' ? 'externalAgent' : 'externalWorkflow';

package/dist/case/external.d.ts

@@ -8,32 +8,43 @@
  * `buildConnectorInputs`, which `check` already runs as `connectorInputs`.
  */
 import type { ResolvedConnector } from '../core/library.js';
-import type { ExternalExecutionMode } from './case-sdk.js';
+import type { ExternalEventPair, ExternalExecutionMode } from './case-sdk.js';
 /**
  * The context rows `serialize` writes on an external task: the set the Case
  * Designer saves for a sync object (`uip`'s
  * `tests/fixtures/external-tasks/designer-saved.json`, the Snowflake Cortex
- * agent). `decompile` refuses a task with any other row, since the lift would
- * drop it without a word. A `hybrid` task (which also carries `operation` and
- * `eventMode`) is refused before this check; see {@link externalHybridRefusal}.
+ * agent). An `async` or `hybrid` task may also carry
+ * {@link EXTERNAL_TASK_EVENT_CONTEXT}. `decompile` refuses a task with any other
+ * row, since the lift would drop it without a word.
  */
 export declare const EXTERNAL_TASK_CONTEXT: readonly string[];
-/** Check's code for {@link externalHybridRefusal}. */
-export declare const EXTERNAL_TASK_HYBRID_UNSUPPORTED = "EXTERNAL_TASK_HYBRID_UNSUPPORTED";
 /**
- * Why an external task on a `hybrid` object cannot be compiled or decompiled
- * yet. The Case Designer saves such a task with an event pair (context
- * `operation`, e.g. `TRIGGER_CREATED`, and `eventMode`, e.g. `polling`, also in
- * the metadata's `activityPropertyConfiguration`) that it reads from live
- * Integration Service metadata. The connector library does not carry that pair
- * (#1387), so the SDK cannot write the task faithfully, and a guessed pair could
- * deploy a task that never completes. `check`, `serialize` and `decompile` all
- * refuse with this text.
+ * The two context rows that carry the event an `async` / `hybrid` object
+ * answers with (`ExternalEventPair`): `operation` (e.g. `TRIGGER_CREATED`) and
+ * `eventMode` (e.g. `polling`). The Designer writes them after `objectName`,
+ * before `executionType` (the Power Automate flow in `designer-saved.json`).
+ */
+export declare const EXTERNAL_TASK_EVENT_CONTEXT: readonly string[];
+/** Check's and compile's code for {@link externalEventRefusal}. */
+export declare const EXTERNAL_TASK_EVENT = "EXTERNAL_TASK_EVENT";
+/** The event modes Integration Service reports for an object's events. */
+export declare function isExternalEventMode(value: unknown): value is ExternalEventPair['mode'];
+/**
+ * Why this task's event pair cannot be written, or `undefined`.
+ *
+ * A `hybrid` object answers through an event, and the Case Designer saves that
+ * event with the task (context `operation` and `eventMode`, and the same pair in
+ * the metadata's `activityPropertyConfiguration`). Without it the task has
+ * nothing to wait on, so `hybrid` needs the pair. An `async` object takes it
+ * when given. A `sync` object answers inline and has none, so a pair there is a
+ * wrong `mode` or a wrong pair. `check`, `serialize` and `decompile` all use this.
  *
  * @param owner - The task as the message names it, e.g. `External Workflow task "Run"`.
- * @returns The refusal.
+ * @param mode - The task's execution type (already known to be valid).
+ * @param event - The authored or saved pair, if any.
+ * @returns The refusal, or `undefined`.
  */
-export declare function externalHybridRefusal(owner: string): string;
+export declare function externalEventRefusal(owner: string, mode: ExternalExecutionMode, event: unknown): string | undefined;
 /** The execution types an external task accepts: the values Integration Service reports. */
 export declare function isExternalExecutionMode(value: unknown): value is ExternalExecutionMode;
 /**

package/dist/case/external.js

@@ -3,34 +3,61 @@ import { CASE_FORMAT_PROFILE } from './format-profile.js';
  * The context rows `serialize` writes on an external task: the set the Case
  * Designer saves for a sync object (`uip`'s
  * `tests/fixtures/external-tasks/designer-saved.json`, the Snowflake Cortex
- * agent). `decompile` refuses a task with any other row, since the lift would
- * drop it without a word. A `hybrid` task (which also carries `operation` and
- * `eventMode`) is refused before this check; see {@link externalHybridRefusal}.
+ * agent). An `async` or `hybrid` task may also carry
+ * {@link EXTERNAL_TASK_EVENT_CONTEXT}. `decompile` refuses a task with any other
+ * row, since the lift would drop it without a word.
  */
 export const EXTERNAL_TASK_CONTEXT = [
     'connectorKey', 'connection', 'resourceKey', 'folderKey', 'objectName', 'method', 'path',
     'executionType', 'metadata', 'activityConfigurationVersion',
 ];
-/** Check's code for {@link externalHybridRefusal}. */
-export const EXTERNAL_TASK_HYBRID_UNSUPPORTED = 'EXTERNAL_TASK_HYBRID_UNSUPPORTED';
 /**
- * Why an external task on a `hybrid` object cannot be compiled or decompiled
- * yet. The Case Designer saves such a task with an event pair (context
- * `operation`, e.g. `TRIGGER_CREATED`, and `eventMode`, e.g. `polling`, also in
- * the metadata's `activityPropertyConfiguration`) that it reads from live
- * Integration Service metadata. The connector library does not carry that pair
- * (#1387), so the SDK cannot write the task faithfully, and a guessed pair could
- * deploy a task that never completes. `check`, `serialize` and `decompile` all
- * refuse with this text.
+ * The two context rows that carry the event an `async` / `hybrid` object
+ * answers with (`ExternalEventPair`): `operation` (e.g. `TRIGGER_CREATED`) and
+ * `eventMode` (e.g. `polling`). The Designer writes them after `objectName`,
+ * before `executionType` (the Power Automate flow in `designer-saved.json`).
+ */
+export const EXTERNAL_TASK_EVENT_CONTEXT = ['operation', 'eventMode'];
+/** Check's and compile's code for {@link externalEventRefusal}. */
+export const EXTERNAL_TASK_EVENT = 'EXTERNAL_TASK_EVENT';
+/** The event modes Integration Service reports for an object's events. */
+export function isExternalEventMode(value) {
+    return value === 'polling' || value === 'webhooks';
+}
+/**
+ * Why this task's event pair cannot be written, or `undefined`.
+ *
+ * A `hybrid` object answers through an event, and the Case Designer saves that
+ * event with the task (context `operation` and `eventMode`, and the same pair in
+ * the metadata's `activityPropertyConfiguration`). Without it the task has
+ * nothing to wait on, so `hybrid` needs the pair. An `async` object takes it
+ * when given. A `sync` object answers inline and has none, so a pair there is a
+ * wrong `mode` or a wrong pair. `check`, `serialize` and `decompile` all use this.
  *
  * @param owner - The task as the message names it, e.g. `External Workflow task "Run"`.
- * @returns The refusal.
+ * @param mode - The task's execution type (already known to be valid).
+ * @param event - The authored or saved pair, if any.
+ * @returns The refusal, or `undefined`.
  */
-export function externalHybridRefusal(owner) {
-    return (`${owner} is on a "hybrid" object, which Case cannot compile yet: the connector library does not carry ` +
-        `the event pair the Case Designer writes for it (operation, e.g. "TRIGGER_CREATED", and eventMode, e.g. "polling"), ` +
-        `so the task cannot be written faithfully. Add this task in Studio Web for now; ` +
-        `https://github.com/UiPath/builder-sdk/issues/1387 tracks the library change.`);
+export function externalEventRefusal(owner, mode, event) {
+    if (event === undefined) {
+        if (mode !== 'hybrid')
+            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.`);
+    }
+    if (mode === 'sync')
+        return `${owner} is on a "sync" object, which answers inline and has no event; drop event, or fix mode.`;
+    const pair = event;
+    if (typeof pair !== 'object' || pair === null || typeof pair.operation !== 'string' || !pair.operation.trim())
+        return `${owner} event.operation must be the object's non-empty event operation, e.g. "TRIGGER_CREATED".`;
+    // Written as given, and Integration Service matches it exactly: " TRIGGER_CREATED" would never match.
+    if (pair.operation !== pair.operation.trim())
+        return `${owner} event.operation ${JSON.stringify(pair.operation)} has surrounding whitespace; write it exactly as the object reports it, e.g. "TRIGGER_CREATED".`;
+    if (!isExternalEventMode(pair.mode))
+        return `${owner} event.mode must be "polling" or "webhooks"; got ${JSON.stringify(pair.mode)}.`;
+    return undefined;
 }
 /** The execution types an external task accepts: the values Integration Service reports. */
 export function isExternalExecutionMode(value) {

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_HYBRID_UNSUPPORTED, externalDescriptorRefusal, externalHybridRefusal, externalServiceType, isExternalExecutionMode, } from './external.js';
+import { EXTERNAL_TASK_DESCRIPTOR_CONTRACT, EXTERNAL_TASK_EVENT, externalDescriptorRefusal, externalEventRefusal, externalServiceType, isExternalExecutionMode, } 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';
@@ -1739,7 +1739,7 @@ function businessRuleTaskData(task, resolver, elementId, ids) {
  * the op's output schema. Connection/folder resolve through `bindings` and are
  * referenced as `=bindings.<id>`, with the binding entry collected at case root.
  */
-function connectorTaskData(spec, resolver, elementId, where, executionType) {
+function connectorTaskData(spec, resolver, elementId, where, executionType, event) {
     if (!resolver.library)
         throw new CompileRefusal('LIBRARY_REQUIRED', `connector task needs the connector library — pass { library } to serialize or use uip maestro case compile --library.`);
     const rc = resolver.library.resolve(spec.key, spec.action, spec.version, spec.object);
@@ -1787,7 +1787,7 @@ function connectorTaskData(spec, resolver, elementId, where, executionType) {
     // from the `body` slot. This used to drop the whole wire and push a filled
     // file part into the body, where the runtime does not look for it (#1420).
     const fileParts = (slots.multipartParameters ?? []).filter((part) => part.dataType.toLowerCase() === 'file');
-    context.push(io('metadata', 'json', { body: connectorMetadata(rc, op, slots, elementId, executionType) }));
+    context.push(io('metadata', 'json', { body: connectorMetadata(rc, op, slots, elementId, executionType, event) }));
     const inputs = [
         ioSlot('pathParameters', pathParameters, `${elementId}`),
         ioSlot('queryParameters', queryParameters, `${elementId}`),
@@ -1816,14 +1816,20 @@ function externalTaskData(kind, spec, resolver, elementId, where) {
         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".`);
-    if (spec.mode === 'hybrid')
-        throw new CompileRefusal(EXTERNAL_TASK_HYBRID_UNSUPPORTED, externalHybridRefusal(where));
+    const eventRefused = externalEventRefusal(where, spec.mode, spec.event);
+    if (eventRefused)
+        throw new CompileRefusal(EXTERNAL_TASK_EVENT, eventRefused);
     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);
+    const data = connectorTaskData(spec.connector, resolver, elementId, where, spec.mode, spec.event);
     const context = data.context;
     const metadataAt = context.findIndex((row) => row.name === 'metadata');
-    context.splice(metadataAt, 0, io('executionType', 'string', { value: spec.mode }));
+    // 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.push(io('activityConfigurationVersion', 'string', { value: 'v2' }));
     return { ...data, serviceType: externalServiceType(kind, spec.mode) };
 }
@@ -1957,7 +1963,7 @@ function folderBindingRef(resolver, name, connection, site) {
  * Generic activity, and the library version where the platform writes
  * `packageVersion: "1.0.0"` (#1420).
  */
-function connectorMetadata(rc, op, slots, seed, executionType) {
+function connectorMetadata(rc, op, slots, seed, executionType, event) {
     // The part DECLARATIONS only: a file part's value rides on its `file` input.
     const multipartParameters = (slots.multipartParameters ?? []).map(({ name, dataType }) => ({ name, dataType }));
     // The configuration replays the authored values (a schema action's parent
@@ -1973,6 +1979,9 @@ function connectorMetadata(rc, op, slots, seed, executionType) {
             uiPathActivityTypeId: rc.activityTypeId ?? '',
             errorState: { issues: [] },
             ...(executionType ? { executionType } : {}),
+            // The event an async / hybrid object answers with, named as the Designer
+            // names it here (`eventType`, where the context row is `operation`).
+            ...(event ? { eventType: event.operation, eventMode: event.mode } : {}),
         },
         activityMetadata: {
             activity: {

package/dist/core/refusals.d.ts

@@ -274,8 +274,8 @@ export declare const REFUSALS: {
     readonly EXTERNAL_TASK_DESCRIPTOR: "lint";
     readonly EXTERNAL_TASK_DESCRIPTOR_CONTRACT: "lowering";
     readonly EXTERNAL_TASK_EMPTY_DATA: "lint";
+    readonly EXTERNAL_TASK_EVENT: "lowering";
     readonly EXTERNAL_TASK_FOLDER: "lowering";
-    readonly EXTERNAL_TASK_HYBRID_UNSUPPORTED: "lowering";
     readonly EXTERNAL_TASK_MODE: "lowering";
     readonly EXTRACT_SCHEMA_SHAPE: "lint";
     readonly FAKE_JOIN: "lint";

package/dist/core/refusals.js

@@ -325,8 +325,8 @@ export const REFUSALS = {
     EXTERNAL_TASK_DESCRIPTOR: 'lint',
     EXTERNAL_TASK_DESCRIPTOR_CONTRACT: 'lowering',
     EXTERNAL_TASK_EMPTY_DATA: 'lint',
+    EXTERNAL_TASK_EVENT: 'lowering',
     EXTERNAL_TASK_FOLDER: 'lowering',
-    EXTERNAL_TASK_HYBRID_UNSUPPORTED: 'lowering',
     EXTERNAL_TASK_MODE: 'lowering',
     EXTRACT_SCHEMA_SHAPE: 'lint',
     FAKE_JOIN: 'lint',

package/dist/index.d.ts

@@ -21,7 +21,7 @@ export { Bindings } from './bindings.js';
 export { check } from './check.js';
 export type { Diagnostic } from './check.js';
 export { casePlan, preserveCaseJson, rule, when } from './case/case-sdk.js';
-export type { CaseRule, CaseRuleInput, CaseRuleGrid, WhenExpression, CaseJsonPreservation, CaseLayout, CaseNodeLayout, PreservedCaseNode, PreservedTaskFields, PreservedVariableLane, CaseRuleType, RuleOpts, BuiltCase, BuiltStage, BuiltTask, TaskKind, UnresolvedReferenceTaskKind, ExternalExecutionMode, ExternalTaskOptions, } from './case/case-sdk.js';
+export type { CaseRule, CaseRuleInput, CaseRuleGrid, WhenExpression, CaseJsonPreservation, CaseLayout, CaseNodeLayout, PreservedCaseNode, PreservedTaskFields, PreservedVariableLane, CaseRuleType, RuleOpts, BuiltCase, BuiltStage, BuiltTask, TaskKind, UnresolvedReferenceTaskKind, ExternalEventPair, ExternalExecutionMode, ExternalTaskOptions, } from './case/case-sdk.js';
 export { serialize as serializeCase } from './case/serialize.js';
 export { decompile as decompileCase, decompileWithDiagnostics as decompileCaseWithDiagnostics } from './case/decompile.js';
 export { bpmn } from './bpmn/bpmn-sdk.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/maestro-builder-sdk",
-  "version": "6.68.4",
+  "version": "6.68.5",
   "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": "f879560df189ceab42f899123d36f0add5b0a562"
+  "gitref": "3f8f0766113501aaf0d1d7c36835ef3c8eb6c2aa"
 }