@uipath/maestro-builder-sdk 6.47.0 → 6.47.2

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

@@ -380,9 +380,9 @@ export interface BuiltCaseExitCondition {
     marksCaseComplete?: boolean;
     rules: CaseRule[][];
 }
-export type TaskKind = 'process' | 'agent' | 'rpa' | 'api-workflow' | 'case-management' | 'flow-process' | 'business-rule' | 'external-agent' | 'external-workflow' | 'action' | 'connector' | 'wait-for-timer' | 'wait-for-connector';
+export type TaskKind = 'process' | 'agent' | 'rpa' | 'api-workflow' | 'case-management' | 'flow-process' | 'function' | 'business-rule' | 'external-agent' | 'external-workflow' | 'action' | 'connector' | 'wait-for-timer' | 'wait-for-connector';
 /** Published-resource task kinds that the Case schema permits as unresolved skeletons. */
-export type UnresolvedReferenceTaskKind = 'process' | 'agent' | 'rpa' | 'api-workflow' | 'case-management';
+export type UnresolvedReferenceTaskKind = 'process' | 'agent' | 'rpa' | 'api-workflow' | 'case-management' | 'function';
 /**
  * A `wait-for-connector` subscription: suspend on an Integration Service event.
  * Omit `connectorKey`/`operation` for a bare **placeholder** (for a connector not
@@ -412,22 +412,47 @@ export type WaitConnectorSpec = WaitConnectorPlaceholderSpec | EventSubscription
 export type ConnectorSpecData = Extract<ActionSpec, {
     kind: 'connector';
 }>;
-/** Whether an external Integration Service task blocks for its result or waits for a callback. */
-export type ExternalExecutionMode = 'sync' | 'async';
+/**
+ * The external agent's or automation's `executionType`, as Integration Service
+ * 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
+ * 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.
+ *
+ * `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.
+ *
+ * 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
+ * Snowflake Cortex Interact Agent is `sync` even when the stage moves on without
+ * it.
+ */
+export type ExternalExecutionMode = 'sync' | 'async' | 'hybrid';
 /** 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`. */
     connection: string;
     /** Symbolic Orchestrator folder binding name declared in `bindings.json`. */
     folder: string;
-    /** Closed runtime mode; each family lowers this to its exact supported service type. */
+    /**
+     * 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
+     * `.required(false)`. See {@link ExternalExecutionMode}.
+     */
     mode: ExternalExecutionMode;
     /** Inputs statically checked by the generated connector descriptor. */
     inputs: I;
 }
 /** Normalized descriptor and execution mode stored on a built external task. */
 export interface ExternalTaskSpecData {
-    /** Requested blocking or callback execution mode. */
+    /** The connector object's `executionType`. */
     mode: ExternalExecutionMode;
     /** Shared connector action identity, inputs, and symbolic bindings. */
     connector: ConnectorSpecData;
@@ -884,6 +909,22 @@ declare class TaskBuilder {
     flowProcess(name: string, opts?: {
         folder?: string;
     }): this;
+    /**
+     * Reference a deployed **Coded Function** (a `uipath-functions` project).
+     *
+     * @remarks
+     * Emits a `function` task bound like the other published resources, with
+     * `resourceSubType: 'Function'`. A function is its own task type: do not
+     * model one as `.apiWorkflow()` or `.agent()`. A function with several
+     * deployments of one name is told apart by its folder.
+     *
+     * @param name - The deployed function's name.
+     * @param opts - `folder` — the Orchestrator folder it lives in, or `'solution_folder'` (the default when omitted) for one built in this solution. Compile binds the task through a name/folderPath pair of root bindings keyed `<folder>.<name>`.
+     * @returns This builder, so calls chain.
+     */
+    function(name: string, opts?: {
+        folder?: string;
+    }): this;
     /**
      * Evaluate a deployed **business rule** (a DMN decision package) and read its
      * decisions back.
@@ -918,7 +959,7 @@ declare class TaskBuilder {
      * Invoke an external agent through its generated Integration Service descriptor.
      *
      * @param descriptor - An `AgentExecution` operation from a generated connector module.
-     * @param opts - Required connection/folder bindings, sync/async mode, and descriptor-typed inputs.
+     * @param opts - Required connection/folder bindings, the object's execution type, and descriptor-typed inputs.
      * @returns This builder, so calls chain.
      */
     externalAgent<I extends Record<string, unknown>, O>(descriptor: ConnectorDescriptor<I, O>, opts: ExternalTaskOptions<I>): this;
@@ -926,7 +967,7 @@ declare class TaskBuilder {
      * Invoke an external workflow through its generated Integration Service descriptor.
      *
      * @param descriptor - A `ProcessExecution` operation from a generated connector module.
-     * @param opts - Required connection/folder bindings, sync/async mode, and descriptor-typed inputs.
+     * @param opts - Required connection/folder bindings, the object's execution type, and descriptor-typed inputs.
      * @returns This builder, so calls chain.
      */
     externalWorkflow<I extends Record<string, unknown>, O>(descriptor: ConnectorDescriptor<I, O>, opts: ExternalTaskOptions<I>): this;

package/dist/case/case-sdk.js

@@ -264,6 +264,22 @@ class TaskBuilder {
     flowProcess(name, opts) {
         return this.reference('flow-process', name, opts);
     }
+    /**
+     * Reference a deployed **Coded Function** (a `uipath-functions` project).
+     *
+     * @remarks
+     * Emits a `function` task bound like the other published resources, with
+     * `resourceSubType: 'Function'`. A function is its own task type: do not
+     * model one as `.apiWorkflow()` or `.agent()`. A function with several
+     * deployments of one name is told apart by its folder.
+     *
+     * @param name - The deployed function's name.
+     * @param opts - `folder` — the Orchestrator folder it lives in, or `'solution_folder'` (the default when omitted) for one built in this solution. Compile binds the task through a name/folderPath pair of root bindings keyed `<folder>.<name>`.
+     * @returns This builder, so calls chain.
+     */
+    function(name, opts) {
+        return this.reference('function', name, opts);
+    }
     /**
      * Evaluate a deployed **business rule** (a DMN decision package) and read its
      * decisions back.
@@ -312,7 +328,7 @@ class TaskBuilder {
      * Invoke an external agent through its generated Integration Service descriptor.
      *
      * @param descriptor - An `AgentExecution` operation from a generated connector module.
-     * @param opts - Required connection/folder bindings, sync/async mode, and descriptor-typed inputs.
+     * @param opts - Required connection/folder bindings, the object's execution type, and descriptor-typed inputs.
      * @returns This builder, so calls chain.
      */
     externalAgent(descriptor, opts) {
@@ -322,7 +338,7 @@ class TaskBuilder {
      * Invoke an external workflow through its generated Integration Service descriptor.
      *
      * @param descriptor - A `ProcessExecution` operation from a generated connector module.
-     * @param opts - Required connection/folder bindings, sync/async mode, and descriptor-typed inputs.
+     * @param opts - Required connection/folder bindings, the object's execution type, and descriptor-typed inputs.
      * @returns This builder, so calls chain.
      */
     externalWorkflow(descriptor, opts) {
@@ -488,12 +504,11 @@ class TaskBuilder {
     _build() {
         if (!this._kind)
             throw new Error(`task "${this._name}" has no kind — call .process()/.agent()/.rpa()/.action()/.connector()/.waitForTimer()/… once.`);
-        // Task I/O binding is reference-mode only — process/agent/rpa/api-workflow,
-        // case-management, and flow-process. Connector tasks derive their own
-        // inputs/outputs from the operation schema.
-        const REF_IO = new Set(['process', 'agent', 'rpa', 'api-workflow', 'case-management', 'flow-process', 'business-rule']);
+        // Task I/O binding is reference-mode only (REF_IO). Connector tasks derive
+        // their own inputs/outputs from the operation schema.
+        const REF_IO = new Set(['process', 'agent', 'rpa', 'api-workflow', 'case-management', 'flow-process', 'function', 'business-rule']);
         if ((this._inputs || this._outputs) && !REF_IO.has(this._kind))
-            throw new Error(`task "${this._name}": .inputs()/.outputs() are only supported on reference-mode tasks (process/agent/rpa/api-workflow/case-management/flow-process/business-rule), not "${this._kind}".`);
+            throw new Error(`task "${this._name}": .inputs()/.outputs() are only supported on reference-mode tasks (process/agent/rpa/api-workflow/case-management/flow-process/function/business-rule), not "${this._kind}".`);
         if (!this._ref && (this._inputs || this._outputs))
             throw new Error(`task "${this._name}": an unresolved reference task cannot declare inputs or outputs.`);
         return {

package/dist/case/check.js

@@ -6,7 +6,7 @@ import { schemaVersionRefusal } from '../schema-version.js';
 import { caseJsonPreservation, caseJsonPreservationErrors } 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 } from './external.js';
+import { EXTERNAL_TASK_DESCRIPTOR_CONTRACT, EXTERNAL_TASK_HYBRID_UNSUPPORTED, externalHybridRefusal, isExternalExecutionMode } from './external.js';
 import { isResourceLabelRefusal, resolveResourceRef } from './resource-identity.js';
 const TYPE_NAMES = new Set(Object.values(types));
 // audit-case-coverage: rule-slot table start
@@ -571,11 +571,18 @@ function checkStage(stage, diags, refStage, refPlacement, bindings) {
                     where: t.name,
                 });
             else {
-                if (t.external.mode !== 'sync' && t.external.mode !== 'async')
+                if (!isExternalExecutionMode(t.external.mode))
                     diags.push({
                         level: 'error',
                         code: 'EXTERNAL_TASK_MODE',
-                        message: `${family} task "${t.name}" mode must be "sync" or "async"; no other service type is valid.`,
+                        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,
                     });
                 if (!t.external.connector?.key?.trim() || !t.external.connector?.action?.trim())

package/dist/case/decompile.js

@@ -1,6 +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 { preserveSchemaVersion } from '../schema-version.js';
 import { ownEntry } from '../core/own-entry.js';
 import { isUnrestorableSlotId } from './preserve.js';
@@ -13,6 +14,7 @@ const TASK_KIND_METHOD = {
     'api-workflow': 'apiWorkflow',
     'case-management': 'caseManagement',
     'flow-process': 'flowProcess',
+    function: 'function',
 };
 function boolLit(value) {
     return value ? 'true' : 'false';
@@ -522,6 +524,42 @@ function connectorVersion(context) {
 function toCamel(value) {
     return value.replace(/_([a-z0-9])/gi, (_match, char) => String(char).toUpperCase());
 }
+/**
+ * A connector activity's authored inputs, lifted from its `pathParameters` /
+ * `queryParameters` / `body` input containers. A `body` key is the authored
+ * name; a path or query key is the camelCased wire name, mapped back to the
+ * operation's parameter name. Shared by the plain connector lift and the
+ * external task lift, so the two cannot drift.
+ *
+ * With `owner`, the lift is strict (the external task shape): a row that is not
+ * one of the three containers, or a container whose body is not an object, is
+ * refused. Without it, such rows are skipped, as the connector lift always did.
+ */
+function connectorInputs(slots, resolved, owner) {
+    const parameterByWireName = new Map();
+    for (const parameter of resolved.entry.operation?.parameters ?? [])
+        parameterByWireName.set(toCamel(String(parameter.name)), String(parameter.name));
+    const inputs = {};
+    for (const slot of slots) {
+        const name = String(slot?.name ?? '');
+        if (owner && !CONNECTOR_INPUT_CONTAINERS.has(name))
+            throw new Error(`${owner} has unsupported input row "${name}".`);
+        const body = slot?.body;
+        if (owner && body === undefined)
+            continue;
+        if (!body || typeof body !== 'object' || Array.isArray(body)) {
+            if (owner)
+                throw new Error(`${owner} input container "${name}" must carry an object body.`);
+            continue;
+        }
+        for (const [wireName, value] of Object.entries(body)) {
+            const authoredName = name === 'body' ? wireName : (parameterByWireName.get(wireName) ?? wireName);
+            inputs[authoredName] = value;
+        }
+    }
+    return inputs;
+}
+const CONNECTOR_INPUT_CONTAINERS = new Set(['pathParameters', 'queryParameters', 'body']);
 function connectorCall(task, refs, library) {
     if (!library)
         throw new Error(`connector task "${task.displayName ?? task.id ?? '?'}" needs the connector library; pass DecompileOptions.library or --library.`);
@@ -541,19 +579,7 @@ function connectorCall(task, refs, library) {
         version: connectorVersion(context),
     });
     const resolved = library.resolve(identity.key, identity.action, identity.version, identity.object);
-    const parameterByWireName = new Map();
-    for (const parameter of resolved.entry.operation?.parameters ?? [])
-        parameterByWireName.set(toCamel(String(parameter.name)), String(parameter.name));
-    const inputs = {};
-    for (const slot of Array.isArray(data.inputs) ? data.inputs : []) {
-        const body = slot?.body;
-        if (!body || typeof body !== 'object' || Array.isArray(body))
-            continue;
-        for (const [wireName, value] of Object.entries(body)) {
-            const authoredName = slot.name === 'body' ? wireName : (parameterByWireName.get(wireName) ?? wireName);
-            inputs[authoredName] = value;
-        }
-    }
+    const inputs = connectorInputs(Array.isArray(data.inputs) ? data.inputs : [], resolved);
     const connection = bindingName(context.get('connection')?.value, refs);
     const folder = bindingName(context.get('folderKey')?.value, refs);
     const options = opts([
@@ -564,6 +590,14 @@ function connectorCall(task, refs, library) {
     ]);
     return `.connector(${tsLiteral(identity.key)}, ${tsLiteral(identity.action)}, ${tsLiteral(inputs)}${options ? `, ${options}` : ''})`;
 }
+/**
+ * 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
+ * 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.
+ */
 function externalCall(task, refs, library) {
     const kind = task.type;
     const owner = `${kind} task "${task.displayName ?? task.id ?? '?'}"`;
@@ -574,33 +608,24 @@ function externalCall(task, refs, library) {
     const unknownData = Object.keys(data).find((name) => !allowed.has(name));
     if (unknownData)
         throw new Error(`${owner} has unsupported data field "${unknownData}".`);
-    if (!Array.isArray(data.bindings) || data.bindings.length !== 0)
+    if (data.bindings !== undefined && (!Array.isArray(data.bindings) || data.bindings.length !== 0))
         throw new Error(`${owner} data.bindings must be an empty array; bindings live at case root.`);
-    const modes = kind === 'external-agent'
-        ? new Map([
-            [CASE_FORMAT_PROFILE.externalAgentSyncServiceType, 'sync'],
-            [CASE_FORMAT_PROFILE.externalAgentAsyncServiceType, 'async'],
-        ])
-        : new Map([
-            [CASE_FORMAT_PROFILE.externalWorkflowSyncServiceType, 'sync'],
-            [CASE_FORMAT_PROFILE.externalWorkflowAsyncServiceType, 'async'],
-        ]);
-    const mode = modes.get(data.serviceType);
-    if (!mode)
-        throw new Error(`${owner} has unsupported serviceType "${String(data.serviceType ?? '')}".`);
     if (!Array.isArray(data.context))
         throw new Error(`${owner} requires a resolved context array.`);
-    // A trailing `activityConfigurationVersion: v2` row only picks the Designer
-    // panel; compile writes it back from the plan's `intsvcActivityConfig` flag.
-    const rows = data.context;
-    const last = rows[rows.length - 1];
-    const configRows = last?.name === 'activityConfigurationVersion' && last.value === 'v2' && last.type === 'string'
-        ? rows.slice(0, -1)
-        : rows;
-    const expectedContext = ['activity', 'connectorKey', 'connection', 'folderKey', 'method', 'path'];
-    if (configRows.map((row) => row.name).join('\0') !== expectedContext.join('\0'))
-        throw new Error(`${owner} context must contain exactly ${expectedContext.join(', ')} in canonical order, optionally followed by activityConfigurationVersion v2.`);
-    const context = contextMap({ context: configRows });
+    // 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.
+    const contextNames = data.context.map((row) => String(row?.name ?? ''));
+    const unknownContext = contextNames.find((name, at) => !EXTERNAL_TASK_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}".`);
+    const context = contextMap(data);
     const stringValue = (name) => {
         const row = context.get(name);
         if (row?.type !== 'string' || typeof row.value !== 'string' || !row.value)
@@ -616,36 +641,26 @@ function externalCall(task, refs, library) {
             throw new Error(`${owner} context ${name} references missing root binding "${id}".`);
         return bindingLabel(refs, id);
     };
+    const mode = stringValue('executionType');
+    if (!isExternalExecutionMode(mode))
+        throw new Error(`${owner} has unsupported executionType "${mode}".`);
+    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}".`);
     const identity = library.identifyAction({
         connectorKey: stringValue('connectorKey'),
         httpMethod: stringValue('method'),
         endpoint: stringValue('path'),
+        objectName: stringValue('objectName'),
+        version: connectorVersion(context),
     });
     const resolved = library.resolve(identity.key, identity.action, identity.version, identity.object);
-    const expectedSubType = kind === 'external-agent' ? 'AgentExecution' : 'ProcessExecution';
-    if (resolved.entry.operation?.subType !== expectedSubType)
-        throw new Error(`${owner} resolves to ${String(resolved.entry.operation?.subType ?? 'no subtype')}, not ${expectedSubType}.`);
-    if (stringValue('activity') !== resolved.activityTypeId)
-        throw new Error(`${owner} activity does not match its descriptor.`);
+    const refused = externalDescriptorRefusal(kind, resolved);
+    if (refused)
+        throw new Error(`${owner}: ${refused}`);
     if (!Array.isArray(data.inputs))
         throw new Error(`${owner} inputs must be an array.`);
-    const fields = new Map(resolved.fields.map((field) => [field.name, field]));
-    const inputs = {};
-    for (const row of data.inputs) {
-        const name = String(row?.name ?? '');
-        if (!name || row.id !== name || row.target !== name || !fields.has(name))
-            throw new Error(`${owner} has unsupported input row "${name}".`);
-        inputs[name] = row.value;
-    }
-    const missing = resolved.fields.find((field) => field.required && !(field.name in inputs));
-    if (missing)
-        throw new Error(`${owner} is missing required input "${missing.name}".`);
-    if (!Array.isArray(data.outputs) || data.outputs.length !== 1)
-        throw new Error(`${owner} must carry exactly one response output.`);
-    const output = data.outputs[0];
-    if (output.name !== 'response' || output.type !== 'json' || output.source !== '.'
-        || typeof output.var !== 'string' || output.id !== output.var)
-        throw new Error(`${owner} has an unsupported response output.`);
+    const inputs = connectorInputs(data.inputs, resolved, owner);
     const descriptor = `{ nodeType: ${tsLiteral(resolved.nodeType)}, version: ${tsLiteral(resolved.version)} }`;
     const options = opts([
         ['connection', tsLiteral(binding('connection'))],

package/dist/case/external.d.ts

@@ -8,6 +8,45 @@
  * `buildConnectorInputs`, which `check` already runs as `connectorInputs`.
  */
 import type { ResolvedConnector } from '../core/library.js';
+import type { 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}.
+ */
+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.
+ *
+ * @param owner - The task as the message names it, e.g. `External Workflow task "Run"`.
+ * @returns The refusal.
+ */
+export declare function externalHybridRefusal(owner: string): string;
+/** The execution types an external task accepts: the values Integration Service reports. */
+export declare function isExternalExecutionMode(value: unknown): value is ExternalExecutionMode;
+/**
+ * The `data.serviceType` the Case Designer saves for an external task of this
+ * execution type. Studio Web runs `hybrid` as `async` (`determineActualIntsvcType`),
+ * so both save as the `Async…Execution` type; the CLI's `externalServiceType`
+ * and its strict validator read the same table.
+ *
+ * @param kind - The task kind.
+ * @param mode - The connector object's `executionType`.
+ * @returns The service type.
+ */
+export declare function externalServiceType(kind: 'external-agent' | 'external-workflow', mode: ExternalExecutionMode): string;
 /** Check's code for {@link externalDescriptorRefusal}. */
 export declare const EXTERNAL_TASK_DESCRIPTOR_CONTRACT = "EXTERNAL_TASK_DESCRIPTOR_CONTRACT";
 /**
@@ -17,8 +56,8 @@ export declare const EXTERNAL_TASK_DESCRIPTOR_CONTRACT = "EXTERNAL_TASK_DESCRIPT
  * Workflow task a `ProcessExecution` one: the service type the task emits
  * (`Intsvc.SyncAgentExecution`, …) is chosen by the family, and a descriptor of
  * the other kind (or a plain connector action) would run the wrong contract.
- * Both need the operation's `uiPathActivityTypeId`, which the task emits as its
- * `activity` context.
+ * Both need the operation's `uiPathActivityTypeId`, which the task's `metadata`
+ * context carries.
  *
  * @param kind - The task kind.
  * @param rc - What `library.resolve` returned for the task's descriptor.

package/dist/case/external.js

@@ -1,3 +1,57 @@
+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}.
+ */
+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.
+ *
+ * @param owner - The task as the message names it, e.g. `External Workflow task "Run"`.
+ * @returns The refusal.
+ */
+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.`);
+}
+/** The execution types an external task accepts: the values Integration Service reports. */
+export function isExternalExecutionMode(value) {
+    return value === 'sync' || value === 'async' || value === 'hybrid';
+}
+/**
+ * The `data.serviceType` the Case Designer saves for an external task of this
+ * execution type. Studio Web runs `hybrid` as `async` (`determineActualIntsvcType`),
+ * so both save as the `Async…Execution` type; the CLI's `externalServiceType`
+ * and its strict validator read the same table.
+ *
+ * @param kind - The task kind.
+ * @param mode - The connector object's `executionType`.
+ * @returns The service type.
+ */
+export function externalServiceType(kind, mode) {
+    const sync = mode === 'sync';
+    if (kind === 'external-agent')
+        return sync ? CASE_FORMAT_PROFILE.externalAgentSyncServiceType : CASE_FORMAT_PROFILE.externalAgentAsyncServiceType;
+    return sync ? CASE_FORMAT_PROFILE.externalWorkflowSyncServiceType : CASE_FORMAT_PROFILE.externalWorkflowAsyncServiceType;
+}
 /** Check's code for {@link externalDescriptorRefusal}. */
 export const EXTERNAL_TASK_DESCRIPTOR_CONTRACT = 'EXTERNAL_TASK_DESCRIPTOR_CONTRACT';
 /**
@@ -7,8 +61,8 @@ export const EXTERNAL_TASK_DESCRIPTOR_CONTRACT = 'EXTERNAL_TASK_DESCRIPTOR_CONTR
  * Workflow task a `ProcessExecution` one: the service type the task emits
  * (`Intsvc.SyncAgentExecution`, …) is chosen by the family, and a descriptor of
  * the other kind (or a plain connector action) would run the wrong contract.
- * Both need the operation's `uiPathActivityTypeId`, which the task emits as its
- * `activity` context.
+ * Both need the operation's `uiPathActivityTypeId`, which the task's `metadata`
+ * context carries.
  *
  * @param kind - The task kind.
  * @param rc - What `library.resolve` returned for the task's descriptor.