@uipath/flow-tool 1.201.0 → 1.202.0-preview.136

package/dist/connector-service-d9ph9kx1.js

@@ -0,0 +1,948 @@
+import {
+  isConnectorTriggerType,
+  isConnectorWaitForEventType,
+  isEventDrivenConnectorType,
+  scanDetailForCrossNodeBindings
+} from "./packager-tool-2wefykg9.js";
+import {
+  regenerateBindingsFile
+} from "./packager-tool-v86fdwvs.js";
+import"./packager-tool-jc34wvrw.js";
+import"./packager-tool-4hx14snw.js";
+import"./packager-tool-cdwpc9fh.js";
+import"./packager-tool-g9y14b10.js";
+import"./packager-tool-5z1eg3ea.js";
+import"./packager-tool-v9rrz038.js";
+import"./packager-tool-fjaa8d3v.js";
+import {
+  ACTIVITY_VERSION_V4,
+  FilterNotSupportedError,
+  MANAGED_HTTP_CONNECTOR_KEY,
+  applySavedFilterTree,
+  assertActivityMetadataResolved,
+  buildActivityEssentialConfiguration,
+  buildInputMetadata,
+  buildManagedHttpEssentialConfiguration,
+  createConfiguredActivityClient,
+  extractMultipartParameters,
+  fetchConnectionInfo,
+  fetchConnectorActivityMetadataV4,
+  fetchConnectorMetadata,
+  inlineMultipartFileValues,
+  isListOperation,
+  isV4ActivityConfiguration,
+  normalizeHttpMethod,
+  substituteFilterVariables
+} from "./packager-tool-v9psxdy5.js";
+import"./packager-tool-ywqc9rtf.js";
+import"./packager-tool-f0kd5kq4.js";
+import"./packager-tool-0gctz400.js";
+import"./packager-tool-qa9gftnj.js";
+import"./packager-tool-yc4kw997.js";
+import"./packager-tool-7exrv6w7.js";
+import {
+  readFlowWorkflow,
+  writeFlowWorkflow
+} from "./packager-tool-94w17vf8.js";
+import"./packager-tool-6m078z5s.js";
+import {
+  addBinding
+} from "./packager-tool-tn5e7wnb.js";
+import"./packager-tool-xhzfwa5p.js";
+import"./packager-tool-nkrmjr3a.js";
+import"./packager-tool-rs6jm14d.js";
+import"./packager-tool-hk1gxnth.js";
+import"./packager-tool-em5r6g6j.js";
+import"./packager-tool-9bec251q.js";
+import"./packager-tool-z9bfhmm5.js";
+import"./packager-tool-6ejqwbw9.js";
+import"./packager-tool-mcaf4ewf.js";
+import"./packager-tool-eypvc2kv.js";
+import {
+  catchError,
+  extractErrorMessageSync
+} from "./packager-tool-5qaxht3k.js";
+import {
+  getFileSystem
+} from "./packager-tool-0v3s8r01.js";
+import"./packager-tool-p9stswjj.js";
+import"./packager-tool-vpqyvh4c.js";
+import"./packager-tool-gbgfwx8f.js";
+import"./packager-tool-58q3tvh7.js";
+import"./packager-tool-sc961w0q.js";
+import {
+  generateRandomId
+} from "./packager-tool-m5qfverj.js";
+import"./packager-tool-e0p2zsyc.js";
+import"./packager-tool-a42jnpy5.js";
+import"./packager-tool-c23zrhj8.js";
+import"./packager-tool-1yh8g550.js";
+
+// src/services/connector-service.ts
+class InvalidDetailError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "InvalidDetailError";
+  }
+}
+function getModelContext(node, definitions) {
+  const nodeContext = node.model?.context;
+  if (nodeContext)
+    return nodeContext;
+  if (definitions) {
+    const def = definitions.find((d) => d.nodeType === node.type);
+    const defModel = def?.model;
+    return defModel?.context ?? [];
+  }
+  return [];
+}
+function getContextValue(context, name) {
+  return context.find((c) => c.name === name)?.value;
+}
+function extractActivityTypeId(context) {
+  const metadata = context.find((c) => c.name === "metadata");
+  const body = metadata?.body;
+  const dtm = body?.designTimeMetadata;
+  const ac = dtm?.activityConfig;
+  const raw = ac?.raw;
+  const activity = raw?.activity;
+  return activity?.uiPathActivityTypeId;
+}
+function findConnectorDetail(definitions, nodeType) {
+  const def = definitions.find((d) => d.nodeType === nodeType);
+  if (!def)
+    return;
+  const form = def.form;
+  const sections = form?.sections;
+  if (!sections)
+    return;
+  for (const section of sections) {
+    const fields = section.fields;
+    if (!fields)
+      continue;
+    for (const field of fields) {
+      const componentProps = field.componentProps;
+      const connectorDetail = componentProps?.connectorDetail;
+      if (connectorDetail)
+        return connectorDetail;
+    }
+  }
+  return;
+}
+function extractActivityTypeIdFromDefinition(definitions, nodeType) {
+  const cd = findConnectorDetail(definitions, nodeType);
+  return cd?.uiPathActivityTypeId;
+}
+function resolveObjectName(instanceParameters, context, config, connectorKey, definitions, nodeType) {
+  const isGeneric = instanceParameters.activityType === "Generic";
+  if (!isGeneric) {
+    const fromContext = getContextValue(context, "objectName");
+    if (typeof fromContext === "string" && fromContext) {
+      return fromContext;
+    }
+    if (typeof config.objectName === "string" && config.objectName) {
+      return config.objectName;
+    }
+    throw new InvalidDetailError(`objectName is missing from the manifest for "${nodeType}" and was not provided in --detail. ` + "Pass --detail.objectName explicitly, or check that the connector manifest includes an objectName context entry.");
+  }
+  if (typeof config.objectName === "string" && config.objectName) {
+    return config.objectName;
+  }
+  const cd = findConnectorDetail(definitions, nodeType);
+  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").`);
+}
+function resolveTriggerObjectName(context, config, connectorKey, operation, nodeType) {
+  const fromContext = getContextValue(context, "objectName");
+  if (typeof fromContext === "string" && fromContext) {
+    return fromContext;
+  }
+  if (typeof config.objectName === "string" && config.objectName) {
+    return config.objectName;
+  }
+  throw new InvalidDetailError(`objectName is required for the trigger "${nodeType}" — its manifest does not carry one (generic triggers are shared across every object the connector exposes). Run:
+` + `  uip is triggers objects ${connectorKey} ${operation} --connection-id ${config.connectionId}
+` + `to enumerate valid object names, then pass it as --detail.objectName (e.g. "objectName": "MyEntity").`);
+}
+function extractInstanceParameters(definitions, nodeType) {
+  const cd = findConnectorDetail(definitions, nodeType);
+  const configStr = cd?.configuration;
+  if (!configStr)
+    return;
+  try {
+    return JSON.parse(configStr);
+  } catch (err) {
+    throw new Error(`Malformed configuration JSON in definition for '${nodeType}': ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+function ensureConnectionBindings(workflow, connectorKey, connectionId, folderKey) {
+  const liveConnectionKeys = collectConfiguredConnectionKeys(workflow);
+  upsertConnectionResourceBinding(workflow, {
+    name: `${connectorKey} connection`,
+    propertyAttribute: "ConnectionId",
+    resourceKey: connectionId,
+    default: connectionId
+  }, liveConnectionKeys);
+  upsertConnectionResourceBinding(workflow, {
+    name: "FolderKey",
+    propertyAttribute: "FolderKey",
+    resourceKey: connectionId,
+    default: folderKey
+  }, liveConnectionKeys);
+}
+function collectConfiguredConnectionKeys(workflow) {
+  const keys = new Set;
+  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);
+    }
+  };
+  collect(workflow.nodes);
+  const subflows = workflow.subflows;
+  for (const entry of Object.values(subflows ?? {})) {
+    collect(entry?.nodes);
+  }
+  return keys;
+}
+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 exact = sameSlot.find((b) => b.resourceKey === spec.resourceKey);
+  if (exact) {
+    exact.resource = "connection";
+    exact.default = spec.default;
+    return;
+  }
+  const claimable = sameSlot.find((b) => !b.resourceKey) ?? sameSlot.find((b) => !liveConnectionKeys.has(b.resourceKey));
+  if (claimable) {
+    claimable.resource = "connection";
+    claimable.resourceKey = spec.resourceKey;
+    claimable.default = spec.default;
+    return;
+  }
+  const fresh = {
+    id: `b${generateRandomId(8)}`,
+    name: spec.name,
+    type: "string",
+    resource: "connection",
+    resourceKey: spec.resourceKey,
+    default: spec.default,
+    propertyAttribute: spec.propertyAttribute
+  };
+  addBinding(workflow, fresh);
+}
+function addManualModeImplicitBindings(workflow, connectorKey) {
+  const connBinding = {
+    id: `b${generateRandomId(8)}`,
+    name: `${connectorKey} connection`,
+    type: "string",
+    resource: "connection",
+    resourceKey: "",
+    default: "ImplicitConnection",
+    propertyAttribute: "ConnectionId"
+  };
+  const folderBinding = {
+    id: `b${generateRandomId(8)}`,
+    name: "FolderKey",
+    type: "string",
+    resource: "connection",
+    resourceKey: "",
+    propertyAttribute: "FolderKey"
+  };
+  addBinding(workflow, connBinding);
+  addBinding(workflow, folderBinding);
+}
+async function createConnectionResourceFile(fs, flowFilePath, connectionId, connectorKey) {
+  const projectDir = fs.path.dirname(fs.path.resolve(flowFilePath));
+  const solutionDir = fs.path.resolve(projectDir, "..");
+  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 resourceDir = fs.path.join(solutionDir, "resources", "solution_folder", "connection", connectorKey);
+  const resourcePath = fs.path.join(resourceDir, `${connectionName}.json`);
+  if (await fs.exists(resourcePath)) {
+    return;
+  }
+  await fs.mkdir(resourceDir, { recursive: true });
+  const resourceFile = {
+    docVersion: "1.0.0",
+    resource: {
+      name: connectionName,
+      kind: "connection",
+      type: connectorKey,
+      apiVersion: "integrationservice.uipath.com/v1",
+      isOverridable: true,
+      dependencies: [],
+      runtimeDependencies: [],
+      files: [],
+      folders: [{ fullyQualifiedName: "solution_folder" }],
+      spec: {
+        connectorName,
+        name: connectionName,
+        description: null,
+        authenticationType: "AuthenticateAfterDeployment",
+        ...connectorVersion ? { connectorVersion } : {},
+        connectorKey,
+        ...pollingInterval != null ? { pollingInterval } : {}
+      },
+      locks: [],
+      key: connectionId
+    }
+  };
+  await fs.writeFile(resourcePath, JSON.stringify(resourceFile, null, 2));
+}
+var VALID_DETAIL_KEYS = new Set([
+  "connectionId",
+  "folderKey",
+  "method",
+  "endpoint",
+  "objectName",
+  "bodyParameters",
+  "queryParameters",
+  "pathParameters",
+  "filter",
+  "customFieldsRequestDetails"
+]);
+var VALID_CUSTOM_FIELDS_KEYS = new Set([
+  "objectActionName",
+  "parameterValues"
+]);
+function validateJsonObjectKeys(config, keys, errors) {
+  for (const key of keys) {
+    const val = config[key];
+    if (val !== undefined && (typeof val !== "object" || val === null || Array.isArray(val))) {
+      errors.push(`${key} must be a JSON object`);
+    }
+  }
+}
+function validateCustomFieldsRequestDetails(value, errors) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    errors.push("customFieldsRequestDetails must be a JSON object with `objectActionName` (string) and `parameterValues` (array of [key, value] tuples)");
+    return;
+  }
+  const cfrd = value;
+  const unknownKeys = Object.keys(cfrd).filter((k) => !VALID_CUSTOM_FIELDS_KEYS.has(k));
+  if (unknownKeys.length > 0) {
+    errors.push(`customFieldsRequestDetails has unknown keys: ${unknownKeys.join(", ")}. Valid keys: ${[...VALID_CUSTOM_FIELDS_KEYS].join(", ")}. ` + "Note: keys are camelCase (Studio Web convention), not PascalCase.");
+  }
+  if (typeof cfrd.objectActionName !== "string" || cfrd.objectActionName === "") {
+    errors.push("customFieldsRequestDetails.objectActionName must be a non-empty string");
+  }
+  if (cfrd.parameterValues === undefined) {
+    errors.push("customFieldsRequestDetails.parameterValues is required (array of [key, value] tuples)");
+  } else if (!Array.isArray(cfrd.parameterValues)) {
+    errors.push("customFieldsRequestDetails.parameterValues must be an array of [key, value] tuples, not an object map. " + "Studio Web emits Maps as `Array.from(entries())`; the runtime expects this form. " + 'Example: `[["list_id", "abc"], ["subscriber_hash", null]]`.');
+  } else {
+    for (let i = 0;i < cfrd.parameterValues.length; i++) {
+      const tuple = cfrd.parameterValues[i];
+      if (!Array.isArray(tuple) || tuple.length !== 2) {
+        errors.push(`customFieldsRequestDetails.parameterValues[${i}] must be a 2-element [key, value] tuple`);
+        continue;
+      }
+      const [k, v] = tuple;
+      if (typeof k !== "string" || k === "") {
+        errors.push(`customFieldsRequestDetails.parameterValues[${i}][0] must be a non-empty string`);
+      }
+      if (v !== null && typeof v !== "string") {
+        errors.push(`customFieldsRequestDetails.parameterValues[${i}][1] must be a string or null`);
+      }
+    }
+  }
+}
+function validateConnectorDetail(config) {
+  const errors = [];
+  if (typeof config.connectionId !== "string" || !config.connectionId) {
+    errors.push("connectionId is required (non-empty string)");
+  }
+  if (typeof config.folderKey !== "string" || !config.folderKey) {
+    errors.push("folderKey is required (non-empty string)");
+  }
+  if (typeof config.method !== "string" || !config.method) {
+    errors.push("method is required (HTTP method from connectorMethodInfo, e.g. GET, POST)");
+  }
+  if (typeof config.endpoint !== "string" || !config.endpoint || !config.endpoint.startsWith("/")) {
+    errors.push("endpoint is required (path from connectorMethodInfo, e.g. /ConversationsInfo/{conversationsInfoId})");
+  }
+  if (config.objectName !== undefined && (typeof config.objectName !== "string" || !config.objectName)) {
+    errors.push("objectName must be a non-empty string (required for Generic-type connector activities; ignored for Curated)");
+  }
+  validateJsonObjectKeys(config, ["bodyParameters", "queryParameters", "pathParameters"], errors);
+  if (config.filter !== undefined && (typeof config.filter !== "object" || config.filter === null || Array.isArray(config.filter))) {
+    errors.push("filter must be a JSON object (FilterTree)");
+  }
+  if (config.filter !== undefined && typeof config.queryParameters === "object" && config.queryParameters !== null && !Array.isArray(config.queryParameters) && "where" in config.queryParameters) {
+    errors.push("queryParameters.where is derived from `filter` and cannot be set alongside it. " + "Drop one of the two — prefer `filter` so Studio Web can re-render the filter widget.");
+  }
+  if (config.customFieldsRequestDetails !== undefined) {
+    validateCustomFieldsRequestDetails(config.customFieldsRequestDetails, errors);
+  }
+  if ("ceqlExpression" in config) {
+    errors.push("ceqlExpression is derived from the filter tree and cannot be provided directly");
+  }
+  const unknownKeys = Object.keys(config).filter((k) => !VALID_DETAIL_KEYS.has(k) && k !== "ceqlExpression");
+  if (unknownKeys.length > 0) {
+    errors.push(`Unknown keys: ${unknownKeys.join(", ")}. Valid keys: ${[...VALID_DETAIL_KEYS].join(", ")}`);
+  }
+  if (errors.length > 0) {
+    throw new InvalidDetailError(`Invalid --detail:
+  - ${errors.join(`
+  - `)}`);
+  }
+  return config;
+}
+var VALID_TRIGGER_DETAIL_KEYS = new Set([
+  "connectionId",
+  "folderKey",
+  "eventMode",
+  "objectName",
+  "eventParameters",
+  "queryParameters",
+  "pathParameters",
+  "filter"
+]);
+function validateConnectorTriggerDetail(config) {
+  const errors = [];
+  if (typeof config.connectionId !== "string" || !config.connectionId) {
+    errors.push("connectionId is required (non-empty string)");
+  }
+  if (typeof config.folderKey !== "string" || !config.folderKey) {
+    errors.push("folderKey is required (non-empty string)");
+  }
+  if (typeof config.eventMode !== "string" || !config.eventMode) {
+    errors.push("eventMode is required (e.g. 'webhooks' or 'polling')");
+  }
+  if (config.objectName !== undefined && (typeof config.objectName !== "string" || !config.objectName)) {
+    errors.push("objectName must be a non-empty string (required for Generic-type connector triggers; ignored for Curated)");
+  }
+  validateJsonObjectKeys(config, ["eventParameters", "queryParameters", "pathParameters"], errors);
+  if ("filterExpression" in config) {
+    errors.push("filterExpression is derived from the filter tree and cannot be provided directly. " + "Pass a structured `filter` (FilterTree) instead.");
+  }
+  if (config.filter !== undefined && (typeof config.filter !== "object" || config.filter === null || Array.isArray(config.filter))) {
+    errors.push("filter must be a JSON object (FilterTree)");
+  }
+  const unknownKeys = Object.keys(config).filter((k) => !VALID_TRIGGER_DETAIL_KEYS.has(k) && k !== "filterExpression");
+  if (unknownKeys.length > 0) {
+    errors.push(`Unknown keys: ${unknownKeys.join(", ")}. Valid keys: ${[...VALID_TRIGGER_DETAIL_KEYS].join(", ")}`);
+  }
+  if (errors.length > 0) {
+    throw new InvalidDetailError(`Invalid --detail:
+  - ${errors.join(`
+  - `)}`);
+  }
+  return 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(", ")}`);
+  }
+  if (errors.length > 0) {
+    throw new InvalidDetailError(`Invalid --detail:
+  - ${errors.join(`
+  - `)}`);
+  }
+  return config;
+}
+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 detail = {
+    connector: MANAGED_HTTP_CONNECTOR_KEY,
+    connectionId: config.authentication === "connector" ? config.connectionId : "ImplicitConnection",
+    connectionResourceId: config.authentication === "connector" ? config.connectionId : null,
+    connectionFolderKey: config.authentication === "connector" ? config.folderKey : null,
+    method: "POST",
+    endpoint: "/http-request",
+    bodyParameters,
+    configuration: `=jsonString:${JSON.stringify(buildManagedHttpEssentialConfiguration())}`,
+    ...activityTypeId ? { uiPathActivityTypeId: activityTypeId } : {},
+    errorState: { issues: [] },
+    telemetryData: {
+      connectorKey: MANAGED_HTTP_CONNECTOR_KEY,
+      connectorName: "HTTP",
+      operationType: "create",
+      objectName: "http-request",
+      objectDisplayName: "HTTP Request",
+      primaryKeyName: ""
+    }
+  };
+  node.inputs = { ...node.inputs ?? {}, detail };
+  if (config.authentication === "connector") {
+    ensureConnectionBindings(workflow, MANAGED_HTTP_CONNECTOR_KEY, config.connectionId, config.folderKey);
+  } else {
+    addManualModeImplicitBindings(workflow, MANAGED_HTTP_CONNECTOR_KEY);
+  }
+}
+function hasFileResponseField(metadata, method) {
+  const fieldsObj = metadata?.fields ?? {};
+  const fields = Array.isArray(fieldsObj) ? fieldsObj : Object.values(fieldsObj);
+  return fields.some((field) => {
+    const methodInfo = field.method?.[method];
+    if (!methodInfo)
+      return false;
+    const isResponse = methodInfo.response === true || methodInfo.responseCurated === true;
+    if (!isResponse)
+      return false;
+    return field.type === "file" || field.type === "octet-stream";
+  });
+}
+function patchOutputType(definitions, nodeType, type) {
+  const def = definitions.find((d) => d.nodeType === nodeType);
+  if (def?.outputDefinition?.output) {
+    def.outputDefinition.output.type = type;
+  }
+}
+function buildAgentToolParamsFromMetadata(metadata, method) {
+  const fieldsRaw = metadata.fields ?? {};
+  const fields = Array.isArray(fieldsRaw) ? fieldsRaw : Object.values(fieldsRaw);
+  const httpMethod = normalizeHttpMethod(method);
+  const methodMap = metadata.metadata?.method ?? {};
+  const methodInfo = methodMap[method] ?? Object.values(methodMap).find((m) => m.method === httpMethod);
+  const prompt = (f) => `{{prompt: "${f.description || f.displayName || f.name}"}}`;
+  const bodyParameters = {};
+  for (const field of fields) {
+    const fm = field.method?.[method] ?? field.method?.[httpMethod];
+    if (!fm || !fm.request && !fm.requestCurated)
+      continue;
+    const enumArr = field.enum && Array.isArray(field.enum) ? field.enum : [];
+    if (enumArr.length === 1) {
+      const only = enumArr[0];
+      bodyParameters[field.name] = typeof only === "string" ? only : only.value ?? only.name;
+    } else {
+      bodyParameters[field.name] = prompt(field);
+    }
+  }
+  const queryParameters = {};
+  const pathParameters = {};
+  for (const param of methodInfo?.parameters ?? []) {
+    if (param.type !== "query" && param.type !== "path")
+      continue;
+    const value = param.defaultValue != null && param.defaultValue !== "" ? param.defaultValue : prompt(param);
+    (param.type === "query" ? queryParameters : pathParameters)[param.name] = value;
+  }
+  return { bodyParameters, queryParameters, pathParameters };
+}
+var UNRESOLVABLE_FILTER_MARKER = "${=js:";
+var MANGLED_FILTER_FRAGMENT = "${";
+var DANGLING_TRAILING_OPERATOR = /(?:^|\s)(?:AND|OR)\s*$/i;
+var DANGLING_LEADING_OPERATOR = /^\s*(?:AND|OR)(?:\s|$)/i;
+var DOUBLED_OPERATOR = /(?:^|\s)(?:AND|OR)\s+(?:AND|OR)(?:\s|$)/i;
+function collectFilterFieldIds(tree) {
+  const ids = (tree.filters ?? []).map((condition) => condition.id);
+  for (const group of tree.groups ?? []) {
+    ids.push(...collectFilterFieldIds(group));
+  }
+  return ids;
+}
+function assertCompiledFilterResolvable(compiled, filterParamName, authoredTree) {
+  if (compiled.includes(MANGLED_FILTER_FRAGMENT)) {
+    throw new Error(`Refusing to persist the compiled filter for '${filterParamName}': it embeds a '\${…}' fragment, which the runtime never resolves — the fragment reaches the connector as literal text and the filter silently matches nothing. Cause: either a dynamic operand escaped placeholder substitution, or the design-time client mis-marked a literal value as an expression (widget-metadata defect ENGCE-60123). Workaround: author the whole filter as one '=js:' template under --detail.queryParameters.${filterParamName} (activities), or re-author the filter with values the connector's picker supports (triggers).`);
+  }
+  if (!authoredTree)
+    return;
+  const fieldIds = collectFilterFieldIds(authoredTree);
+  if (fieldIds.length === 0)
+    return;
+  const isEmpty = compiled.trim() === "";
+  const isMalformed = DANGLING_TRAILING_OPERATOR.test(compiled) || DANGLING_LEADING_OPERATOR.test(compiled) || DOUBLED_OPERATOR.test(compiled);
+  if (!isEmpty && !isMalformed)
+    return;
+  const outcome = isEmpty ? "The compiled expression is empty, so the filter disappears and the query returns every record." : `The compiled expression is broken: '${compiled}'. It holds a stray logical operator, so the connector faults at run time.`;
+  const names = [...new Set(fieldIds)].map((id) => `'${id}'`).join(", ");
+  throw new InvalidDetailError(`Refusing to persist the compiled filter for '${filterParamName}': the connector dropped at least one condition of --detail.filter. ${outcome} The filter tree names these fields: ${names}. Cause: a field id does not match the entity schema, or a condition has no operator. Field id matching is case-sensitive. Fix: read the supported field ids, then re-send --detail.filter with the exact ids. Run 'uip df entities get <ENTITY_ID> --output json' for a Data Service entity, or 'uip maestro flow registry get <NODE_TYPE> --connection-id <CONNECTION_ID> --output json' and read filterFields for a connector.`);
+}
+function assertLiteralEventParameters(eventParameters, nodeType) {
+  const dynamic = Object.entries(eventParameters).filter(([, value]) => typeof value === "string" && value.startsWith("=js:")).map(([name]) => `'${name}'`);
+  if (dynamic.length === 0)
+    return;
+  const params = dynamic.join(", ");
+  if (isConnectorTriggerType(nodeType)) {
+    throw new InvalidDetailError(`Event parameter(s) ${params} on start trigger "${nodeType}" hold a '=js:' expression, but event parameters on a start trigger cannot reference flow variables: the trigger is evaluated before any flow run exists, so there are no variables to read. Pass a literal value.`);
+  }
+  throw new InvalidDetailError(`Event parameter(s) ${params} on wait-for event "${nodeType}" hold a '=js:' expression, but dynamic values are not supported on mandatory event parameters. Pass a literal value here and move the dynamic condition to --detail.filter, where it compiles to a '{var_…}' placeholder plus detail.filterVariables that the runtime resolves mid-run.`);
+}
+function substituteDetailFilter(tree) {
+  try {
+    return substituteFilterVariables(tree);
+  } catch (error) {
+    if (error instanceof FilterNotSupportedError) {
+      throw new InvalidDetailError(error.message);
+    }
+    throw error;
+  }
+}
+async function configureActivity(workflow, node, config) {
+  const definitions = workflow.definitions ?? [];
+  const context = getModelContext(node, definitions);
+  const connectorKey = getContextValue(context, "connectorKey") ?? "";
+  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);
+  let objectName;
+  if (isV4Activity) {
+    const activityName = instanceParameters.activityName;
+    if (typeof activityName !== "string" || !activityName) {
+      throw new InvalidDetailError(`"${node.type}" is a 4.0.0 activity but its definition's configuration carries no activityName — the local registry copy may be stale. Run 'uip maestro flow registry pull --force', delete the definitions[] entry, and re-add the node.`);
+    }
+    objectName = activityName;
+  } else {
+    objectName = resolveObjectName(instanceParameters, context, config, connectorKey, definitions, node.type ?? "");
+  }
+  const detail = {
+    connector: connectorKey,
+    connectionId: config.connectionId,
+    connectionResourceId: config.connectionId,
+    connectionFolderKey: config.folderKey,
+    ...isV4Activity && {
+      activityContext: {
+        version: ACTIVITY_VERSION_V4,
+        scriptRef: objectName
+      }
+    },
+    method: normalizeHttpMethod(config.method),
+    endpoint: config.endpoint
+  };
+  if (isV4Activity) {
+    const v4Body = {};
+    if (config.bodyParameters)
+      v4Body.body = config.bodyParameters;
+    if (config.queryParameters)
+      v4Body.query = config.queryParameters;
+    if (config.pathParameters)
+      v4Body.pathParameters = config.pathParameters;
+    detail.bodyParameters = v4Body;
+  } else {
+    if (config.bodyParameters)
+      detail.bodyParameters = config.bodyParameters;
+    if (config.queryParameters)
+      detail.queryParameters = config.queryParameters;
+    if (config.pathParameters)
+      detail.pathParameters = config.pathParameters;
+  }
+  if (activityTypeId)
+    detail.uiPathActivityTypeId = activityTypeId;
+  detail.errorState = { issues: [] };
+  const isGeneric = instanceParameters.activityType === "Generic";
+  const resolvedInstanceParameters = isV4Activity ? { ...instanceParameters } : {
+    ...instanceParameters,
+    objectName
+  };
+  if (isGeneric && typeof instanceParameters.operation === "string") {
+    resolvedInstanceParameters.operation = instanceParameters.operation.toLowerCase();
+  }
+  const [metaError, metadata] = await catchError(isV4Activity ? fetchConnectorActivityMetadataV4(connectorKey, objectName) : fetchConnectorMetadata(connectorKey, objectName, config.connectionId));
+  if (metaError) {
+    throw new Error(`Failed to fetch IS metadata for ${connectorKey}/${objectName}: ${extractErrorMessageSync(metaError)}`);
+  }
+  const methodMap = metadata?.metadata?.method ?? {};
+  const methodInfo = methodMap[config.method] ?? Object.values(methodMap).find((m) => m.method === config.method);
+  if (methodInfo) {
+    let filterInputName = null;
+    let filterVariables = {};
+    if (isV4Activity) {
+      if (config.filter && config.filter.groupOperator !== null) {
+        throw new InvalidDetailError(`--detail.filter is not supported for the 4.0.0 activity "${node.type}" — the design-time filter compiler reads v3 metadata only. Drop \`filter\` from --detail.`);
+      }
+      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))}`;
+    } else {
+      const filterBuilderParam = (methodInfo.parameters ?? []).find((p) => p.design?.component === "FilterBuilder");
+      let rawJsFilterParamName = null;
+      if (filterBuilderParam && !config.filter && config.queryParameters && filterBuilderParam.name in config.queryParameters) {
+        const rawValue = config.queryParameters[filterBuilderParam.name];
+        if (typeof rawValue === "string" && rawValue.startsWith("=js:")) {
+          if (rawValue.includes(UNRESOLVABLE_FILTER_MARKER)) {
+            throw new InvalidDetailError(`--detail.queryParameters.${filterBuilderParam.name} embeds '\${=js:', which the runtime never resolves — the filter would be sent as literal text and silently match nothing. Reference the value directly inside the outer '=js:' expression, or pass a structured tree under --detail.filter.`);
+          }
+          rawJsFilterParamName = filterBuilderParam.name;
+        } else {
+          throw new InvalidDetailError(`'${filterBuilderParam.name}' is a FilterBuilder parameter on activity "${node.type}" — pass a structured filter tree under --detail.filter, not a raw string under --detail.queryParameters.${filterBuilderParam.name}. Studio Web reads essentialConfiguration.savedFilterTrees.${filterBuilderParam.name} to render the filter UI; only --detail.filter populates it. See the CEQL filter-tree contract in the uipath-platform skill (integration-service/activities.md).`);
+        }
+      }
+      let savedFilterTrees = null;
+      let authoredFilterTree = null;
+      if (config.filter && config.filter.groupOperator !== null) {
+        if (!filterBuilderParam) {
+          throw new InvalidDetailError(`Activity "${node.type}" does not declare a FilterBuilder parameter — server-side filtering is not supported by this operation. Drop \`filter\` from --detail.`);
+        }
+        filterInputName = filterBuilderParam.name;
+        authoredFilterTree = config.filter;
+        const substituted = substituteDetailFilter(config.filter);
+        filterVariables = substituted.variables;
+        savedFilterTrees = { [filterInputName]: substituted.tree };
+      }
+      const fieldValues = {
+        ...detail.bodyParameters,
+        ...detail.queryParameters,
+        ...detail.pathParameters
+      };
+      if (rawJsFilterParamName !== null) {
+        delete fieldValues[rawJsFilterParamName];
+      }
+      const activityClient = await createConfiguredActivityClient({
+        instanceParameters: resolvedInstanceParameters,
+        connectionId: config.connectionId,
+        savedFilterTrees,
+        customFieldsRequestDetails: config.customFieldsRequestDetails ?? null,
+        fieldValues
+      });
+      assertActivityMetadataResolved(activityClient.getEssentialConfiguration().essentialConfiguration, config.connectionId);
+      if (filterInputName && authoredFilterTree) {
+        const compiledFilter = activityClient.getCompiledFilter(filterInputName);
+        assertCompiledFilterResolvable(compiledFilter, filterInputName, authoredFilterTree);
+        detail.queryParameters = {
+          ...detail.queryParameters ?? {},
+          [filterInputName]: compiledFilter
+        };
+        if (Object.keys(filterVariables).length > 0) {
+          detail.filterVariables = filterVariables;
+          await applySavedFilterTree(activityClient, filterInputName, authoredFilterTree);
+        }
+      }
+      const { essentialConfiguration } = activityClient.getEssentialConfiguration();
+      detail.configuration = `=jsonString:${JSON.stringify({ essentialConfiguration })}`;
+    }
+    if ((node.type ?? "").startsWith("uipath.agent.resource.tool.connector.")) {
+      const { bodyParameters, queryParameters, pathParameters } = buildAgentToolParamsFromMetadata(metadata, config.method);
+      if (!detail.bodyParameters && Object.keys(bodyParameters).length > 0)
+        detail.bodyParameters = bodyParameters;
+      if (!detail.queryParameters && Object.keys(queryParameters).length > 0)
+        detail.queryParameters = queryParameters;
+      if (!detail.pathParameters && Object.keys(pathParameters).length > 0)
+        detail.pathParameters = pathParameters;
+    }
+    const params = methodInfo.parameters ?? [];
+    const rawMultipartParams = extractMultipartParameters(params);
+    const { multipartParams, bodyParameters: cleanedBodyParameters } = inlineMultipartFileValues(rawMultipartParams, detail.bodyParameters);
+    if (multipartParams.length > 0) {
+      detail.multipartParameters = multipartParams;
+    }
+    if (cleanedBodyParameters) {
+      detail.bodyParameters = cleanedBodyParameters;
+    } else {
+      delete detail.bodyParameters;
+    }
+    const inputMeta = buildInputMetadata(multipartParams, methodInfo.operation, methodInfo.pagination?.maxPageSize, filterInputName && Object.keys(filterVariables).length > 0 ? [filterInputName] : undefined);
+    if (inputMeta) {
+      detail.inputMetadata = inputMeta;
+    }
+    patchOutputType(definitions, node.type ?? "", hasFileResponseField(metadata, config.method) ? "file" : isListOperation(methodInfo.operation) ? "array" : "object");
+  } else {
+    throw new Error(`IS metadata for ${connectorKey}/${objectName} has no entry for method "${config.method}" — cannot build configuration`);
+  }
+  node.inputs = { ...node.inputs ?? {}, detail };
+  ensureConnectionBindings(workflow, connectorKey, config.connectionId, config.folderKey);
+}
+async function configureTrigger(workflow, node, config) {
+  const definitions = workflow.definitions ?? [];
+  const context = getModelContext(node, definitions);
+  const connectorKey = getContextValue(context, "connectorKey") ?? "";
+  const operation = getContextValue(context, "operation") ?? "";
+  const objectName = resolveTriggerObjectName(context, config, connectorKey, operation, node.type ?? "");
+  const activityTypeId = extractActivityTypeIdFromDefinition(definitions, node.type ?? "");
+  const instanceParameters = extractInstanceParameters(definitions, node.type ?? "");
+  if (!instanceParameters) {
+    throw new Error(`No instanceParameters found in definition for trigger "${node.type}" — cannot build configuration`);
+  }
+  if (isConnectorWaitForEventType(node.type ?? "")) {
+    instanceParameters.activityType = "CuratedWaitFor";
+  }
+  const resolvedInstanceParameters = {
+    ...instanceParameters,
+    objectName
+  };
+  const eventParameters = config.eventParameters ?? {};
+  assertLiteralEventParameters(eventParameters, node.type ?? "");
+  const filterTree = config.filter && config.filter.groupOperator !== null ? config.filter : null;
+  const substitutedFilter = filterTree ? substituteDetailFilter(filterTree) : null;
+  const filterVariables = substitutedFilter?.variables ?? {};
+  const detail = {
+    connector: connectorKey,
+    connectionId: config.connectionId,
+    connectionResourceId: config.connectionId,
+    connectionFolderKey: config.folderKey,
+    eventParameters,
+    objectName,
+    eventType: operation,
+    eventMode: config.eventMode
+  };
+  if (config.queryParameters)
+    detail.queryParameters = config.queryParameters;
+  if (config.pathParameters)
+    detail.pathParameters = config.pathParameters;
+  const triggerClient = await createConfiguredActivityClient({
+    instanceParameters: resolvedInstanceParameters,
+    connectionId: config.connectionId,
+    savedFilterTrees: substitutedFilter ? { filter: substitutedFilter.tree } : null,
+    fieldValues: eventParameters
+  });
+  assertActivityMetadataResolved(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);
+  }
+  const { essentialConfiguration } = triggerClient.getEssentialConfiguration();
+  detail.configuration = `=jsonString:${JSON.stringify({ essentialConfiguration })}`;
+  if (activityTypeId)
+    detail.uiPathActivityTypeId = activityTypeId;
+  detail.errorState = { issues: [] };
+  node.inputs = { ...node.inputs ?? {}, detail };
+  ensureConnectionBindings(workflow, connectorKey, config.connectionId, config.folderKey);
+}
+async function configureConnectorNode(filePath, nodeId, rawDetail) {
+  const { workflow, refMap } = await readFlowWorkflow(filePath);
+  const node = workflow.nodes.find((n) => n.id === nodeId);
+  if (!node)
+    throw new Error(`Node '${nodeId}' not found`);
+  const nodeType = node.type ?? "";
+  const nodeIds = new Set(workflow.nodes.map((n) => n.id));
+  if (isManagedHttpType(nodeType)) {
+    const config = validateManagedHttpDetail(rawDetail);
+    configureManagedHttp(workflow, node, config);
+    await writeFlowWorkflow(filePath, workflow, refMap);
+    const fs2 = getFileSystem();
+    await regenerateBindingsFile(fs2, filePath);
+    if (config.authentication === "connector") {
+      await createConnectionResourceFile(fs2, filePath, config.connectionId, config.targetConnector);
+    }
+    return {
+      bindingsCreated: workflow.bindings.length,
+      detailPopulated: true,
+      ...crossNodeBindingWarnings(node, nodeIds)
+    };
+  }
+  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.`);
+  }
+  if (isEventDrivenConnectorType(nodeType)) {
+    const config = validateConnectorTriggerDetail(rawDetail);
+    await configureTrigger(workflow, node, config);
+  } else {
+    const config = validateConnectorDetail(rawDetail);
+    await configureActivity(workflow, node, config);
+  }
+  await writeFlowWorkflow(filePath, workflow, refMap);
+  const fs = getFileSystem();
+  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);
+  }
+  return {
+    bindingsCreated: workflow.bindings.length,
+    detailPopulated: true,
+    ...isEventDrivenConnectorType(nodeType) ? {} : crossNodeBindingWarnings(node, nodeIds)
+  };
+}
+function crossNodeBindingWarnings(node, nodeIds) {
+  const detail = node.inputs?.detail;
+  const issues = scanDetailForCrossNodeBindings(detail, nodeIds, "warning");
+  if (issues.length === 0)
+    return {};
+  return { warnings: issues.map((i) => `[${i.path}] ${i.message}`) };
+}
+export {
+  InvalidDetailError,
+  buildAgentToolParamsFromMetadata,
+  configureConnectorNode,
+  validateConnectorDetail,
+  validateConnectorTriggerDetail,
+  validateManagedHttpDetail
+};
+
+//# debugId=A0238AA222C5EF2164756E2164756E21