@uipath/flow-tool 1.205.0-preview.277 → 1.206.0-preview.279

package/dist/{connector-service-kdg7mq7z.js → connector-service-r86mtxwn.js}

@@ -1,112 +1,102 @@
 import {
-  isConnectorTriggerType,
-  isConnectorWaitForEventType,
-  isEventDrivenConnectorType,
-  readEssentialConfiguration,
-  scanDetailForCrossNodeBindings
-} from "./packager-tool-nhrc54tz.js";
+  getFileSystem
+} from "./packager-tool-vgrswa8p.js";
 import {
-  INLINE_ACTIVITY_SOURCE,
-  REQUEST_BUCKETS,
-  createEntityBindings,
-  getInlineActivityConfiguration,
-  isEntityNode,
-  regenerateBindingsFile,
-  resolveEntityIdentity
-} from "./packager-tool-kkwrd05c.js";
-import"./packager-tool-cqtsj6yh.js";
-import"./packager-tool-143kcy6z.js";
+  catchError2
+} from "./packager-tool-pxq0bwp0.js";
+import {
+  extractErrorMessageSync,
+  logger
+} from "./packager-tool-8ed52y5r.js";
 import {
-  ACTIVITY_VERSION_V4,
+  generateRandomId2
+} from "./packager-tool-fzgfb0jt.js";
+import {
+  addBinding2
+} from "./packager-tool-2b0tn4p4.js";
+import {
+  storedActivityBindings,
+  planResourceBindings,
+  guardJsonString,
+  upsertResourceBinding,
+  externalExecutionOf,
+  externalExecutionWarning,
+  MANAGED_HTTP_CONNECTOR_KEY2,
+  MANAGED_HTTP_ENDPOINT,
+  IMPLICIT_CONNECTION,
+  managedHttpDetailErrors,
+  buildManagedHttpBodyParameters,
+  MANAGED_HTTP_TELEMETRY,
+  ACTIVITY_VERSION_V42,
+  isV4ActivityConfiguration2,
   FilterNotSupportedError,
-  MANAGED_HTTP_CONNECTOR_KEY,
-  applySavedFilterTree,
-  assertActivityMetadataResolved,
-  buildActivityEssentialConfiguration,
-  buildInputMetadata,
-  buildManagedHttpEssentialConfiguration,
+  substituteFilterVariables,
+  buildActivityEssentialConfiguration2,
   configureActivityClient,
-  extractMultipartParameters,
-  fetchConnectionInfo,
-  fetchConnectorActivityMetadataV4,
-  fetchConnectorMetadata,
-  inlineMultipartFileValues,
+  applySavedFilterTree2,
+  assertActivityMetadataResolved2,
+  buildManagedHttpEssentialConfiguration2,
+  extractMultipartParameters2,
+  inlineMultipartFileValues2,
   isListOperation,
-  isV4ActivityConfiguration,
+  buildInputMetadata2,
   normalizeHttpMethod,
-  planResourceBindings,
-  storedActivityBindings,
-  substituteFilterVariables
-} from "./packager-tool-mgwzjh8c.js";
-import"./packager-tool-dxgrhfq5.js";
-import"./packager-tool-7hw344bt.js";
-import"./packager-tool-z21c6mbp.js";
-import"./packager-tool-409n51pv.js";
-import"./packager-tool-skcjythd.js";
-import"./packager-tool-4x7tzvv0.js";
-import"./packager-tool-3jkppykr.js";
-import"./packager-tool-ymma2s85.js";
-import"./packager-tool-tqjfdpda.js";
-import"./packager-tool-frjt46rb.js";
-import {
-  findNodeDefinition
-} from "./packager-tool-hxyjn885.js";
-import"./packager-tool-xk78j7dz.js";
-import"./packager-tool-8qp60s20.js";
-import"./packager-tool-kn86394c.js";
-import"./packager-tool-0gctz400.js";
-import"./packager-tool-qa9gftnj.js";
-import"./packager-tool-yc4kw997.js";
-import {
-  readFlowWorkflow,
-  writeFlowWorkflow
-} from "./packager-tool-hgfygxyj.js";
-import"./packager-tool-9rmaeaww.js";
-import"./packager-tool-paq9c70w.js";
+  assertConnectionConnector2,
+  fetchConnectionInfo2,
+  fetchConnectorMetadata2,
+  fetchConnectorActivityMetadataV42
+} from "./packager-tool-kz3t4raw.js";
+import"./packager-tool-1qg04b7q.js";
+import"./packager-tool-p123mtfx.js";
+import"./packager-tool-65yf8zqb.js";
+import"./packager-tool-508ka40b.js";
+import"./packager-tool-jmrhzfyj.js";
+import"./packager-tool-xb16e3tz.js";
+import"./packager-tool-gdpw0daf.js";
+import"./packager-tool-d07g2kpn.js";
+import"./packager-tool-a1h0q79w.js";
+import"./packager-tool-21t17xzz.js";
+import"./packager-tool-b2pkwwj1.js";
+import"./packager-tool-ze3fnf3s.js";
 import {
   entityScopeKey
-} from "./packager-tool-dw1bm5y7.js";
+} from "./packager-tool-mdf7bws6.js";
 import {
-  addBinding
-} from "./packager-tool-pvhx9e12.js";
-import"./packager-tool-jgfzfqjm.js";
-import"./packager-tool-dbsdy4xx.js";
+  readFlowWorkflow2,
+  writeFlowWorkflow2
+} from "./packager-tool-6jpvvxyb.js";
+import"./packager-tool-1rhch6b5.js";
+import"./packager-tool-8n4bdvke.js";
 import {
-  generateRandomId
-} from "./packager-tool-qkn0c042.js";
-import"./packager-tool-pacrqxv2.js";
-import"./packager-tool-nkrmjr3a.js";
-import"./packager-tool-rs6jm14d.js";
-import"./packager-tool-hk1gxnth.js";
-import"./packager-tool-mgcz986r.js";
-import"./packager-tool-xj0agqpk.js";
-import"./packager-tool-pcvhcn2k.js";
-import"./packager-tool-sc961w0q.js";
-import"./packager-tool-t07ev0jj.js";
-import"./packager-tool-7bam8cjq.js";
-import"./packager-tool-gbgfwx8f.js";
-import"./packager-tool-6z1hsm2h.js";
-import"./packager-tool-jysvpt8p.js";
-import"./packager-tool-s7wb0s9n.js";
-import"./packager-tool-p79yh9ww.js";
-import"./packager-tool-jrnjzs5t.js";
-import"./packager-tool-z83pga0z.js";
-import"./packager-tool-6ejqwbw9.js";
-import"./packager-tool-mcaf4ewf.js";
-import"./packager-tool-eypvc2kv.js";
+  findNodeDefinition
+} from "./packager-tool-ac6rvny7.js";
 import {
-  extractErrorMessageSync,
-  logger
-} from "./packager-tool-apawc11t.js";
+  REQUEST_BUCKETS,
+  INLINE_ACTIVITY_SOURCE,
+  getInlineActivityConfiguration,
+  findOrchestratorConnectionField,
+  orchestratorConnectionKey,
+  regenerateBindingsFile,
+  isEntityNode2,
+  createEntityBindings2,
+  resolveEntityIdentity2
+} from "./packager-tool-5dgpfh5e.js";
 import {
-  catchError
-} from "./packager-tool-t7ahhaer.js";
+  isConnectorTriggerType,
+  isConnectorWaitForEventType,
+  isEventDrivenConnectorType,
+  readEssentialConfiguration,
+  scanDetailForCrossNodeBindings
+} from "./packager-tool-bbkkxbyq.js";
+import"./packager-tool-2sazb7th.js";
+import"./packager-tool-64r7e4ek.js";
+import"./packager-tool-8ba22j6n.js";
+import"./packager-tool-14rdgz3c.js";
+import"./packager-tool-jd3v0bh1.js";
+import"./packager-tool-4g87fbz6.js";
 import {
-  getFileSystem
-} from "./packager-tool-myhbp761.js";
-import"./packager-tool-4mna26cc.js";
-import"./packager-tool-c23zrhj8.js";
-import"./packager-tool-1yh8g550.js";
+  genericObjectDiscoveryCommands
+} from "./packager-tool-4zt1s51a.js";
 
 // src/services/connector-service.ts
 class InvalidDetailError extends Error {
@@ -182,8 +172,8 @@ function resolveObjectName(instanceParameters, context, config, connectorKey, de
   const displayName = cd?.displayName ?? nodeType ?? "<unknown>";
   const operation = typeof instanceParameters.operation === "string" ? instanceParameters.operation : "Create";
   throw new InvalidDetailError(`objectName is required for the generic '${displayName}' activity. Run:
-` + `  uip is resources list ${connectorKey} --operation ${operation} --connection-id ${config.connectionId}
-` + `to enumerate valid object names, then pass it as --detail.objectName (e.g. "objectName": "Account").`);
+` + genericObjectDiscoveryCommands(connectorKey, config.connectionId, operation).map((command) => `  ${command}
+`).join("") + `to find a valid object name, then pass it as --detail.objectName (e.g. "objectName": "Account").`);
 }
 function resolveTriggerObjectName(context, config, connectorKey, operation, nodeType) {
   const fromContext = getContextValue(context, "objectName");
@@ -208,19 +198,21 @@ function extractInstanceParameters(definitions, nodeType) {
     throw new Error(`Malformed configuration JSON in definition for '${nodeType}': ${err instanceof Error ? err.message : String(err)}`);
   }
 }
-function ensureConnectionBindings(workflow, connectorKey, connectionId, folderKey) {
+function ensureConnectionBindings(workflow, connectorKey, connectionId, folderKey, resourceSubType) {
   const liveConnectionKeys = collectConfiguredConnectionKeys(workflow);
   upsertConnectionResourceBinding(workflow, {
     name: `${connectorKey} connection`,
     propertyAttribute: "ConnectionId",
     resourceKey: connectionId,
-    default: connectionId
+    default: connectionId,
+    resourceSubType
   }, liveConnectionKeys);
   upsertConnectionResourceBinding(workflow, {
     name: "FolderKey",
     propertyAttribute: "FolderKey",
     resourceKey: connectionId,
-    default: folderKey
+    default: folderKey,
+    resourceSubType
   }, liveConnectionKeys);
 }
 function collectConfiguredConnectionKeys(workflow) {
@@ -228,9 +220,16 @@ function collectConfiguredConnectionKeys(workflow) {
   const collect = (nodes) => {
     for (const node of nodes ?? []) {
       const detail = node.inputs?.detail;
-      const key = detail?.connectionResourceId;
-      if (typeof key === "string" && key.length > 0)
-        keys.add(key);
+      if (isManagedHttpType(node.type ?? "") && detail?.connectionId === IMPLICIT_CONNECTION) {
+        keys.add("");
+      }
+      for (const key of [
+        detail?.connectionResourceId,
+        orchestratorConnectionKey(workflow.definitions, node)
+      ]) {
+        if (typeof key === "string" && key.length > 0)
+          keys.add(key);
+      }
     }
   };
   collect(workflow.nodes);
@@ -243,50 +242,62 @@ function collectConfiguredConnectionKeys(workflow) {
 function upsertConnectionResourceBinding(workflow, spec, liveConnectionKeys) {
   const bindings = workflow.bindings ?? [];
   const sameSlot = bindings.filter((b) => b.name === spec.name && b.resource?.toLowerCase() === "connection" && b.propertyAttribute === spec.propertyAttribute);
+  const claim = (row) => {
+    const rekeyed = row.resourceKey !== spec.resourceKey;
+    row.resource = "connection";
+    row.resourceKey = spec.resourceKey;
+    row.default = spec.default;
+    if (spec.resourceSubType !== undefined) {
+      row.resourceSubType = spec.resourceSubType;
+    } else if (rekeyed) {
+      delete row.resourceSubType;
+    }
+  };
   const exact = sameSlot.find((b) => b.resourceKey === spec.resourceKey);
   if (exact) {
-    exact.resource = "connection";
-    exact.default = spec.default;
+    claim(exact);
     return;
   }
-  const claimable = sameSlot.find((b) => !b.resourceKey) ?? sameSlot.find((b) => !liveConnectionKeys.has(b.resourceKey));
+  const isFree = (b) => !liveConnectionKeys.has(b.resourceKey ?? "");
+  const claimable = sameSlot.find((b) => !b.resourceKey && isFree(b)) ?? sameSlot.find(isFree);
   if (claimable) {
-    claimable.resource = "connection";
-    claimable.resourceKey = spec.resourceKey;
-    claimable.default = spec.default;
+    claim(claimable);
     return;
   }
   const fresh = {
-    id: `b${generateRandomId(8)}`,
+    id: `b${generateRandomId2(8)}`,
     name: spec.name,
     type: "string",
     resource: "connection",
     resourceKey: spec.resourceKey,
     default: spec.default,
-    propertyAttribute: spec.propertyAttribute
+    propertyAttribute: spec.propertyAttribute,
+    ...spec.resourceSubType !== undefined && {
+      resourceSubType: spec.resourceSubType
+    }
   };
-  addBinding(workflow, fresh);
+  addBinding2(workflow, fresh);
 }
 function addManualModeImplicitBindings(workflow, connectorKey) {
   const connBinding = {
-    id: `b${generateRandomId(8)}`,
+    id: `b${generateRandomId2(8)}`,
     name: `${connectorKey} connection`,
     type: "string",
     resource: "connection",
     resourceKey: "",
-    default: "ImplicitConnection",
+    default: IMPLICIT_CONNECTION,
     propertyAttribute: "ConnectionId"
   };
   const folderBinding = {
-    id: `b${generateRandomId(8)}`,
+    id: `b${generateRandomId2(8)}`,
     name: "FolderKey",
     type: "string",
     resource: "connection",
     resourceKey: "",
     propertyAttribute: "FolderKey"
   };
-  addBinding(workflow, connBinding);
-  addBinding(workflow, folderBinding);
+  addBinding2(workflow, connBinding);
+  addBinding2(workflow, folderBinding);
 }
 function solutionDirOf(fs, flowFilePath) {
   const projectDir = fs.path.dirname(fs.path.resolve(flowFilePath));
@@ -358,24 +369,10 @@ function applyResolvedFolderKeys(detail, resolved) {
   }
 }
 function upsertSolutionResourceBinding(workflow, spec) {
-  const bindings = workflow.bindings ?? [];
-  const existing = bindings.find((b) => b.resource === spec.resource && b.resourceKey === spec.resourceKey && b.propertyAttribute === spec.propertyAttribute);
-  if (existing) {
-    existing.name = spec.name;
-    existing.default = spec.default;
-    return existing;
-  }
-  const fresh = {
-    id: `b${generateRandomId(8)}`,
-    name: spec.name,
-    type: "string",
-    resource: spec.resource,
-    resourceKey: spec.resourceKey,
-    ...spec.default ? { default: spec.default } : {},
-    propertyAttribute: spec.propertyAttribute
-  };
-  addBinding(workflow, fresh);
-  return fresh;
+  const { binding, created } = upsertResourceBinding(workflow.bindings ?? [], spec, () => `b${generateRandomId2(8)}`);
+  if (created)
+    addBinding2(workflow, binding);
+  return binding;
 }
 function promoteResourceBindings(workflow, detail, storedBindings, resolved) {
   for (const plan of planResourceBindings(storedBindings, resolved)) {
@@ -399,13 +396,12 @@ function persistActivityBindings(workflow, detail, bindings, resolved) {
     detail.bindings = stored;
   promoteResourceBindings(workflow, detail, stored, resolved);
 }
-async function createConnectionResourceFile(fs, flowFilePath, connectionId, connectorKey) {
+async function createConnectionResourceFile(fs, flowFilePath, connectionId, connectorKey, connInfo) {
   const solutionDir = solutionDirOf(fs, flowFilePath);
-  const [fetchErr, connInfo] = await catchError(fetchConnectionInfo(connectionId));
-  const connectionName = fetchErr ? connectionId : connInfo.name;
-  const connectorName = fetchErr ? connectorKey : connInfo.connectorName;
-  const connectorVersion = fetchErr ? null : connInfo.connectorVersion;
-  const pollingInterval = fetchErr ? null : connInfo.pollingInterval;
+  const connectionName = connInfo?.name ?? connectionId;
+  const connectorName = connInfo?.connectorName ?? connectorKey;
+  const connectorVersion = connInfo?.connectorVersion ?? null;
+  const pollingInterval = connInfo?.pollingInterval ?? null;
   const resourceDir = fs.path.join(solutionDir, "resources", "solution_folder", "connection", connectorKey);
   const resourcePath = fs.path.join(resourceDir, `${connectionName}.json`);
   if (await fs.exists(resourcePath)) {
@@ -414,7 +410,7 @@ async function createConnectionResourceFile(fs, flowFilePath, connectionId, conn
   if (await hasConnectionResourceWithKey(fs, resourceDir, connectionId)) {
     return;
   }
-  await fs.mkdir(resourceDir, { recursive: true });
+  await fs.mkdir(resourceDir);
   const resourceFile = {
     docVersion: "1.0.0",
     resource: {
@@ -449,10 +445,10 @@ async function hasConnectionResourceWithKey(fs, resourceDir, connectionId) {
   for (const file of await fs.readdir(resourceDir)) {
     if (!file.endsWith(".json"))
       continue;
-    const [readErr, raw] = await catchError(fs.readFile(fs.path.join(resourceDir, file), "utf-8"));
+    const [readErr, raw] = await catchError2(fs.readFile(fs.path.join(resourceDir, file), "utf-8"));
     if (readErr || !raw)
       continue;
-    const [parseErr, parsed] = catchError(() => JSON.parse(raw));
+    const [parseErr, parsed] = catchError2(() => JSON.parse(raw));
     if (!parseErr && parsed?.resource?.key === connectionId) {
       return true;
     }
@@ -603,63 +599,8 @@ function validateConnectorTriggerDetail(config) {
 function isManagedHttpType(nodeType) {
   return nodeType === "core.action.http.v2";
 }
-var VALID_HTTP_METHODS = new Set([
-  "GET",
-  "POST",
-  "PUT",
-  "PATCH",
-  "DELETE",
-  "OPTIONS",
-  "HEAD"
-]);
-var VALID_MANAGED_HTTP_KEYS = new Set([
-  "authentication",
-  "method",
-  "url",
-  "connectionId",
-  "folderKey",
-  "targetConnector",
-  "headers",
-  "query",
-  "body"
-]);
 function validateManagedHttpDetail(config) {
-  const errors = [];
-  const auth = config.authentication;
-  if (auth !== "connector" && auth !== "manual") {
-    errors.push('authentication is required ("connector" or "manual")');
-  }
-  if (typeof config.method !== "string" || !VALID_HTTP_METHODS.has(config.method)) {
-    errors.push(`method must be one of: ${[...VALID_HTTP_METHODS].join(", ")}`);
-  }
-  if (auth === "connector") {
-    if (typeof config.connectionId !== "string" || !config.connectionId) {
-      errors.push("connectionId is required for connector mode");
-    }
-    if (typeof config.folderKey !== "string" || !config.folderKey) {
-      errors.push("folderKey is required for connector mode");
-    }
-    if (typeof config.targetConnector !== "string" || !config.targetConnector) {
-      errors.push("targetConnector is required for connector mode");
-    }
-    if (config.url !== undefined && typeof config.url !== "string") {
-      errors.push("url must be a string");
-    }
-  } else if (auth === "manual") {
-    if (typeof config.url !== "string" || !config.url) {
-      errors.push("url is required for manual mode");
-    }
-  }
-  for (const key of ["headers", "query"]) {
-    const val = config[key];
-    if (val !== undefined && (typeof val !== "object" || val === null || Array.isArray(val))) {
-      errors.push(`${key} must be a JSON object`);
-    }
-  }
-  const unknownKeys = Object.keys(config).filter((k) => !VALID_MANAGED_HTTP_KEYS.has(k));
-  if (unknownKeys.length > 0) {
-    errors.push(`Unknown keys: ${unknownKeys.join(", ")}. Valid keys: ${[...VALID_MANAGED_HTTP_KEYS].join(", ")}`);
-  }
+  const errors = managedHttpDetailErrors(config);
   if (errors.length > 0) {
     throw new InvalidDetailError(`Invalid --detail:
   - ${errors.join(`
@@ -671,52 +612,62 @@ function configureManagedHttp(workflow, node, config) {
   const definitions = workflow.definitions ?? [];
   const context = getModelContext(node, definitions);
   const activityTypeId = extractActivityTypeId(context) ?? extractActivityTypeIdFromDefinition(definitions, node.type ?? "");
-  const bodyParameters = {
-    authentication: config.authentication,
-    method: config.method
-  };
-  if (config.authentication === "connector") {
-    bodyParameters.targetConnector = config.targetConnector;
-    bodyParameters.connection = config.connectionId;
-    if (config.url !== undefined) {
-      bodyParameters.path = config.url;
-      bodyParameters.url = config.url;
-    }
-  } else {
-    bodyParameters.url = config.url;
-  }
-  if (config.headers !== undefined)
-    bodyParameters.headers = config.headers;
-  if (config.query !== undefined)
-    bodyParameters.query = config.query;
-  if (config.body !== undefined)
-    bodyParameters.body = config.body;
+  const bodyParameters = buildManagedHttpBodyParameters(config);
   const detail = {
-    connector: MANAGED_HTTP_CONNECTOR_KEY,
-    connectionId: config.authentication === "connector" ? config.connectionId : "ImplicitConnection",
+    connector: MANAGED_HTTP_CONNECTOR_KEY2,
+    connectionId: config.authentication === "connector" ? config.connectionId : IMPLICIT_CONNECTION,
     connectionResourceId: config.authentication === "connector" ? config.connectionId : null,
     connectionFolderKey: config.authentication === "connector" ? config.folderKey : null,
     method: "POST",
-    endpoint: "/http-request",
+    endpoint: MANAGED_HTTP_ENDPOINT,
     bodyParameters,
-    configuration: `=jsonString:${JSON.stringify(buildManagedHttpEssentialConfiguration())}`,
+    configuration: guardJsonString(JSON.stringify(buildManagedHttpEssentialConfiguration2())),
     ...activityTypeId ? { uiPathActivityTypeId: activityTypeId } : {},
     errorState: { issues: [] },
-    telemetryData: {
-      connectorKey: MANAGED_HTTP_CONNECTOR_KEY,
-      connectorName: "HTTP",
-      operationType: "create",
-      objectName: "http-request",
-      objectDisplayName: "HTTP Request",
-      primaryKeyName: ""
-    }
+    telemetryData: { ...MANAGED_HTTP_TELEMETRY }
   };
   node.inputs = { ...node.inputs ?? {}, detail };
   if (config.authentication === "connector") {
-    ensureConnectionBindings(workflow, MANAGED_HTTP_CONNECTOR_KEY, config.connectionId, config.folderKey);
+    ensureConnectionBindings(workflow, MANAGED_HTTP_CONNECTOR_KEY2, config.connectionId, config.folderKey);
   } else {
-    addManualModeImplicitBindings(workflow, MANAGED_HTTP_CONNECTOR_KEY);
+    addManualModeImplicitBindings(workflow, MANAGED_HTTP_CONNECTOR_KEY2);
+  }
+}
+var VALID_ORCHESTRATOR_CONNECTION_KEYS = new Set([
+  "connectionId",
+  "folderKey"
+]);
+async function configureOrchestratorConnection(workflow, node, field, rawDetail) {
+  const errors = [];
+  const { connectionId, folderKey } = rawDetail;
+  if (typeof connectionId !== "string" || !connectionId) {
+    errors.push("connectionId is required");
   }
+  if (folderKey !== undefined && (typeof folderKey !== "string" || !folderKey)) {
+    errors.push("folderKey must be a non-empty string");
+  }
+  const unknownKeys = Object.keys(rawDetail).filter((k) => !VALID_ORCHESTRATOR_CONNECTION_KEYS.has(k));
+  if (unknownKeys.length > 0) {
+    errors.push(`Unknown keys: ${unknownKeys.join(", ")}. Valid keys: ${[...VALID_ORCHESTRATOR_CONNECTION_KEYS].join(", ")}`);
+  }
+  if (errors.length > 0) {
+    throw new InvalidDetailError(`Invalid --detail:
+  - ${errors.join(`
+  - `)}`);
+  }
+  const id = connectionId;
+  const [fetchErr, info] = await catchError2(fetchConnectionInfo2(id));
+  if (!fetchErr && info.connectorKey && info.connectorKey !== field.connectorKey) {
+    throw new InvalidDetailError(`Connection '${id}' belongs to connector '${info.connectorKey}'. Node '${node.id}' needs a '${field.connectorKey}' connection.`);
+  }
+  const folder = folderKey ?? info?.folderKey;
+  if (!folder) {
+    const reason = fetchErr ? `: ${extractErrorMessageSync(fetchErr)}` : "";
+    throw new InvalidDetailError(`Could not read the folder of connection '${id}'${reason}. Pass folderKey in --detail.`);
+  }
+  node.inputs = { ...node.inputs, connectionId: id };
+  ensureConnectionBindings(workflow, field.bindingConnectorKey, id, folder, field.connectorKey);
+  return { connectionId: id, connection: fetchErr ? undefined : info };
 }
 function hasFileResponseField(metadata, method) {
   const fieldsObj = metadata?.fields ?? {};
@@ -960,16 +911,26 @@ function substituteDetailFilter(tree) {
     throw error;
   }
 }
-async function configureActivity(workflow, node, config, solutionDir) {
+async function fetchConnectionIfReachable(connectionId) {
+  if (!connectionId)
+    return;
+  const [error, info] = await catchError2(fetchConnectionInfo2(connectionId));
+  return error ? undefined : info;
+}
+async function configureActivity(workflow, node, config, solutionDir, connection) {
+  const warnings = [];
   const definitions = workflow.definitions ?? [];
   const context = getModelContext(node, definitions);
   const connectorKey = getContextValue(context, "connectorKey") ?? "";
+  if (connection) {
+    assertConnectionConnector2(config.connectionId, connection, connectorKey, `"${node.type ?? ""}"`);
+  }
   const activityTypeId = extractActivityTypeId(context) ?? extractActivityTypeIdFromDefinition(definitions, node.type ?? "");
   const instanceParameters = extractInstanceParameters(definitions, node.type ?? "");
   if (!instanceParameters) {
     throw new Error(`No instanceParameters found in definition for "${node.type}" — cannot build configuration`);
   }
-  const isV4Activity = isV4ActivityConfiguration(instanceParameters);
+  const isV4Activity = isV4ActivityConfiguration2(instanceParameters);
   const inline = getInlineActivityConfiguration(node);
   let objectName;
   if (isV4Activity) {
@@ -987,7 +948,7 @@ async function configureActivity(workflow, node, config, solutionDir) {
     connectionFolderKey: config.folderKey,
     ...isV4Activity && {
       activityContext: {
-        version: ACTIVITY_VERSION_V4,
+        version: ACTIVITY_VERSION_V42,
         ...inline && { source: INLINE_ACTIVITY_SOURCE },
         scriptRef: inline?.scriptRef ?? objectName
       }
@@ -1012,13 +973,29 @@ async function configureActivity(workflow, node, config, solutionDir) {
   if (isGeneric && typeof instanceParameters.operation === "string") {
     resolvedInstanceParameters.operation = instanceParameters.operation.toLowerCase();
   }
-  const [metaError, metadata] = inline ? [null, inline.metadata] : await catchError(isV4Activity ? fetchConnectorActivityMetadataV4(connectorKey, objectName) : fetchConnectorMetadata(connectorKey, objectName, config.connectionId));
+  const [metaError, metadata] = inline ? [null, inline.metadata] : await catchError2(isV4Activity ? fetchConnectorActivityMetadataV42(connectorKey, objectName) : fetchConnectorMetadata2(connectorKey, objectName, config.connectionId));
   if (metaError) {
     throw new Error(`Failed to fetch IS metadata for ${connectorKey}/${objectName}: ${extractErrorMessageSync(metaError)}`);
   }
+  const external = externalExecutionOf(metadata);
+  if (external) {
+    detail.executionType = external.executionType;
+    if (external.eventMode)
+      detail.eventMode = external.eventMode;
+    if (external.eventType)
+      detail.eventType = external.eventType;
+    const warning = externalExecutionWarning(external, `${connectorKey}/${objectName}`);
+    if (warning)
+      warnings.push(warning);
+  }
   const methodMap = metadata?.metadata?.method ?? {};
-  const methodInfo = methodMap[config.method] ?? Object.values(methodMap).find((m) => m.method === config.method);
+  const manifestMethod = instanceParameters.httpMethod;
+  const metadataMethodKey = typeof manifestMethod === "string" && manifestMethod in methodMap ? manifestMethod : (config.method in methodMap) ? config.method : Object.keys(methodMap).find((key) => methodMap[key]?.method === config.method) ?? config.method;
+  const methodInfo = methodMap[metadataMethodKey];
   if (methodInfo) {
+    if (typeof methodInfo.method === "string" && methodInfo.method) {
+      detail.method = normalizeHttpMethod(methodInfo.method);
+    }
     let filterInputName = null;
     let filterVariables = {};
     if (isV4Activity) {
@@ -1028,7 +1005,7 @@ async function configureActivity(workflow, node, config, solutionDir) {
       if (config.customFieldsRequestDetails) {
         throw new InvalidDetailError(`customFieldsRequestDetails is not supported for the 4.0.0 activity "${node.type}" — design-time ObjectActions are v3-only. Drop it from --detail.`);
       }
-      detail.configuration = `=jsonString:${JSON.stringify(buildActivityEssentialConfiguration(resolvedInstanceParameters, methodInfo))}`;
+      detail.configuration = guardJsonString(JSON.stringify(buildActivityEssentialConfiguration2(resolvedInstanceParameters, methodInfo)));
     } else {
       const filterBuilderParam = (methodInfo.parameters ?? []).find((p) => p.design?.component === "FilterBuilder");
       let rawJsFilterParamName = null;
@@ -1072,7 +1049,7 @@ async function configureActivity(workflow, node, config, solutionDir) {
         solutionDir
       });
       applyResolvedFolderKeys(detail, resolvedResources);
-      assertActivityMetadataResolved(activityClient.getEssentialConfiguration().essentialConfiguration, config.connectionId);
+      assertActivityMetadataResolved2(activityClient.getEssentialConfiguration().essentialConfiguration, config.connectionId);
       if (filterInputName && authoredFilterTree) {
         const compiledFilter = activityClient.getCompiledFilter(filterInputName);
         assertCompiledFilterResolvable(compiledFilter, filterInputName, authoredFilterTree);
@@ -1082,15 +1059,15 @@ async function configureActivity(workflow, node, config, solutionDir) {
         };
         if (Object.keys(filterVariables).length > 0) {
           detail.filterVariables = filterVariables;
-          await applySavedFilterTree(activityClient, filterInputName, authoredFilterTree);
+          await applySavedFilterTree2(activityClient, filterInputName, authoredFilterTree);
         }
       }
       const { essentialConfiguration } = activityClient.getEssentialConfiguration();
-      detail.configuration = `=jsonString:${JSON.stringify({ essentialConfiguration })}`;
+      detail.configuration = guardJsonString(JSON.stringify({ essentialConfiguration }));
       persistActivityBindings(workflow, detail, activityClient.getBindings(), resolvedResources);
     }
     if ((node.type ?? "").startsWith("uipath.agent.resource.tool.connector.")) {
-      const { bodyParameters, queryParameters, pathParameters } = buildAgentToolParamsFromMetadata(metadata, config.method);
+      const { bodyParameters, queryParameters, pathParameters } = buildAgentToolParamsFromMetadata(metadata, metadataMethodKey);
       if (!detail.bodyParameters && Object.keys(bodyParameters).length > 0)
         detail.bodyParameters = bodyParameters;
       if (!detail.queryParameters && Object.keys(queryParameters).length > 0)
@@ -1099,8 +1076,8 @@ async function configureActivity(workflow, node, config, solutionDir) {
         detail.pathParameters = pathParameters;
     }
     const params = methodInfo.parameters ?? [];
-    const rawMultipartParams = extractMultipartParameters(params);
-    const { multipartParams, bodyParameters: cleanedBodyParameters } = inlineMultipartFileValues(rawMultipartParams, detail.bodyParameters);
+    const rawMultipartParams = extractMultipartParameters2(params);
+    const { multipartParams, bodyParameters: cleanedBodyParameters } = inlineMultipartFileValues2(rawMultipartParams, detail.bodyParameters);
     if (multipartParams.length > 0) {
       detail.multipartParameters = multipartParams;
     }
@@ -1109,12 +1086,12 @@ async function configureActivity(workflow, node, config, solutionDir) {
     } else {
       delete detail.bodyParameters;
     }
-    const inputMeta = buildInputMetadata(multipartParams, methodInfo.operation, methodInfo.pagination?.maxPageSize, filterInputName && Object.keys(filterVariables).length > 0 ? [filterInputName] : undefined);
+    const inputMeta = buildInputMetadata2(multipartParams, methodInfo.operation, methodInfo.pagination?.maxPageSize, filterInputName && Object.keys(filterVariables).length > 0 ? [filterInputName] : undefined);
     if (inputMeta) {
       detail.inputMetadata = inputMeta;
     }
-    patchOutputType(definitions, node, hasFileResponseField(metadata, config.method) ? "file" : isListOperation(methodInfo.operation) ? "array" : "object");
-    patchRequiredInputs(workflow, definitions, node, metadata, config.method, {
+    patchOutputType(definitions, node, hasFileResponseField(metadata, metadataMethodKey) ? "file" : isListOperation(methodInfo.operation) ? "array" : "object");
+    patchRequiredInputs(workflow, definitions, node, metadata, metadataMethodKey, {
       objectName,
       path: methodInfo.path,
       operation: methodInfo.operation
@@ -1124,11 +1101,15 @@ async function configureActivity(workflow, node, config, solutionDir) {
   }
   node.inputs = { ...node.inputs ?? {}, detail };
   ensureConnectionBindings(workflow, connectorKey, config.connectionId, config.folderKey);
+  return warnings;
 }
-async function configureTrigger(workflow, node, config, solutionDir) {
+async function configureTrigger(workflow, node, config, solutionDir, connection) {
   const definitions = workflow.definitions ?? [];
   const context = getModelContext(node, definitions);
   const connectorKey = getContextValue(context, "connectorKey") ?? "";
+  if (connection) {
+    assertConnectionConnector2(config.connectionId, connection, connectorKey, `"${node.type ?? ""}"`);
+  }
   const operation = getContextValue(context, "operation") ?? "";
   const objectName = resolveTriggerObjectName(context, config, connectorKey, operation, node.type ?? "");
   const activityTypeId = extractActivityTypeIdFromDefinition(definitions, node.type ?? "");
@@ -1175,16 +1156,16 @@ async function configureTrigger(workflow, node, config, solutionDir) {
     solutionDir
   });
   applyResolvedFolderKeys(detail, resolvedResources);
-  assertActivityMetadataResolved(triggerClient.getEssentialConfiguration().essentialConfiguration, config.connectionId);
+  assertActivityMetadataResolved2(triggerClient.getEssentialConfiguration().essentialConfiguration, config.connectionId);
   const compiledTriggerFilter = triggerClient.getCompiledFilter("filter");
   assertCompiledFilterResolvable(compiledTriggerFilter, "filter", filterTree);
   detail.filterExpression = compiledTriggerFilter;
   if (filterTree && Object.keys(filterVariables).length > 0) {
     detail.filterVariables = filterVariables;
-    await applySavedFilterTree(triggerClient, "filter", filterTree);
+    await applySavedFilterTree2(triggerClient, "filter", filterTree);
   }
   const { essentialConfiguration } = triggerClient.getEssentialConfiguration();
-  detail.configuration = `=jsonString:${JSON.stringify({ essentialConfiguration })}`;
+  detail.configuration = guardJsonString(JSON.stringify({ essentialConfiguration }));
   persistActivityBindings(workflow, detail, triggerClient.getBindings(), resolvedResources);
   if (activityTypeId)
     detail.uiPathActivityTypeId = activityTypeId;
@@ -1193,7 +1174,7 @@ async function configureTrigger(workflow, node, config, solutionDir) {
   ensureConnectionBindings(workflow, connectorKey, config.connectionId, config.folderKey);
 }
 async function configureConnectorNode(filePath, nodeId, rawDetail) {
-  const { workflow, refMap } = await readFlowWorkflow(filePath);
+  const { workflow, refMap } = await readFlowWorkflow2(filePath);
   const node = workflow.nodes.find((n) => n.id === nodeId);
   if (!node)
     throw new Error(`Node '${nodeId}' not found`);
@@ -1202,11 +1183,11 @@ async function configureConnectorNode(filePath, nodeId, rawDetail) {
   if (isManagedHttpType(nodeType)) {
     const config = validateManagedHttpDetail(rawDetail);
     configureManagedHttp(workflow, node, config);
-    await writeFlowWorkflow(filePath, workflow, refMap);
-    const fs2 = getFileSystem();
-    await regenerateBindingsFile(fs2, filePath);
+    await writeFlowWorkflow2(filePath, workflow, refMap);
+    const fs = getFileSystem();
+    await regenerateBindingsFile(fs, filePath);
     if (config.authentication === "connector") {
-      await createConnectionResourceFile(fs2, filePath, config.connectionId, config.targetConnector);
+      await createConnectionResourceFile(fs, filePath, config.connectionId, config.targetConnector, await fetchConnectionIfReachable(config.connectionId));
     }
     return {
       bindingsCreated: workflow.bindings.length,
@@ -1214,7 +1195,7 @@ async function configureConnectorNode(filePath, nodeId, rawDetail) {
       ...crossNodeBindingWarnings(node, nodeIds)
     };
   }
-  if (isEntityNode({ nodeType })) {
+  if (isEntityNode2({ nodeType })) {
     const entityName = rawDetail.entityName;
     if (typeof entityName !== "string" || entityName.trim() === "") {
       throw new InvalidDetailError(`Data Fabric node '${nodeId}' needs an entity name: --detail '{"entityName":"<Name>"}'.`);
@@ -1232,12 +1213,12 @@ async function configureConnectorNode(filePath, nodeId, rawDetail) {
     inputs.entityConfig = merged;
     node.inputs = inputs;
     const bindingsBefore = workflow.bindings?.length ?? 0;
-    await resolveEntityIdentity(filePath, node);
-    for (const entityBinding of createEntityBindings(node)) {
-      addBinding(workflow, entityBinding);
+    await resolveEntityIdentity2(filePath, node);
+    for (const entityBinding of createEntityBindings2(node)) {
+      addBinding2(workflow, entityBinding);
     }
     const bindingsCreated = (workflow.bindings?.length ?? 0) - bindingsBefore;
-    await writeFlowWorkflow(filePath, workflow, refMap);
+    await writeFlowWorkflow2(filePath, workflow, refMap);
     await regenerateBindingsFile(getFileSystem(), filePath);
     const bound = entityScopeKey(node.inputs?.entityConfig) !== "";
     const warnings = bound ? [] : [
@@ -1249,6 +1230,18 @@ async function configureConnectorNode(filePath, nodeId, rawDetail) {
       ...warnings.length > 0 ? { warnings } : {}
     };
   }
+  const orchestratorField = findOrchestratorConnectionField(workflow.definitions, node);
+  if (orchestratorField) {
+    const { connectionId, connection } = await configureOrchestratorConnection(workflow, node, orchestratorField, rawDetail);
+    await writeFlowWorkflow2(filePath, workflow, refMap);
+    const fs = getFileSystem();
+    await regenerateBindingsFile(fs, filePath);
+    await createConnectionResourceFile(fs, filePath, connectionId, orchestratorField.connectorKey, connection);
+    return {
+      bindingsCreated: workflow.bindings.length,
+      detailPopulated: true
+    };
+  }
   if (!nodeType.startsWith("uipath.connector") && !nodeType.startsWith("uipath.agent.resource.tool.connector.")) {
     throw new Error(`Node '${nodeId}' is not a connector type node, no operation done.`);
   }
@@ -1257,26 +1250,32 @@ async function configureConnectorNode(filePath, nodeId, rawDetail) {
   const pickerRows = nodePickerRows(workflow, node);
   const previousPickerRows = pickerRows.map((binding) => binding.id);
   const detailInput = restorePickerLiterals(pickerRows, rawDetail);
+  const connectionId = rawDetail.connectionId;
+  const connection = await fetchConnectionIfReachable(connectionId);
+  let configureWarnings = [];
   if (isEventDrivenConnectorType(nodeType)) {
     const config = validateConnectorTriggerDetail(detailInput);
-    await configureTrigger(workflow, node, config, solutionDir);
+    await configureTrigger(workflow, node, config, solutionDir, connection);
   } else {
     const config = validateConnectorDetail(detailInput);
-    await configureActivity(workflow, node, config, solutionDir);
+    configureWarnings = await configureActivity(workflow, node, config, solutionDir, connection);
   }
   dropReleasedPickerRows(workflow, previousPickerRows);
-  await writeFlowWorkflow(filePath, workflow, refMap);
+  await writeFlowWorkflow2(filePath, workflow, refMap);
   await regenerateBindingsFile(fs, filePath);
-  const connectionId = rawDetail.connectionId;
   const defs = workflow.definitions ?? [];
   const connectorKey = getContextValue(getModelContext(node, defs), "connectorKey");
   if (connectionId && connectorKey) {
-    await createConnectionResourceFile(fs, filePath, connectionId, connectorKey);
+    await createConnectionResourceFile(fs, filePath, connectionId, connectorKey, connection);
   }
+  const warnings = [
+    ...configureWarnings,
+    ...(isEventDrivenConnectorType(nodeType) ? undefined : crossNodeBindingWarnings(node, nodeIds).warnings) ?? []
+  ];
   return {
     bindingsCreated: workflow.bindings.length,
     detailPopulated: true,
-    ...isEventDrivenConnectorType(nodeType) ? {} : crossNodeBindingWarnings(node, nodeIds)
+    ...warnings.length > 0 ? { warnings } : {}
   };
 }
 function crossNodeBindingWarnings(node, nodeIds) {
@@ -1288,11 +1287,7 @@ function crossNodeBindingWarnings(node, nodeIds) {
 }
 export {
   InvalidDetailError,
-  buildAgentToolParamsFromMetadata,
-  configureConnectorNode,
-  validateConnectorDetail,
-  validateConnectorTriggerDetail,
-  validateManagedHttpDetail
+  configureConnectorNode
 };
 
-//# debugId=D8F02FE5A99E3D7164756E2164756E21
+//# debugId=AC17D6779AD7944264756E2164756E21