@uipath/maestro-builder-sdk 6.52.0 → 6.52.1

package/dist/case/decompile.js

@@ -506,7 +506,11 @@ function connectorVersion(context) {
     const encoded = metadata?.activityPropertyConfiguration?.configuration;
     if (typeof encoded === 'string' && encoded.startsWith('=jsonString:')) {
         try {
-            return JSON.parse(encoded.slice('=jsonString:'.length))?.essentialConfiguration?.packageVersion;
+            // The activity's version is `instanceParameters.version`. `packageVersion`
+            // is what the platform writes as "1.0.0" on every activity; an SDK plan
+            // once wrote the library version there, so it stays the fallback.
+            const essential = JSON.parse(encoded.slice('=jsonString:'.length))?.essentialConfiguration;
+            return essential?.instanceParameters?.version ?? essential?.packageVersion;
         }
         catch {
             throw new Error('connector task has malformed activity metadata configuration JSON.');

package/dist/case/serialize.js

@@ -11,7 +11,8 @@
 import { IdGen, offlineBindingSeed } from './ids.js';
 import { isUnrestorableSlotId } from './preserve.js';
 import { v31TaskSets } from './task-sets.js';
-import { buildConnectorInputs, nestConnectorBody, transportHttpMethod } from '../core/connector-inputs.js';
+import { buildConnectorInputs, nestConnectorBody, replayInputsOf, transportHttpMethod } from '../core/connector-inputs.js';
+import { buildEssentialConfiguration } from '../core/connector-configuration.js';
 import { EQUALS_EXPR_DIALECT } from '../core/connector-checks.js';
 import { bindingLabelRefusal } from '../core/binding-messages.js';
 import { resolveEventWhere } from '../core/lookups.js';
@@ -1444,7 +1445,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, executionType) }));
+    context.push(io('metadata', 'json', { body: connectorMetadata(rc, op, slots, elementId, executionType) }));
     const inputs = [
         ioSlot('pathParameters', pathParameters, `${elementId}`),
         ioSlot('queryParameters', queryParameters, `${elementId}`),
@@ -1601,45 +1602,39 @@ function folderBindingRef(resolver, name, connection, site) {
     }
     return { id };
 }
-/** The connector `metadata` json blob: the FUNCTIONAL essentialConfiguration +
+/**
+ * The connector `metadata` json blob: the FUNCTIONAL essentialConfiguration +
  * activityTypeId, and the multipart wire of a multipart operation. Designer
  * cosmetics (packageId/activityColor/…) are omitted — the caseplan
- * schema-validates without them (see design §C). */
-function connectorMetadata(rc, op, slots, executionType) {
+ * schema-validates without them (see design §C).
+ *
+ * The configuration is the one Flow writes, from the shared
+ * {@link buildEssentialConfiguration}. Case used to build its own, thinner copy:
+ * no `operation` verb, `customFieldsRequestDetails`, `connectorVersion` or
+ * `unifiedTypesCompatible`, a curated-only `instanceParameters` even for a
+ * Generic activity, and the library version where the platform writes
+ * `packageVersion: "1.0.0"` (#1420).
+ */
+function connectorMetadata(rc, op, slots, seed, executionType) {
     // The part DECLARATIONS only: a file part's value rides on its `file` input.
     const multipartParameters = (slots.multipartParameters ?? []).map(({ name, dataType }) => ({ name, dataType }));
-    const instanceParameters = {
-        connectorKey: rc.connectorKey,
-        objectName: op.objectName ?? rc.nodeType.split('.').pop(),
-        httpMethod: rc.httpMethod,
-        activityType: op.activityType ?? 'Curated',
-        version: rc.version,
-        supportsStreaming: op.supportsStreaming ?? false,
-        subType: op.subType ?? 'standard',
-    };
-    const configuration = {
-        essentialConfiguration: {
-            instanceParameters,
-            objectName: instanceParameters.objectName,
-            httpMethod: transportHttpMethod(rc.httpMethod),
-            path: rc.endpoint,
-            packageVersion: rc.version,
-            // An external task's object states how it runs; the Designer saves it here
-            // and beside the configuration. A plain connector activity has none.
-            ...(executionType ? { executionType } : {}),
-        },
-    };
+    // The configuration replays the authored values (a schema action's parent
+    // fields, a CEQL filter's tree), keyed by the library's own names, as Flow's.
+    const essential = buildEssentialConfiguration(rc.entry, rc.version, replayInputsOf(slots), seed, executionType ?? null);
+    const configuration = `=jsonString:${JSON.stringify({ essentialConfiguration: essential })}`;
+    const instanceParameters = essential.instanceParameters;
+    const objectName = String(op.objectName ?? rc.nodeType.split('.').pop());
     return {
         activityPropertyConfiguration: {
             ...(multipartParameters.length ? { multipartParameters } : {}),
-            configuration: `=jsonString:${JSON.stringify(configuration)}`,
+            configuration,
             uiPathActivityTypeId: rc.activityTypeId ?? '',
             errorState: { issues: [] },
             ...(executionType ? { executionType } : {}),
         },
         activityMetadata: {
             activity: {
-                displayName: rc.entry.display?.label ?? instanceParameters.objectName,
+                displayName: rc.entry.display?.label ?? objectName,
                 description: rc.entry.display?.description ?? '',
                 category: rc.connectorName,
                 configuration: JSON.stringify(instanceParameters),
@@ -1653,7 +1648,7 @@ function connectorMetadata(rc, op, slots, executionType) {
         telemetryData: {
             connectorKey: rc.connectorKey,
             connectorName: rc.connectorName,
-            objectName: instanceParameters.objectName,
+            objectName,
             objectDisplayName: op.objectDisplayName ?? rc.entry.display?.operationLabel ?? '',
         },
     };

package/dist/core/connector-configuration.d.ts

@@ -63,6 +63,33 @@
  *
  * Neither is cosmetic for a generic node: v1's own `check_generic_dynamic_node.py`
  * identifies the activity semantically, by `activityType == 'generic'` **and
- * `operation == 'list'`**, read from these very keys.
+ * `operation == 'list'`**, read from these very keys. *
+ * ## `savedJitInputFieldId` is not written, because the library cannot say when
+ *
+ * The CLI writes `savedJitInputFieldId: "in_<objectName>"` for a create /
+ * update / replace whose IS metadata declares a `body` PARAMETER (a
+ * just-in-time body). The offline library does not carry that parameter: its
+ * `operation.parameters` hold only `query` · `path` · `multipart`. Its body
+ * FIELDS do not stand in for it. Measured over the Designer- and CLI-saved
+ * create/update/replace nodes in the eval corpus: Slack `create-channel` (2
+ * body fields) carries the key, while `join-channel` (1 body field, 0/2) and
+ * `create-group-direct-message` (1 body field, 0/89) do not, and Data Service
+ * `create-entity-record` (no body fields) does (336/405). Writing it on a
+ * guess would be wrong on hundreds of nodes, so it stays out until the library
+ * records the body parameter.
+ */
+export declare function buildConfiguration(entry: any, version: string, inputValues?: Record<string, unknown>, seed?: string, executionType?: string | null): string;
+/**
+ * The `essentialConfiguration` object that {@link buildConfiguration} wraps in
+ * its `=jsonString:` envelope. For a caller that also needs a field of it (Case
+ * copies its `instanceParameters` into the activity metadata), so it does not
+ * parse the string back.
+ *
+ * @param entry - The connector library entry.
+ * @param version - The connector version.
+ * @param inputValues - The authored inputs to replay, keyed by the library's names.
+ * @param seed - Seed for the saved filter tree ids.
+ * @param executionType - An External Agent / Workflow object's run mode, or `null`.
+ * @returns The essential configuration, with only Studio Web's essential keys.
  */
-export declare function buildConfiguration(entry: any, version: string, inputValues?: Record<string, unknown>, seed?: string): string;
+export declare function buildEssentialConfiguration(entry: any, version: string, inputValues?: Record<string, unknown>, seed?: string, executionType?: string | null): Record<string, unknown>;

package/dist/core/connector-configuration.js

@@ -20,6 +20,14 @@ const ESSENTIAL_DEFAULTS = {
     executionType: null,
     operation: 'create',
     packageVersion: '1.0.0',
+    // The CLI's offline builder writes these two on every activity
+    // (`buildActivityEssentialConfiguration`, uipath-cli
+    // `integrationservice-sdk/src/dap/essential-config.ts`), and so does every
+    // Designer save in the eval corpus. `connectorVersion` is a request header
+    // the library does not carry; Studio Web fills it from its type cache on
+    // open, so offline it is `null`, as the CLI and the Case fixture write it.
+    connectorVersion: null,
+    unifiedTypesCompatible: true,
 };
 /**
  * Which of an operation's parameters carries a CEQL filter.
@@ -161,9 +169,40 @@ function envelope(flat) {
  *
  * Neither is cosmetic for a generic node: v1's own `check_generic_dynamic_node.py`
  * identifies the activity semantically, by `activityType == 'generic'` **and
- * `operation == 'list'`**, read from these very keys.
+ * `operation == 'list'`**, read from these very keys. *
+ * ## `savedJitInputFieldId` is not written, because the library cannot say when
+ *
+ * The CLI writes `savedJitInputFieldId: "in_<objectName>"` for a create /
+ * update / replace whose IS metadata declares a `body` PARAMETER (a
+ * just-in-time body). The offline library does not carry that parameter: its
+ * `operation.parameters` hold only `query` · `path` · `multipart`. Its body
+ * FIELDS do not stand in for it. Measured over the Designer- and CLI-saved
+ * create/update/replace nodes in the eval corpus: Slack `create-channel` (2
+ * body fields) carries the key, while `join-channel` (1 body field, 0/2) and
+ * `create-group-direct-message` (1 body field, 0/89) do not, and Data Service
+ * `create-entity-record` (no body fields) does (336/405). Writing it on a
+ * guess would be wrong on hundreds of nodes, so it stays out until the library
+ * records the body parameter.
+ */
+export function buildConfiguration(entry, version, inputValues, seed = 'node', executionType = null) {
+    return '=jsonString:' + JSON.stringify({
+        essentialConfiguration: buildEssentialConfiguration(entry, version, inputValues, seed, executionType),
+    });
+}
+/**
+ * The `essentialConfiguration` object that {@link buildConfiguration} wraps in
+ * its `=jsonString:` envelope. For a caller that also needs a field of it (Case
+ * copies its `instanceParameters` into the activity metadata), so it does not
+ * parse the string back.
+ *
+ * @param entry - The connector library entry.
+ * @param version - The connector version.
+ * @param inputValues - The authored inputs to replay, keyed by the library's names.
+ * @param seed - Seed for the saved filter tree ids.
+ * @param executionType - An External Agent / Workflow object's run mode, or `null`.
+ * @returns The essential configuration, with only Studio Web's essential keys.
  */
-export function buildConfiguration(entry, version, inputValues, seed = 'node') {
+export function buildEssentialConfiguration(entry, version, inputValues, seed = 'node', executionType = null) {
     const op = entry.operation ?? {};
     const conn = entry.connector ?? {};
     const at = op.activityType;
@@ -177,6 +216,9 @@ export function buildConfiguration(entry, version, inputValues, seed = 'node') {
         : ESSENTIAL_DEFAULTS.operation;
     const composed = {
         ...ESSENTIAL_DEFAULTS,
+        // An External Agent / Workflow object states how it runs; a connector
+        // activity has none (`null`, the default).
+        executionType,
         operation: verb,
         customFieldsRequestDetails: schemaReplayDetails(op, inputValues),
         savedFilterTrees: savedFilterTrees(op, inputValues, seed),
@@ -202,5 +244,5 @@ export function buildConfiguration(entry, version, inputValues, seed = 'node') {
             },
         ...(op.pathTemplate || op.path ? { path: op.pathTemplate || op.path } : {}),
     };
-    return '=jsonString:' + JSON.stringify(envelope(composed));
+    return envelope(composed).essentialConfiguration;
 }

package/dist/core/connector-inputs.d.ts

@@ -58,6 +58,16 @@ export declare const CONNECTOR_INPUT_MISSING = "CONNECTOR_INPUT_MISSING";
  */
 export declare function connectorInputErrors(rc: ResolvedConnector, inputs: Record<string, unknown>, resolutions?: LookupResolutions, lookups?: Readonly<Record<string, LookupSpec>>, wire?: Pick<ConnectorInputOpts, 'dialect' | 'render'>): string | undefined;
 export declare function buildConnectorInputs(rc: any, inputs: Record<string, unknown>, opts: ConnectorInputOpts): ConnectorSlots;
+/**
+ * The authored values a connector's `configuration` replays (a schema action's
+ * parent fields, a CEQL filter's tree), keyed by the library's own names: the
+ * body, path and query slots, merged. Flow and Case both write the
+ * configuration from this, so the two cannot drift.
+ *
+ * @param slots - The slots {@link buildConnectorInputs} returned.
+ * @returns The merged body, path and query values.
+ */
+export declare function replayInputsOf(slots: ConnectorSlots): Record<string, unknown>;
 /**
  * `inputMetadata.multipart.bodyFieldName` names the CONTAINER part — the one the
  * runtime composes from `bodyParameters`. Measured on the designer's own nodes in

package/dist/core/connector-inputs.js

@@ -253,6 +253,22 @@ function swapLookupTokens(value, resolutions, unresolved) {
         return value.map((item) => swapLookupTokens(item, resolutions, unresolved));
     return value;
 }
+/**
+ * The authored values a connector's `configuration` replays (a schema action's
+ * parent fields, a CEQL filter's tree), keyed by the library's own names: the
+ * body, path and query slots, merged. Flow and Case both write the
+ * configuration from this, so the two cannot drift.
+ *
+ * @param slots - The slots {@link buildConnectorInputs} returned.
+ * @returns The merged body, path and query values.
+ */
+export function replayInputsOf(slots) {
+    return {
+        ...(slots.bodyParameters ?? {}),
+        ...(slots.pathParameters ?? {}),
+        ...(slots.queryParameters ?? {}),
+    };
+}
 /**
  * `inputMetadata.multipart.bodyFieldName` names the CONTAINER part — the one the
  * runtime composes from `bodyParameters`. Measured on the designer's own nodes in

package/dist/nodes/connector/flow/node-type.js

@@ -1,7 +1,7 @@
 import { BindingRefusal, bindingMissingMessage, missingBindingLabels } from '../../../core/binding-messages.js';
 import { prepareCommand } from '../../../core/cli-spelling.js';
 import { buildConfiguration } from '../../../core/connector-configuration.js';
-import { CONNECTOR_INPUT_MISSING, FLOW_EXPR_DIALECT, buildConnectorInputs, transportHttpMethod } from '../../../core/connector-inputs.js';
+import { CONNECTOR_INPUT_MISSING, FLOW_EXPR_DIALECT, buildConnectorInputs, replayInputsOf, transportHttpMethod } from '../../../core/connector-inputs.js';
 import { ConnectorResolveError } from '../../../core/connector-resolve-error.js';
 import { definitionHasErrorPort } from '../../../core/error-port.js';
 import { Expr } from '../../../core/expr.js';
@@ -141,11 +141,7 @@ function serializeConnector(spec, ctx) {
             ? library.lookupSpecs(spec.key, spec.action, spec.version, spec.object)
             : {},
     });
-    const replayInputs = {
-        ...(connectorInputs.bodyParameters ?? {}),
-        ...(connectorInputs.pathParameters ?? {}),
-        ...(connectorInputs.queryParameters ?? {}),
-    };
+    const replayInputs = replayInputsOf(connectorInputs);
     const detail = {
         connector: rc.connectorKey,
         method: transportHttpMethod(rc.httpMethod),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/maestro-builder-sdk",
-  "version": "6.52.0",
+  "version": "6.52.1",
   "description": "Build UiPath Flow, Case, and BPMN artifacts by writing TypeScript.",
   "license": "MIT",
   "homepage": "https://docs.uipath.com/maestro",
@@ -96,5 +96,5 @@
     "@types/node": "^22.7.0",
     "esbuild": "^0.28.1"
   },
-  "gitref": "4338e0cd3aa57c2329696080bee010a1e80d2e87"
+  "gitref": "d3566b616cb3addce005fe0b6962aa504adb79a3"
 }